BlogJava-kxbin-文章分类-J2EE

手工配置tomcat 的log参数显示详细的log信息（转）

kxbin — Wed, 21 Mar 2012 10:00:00 GMT

开发测试中经常有tomcat报[严重]的错，但没有明细，这种情况下要手工配置tomcat 的log参数。

昨天部署web应用到Tomcat之后,无法成功启动,并且控制台没有详细的错误信息,
顶多就两行提示信息,例如:
严重: Error listenerStart
严重: Context [/lizongbo] startup failed due to previous errors

或者

严重: Error filterStart
org.apache.catalina.core.StandardContext start
严重: Context startup failed due to previous errors

查找logs目录下的信息,除了这两句话,也没别的辅助内容.
给查错带来了困难,在这种情况下,是因为Tomcat自身的默认日志没有将一些错误信息输出到控制台或文件,
这个时候则需要配置Tomcat自身的log,启用详细的调试日志.

在Tomcat 5.5和Tomcat 6.0中的配置基本一样,只是相关文件放的目录有所不同.

首先需要准备的文件为:

1.log4j.jar , 下载地址 : http://www.apache.org/dist/logging/--escaped_anchor:e0a22b16b97ca8dedb8d5b8c15ffbcaa--/1.2.15/apache-log4j-1.2.15.zip
2.Tomcat 5.5所需的 commons-logging.jar,下载地址: http://www.apache.org/dist/commons/logging/binaries/commons-logging-1.1.zip

3.log4j配置文件:
log4j.properties
配置内容为:

log4j.rootLogger=ERROR,R

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=[%p]%t-%c-%m%n

log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=${catalina.home}/logs/lizongbo.log
log4j.appender.R.MaxFileSize=10MB
log4j.appender.R.MaxBackupIndex=10
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=[%p]%t-%c-%m%n

log4j.logger.org.apache.catalina=INFO,R,CONSOLE

#日志级别不能太低,如果配置为debug的话,输出的日志信息太多,导致tomcat启动非常的慢.

4.Tomcat 6.0所需的juli替换文件:
http://www.apache.org/dist/--escaped_anchor:079305423cce36d6691457475e081123--/tomcat-6/v6.0.14/bin/extras/tomcat-juli-adapters.jar
http://www.apache.org/dist/--escaped_anchor:079305423cce36d6691457475e081123--/tomcat-6/v6.0.14/bin/extras/tomcat-juli.jar

在Tomcat6.0中,

将tomcat-juli-adapters.jar,log4j-1.2.15.jar,log4j.properties复制到D:\Java\ApacheTomcat6.0.14\lib下面.

将tomcat-juli.jar复制到D:\Java\apache-tomcat-6.0.14\bin\下面.

然后启动tomcat,就可以在D:\Java\apache-tomcat-6.0.14\logs下看到lizongbo.log了.

在 Tomcat5.5中,

将commons-logging-1.1.jar,log4j-1.2.15.jar,复制到D:\Java\apache-tomcat-5.5.25\common\lib下面.
将log4j.properties复制到D:\Java\apache-tomcat-5.5.25\common\classes下面.

然后启动tomcat,就可以在D:\Java\apache-tomcat-5.5.25\logs下看到lizongbo.log了.

在这个时候,再通过日志文件来分析,则会发现出现这种错误的情况可能有:
(以下是我遇到的出错情况,大多是些低级错误)
1.webapps要用到的classe文件根本没有复制到WEB-INF/classes目录下面
(java.lang.NoClassDefFoundError,而这个信息可能默认没输出到控制台,尤其是用了spring的,昨天就是这个粗心的低级错误)
2.要用到lib文件没有复制完,缺少lib
3.lib下的同一个库的jar文件存在多个不同版本,引起版本冲突.
4.lib下的jar与tomcat版本不相对应(我遇到的问题是web应用在Tomcat5.5上运行正常,换到Tomcat6.0上就出错,
例如一个用了struts的webapp在Tomcat 6上报下面的错误
“Parse Fatal Error at line 17 column 6: The processing instruction
target matching “[xX][mM][lL]” is not allowed” )

愿意看英文的可以参考官方网站说明:
http://tomcat.apache.org/tomcat-6.0-doc/logging.html
http://tomcat.apache.org/tomcat-5.5-doc/logging.html

kxbin 2012-03-21 18:00 发表评论

html中area标签使用

kxbin — Thu, 09 Feb 2012 02:24:00 GMT


 请点击图像上的星球，把它们放大。
 src="http://www.w3school.com.cn/i/eg_planets.jpg"
border="0" usemap="#planetmap"
alt="Planets" />
 
 shape="circle"
coords="180,139,14"
href ="http://www.w3school.com.cn/example/html/venus.html"
target ="_blank"
alt="Venus" />
 shape="circle"
coords="129,161,10"
href ="http://www.w3school.com.cn/example/html/mercur.html"
target ="_blank"
alt="Mercury" />
 shape="rect"
coords="0,0,110,260"
href ="http://www.w3school.com.cn/example/html/sun.html"
target ="_blank"
alt="Sun" />
 
 注释：img 元素中的 "usemap" 属性引用 map 元素中的 "id" 或 "name" 属性（根据浏览器），所以我们同时向 map 元素添加了 "id" 和 "name" 属性。
 


1.第一个area是圆形
shape="circle"                      /*说明是圆形*/
coords="180,139,14"            /*圆心坐标是(180,139)，半径14*/
2.第二area个是矩形
shape="rect"                         /*说明是矩形*/
coords="0,0,110,260"            /*左上角坐标是(0,0)，右下角坐标是(110,260)/
 注。单位是像素，坐标可以是负值

kxbin 2012-02-09 10:24 发表评论

web.xml中Servlet Filter的调用顺序(转载)

kxbin — Wed, 28 Dec 2011 00:58:00 GMT

Filter是一个很有用的东西，使用filter可以修改request, response, session, application中的内容。

1. javax.servlet.Filter有两个重要的方法
public void init(FilterConfig config)
public void doFilter(ServletRequest request, ServletResponse response,

FilterChain chain)
其中init方法用来作一些初始化的方法，而doFilter方法用来执行真正的过滤操作。

2. Filter的部署方法
在web.xml中要声明filter元素，并分配需要其处理的url，如下：

Filter1

com.baidu.Filter1

Filter2

com.baidu.Filter2

Filter1

Filter2

3. doFilter函数的执行顺序
当某个url请求匹配了多个Filter时，应用服务器将多个Filter组织成FilterChain，这个链的执行顺序是由其元素在web.xml文件中的顺序决定的。
doFilter函数可以过滤请求或者响应，当其过滤完请求后将调用FilterChain的doFilter函数让FilterChain中的下一个Filter来过滤请求。最先过滤请求的Filter将最后过滤相应，下面是个简单的例子。
public void doFilter(ServletRequest request, ServletResponse response,FilterChain chain) throws IOException, ServletException
{
       system.out.println(“filter request here ----”);
        // todo:
       chain.doFilter(request,response);
       system.out.println(“filter response here ----”);
        // todo:

}

4.init函数的执行顺序
    对于不同的应用服务器，Filter的init函数的执行时间是不同的，例如：tomcat会在tomcat启动的时候执行init函数，而weblogic等一些其他的应用服务器则会在该Filter匹配的url被首次请求的时候加载。
（下面的部分是我通过实验猜想的，不一定正确。）
    对于tomcat而言，tomcat启动时会解析web.xml文件，然后按照元素的顺序将各个Filter元素加载到一个 HashMap中。解析完成后，会从HashMap中一个个的拿出Filter元素，串行的执行其init函数（这里的执行有先后关系，是在一个线程中执行的）。所以在tomcat中定义的多个Filter其init函数的执行顺序就是其在HashMap中的散列顺序，具体来说与其在web.xml文件中的定义位置及其名字有关。
    对于HashMap来说，如果其元素固定不变，则其顺序也是固定不变的，但当元素个数发生变化时，便不能保证其顺序（例如：当有两个元素时，A在B的前面，当再加入20个元素的时候A就不一定在B的前面了），所以init函数的执行顺序是无法保证的。

kxbin 2011-12-28 08:58 发表评论

网站用户单点登录系统解决方案(转)

kxbin — Wed, 28 Dec 2011 00:53:00 GMT

网站用户单点登录系统解决方案

1 背景

　　在网站建设的过程中，多个应用系统一般是在不同的时期开发完成的。各应用系统由于功能侧重、设计方法和开发技术有所不同，也就形成了各自独立的用户库和用户认证体系。随着网站的发展，会出现这样的用户群体：以其中的一个用户为例，他（她）使用网站的多个应用系统，但在每个应用系统中有独立的账号，没有一个整体上的网站用户账号的概念，进入每一个应用系统前都需要以该应用系统的账号来登录。这带给用户不方便的使用感受，用户会想：既然我使用的是同一个网站上的应用，为什么不能在一次在网站上登录之后不必再经过应用系统认证直接进入应用系统呢？用户的要求我们称之为 "单点登录"。

图 1.1 网站用户要求单点登录

2 分析

　　在多个拥有各自独立的用户体系的应用系统间实现单点登录，我们要考虑以下的问题：

单点登录系统的实现在各应用系统都采用B/S模式这一前提下进行。
需要在各应用系统间统一用户认证标志，用户登录后可以得到用户令牌，各应用系统认可统一的用户令牌。
用户令牌应当是安全加密的，并且要限定时效期。
由于每个应用系统都有自己的用户库，一个用户可能在不同的应用系统中使用不同的账号，因此每个要使用多个应用系统的用户要设置一个统一的用户账号并以此账号进行单点登录，该账号与该用户在各应用系统中的一个账号形成映射关系。
各应用系统可能属于不同的域，因此要实现跨域的单点登录。
已经上线运行的应用系统需要进行改造来支持单点登录，正在开发的应用系统则可以在开发阶段增加对单点登录的支持，但应用系统之间应该是松耦合。
由于各应用系统往往都已经处于稳定运行期，单点登录系统的实现应该对各应用系统的登录认证体系冲击最小，各应用系统原有的登录流程依然可用。
一些应用服务器平台虽然提供对单点登录的支持，但要求应用系统用户认证的设计符合其规范，这对已经处于运行期的应用系统来说难以实现。

3 设计

　　以下是系统的整体设计结构：

图 3.1 系统结构图

3.1 单点登录管理应用

　　我们首先设计单点登录管理应用：

图 3.2 单点登录管理应用

　　用户在其中注册一个单点登录账号，然后针对每个应用系统绑定一个该应用系统中原有的账号，并维护这些注册和绑定信息。绑定的过程需要单点登录管理应用服务器到应用系统服务器上验证用户提供的该应用系统中原有账号和密码，应用服务器均以相同的Web Service接口提供该功能支持。

3.2 用户单点登录流程

　　之后以用户单点登录管理应用和令牌传输识别的标准来实现用户单点登录流程。

1、用户访问应用系统。
图 3.3 用户单点登录流程 - 步骤一

2、应用系统如果检查到用户没有在自己的服务器登录，则将用户请求重定向到单点登录服务器上。（使用重定向就可以处理各服务器跨域的情况）
图 3.4 用户单点登录流程 - 步骤二

3、单点登录服务器检查到用户已经单点登录（如果用户没有单点登录则要求用户登录，登录标志存储为客户端浏览器的Cookie），找到该用户在相应应用系统上绑定的账号。
图 3.5 用户单点登录流程 - 步骤三
4、单点登录服务器根据第三步的结果生成用户令牌，重定向回应用系统。
图 3.6 用户单点登录流程 - 步骤四
5、应用系统接收统一格式的用户令牌，取得用户在本系统上的登录账号，将用户在本系统上状态置为登录，返回用户请求访问的页面。
图 3.7 用户单点登录流程 - 步骤五

　　如果用户在访问应用系统之前已经在单点登录服务器上登录过，第二步到第四布对用户来说就是透明的，用户感觉只是向应用系统发出了访问请求，然后得到了页面反馈。

4 实现

(略)

5 总结

　　本方案设计的用户单点登录系统做到了：

真正了实现单点登录、全网访问，方便用户的使用过程。
各系统之间耦合度低，应用系统的改造不破坏其固有流程和结构，整个系统的实施过程安全平滑。
统一了单点登录服务器到应用服务器的用户认证信息访问标准，统一了令牌安全加密的传输和识别标准，为将来更多应用系统提供了统一的单点登录框架。
整合了过去分散在各应用系统中虽然有内在关联却难以判别的用户信息资源，为更进一步的用户个性化服务打下了基础。

kxbin 2011-12-28 08:53 发表评论

org.hibernate.exception.GenericJDBCException: Cannot release connection（转）

kxbin — Fri, 09 Dec 2011 01:01:00 GMT

org.hibernate.exception.GenericJDBCException: Cannot release connection

问题：
    系统采用Spring MVC 2.5 + Spring 2.5 + Hibernate 3.2架构，其中数据源连接池采用的是Apache commons DBCP。问题是这样的，系统运行一段时间后（大致每隔8小时），访问系统会出现如下错误，再次访问恢复正常。
view plain
org.springframework.web.util.NestedServletException: Request processing failed; nested exception is org.hibernate.exception.GenericJDBCException: Cannot release connection  
 at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:583)  
 at org.springframework.web.servlet.FrameworkServlet.doGet(FrameworkServlet.java:501)  
 at javax.servlet.http.HttpServlet.service(HttpServlet.java:617)  
 at javax.servlet.http.HttpServlet.service(HttpServlet.java:717)  
 at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:290)  
 at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206)  
  
Caused by: org.hibernate.exception.GenericJDBCException: Cannot release connection  
 at org.hibernate.exception.SQLStateConverter.handledNonSpecificException(SQLStateConverter.java:103)  
 at org.hibernate.exception.SQLStateConverter.convert(SQLStateConverter.java:91)  
 at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:43)  
 at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:29)  
 at org.hibernate.jdbc.ConnectionManager.closeConnection(ConnectionManager.java:449)  
 at org.hibernate.jdbc.ConnectionManager.cleanup(ConnectionManager.java:379)  
 at org.hibernate.jdbc.ConnectionManager.manualDisconnect(ConnectionManager.java:333)  
 at org.hibernate.impl.SessionImpl.disconnect(SessionImpl.java:375)  
 at org.springframework.orm.hibernate3.HibernateTransactionManager.doCleanupAfterCompletion(HibernateTransactionManager.java:744)  
 at org.springframework.transaction.support.AbstractPlatformTransactionManager.cleanupAfterCompletion(AbstractPlatformTransactionManager.java:989)  
 at org.springframework.transaction.support.AbstractPlatformTransactionManager.processRollback(AbstractPlatformTransactionManager.java:855)  
 at org.springframework.transaction.support.AbstractPlatformTransactionManager.rollback(AbstractPlatformTransactionManager.java:800)  
 at org.springframework.transaction.interceptor.TransactionAspectSupport.completeTransactionAfterThrowing(TransactionAspectSupport.java:339)  
 at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:110)  
 at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:171)  
 at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:89)  
 at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:171)  
 at org.springframework.aop.framework.Cglib2AopProxy$DynamicAdvisedInterceptor.intercept(Cglib2AopProxy.java:635)  
 at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)  
 at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)  
 at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)  
 at java.lang.reflect.Method.invoke(Method.java:585)  
 at org.springframework.web.bind.annotation.support.HandlerMethodInvoker.doInvokeMethod(HandlerMethodInvoker.java:421)  
 at org.springframework.web.bind.annotation.support.HandlerMethodInvoker.invokeHandlerMethod(HandlerMethodInvoker.java:136)  
 at org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter.invokeHandlerMethod(AnnotationMethodHandlerAdapter.java:326)  
 at org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter.handle(AnnotationMethodHandlerAdapter.java:313)  
 at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:875)  
 at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:807)  
 at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:571)  
  36 more  
Caused by: java.sql.SQLException: Already closed.  
 at org.apache.commons.dbcp.PoolableConnection.close(PoolableConnection.java:77)  
 at org.apache.commons.dbcp.PoolingDataSource$PoolGuardConnectionWrapper.close(PoolingDataSource.java:180)  
 at org.springframework.orm.hibernate3.LocalDataSourceConnectionProvider.closeConnection(LocalDataSourceConnectionProvider.java:96)  
 at org.hibernate.jdbc.ConnectionManager.closeConnection(ConnectionManager.java:445)  
  62 more  
解决：
    造成Cannot release connection的原因有很多，要具体问题具体分析。从异常分析，造成这个异常 org.hibernate.exception.GenericJDBCException: Cannot release connection 归根结底是Caused by: java.sql.SQLException: Already closed. 即连接已关闭。所以解决的办法就要从DBCP的参数配置入手，见下面的参数配置properties文件。
 
view plain
#### :: Apache DBCP :: ####  
jdbc.driverClassName=oracle.jdbc.driver.OracleDriver  
jdbcjdbc.url=jdbc:oracle:thin:@10.165.153.9:1521:PRDC  
jdbc.username=guser  
jdbc.password=guser  
#初始化连接  
jdbc.initialSize=0  
#连接池的最大活动个数  
jdbc.maxActive=20  
#没有人用连接的时候，最大闲置的连接个数。  
jdbc.maxIdle=100  
#没有人用连接的时候，最小闲置的连接个数。  
jdbc.minIdle=0  
#超时等待时间以毫秒为单位  
jdbc.maxWait=10000  
#是否自动回收超时连接  
jdbc.removeAbandoned=true  
#设置被遗弃的连接的超时的时间（以秒数为单位），即当一个连接被遗弃的时间超过设置的时间，则它会自动转换成可利用的连接。默认的超时时间是300秒。  
jdbc.removeAbandonedTimeout=60  
#是否在自动回收超时连接的时候打印连接的超时错误  
jdbc.logAbandoned = true  
#给出一条简单的sql语句进行验证  
jdbc.validationQuery=select 1 from dual  
#在取出连接时进行有效验证  
jdbc.testOnBorrow=true  
其中标红的两个参数的作用是对池化连接进行验证，This will ensure that DBCP only hands out good connections to Hibernate. 故加上这两个参数后，这个异常就不会再出现了。在Spring中指定数据源如下： 
 
view plain
  
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
        <property name="driverClassName" value="${jdbc.driverClassName}" />  
        <property name="url" value="${jdbc.url}" />  
        <property name="username" value="${jdbc.username}" />  
        <property name="password" value="${jdbc.password}" />  
        <property name="maxActive" value="${jdbc.maxActive}" />  
        <property name="maxIdle" value="${jdbc.maxIdle}" />  
        <property name="maxWait" value="${jdbc.maxWait}" />  
        <property name="removeAbandoned" value="${jdbc.removeAbandoned}" />  
        <property name="removeAbandonedTimeout" value="${jdbc.removeAbandonedTimeout}" />  
        <property name="logAbandoned" value="${jdbc.logAbandoned}" />  
        <property name="validationQuery" value="${jdbc.validationQuery}" />  
        <property name="testOnBorrow" value="${jdbc.testOnBorrow}" />  
    bean>  
 

kxbin 2011-12-09 09:01 发表评论

beanutils,StringUtils等工具包的学习

kxbin — Fri, 02 Dec 2011 06:11:00 GMT

1.beanutils
2.StringUtils

kxbin 2011-12-02 14:11 发表评论

saveToken介绍一

kxbin — Fri, 02 Dec 2011 01:32:00 GMT

1》防止多次点击“提交”,让多次“提交”变成只一次“提交”

saveToken(rquest)

的目的是页面上的按钮只相应一次，比如说，在页面上有个新增按钮，如果你连续点击数次，后台程序可能会响应n次，加了这句话，在页面

上自动生成一个hidden变量

2》防止页面重复提交

利用同步令牌（Token）机制来解决Web应用中重复提交的问题，Struts也给出了一个参考实现。

　　基本原理：　

　　服务器端在处理到达的请求之前，会将请求中包含的令牌值与保存在当前用户会话中的令牌值进行比较，看是否匹配。在处理完该请求后

，且在答复发送给客户端之前，将会产生一个新的令牌，该令牌除传给客户端以外，也会将用户会话中保存的旧的令牌进行替换。这样如果用

户回退到刚才的提交页面并再次提交的话，客户端传过来的令牌就和服务器端的令牌不一致，从而有效地防止了重复提交的发生。　

　　if (isTokenValid(request, true)) {

　　// 表单不是重复提交

　　//这里是保存数据的代码

　　} else {

　　//表单重复提交

　　saveToken(request);

　　//其它的处理代码

　　}

网上例子为证：

public ActionForward execute(ActionMapping mapping, ActionForm form,

HttpServletRequest request, HttpServletResponse response) {

UserForm userForm = (UserForm)form;

if(!isTokenValid(request)){

saveToken(request);

userForm.setMessage("重复提交");

return mapping.findForward("failure");

}

else{

resetToken(request);

}

request.setAttribute("user", userForm);

return mapping.findForward("success");

}

模板经典例子：

public ActionForward save(ActionMapping mapping, ActionForm form,

HttpServletRequest request, HttpServletResponse response)

throws BaseException {

if (!isTokenValid(request)) { // 如果指令无效，则属于重复提交

return (new ActionForward(mapping.getInput()));

} else {

resetToken(request);

}

BaseDao dao = DAOFactory.getDao(getEntityDAOClassName());

dao.begingTransaction();

Class cls = dao.getEntityClass();

try {

BaseVO vo = (BaseVO) cls.newInstance();

DataTrans.copyProperties(vo, form);

this.saveEx(mapping, form, request, response, vo);

dao.save(vo);

dao.commitTransaction();

} catch (Exception e) {

dao.rollback();

throw new BaseException("保存数据出现异常");

} finally {

dao.sessionClose();

}

return mapping.findForward("saveSuccess");

}

kxbin 2011-12-02 09:32 发表评论

saveToken介绍二

kxbin — Fri, 02 Dec 2011 01:32:00 GMT

Struts的Token（令牌）机制能够很好的解决表单重复提交的问题，基本原理是：服务器端在处理到达的请求之前，会将请求中包含的令牌值与保存在当前用户会话中的令牌值进行比较，看是否匹配。在处理完该请求后，且在答复发送给客户端之前，将会产生一个新的令牌，该令牌除传给客户端以外，也会将用户会话中保存的旧的令牌进行替换。这样如果用户回退到刚才的提交页面并再次提交的话，客户端传过来的令牌就和服务器端的令牌不一致，从而有效地防止了重复提交的发生。

这时其实也就是两点，第一：你需要在请求中有这个令牌值，请求中的令牌值如何保存，其实就和我们平时在页面中保存一些信息是一样的，通过隐藏字段来保存，保存的形式如： 〈input type="hidden" name="org.apache.struts.taglib.html.TOKEN" value="6aa35341f25184fd996c4c918255c3ae"〉，这个value是TokenProcessor类中的generateToken()获得的，是根据当前用户的session id和当前时间的long值来计算的。第二：在客户端提交后，我们要根据判断在请求中包含的值是否和服务器的令牌一致，因为服务器每次提交都会生成新的Token，所以，如果是重复提交，客户端的Token值和服务器端的Token值就会不一致。下面就以在数据库中插入一条数据来说明如何防止重复提交。

在Action中的add方法中，我们需要将Token值明确的要求保存在页面中，只需增加一条语句：saveToken(request);，如下所示：
public ActionForward add(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
//前面的处理省略
saveToken(request);
return mapping.findForward("add");
}在Action的insert方法中，我们根据表单中的Token值与服务器端的Token值比较，如下所示：
public ActionForward insert(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
if (isTokenValid(request, true)) {
// 表单不是重复提交
//这里是保存数据的代码
} else {
//表单重复提交
saveToken(request);
//其它的处理代码
}
}

其实使用起来很简单，举个最简单、最需要使用这个的例子：
 一般控制重复提交主要是用在对数据库操作的控制上，比如插入、更新、删除等，由于更新、删除一般都是通过id来操作（例如：updateXXXById, removeXXXById），所以这类操作控制的意义不是很大（不排除个别现象），重复提交的控制也就主要是在插入时的控制了。

先说一下，我们目前所做项目的情况：
 目前的项目是用Struts＋Spring＋Ibatis，页面用jstl，Struts复杂View层，Spring在Service层提供事务控制，Ibatis是用来代替JDBC，所有页面的访问都不是直接访问jsp，而是访问Structs的Action，再由Action来Forward到一个Jsp，所有针对数据库的操作，比如取数据或修改数据，都是在Action里面完成，所有的Action一般都继承BaseDispatchAction，这个是自己建立的类，目的是为所有的Action做一些统一的控制，在Struts层，对于一个功能，我们一般分为两个Action，一个Action里的功能是不需要调用Struts的验证功能的（常见的方法名称有add,edit,remove,view,list），另一个是需要调用Struts的验证功能的（常见的方法名称有insert,update）。

就拿论坛发贴来说吧，论坛发贴首先需要跳转到一个页面，你可以填写帖子的主题和内容，填写完后，单击“提交”，贴子就发表了，所以这里经过两个步骤：
 1、转到一个新增的页面，在Action里我们一般称为add，例如：
 public ActionForward add(ActionMapping mapping, ActionForm form,
              HttpServletRequest request, HttpServletResponse response)
              throws Exception {
          //这一句是输出调试信息，表示代码执行到这一段了
          log.debug(":: action - subject add");    
      
          //your code here

        //这里保存Token值
          saveToken(request);
         
         //跳转到add页面，在Structs-config.xml里面定义，例如，跳转到subjectAdd.jsp
          return mapping.findForward("add");
      }

2、在填写标题和内容后，选择 提交 ，会提交到insert方法，在insert方法里判断，是否重复提交了。
 public ActionForward insert(ActionMapping mapping, ActionForm form, 
 HttpServletRequest request, HttpServletResponse response){
 if (isTokenValid(request, true)) {
 // 表单不是重复提交
 //这里是保存数据的代码
 } else {
 //表单重复提交
 saveToken(request);
 //其它的处理代码
 }
 }

下面更详细一点（注意，下面所有的代码使用全角括号）：
 1、你想发贴时，点击“我要发贴”链接的代码可以里这样的：
 〈html:link action="subject.do?method=add"〉我要发贴〈/html:link〉
 subject.do 和 method 这些在struct-config.xml如何定义我就不说了，点击链接后，会执行subject.do的add方法，代码如上面说的，跳转到subjectAdd.jsp页面。页面的代码大概如下：
 〈html:form action="subjectForm.do?method=insert"〉
    〈html:text property="title" /〉
    〈html:textarea property="content" /〉
    〈html:submit property="发表" /〉
    〈html:reset property="重填" /〉
 〈html:form〉
 如果你在add方法里加了“saveToken(request);”这一句，那在subjectAdd.jsp生成的页面上，会多一个隐藏字段，类似于这样〈input type="hidden" name="org.apache.struts.taglib.html.TOKEN" value="6aa35341f25184fd996c4c918255c3ae"〉，

2、点击发表后，表单提交到subjectForm.do里的insert方法后，你在insert方法里要将表单的数据插入到数据库中，如果没有进行重复提交的控制，那么每点击一次浏览器的刷新按钮，都会在数据库中插入一条相同的记录，增加下面的代码，你就可以控制用户的重复提交了。
 if (isTokenValid(request, true)) {
 // 表单不是重复提交
 //这里是保存数据的代码
 } else {
 //表单重复提交
 saveToken(request);
 //其它的处理代码
 }
 注意，你必须在add方法里使用了saveToken(request)，你才能在insert里判断，否则，你每次保存操作都是重复提交。
 记住一点，Struts在你每次访问Action的时候，都会产生一个令牌，保存在你的Session里面，如果你在Action里的函数里面，使用了saveToken(request);，那么这个令牌也会保存在这个Action所Forward到的jsp所生成的静态页面里。
 如果你在你Action的方法里使用了isTokenValid，那么Struts会将你从你的request里面去获取这个令牌值，然后和Session里的令牌值做比较，如果两者相等，就不是重复提交，如果不相等，就是重复提交了。

由于我们项目的所有Action都是继承自BaseDispatchAction这个类，所以我们基本上都是在这个类里面做了表单重复提交的控制，默认是控制add方法和insert方法，如果需要控制其它的方法，就自己手动写上面这些代码，否则是不需要手写的，控制的代码如下：
 public abstract class BaseDispatchAction extends BaseAction {
 protected ActionForward perform(ActionMapping mapping, ActionForm form,
      HttpServletRequest request, HttpServletResponse response)
      throws Exception {
          String parameter = mapping.getParameter();
          String name = request.getParameter(parameter);
 if (null == name) { //如果没有指定 method ，则默认为 list
              name = "list";
          }

         if ("add".equals(name)) {
              if ("add".equals(name)) {
                  saveToken(request);
              }
          } else if ("insert".equals(name)) {
              if (!isTokenValid(request, true)) {
                  resetToken(request);
                  saveError(request, new ActionMessage("error.repeatSubmit"));
                  log.error("重复提交！");
                  return mapping.findForward("error");
              }
          }
          return dispatchMethod2(mapping, form, request, response, name);
      }
 }

kxbin 2011-12-02 09:32 发表评论

使用连接池连接MySQL

kxbin — Mon, 05 Jul 2010 08:15:00 GMT

TomCat6.0数据库连接池配置有几种方式，在这里我只介绍其中的一种供大家参考：
下面我把配置过程分成三个步骤来完成：
第一步：在你安装TomCat的目录下找到context.xml配置文件。（例如：D:\Tomcat 6.0\conf\context.xml）然后打开context.xml，在标签之间加入以下内容：(为了大家容易理解，我加了较详细的注释)
name="jdbc/course" //数据源名称（自定义）到时候要用到的，所以最好起
//个有含义的名字，例如我这个数据源名字，jdbc表示与//数据库连接有关的，而course是我这个项目的名字。
auth="Container" //这个默认就好了
type="javax.sql.DataSource" //这个也默认就好了
              driverClassName="com.mysql.jdbc.Driver"//这里用到的是mysql数据库的驱动包。
              url="jdbc:mysql://localhost/course" //这里是连接到mysql数据库的url，其中url="jdbc:mysql://localhost/"是固定的，而course是我这个 //项目的数据库名称，所以这里改为你们的数据库名称就好了。
              username="root"//登陆数据库的用户名
     password="birchhua" //登陆数据库的密码
     maxIdle="5"//这个也默认就好了
              maxWait="5000"//这个也默认就好了
              maxActive="10"/>//这个也默认就好了

第二步：在你的项目WEB-INF目录下找到web.xml配置文件，然后打开，在标签之间加入以下内容：

DB Connection

jdbc/course

javax.sql.DataSource

Container

其中：DB Connection 是自定义的，而jdbc/course是对应上面标签中的name属性的值，还有 javax.sql.DataSource就对应type属性的值，而最后Container对应的是auth属性的值。

第三步：上网下载一个叫mysql-connector-java-3.1.10-bin.jar的jar包，然后将该jar包放到TomCat 安装目录下的lib文件夹里。（例如：D:\Tomcat 6.0\lib\mysql-connector-java-3.1.10-bin.jar）完成这三步就配置好了TomCat数据源了。

<%@ page contentType="text/html; charset=gb2312" %>
<%@ page import="javax.naming.Context" %>
<%@ page import="javax.sql.DataSource"%>
<%@ page import="javax.naming.InitialContext"%>
<%@ page import="java.sql.*"%>

<%
       DataSource ds = null;
       try{
          Context initCtx = new InitialContext();
          Context envCtx = (Context) initCtx.lookup("java:comp/env/");
         //从Context中lookup数据源。
          ds = (DataSource)envCtx.lookup("jdbc/kxbin");
          if(ds!=null){
            out.println("已经获得DataSource!");
            out.println("
");
            Connection conn = ds.getConnection();
            PreparedStatement pstmt = conn.prepareStatement("select * from student");
            ResultSet rs = pstmt.executeQuery();
            while(rs.next()){
                out.println(rs.getString("id"));
                out.println(rs.getString("stuName"));
                out.println(rs.getString("password"));
                out.println("
");
            }
           }
        }catch(Exception ne){
           out.println("出现如下错误：
");
           out.println(ne);
       }

%>

kxbin 2010-07-05 16:15 发表评论

JAVA 编码不可不注意的规范

kxbin — Sat, 20 Feb 2010 05:45:00 GMT

一、规范存在的意义

应用编码规范对于软件本身和软件开发人员而言尤为重要，有以下几个原因：

1、好的编码规范可以尽可能的减少一个软件的维护成本 , 并且几乎没有任何一个软件，在其整个生命周期中，均由最初的开发人员来维护；

2、好的编码规范可以改善软件的可读性，可以让开发人员尽快而彻底地理解新的代码；

3、好的编码规范可以最大限度的提高团队开发的合作效率；

4、长期的规范性编码还可以让开发人员养成好的编码习惯，甚至锻炼出更加严谨的思维；

二、命名规范

1、一般概念

1、尽量使用完整的英文描述符

2、采用适用于相关领域的术语

3、采用大小写混合使名字可读

4、尽量少用缩写，但如果用了，必须符合整个工程中的统一定义

5、避免使用长的名字（小于 15 个字母为正常选择）

6、避免使用类似的名字，或者仅仅是大小写不同的名字

7、避免使用下划线（除静态常量等）

2、标识符类型说明

1、包（ Package ）的命名

Package 的名字应该采用完整的英文描述符，都是由一个小写单词组成。并且包名的前缀总是一个顶级域名，

通常是 com、edu、gov、mil、net、org 等；
如： com.yjhmily.test

2、类（ Class ）的命名

类名应该是个一名词，采用大小写混合的方式，每个单词的首字母大写。尽量保证类名简洁而富于描述。

使用完整单词，避免缩写词 ( 除非工程内有统一缩写规范或该缩写词被更广泛使用，像 URL ， HTML)

如： FileDescription

3、接口（ Interface ）的命名

基本与 Class 的命名规范类似。在满足 Classd 命名规则的基础之上，保证开头第一个字母为 ”I”，

便于与普通的 Class区别开。其实现类名称取接口名的第二个字母到最后，且满足类名的命名规范；

如： IMenuEngine

4、枚举（ Enum ）的命名

基本与 Class 的命名规范类似。在满足 Classd 命名规则的基础之上，保证开头第一个字母为 ”E” ，

便于与普通的 Class区别开。
如： EUserRole

5、异常（ Exception ）的命名

异常（ Exception ）通常采用字母 e 表示异常，对于自定义的异常类，其后缀必须为 Exception

如： BusinessException

6、方法（ Method ）的命名

方法名是一个动词，采用大小写混合的方式，第一个单词的首字母小写，其后单词的首字母大写。

方法名尽可能的描述出该方法的动作行为。返回类型为 Boolean 值的方法一般由“ is ”或“ has ”来开头

如： getCurrentUser() 、 addUser() 、 hasAuthority()

7、参数（ Param ）的命名

第一个单词的首字母小写，其后单词的首字母大写。参数量名不允许以下划线或美元符号开头，

虽然这在语法上是允许的。参数名应简短且富于描述。

如： public UserContext getLoginUser(String loginName);

8、常量字段（ Constants ）的命名

静态常量字段（ static final ）全部采用大写字母，单词之间用下划线分隔；

如： public static final Long FEEDBACK;
public static Long USER_STATUS;

三、注释规范

一个很好的可遵循的有关注释的经验法则是：

问问你自己，你如果从未见过这段代码，要在合理的时间内有效地明白这段代码，你需要一些什么信息？？？

1、一般概念

1、注释应该增加代码的清晰度

2、保持注释的简洁

3、在写代码之前或同时写注释

4、注释出为什么做了一些事，而不仅仅是做了什么

2、注释哪些部分

1、Java 文件：必须写明版权信息以及该文件的创建时间和作者；

2、类：类的目的、即类所完成的功能，以及该类创建的时间和作者名称；多人一次编辑或修改同一个类时，

应在作者名称处出现多人的名称；

3、接口：在满足类注释的基础之上，接口注释应该包含设置接口的目的、它应如何被使用以及如何不被使用。

在接口注释清楚的前提下对应的实现类可以不加注释；

4、方法注释：对于设置 (Set 方法 ) 与获取 (Get 方法 ) 成员的方法，在成员变量已有说明的情况下，

可以不加注释；普通成员方法要求说明完成什么功能，参数含义是什么且返回值什么；另外方法的创建

时间必须注释清楚，为将来的维护和阅读提供宝贵线索；

5、方法内部注释：控制结构，代码做了些什么以及为什么这样做，处理顺序等，特别是复杂的逻辑处理部分，

要尽可能的给出详细的注释；

6、参数：参数含义、及其它任何约束或前提条件；

7、属性：字段描述；

8、局部 ( 中间 ) 变量：无特别意义的情况下不加注释；

3、注释格式

遵循工程规定的统一注释格式，一般情况下会以 codetemplates.xml 格式的文件导入 IDE(Eclipse)

或者用Eclipse默认的；

四、代码格式规范

遵循工程规定的统一代码格式，一般情况下直接使用 IDE(Eclipse) 自带的默认代码格式对代码进行格式化；

五、其他规范

JSP 文件命名

采用完整的英文描述说明 JSP 所完成的功能，尽可能包括一个生动的动词，第一个字母小写，

如： viewMessage.jsp 、editUser.jsp 等。

六、工程特有命名规范

1、持久层

1、 Hibernate 映射文件及实体

与数据库表名称完全对应；
如： Advertisement.hbm.xml 、 Advertisement.java

2、数据访问 DAO

DAO 接口和实现类名称必须完全符合正常接口和实现类的命名规则，且最后以 ”DAO” 结尾

DAO 内的数据访问方法必须足够抽象的描述出对数据库的基本 CRUD 操作；
如： ICrossAdDAO( 接口 ) 、 CrossAdDAO( 实现类 )

3、各种操作数据库的 HQL 配置文件

HQL 文件的个数原则上与系统的 Services 层的服务个数相等，且以服务名称命名 HQL 文件；

如： resource.hbm.xml

2、服务层

1、服务接口和实现

服务接口和实现类必须完全符合正常接口和实现类的命名规则；以工程定义的服务名为主体，

并统一以 ”Serv” 结尾
如： IResourceServ( 服务接口 ) 、 ResourceServ( 接口实现类 )

2、服务接口方法

方法名是一个动词，采用大小写混合的方式，第一个单词的首字母小写，其后单词的首字母大写。

方法名尽可能的描述出该方法的动作行为。

返回类型为 Boolean 值：用“ is ”或“ has ”来开头
得到某数据： get+ 数据描述名词复数 + 数据类型；
得到所有数据： get+All+ 数据描述名词复数 + 数据类型；
通过 XXX 得到 / 查询某数据： get/query+ 数据描述名词复数 + 数据类型 +By+ 条件；
添加某数据： save/add+ 数据描述名词 ()
更新某数据： save/update+ 数据描述名词；
删除某数据： delete/remove+ 数据描述名词；

3、业务对象

业务名称 +BO

4、查询参数对象

凡是继承 Abst***QuerySpec 的查询参数类全部满足以下规则：
Query+ 所要查询的数据描述名词 +Spec
作为参数传入时，参数名必须为：所要查询的数据描述名词 +Spec
如： QueryProgramSpec

3、MVC 层

1、Action 控制层

Action 类名：功能模块名称 +Action ；
Actoin 方法名称尽可能的描述出页面迁移的去向
如： LoginAction( 登录用 action) ， toWelcome( 转向欢迎页的 action 方法 )

2、资源文件

系统全局资源文件： globalMessages_+ 字符编码类型 +.properties
功能模块内部的资源文件： package.properties

4、Spring 配置文件

1、Action 相关配置文件
文件目录： WebRoot/WEB-INF/spring/action/ 功能模块名称 +_ApplicationContext.xml

2、Services 相关配置文件

文件目录： WebRoot/WEB-INF/spring/services/Services_ApplicationContext.xml

3、全局性配置文件

文件目录： WebRoot/WEB-INF/spring/工程名+_ApplicationContext.xml

5、JSP 文件

采用完整的英文描述说明 JSP 所完成的功能，尽可能包括一个生动的动词，第一个字母小写，
如： viewMessage.jsp 、editUser.jsp 等。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/lyjia2001/archive/2007/11/02/1863402.aspx

kxbin 2010-02-20 13:45 发表评论

EL表达式

kxbin — Sun, 11 Oct 2009 03:56:00 GMT

作用域

使用el的时候，默认会以一定顺序搜索四个作用域，将最先找到的变量值显示出来。

如果我们有${username}这样一个正则表达式，它回去依次调用pageContext.getAttribute("username") -> request.getAttribute("username") -> session.getAttribute("username") -> application.getAttribute("username")，只要找到某一个不为空的值就立刻返回。

这样的确方便我们的操作，但是随之也出现了另外一个问题，如果pageContext和request中有同名变量，但是我想取得request中的变量该如何是好呢？这就需要为el表达式引入作用域的概念了。

${pageScope.username}

${requestScope.username}

我们可以直接访问13-04这个应用，看看el表达式支持的所有对象。

下面我们分别对每个作用域对象进行讲解。

表 13.1. el中的作用域

el中的作用域	对应关系
pageContext(1)	当前页的pageContext对象
pageScope	把page作用域中的数据映射为一个map对象
requestScope(2)	把request作用域中的数据映射为一个map对象
sessionScope	把session作用域中的数据映射为一个map对象
applicationScope	把application作用域中的数据映射为一个map对象
param	对应request.getParameter()
paramValues(3)	对应request.getParameterValues()
header(4)	对应request.getHeader()
headerValues	对应request.getHeaderValues()
cookie(5)	对应request.getCookies()
initParam(6)	对应ServletContext.getInitParamter()

(1)	例子中的${pageContext.request.contextPath}返回的是request.getContextPath()的值，在此例中就是/13-04，我们经常使用这个来拼接jsp中的绝对路径。这里的${pageContext.request.contextPath}是一种特殊用法，不能使用${request.contextPath}的形式替代。
(2)	pageScope, requestScope, sessionScope, appliationScope都可以看作是Map型变量，调用其中的数据可以使用${pageScope.name} 或${pageScope["name"]}的形式，这两种写法是等价的。在某些情况下只能使用${pageScope["content-type"]}，这里不能写成${pageScope.content-type}，jsp无法解析连字符（-）会出现错误。
(3)	需要注意的是${paramValues.name}得到的是一个字符串数组，如果需要获得其中某个值，还需要使用${paramValues.name[0]}指定数组中的索引。这与下面的${headerValues.name}是相似的。
(4)	${header.name}会取得http请求中的header参数，现实工作中很少用到这里的数据。例子中使用Host是指请求访问的主机地址，包括ip和端口号。而Referer比较有趣，如果用户通过超链接跳转过来的，Referer会保存上次访问页面的地址，我们就可以通过它来统计哪些用户是从哪里转来的了。
(5)	${cookie.name}将获得对应cookie的对象，比如我们用jsp将一段cookie发送给客户端。 Cookie cookie = new Cookie("username", "Username in cookie"); response.addCookie(cookie); 创建一个名称为username，值为"Username in cookie"的Cookie对象，然后发送给客户端。然后我们就可以使用${cookie.username}获得这个cookie了，${cookie.username.name}获得cookie名称，${cookie.username.value}获得cookie值。
(6)	ServletContext.getInitParamter()指的应用的初始变量，这些变量都是定义在web.xml中的。 <context-param> <param-name>username</param-name> <param-value>username with context param</param-value> </context-param> ${initParam.username}就会得到这里的变量值。

以上都是死记硬背的东西，建议实际用到的时候翻看一下就好了，演示代码都放在13-04下，为了获得param和cookie还要点击一下最下边的连接才可以。

运算符

el表达式中支持java中所有的操作符，并且还有一些扩展，下面我们简要做一下对照。

表 13.2. 加减乘除四则运算

符号	说明
+	加
-	减
*	乘
/或div	除
%或mod	求余

表 13.3. 比较运算

符号	说明
==或eq	相等（equals）
!=或ne	不相等（not equals）
<或lt	小于（less than）
>或gt	大于（greater than）
<=或le	小于等于（less than or equals）
>=或ge	大于等于（greater than or equals）

表 13.4. 逻辑运算

符号	说明
&&或and	逻辑和
\|\|或or	逻辑或
!或not	取反

表 13.5. 特殊运算

符号	说明
empty	是否为null或空字符串
? :	三元运算符

下面上所有运算符的显示结果，顺便说一下如果想在jsp中显示${name}而不让jsp把它当作el计算出来，可以写成\${name}，这样最后显示的结果就是${name}了。

kxbin 2009-10-11 11:56 发表评论

getAttribute和getParameter的区别

kxbin — Sat, 10 Oct 2009 08:24:00 GMT

2009年10月10日
JSP中getParameter与getAttribute有何区别？

——getParameter得到的都是String类型的。或者是http://a.jsp?id=123中的123，或者是某个表单提交过去的数据。
——getAttribute则可以是对象。
——getParameter()是获取POST/GET传递的参数值；
——getAttribute()是获取对象容器中的数据值；
——getParameter：用于客户端重定向时，即点击了链接或提交按扭时传值用，即用于在用表单或url重定向传值时接收数据用。
——getAttribute：用于服务器端重定向时，即在sevlet中使用了forward函数,或struts中使用了mapping.findForward。getAttribute只能收到程序用setAttribute传过来的值。
——getParameter()是获取POST/GET传递的参数值；
——getAttribute()是获取SESSION的值；
另外，可以用setAttribute,getAttribute发送接收对象.而getParameter显然只能传字符串。
setAttribute 是应用服务器把这个对象放在该页面所对应的一块内存中去，当你的页面服务器重定向到另一个页面时，应用服务器会把这块内存拷贝另一个页面所对应的内存中。这样getAttribute就能取得你所设下的值，当然这种方法可以传对象。session也一样，只是对象在内存中的生命周期不一样而已。
getParameter只是应用服务器在分析你送上来的request页面的文本时，取得你设在表单或url重定向时的值。

getParameter 返回的是String, 用于读取提交的表单中的值;
getAttribute 返回的是Object，需进行转换,可用setAttribute设置成任意对象，使用很灵活，可随时用；

kxbin 2009-10-10 16:24 发表评论