\WEB-INF\lib文件夹加入包msbase.jar;mssqlserver.jar;msutil.jar;log4j-1.2.8.jar

放在WEB_INF\class文件夹下的log.properties文件的内容如下

#输出到F:/home/example.log
log4j.rootLogger=DEBUG, A1
log4j.appender.A1=org.apache.log4j.RollingFileAppender
log4j.appender.A1.File=F:/home/example.log
log4j.appender.A1.MaxBackeupIndex=1
log4j.appender.A1.MaxFileSize=1MB
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=[%-5p][%d]%n%m%n%n

#控制台输出
#log4j.logger.A2=, myAppender
#log4j.appender.A1=org.apache.log4j.ConsoleAppender
#log4j.appender.A1.layout=org.apache.log4j.PatternLayout
#log4j.appender.A1.layout.ConversionPattern= [%-5p][%d]%n%m%n%n

#写入数据库
#log4j.rootLogger=DEBUG, DATABASE
#log4j.appender.DATABASE=org.apache.log4j.jdbc.JDBCAppender//（root日志记录器的存储器）
#log4j.appender.DATABASE.URL=jdbc:microsoft:sqlserver://localhost:1433;SelectMethod=cursor
#log4j.appender.DATABASE.driver=com.microsoft.jdbc.sqlserver.SQLServerDriver
#log4j.appender.DATABASE.user=sd //用户名
#log4j.appender.DATABASE.password=
#log4j.appender.DATABASE.sql=Insert INTO LOG4J (Message) VALUES ('%d %c %p %m%n')//写入pubs数据库中的表LOG4J的Message字段中，内容％d（日期）%c: 日志信息所在地（类名）%p: 日志信息级别%m: 产生的日志具体信息 %n: 输出日志信息换行
#log4j.appender.DATABASE.layout=org.apache.log4j.PatternLayout
#log4j.appender.DATABASE.layout.ConversionPattern=%d %c %p %m%n

类文件中的使用方法

import org.apache.log4j.Logger;

import javax.sql.DataSource;
import javax.naming.Context;
import javax.naming.InitialContext;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Vector;

/**
* 封装DataSource
*
* @version 1.0, 2005-9-16 11:18:44
*/

public class DataSourcePackBean {
     /**
      * log4j
      */
     private Logger logger = Logger.getLogger(DataSourcePackBean.class);

//DataSourcePackBean.class日志记录器的名与类名相同；

     /**
      * 引用名
      */
     private String ref;

     /**
      * DataSource对象
      */
     private DataSource ds;

     /**
      * 保存当前DataSource对象中所有打开的Connection对象的引用。
      */
     private Vector openedConnections = new Vector();

     /**
      * 接收DataSource引用名，查找DataSource对象。
      *
      * @param ref DataSource引用名
      */
     protected DataSourcePackBean(String ref) {
         this.ref = ref;
         this.ds = lookup(ref);
     }

     public String getRef() {
         return ref;
     }

     public int getActive() {
         return openedConnections.size();
     }

     /**
      * 打开一个连接
      *
      * @param username 连接数据库的登录用户名，如果为null，表示用默认用户连接
      * @param password 连接数据库的登录密码
      * @return
      * @throws SQLException
      */
     public Connection getConnection(String username, String password) throws SQLException {
         Connection conn = (username == null) ? ds.getConnection() : ds.getConnection(username, password);
         // add to vector
         openedConnections.add(conn);
         // log
         StringBuffer log = new StringBuffer();
         log.append("Open").append(" a connection(").append(conn.hashCode()).append(") of [").append(ref).append("]\n");
         log.append(openedConnections.size()).append(" connection").append(" in use");
         logger.debug(log);
         // return
         return conn;
     }

     /**
      * 关闭一个连接
      *
      * @param conn
      * @throws SQLException
      */
     public void closeConnection(Connection conn) throws SQLException {
         conn.close();
         // remove from Vector
         openedConnections.remove(conn);
         // log
         StringBuffer log = new StringBuffer();
         log.append("Close").append(" a connection(").append(conn.hashCode()).append(") of [").append(ref).append("]\n");//添加内容到日志记录中
         log.append(openedConnections.size()).append(" connection").append(" in use");
         logger.debug(log);
     }

     /**
      * close all Connection of this DataSource
      * @throws SQLException
      */
     public void closeAll() throws SQLException {
         for (int i = 0; i < openedConnections.size(); i++) {
             ((Connection)openedConnections.get(i)).close();
         }
         // clear Vector
         openedConnections.removeAllElements();
     }

     /**
      * get a DataSource
      * @param ref the JNDI name of the DataSource
      * @return
      */
     private DataSource lookup(String ref) {
         DataSource dataSource = null;
         // 查找ref数据源对象
         try {
             Context env = new InitialContext();
             dataSource = (DataSource) env.lookup(ref);
             // 测试数据库有效性
             dataSource.getConnection().close();
             logger.debug(new StringBuffer().append("DataSource[").append(ref).append("] has been initialized successfully."));
         } catch (Exception e) {
             e.printStackTrace();
         }
         // return
         return dataSource;
     }

     public SQLRunnerIfc getSQLRunner(String username, String password) throws SQLException {
         return new SQLRunner(username, password, this);
     }

     public SQLRunnerIfc getSQLRunner() throws SQLException {
         return getSQLRunner(null, null);
     }
}

拦截器

名字

说明

Alias Interceptor

alias

在不同请求之间将请求参数在不同名字件转换，请求内容不变

Chaining Interceptor

chain

让前一个Action的属性可以被后一个Action访问，现在和chain类型的result（）结合使用。

Checkbox Interceptor

checkbox

添加了checkbox自动处理代码，将没有选中的checkbox的内容设定为false，而html默认情况下不提交没有选中的checkbox。

Cookies Interceptor

cookies

使用配置的name,value来是指cookies

Conversion Error Interceptor

conversionError

将错误从ActionContext中添加到Action的属性字段中。

Create Session Interceptor

createSession

自动的创建HttpSession，用来为需要使用到HttpSession的拦截器服务。

Debugging Interceptor

debugging

提供不同的调试用的页面来展现内部的数据状况。

Execute and Wait Interceptor

execAndWait

在后台执行Action，同时将用户带到一个中间的等待页面。

Exception Interceptor

exception

将异常定位到一个画面

File Upload Interceptor

fileUpload

提供文件上传功能

I18n Interceptor

i18n

记录用户选择的locale

Logger Interceptor

logger

输出Action的名字

Message Store Interceptor

store

存储或者访问实现ValidationAware接口的Action类出现的消息，错误，字段错误等。

Model Driven Interceptor

model-driven

如果一个类实现了ModelDriven，将getModel得到的结果放在Value Stack中。

Scoped Model Driven

scoped-model-driven

如果一个Action实现了ScopedModelDriven，则这个拦截器会从相应的Scope中取出model调用Action的setModel方法将其放入Action内部。

Parameters Interceptor

params

将请求中的参数设置到Action中去。

Prepare Interceptor

prepare

如果Acton实现了Preparable，则该拦截器调用Action类的prepare方法。

Scope Interceptor

scope

将Action状态存入session和application的简单方法。

Servlet Config Interceptor

servletConfig

提供访问HttpServletRequest和HttpServletResponse的方法，以Map的方式访问。

Static Parameters Interceptor

staticParams

从struts.xml文件中将中的 中的内容设置到对应的Action中。

Roles Interceptor

roles

确定用户是否具有JAAS指定的Role，否则不予执行。

Timer Interceptor

timer

输出Action执行的时间

Token Interceptor

token

通过Token来避免双击

Token Session Interceptor

tokenSession

和Token Interceptor一样，不过双击的时候把请求的数据存储在Session中

Validation Interceptor

validation

使用action-validation.xml文件中定义的内容校验提交的数据。

Workflow Interceptor

workflow

调用Action的validate方法，一旦有错误返回，重新定位到INPUT画面

Parameter Filter Interceptor

N/A

从参数列表中删除不必要的参数

Profiling Interceptor

profiling

通过参数激活profile

/**
 * @company MMGG.NET
 * @date Apr 29, 2008 5:49:47 PM
 */

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

/**
 * TokenProcessor类是一个单例类。
*/
public class TokenProcessor
{
    static final String TOKEN_KEY="net.mmgg";
  
    private static TokenProcessor instance = new TokenProcessor();

    /**
     * getInstance()方法得到单例类的实例。
     */
    public static TokenProcessor getInstance()
    {
        return instance;
    }

    /**
     * 最近一次生成令牌值的时间戳。
     */
    private long previous;

    /**
     * 判断请求参数中的令牌值是否有效。
     */
    public synchronized boolean isTokenValid(HttpServletRequest request)
    {
        //得到请求的当前Session对象。
        HttpSession session = request.getSession(false);
        if (session == null)
        {
            return false;
        }
       
        //从Session中取出保存的令牌值。
        String saved = (String) session.getAttribute(TOKEN_KEY);
        if (saved == null) {
            return false;
        }
       
        //清除Session中的令牌值。
        resetToken(request);
       
       
        //得到请求参数中的令牌值。
        String token = request.getParameter(TOKEN_KEY);
        if (token == null) {
            return false;
        }
       
        return saved.equals(token);
    }

    /**
     * 清除Session中的令牌值。
     */
    public synchronized void resetToken(HttpServletRequest request)
    {

        HttpSession session = request.getSession(false);
        if (session == null) {
            return;
        }
        session.removeAttribute(TOKEN_KEY);
    }

    /**
     * 产生一个新的令牌值，保存到Session中，
     * 如果当前Session不存在，则创建一个新的Session。
     */
    public synchronized void saveToken(HttpServletRequest request)
    {

        HttpSession session = request.getSession();
        String token = generateToken(request);
        if (token != null) {
            session.setAttribute(TOKEN_KEY, token);
        }

    }

    /**
     * 根据用户会话ID和当前的系统时间生成一个唯一的令牌。
     */
    public synchronized String generateToken(HttpServletRequest request)
    {

        HttpSession session = request.getSession();
        try
        {
            byte id[] = session.getId().getBytes();
            long current = System.currentTimeMillis();
            if (current == previous)
            {
                current++;
            }
            previous = current;
            byte now[] = new Long(current).toString().getBytes();
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(id);
            md.update(now);
            return toHex(md.digest());
        }
        catch (NoSuchAlgorithmException e)
        {
            return null;
        }
    }

    /**
     * 将一个字节数组转换为一个十六进制数字的字符串。
     */
    private String toHex(byte buffer[])
    {
        StringBuffer sb = new StringBuffer(buffer.length * 2);
        for (int i = 0; i < buffer.length; i++)
        {
            sb.append(Character.forDigit((buffer[i] & 0xf0) >> 4, 16));
            sb.append(Character.forDigit(buffer[i] & 0x0f, 16));
        }
        return sb.toString();
    }
   
    /**
     * 从Session中得到令牌值，如果Session中没有保存令牌值，则生成一个新的令牌值。
     */
    public synchronized String getToken(HttpServletRequest request)
    {
        HttpSession session = request.getSession(false);
        if(null==session)
            return null;
        String token=(String)session.getAttribute(TOKEN_KEY);
        if(null==token)
        {
           token = generateToken(request);
            if (token != null)
            {
                session.setAttribute(TOKEN_KEY, token);
                return token;
            }
            else
                return null;
        }
        else
            return token;
    }
}

serialVersionUID作用：
序列化时为了保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。

你可以随便写一个，在Eclipse中它替你生成一个，有两种生成方式：
一个是默认的1L，比如：private static final long serialVersionUID = 1L;
一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如：private static final long serialVersionUID = -8940196742313994740L;之类的。

当你一个类实现了Serializable接口，如果没有定义serialVersionUID，Eclipse会提供这个提示功能告诉你去定义之。
在Eclipse中点击类中warning的图标一下，Eclipse就会自动给定两种生成的方式，如上面所述。如果不想定义它，在Eclipse的设置中也可以把它关掉的，设置如下：
Window ==> Preferences ==> Java ==> Compiler ==> Error/Warnings ==> Potential programming problems
将Serializable class without serialVersionUID的warning改成ignore即可。

如果你没有考虑到兼容性问题时，就把它关掉，不过有这个功能是好的，只要任何类别实现了Serializable这个接口的话，如果没有加入serialVersionUID，Eclipse都会给你warning提示，这个serialVersionUID为了让该类别Serializable向后兼容。

如果你的类Serialized存到硬盘上面后，可是后来你却更改了类别的field(增加或减少或改名)，当你Deserialize时，就会出现Exception的，这样就会造成不兼容性的问题。

但当serialVersionUID相同时，它就会将不一样的field以type的预设值Deserialize，这个可以避开不兼容性的问题。