使用如下命令可以建立一个Struts2 Starter应用程序

mvn archetype:create 

-DgroupId=tutorial

    -DartifactId=tutorial

    -DarchetypeGroupId=org.apache.struts \

    -DarchetypeArtifactId=struts2-archetype-starter \

    -DarchetypeVersion=2.0.5-SNAPSHOT

-DremoteRepositories=http://people.apache.org/repo/m2-snapshot-repository

参数含义：

一些相关的Maven命令（注意要再项目目录中运行）

构建

mvn install

创建IntelliJ IDEA项目文件

mvn idea:idea

创建Eclipse项目文件

  mvn eclipse:eclipse

运行测试

mvn test

清除

mvn clean

打包

mvn package

获得需要的JAR文件

mvn initialize

使用Jetty运行

1.  从http://maven.apache.org 下载最新的maven压缩文件，在windows操作系统下通常下载zip文件，使用解压缩工具将文件解压缩到某个目录（以下称为Maven安装目录）。

例如：E:\struts2\maven-2.0.7，这个目录的文件结构为：

E:\struts2\maven-2.0.7

bin\

boot\

conf\

lib\

LICENSE.TXT

NOTICE.TXT

README.TXT

2.  设置环境变量MVN_HOME使其指向Maven安装目录

3.  将%MVN_HOME%\bin添加到系统环境变量Path中

4.  开始 > 运行中输入cmd 点击ok

5.  在弹出的命令行窗口中输入mvn –v 看到如下信息说明mvn安装成功

E:\>mvn -v

Maven version: 2.0.7

Java version: 1.6.0_01

OS name: "windows xp" version: "5.1" arch: "x86"

Maven将不同项目依赖的jar文件做了统一管理，这些jar文件都放在一个叫资源库的目录，这个目录通常情况下是用户HOME目录下的/.m2/repository目录，可以通过修改conf目录下的settings.xml文件中的<localRepository>段来自定义资源库的位置，例如：

<settings>

  <localRepository>C:/struts2/maven-2.0.7/repository</localRepository>

  …

</settings>

上述内容把maven的资源库定位到了目录C:/struts2/maven-2.0.7/repository

另外，使用代理服务器上网的PC机还可以修改settings.xml文件中的<proxies>段来利用代理服务器，例如：

<proxies>

    <proxy>

      <id>optional</id>

      <active>true</active>

      <protocol>http</protocol>

      <username>proxyuser</username>

      <password>proxypass</password>

      <host>proxy.jpleasure.com</host>

      <port>808</port>

      <nonProxyHosts>local.net,some.host.com</nonProxyHosts>

    </proxy>

         在Web项目中，离线并发显得尤其严重。例如，用户A和用户B同时修改数据库中的某张表的R行，加入R行有两个字段分别是C1，C2。

         假如按照如下过程修改：

         1 用户A将数据R（C1,C2）读取到A的浏览器中。

         2 用户B将数据R（C1,C2）读取到B的浏览器中。

         3 用户A在浏览器上将数据修改为R（C1’，C2），同时更新到数据库。

         4 用户B在浏览器上将数据修改为R（C1，C2’），同时更新到数据库。

         上述过程存在两个问题，第一，第4步B在修改数据的时候数据库中的数据和B的浏览器中数据已经不一致了；第二，如果程序按照哪个字段变化在数据库中更新哪个字段的方式处理的话，那么经过上述四步修改，数据库中R行的内容是（C1’,C2’），这和A或者B的想法都不同（A认为是（C1’，C2），B认为是（C1，C2’））。

         上述过程中A对数据库的修改过程或者B对数据库的修改过程，都是无法根据数据库的最新内容做修改，所以成为离线。A和B同时对记录R进行就该叫离线。

         以上的环境叫离线并发。

         那么如何解决离线并发过程中遇到的问题呢？我们引入锁机制。

锁机制

         锁机制，就是在需要修改的数据上加互斥锁，通过互斥锁避免数据被同时修改。锁机制更具其应用环境又分为乐观锁和悲观锁

         乐观锁

乐观锁，指认为冲突很少发生，所以只是在数据修改的时候比较修改的基础数据和数据库中的数据是否相同，相同则修改，否则提示用户重新装入数据库中已经变化的数据。

实现方法1：在进行update的时候使用where条件，在Where标间中比较所有上一步中查询得到的数据。如果数据库中的数据没有变化，则update可以更新到内容，否则update语句不能更新到内容，可以根据update的返回值确定更新是否成功。

实现方法2：在每一个表中追加一个特殊字段，类型为timestamp，每次更新的时候比较这个字段的值是否一致，如果一致，则更新，同时将这个字段更新为当前时间，否则，说明数据已经变更。这也可以使用update加上where实现。

         悲观锁

悲观锁指，需要修改的数据，在读取的时候就对数据加锁，其他用户在准备修改，读取数据的阶段判断数据是否上锁，以此来决定是否进行修改前的读操作。

                  实现方法：

                   通常在数据库中建立一张lock表，该表的字段包括，表明，唯一索引，时间，用户信息等。

在用户读取数据准备修改的时候，首先判断lock表中是否存在自己将要读取的数据。

如果不存在，则在lock表中添加一条记录，记录对那张表的哪行数据进行修改；如果存在，在判断时间字段是否超时。

如果超时，则更新lock表中本条记录的时间字段。（防止死锁的必要手段）

如果存在，也不超时，说明本条记录正在被其他用户修改，则返回并发信息。

Java中的两类异常

Java中的异常分为两种类型运行时的异常（RuntimeException）和检查异常（Checked Exception）。

运行时的异常（RuntimeException）可以在程序运行的时候动态的抛出，但是不需要在方法接口中声明要跑出的运行时异常，也不需要在方 法调用的时候做try-catch处理。系统的运行时异常是指java.lang.RuntimeExceptioin或者他的子类型。 RuntimeException在逻辑上的含义是：

检查异常（Checked Exception）必须要在方法的接口中声明，并且在使用方法的时候，其抛出的Checked Exception必须使用try-catch处理，检查异常指的是java.lang.Exception或者他的子类型。

注意：有一点需要指出，java.lang.RuntimeException是java.lang.Exception的子类型。所以上述中说的 检查异常（Checked Exception）指的是java.lang.Exception和其他的非java.lang.RuntimeException子类的子类型。

如下代码展示了RuntimeException的使用：

package com.jpleasure.exception;

/**
 * System Exception
 * @author mazhao@dl.cn
 *
 */
public class SystemException extends RuntimeException {

 public SystemException() {
 }

 public SystemException(String message) {
  super(message);
 }

 public SystemException(Throwable cause) {
  super(cause);
 }

 public SystemException(String message, Throwable cause) {
  super(message, cause);
 }
}

以下代码可以编译通过，运行的时候抛出异常：

package com.jpleasure.exception;

public class Main {
 public static void main(String ... args ) {
  testRuntimeException();
  
 }
 
 public static void testRuntimeException() {
  
  methodThrowsRuntimeException();
  
 }
 
 private static void methodThrowsRuntimeException() {
  if(true) {
   throw new SystemException("Hello World!");
  }
 }
}

运行的时候输出内容为：

 Exception in thread "main" com.jpleasure.exception.SystemException: Hello World!
 at com.jpleasure.exception.Main.methodThrowsRuntimeException(Main.java:17)
 at com.jpleasure.exception.Main.testRuntimeException(Main.java:11)
 at com.jpleasure.exception.Main.main(Main.java:5)

以下代码展示了Exception的使用：

 package com.jpleasure.exception;

/**
 * Application Exception
 * @author mazhao@dl.cn
 *
 */
public class ApplicationException extends Exception {

 public ApplicationException() {
  // TODO Auto-generated constructor stub
 }

 public ApplicationException(String message) {
  super(message);
  // TODO Auto-generated constructor stub
 }

 public ApplicationException(Throwable cause) {
  super(cause);
  // TODO Auto-generated constructor stub
 }

 public ApplicationException(String message, Throwable cause) {
  super(message, cause);
  // TODO Auto-generated constructor stub
 }

}

异常使用代码：

package com.jpleasure.exception;

public class Main2 {

 /**
  * @param args
  */
 public static void main(String[] args) {
  

 }
 
 public static void testCheckedException() {
  
  try {
   methodThrowsCheckedException();
  } catch (ApplicationException e) {
   // 异常处理代码
  }
  
 }
 
 private static void methodThrowsCheckedException() throws ApplicationException {
  if(true) {
   throw new ApplicationException("Hello World!");
  }
 }

}

由于ApplicationException是Checked Exception，所以在方法的接口中必须加以声明，并且在使用的时候必须包括在try-catch代码块中。

应用程序开发中的异常

如上述代码中说明的那样处于使用方便我们总是将系统异常设置为RuntimeException的子类，在统一的地方处理。

为什么要将系统异常设置为Runtime的呢？

try-catch块主要是为了在异常发生的时候有可以挽救的方式，所以会在try部分异常发生的时候进入catch部分，但是系统异常（例如数据 库无法链接，配置文件不存在等）一旦发生基本上没有挽救的办法，所以将系统异常声明为RuntimeException的子类。

另外，系统异常是一种很少会发生的异常，所以在开发中基本不需要考虑，所以将系统异常生命为RuntimeException的子类，这样在开发的时候基本不需要考虑系统异常发生的情况，只需要统一的做错误处理即可。

应用程序异常通常设置为Checked Exception。需要在使用的地方逐个处理。

异常消息定义

异常消息通常不会在构造异常的时候传入，通常情况下在构造异常的时候传入的是异常消息的编号。

编号一般包含的内容有：系统ID，子系统ID，消息类型，流水号等。系统ID，子系统ID，流水号等都比较好理解，那么消息类型是什么呢？我们的消 息常见的有以下一些类型：提示性的，警告性的，错误性的。所以我们可以分别以C（Confirm），W（Warnning），E（Error）来区分消息 的类型

消息一般存储在属性文件（Properties）中使用ResourceBundle类或者Properties类来获取。当使用到多国语言的错误消息的时候需要使用ResourceBundle类。

有些时候也可以存储在代码中，这个时候需要使用到ListResourceBundle类。

异常发生时的操作

第一就是要记录错误日志，需要将类，方法，操作数据，异常类型，异常内容的信息记录下来，便于系统维护人员分析问题数据。

第二及时要抛出错误信息，反馈给系统用户，让客户知道系统无法处理他的当前操作。如果有必要还需要提示客户可能的错误情况，希望用户改善。

如何获得异常的详细信息

从异常中可以获得详细的抛出信息，例如都那些代码涉及到这个异常，分别在那些类的那些方法中，代码行数是多少，代码文件名字是什么等。

例如类LoginLogic调用了LoginDao，而Main调用了LoginLogic，代码为：

package com.jpleasure.exception;

/**
 * Created by IntelliJ IDEA.
 * User: ma.zhao@dl.cn
 * Date: 2007-9-3
 * Time: 22:55:47
 * To change this template use File | Settings | File Templates.
 */
public class LoginDao {
    public void testLogin() throws SystemException {
        if(true) {
            throw new SystemException("System Exception Occurs!");
        }
    }
}

package com.jpleasure.exception;

import java.util.Random;

/**
 * Created by IntelliJ IDEA.
 * User: ma.zhao@dl.cn
 * Date: 2007-9-3
 * Time: 22:56:30
 * To change this template use File | Settings | File Templates.
 */
public class LoginLogic {
    private LoginDao dao = new LoginDao();

    public void testLogin() throws ApplicationException {

        Random randam = new Random(System.currentTimeMillis());
        int randamInt = randam.nextInt();

        if (randamInt % 2 == 0) {
            dao.testLogin();
        } else {
            throw new ApplicationException("Application Exception Occurs!");
        }
    }
}

异常处理代码：

package com.jpleasure.exception;

/**
 * Created by IntelliJ IDEA.
 * User: ma.zhao@dl.cn
 * Date: 2007-9-3
 * Time: 22:57:38
 * To change this template use File | Settings | File Templates.
 */
public class Main {
    public static void main(String[] args) {

        LoginLogic logic = new LoginLogic();

        try {
            logic.testLogin();
        } catch (ApplicationException e) {
            printException(e);
        } catch (SystemException e) {
            printException(e);
        }

    }

    private static void printException(Exception e) {
        String msg = e.getMessage();
        System.out.println("exception message:" + msg);
        StackTraceElement[] stes = e.getStackTrace();
        for (int i = 0; i < stes.length; i++) {
            printStackTraceElement(stes[i]);
        }
    }

    
    private static void printStackTraceElement(StackTraceElement ste) {
        String fileName = ste.getFileName();
        String className = ste.getClassName();
        String methodName = ste.getMethodName();
        int line = ste.getLineNumber();
        System.out.println("file:" + fileName + "\t class:" + className + "\t method:" + methodName + "\t line:" + line);
        System.out.println("");
    }
}

public class AbstractSqlManager {

     private Map sqlMap ;

     public AbstractSqlManager(String filePath) {

         sqlMap = initSqlMap(filePath)

     }

     public String getSql(String key) {

         return (String)sqlMap.get(key);

     } 

     public abstract Map initSqlMap(String filePath);

} 

public class XmlSqlManager extends AbstractSqlMamager {

     public Map initSqlMap(String filePath) {

         // 解析XML文件将SQL语句，以SQL语句的名字为Key，放在sqlMap中。

      }

}

public class PropertiesSqlManager extends AbstractSqlMamager {

     public Map initSqlMap(String filePath) {

         // 解析Properties文件将SQL语句，以SQL语句的名字为Key，放在sqlMap中。

      }

}

public class TextSqlManager extends AbstractSqlMamager {

     public Map initSqlMap(String filePath) {

         // 解析Text文件将SQL语句，以SQL语句的名字为Key，放在sqlMap中。

      }

}

参看上述的代码，在AbstractSqlManager 中，因为可能处理的文件的内容不同，所以将解析不同代码的方法实现放在了具体的类（XmlSqlManager ，PropertiesSqlManager 和TextSqlManager ）中，只在AbstractSqlManager中实现了getSql方法。

我们在来考虑三个具体的实现类，在这些类实现的时候，需要从AbstractSqlManager集成，所以必须实现initSqlMap这个方法，并且必须按照AbstractSqlManager中定义的格式（模板）来实现。

这样可以称initSqlMap为模板方法，也可以称上述的设计为模板方法。

模板方法设计的好处有那些呢？

第一，也是继承的好处，可以重用代码

     如上述的例子，使用了模板方法之后，可以将公共的方法和流程在基类中编写，这样可以重用这些代码。（关于继承和组合重用代码的问题参看另外的相关讨论）

第二，可以灵活的对应变更

     因为使用了模板方法，所以相同的操作可以在基类中 完成，具体的不同实现可以在具体类中完成。所以首先有了变更修改的范围很容易确定，如果是通用的操作则需要在基类中完成，例如initSqlMap之前需 要使用日志记录文件的信息。如果是特殊的操作则需要在具体类中完成，例如XML文件格式发生了变更。

第三，规范处理流程（例如有三个模板方法）

     使用模板方法可以规范处理流程，例如要对输入的数进行相关的操作，我们可以定义这样的几个过程，（1）数据格式校验（2）数据逻辑校验（3）预处理（4）处理（5）处理输出值（6）结束

     我们可以定义这样子一个基类，包含需要的模板方法：

public class BaseTarget{

     public void execute(InputVO vo) throw ExecuteException {

         try {

                 formatCheck(vo);

                 logicCheck(vo);

                 preProcess(vo);

                 OutputVO out = process(vo);

                 formatCheck(out);

         } catch(FormatException ex) {

             // 异常处理

         } catch(LogicException ex) {

             // 异常处理 

         } catch(PreProcessExceptionex) {

              // 异常处理

         } catch(ProcessExceptionex) {

              // 异常处理

         } catch(PostProcessExceptionex) {

              // 异常处理

         } 

     }

     public abstract void formatCheck(InputVO vo) throw FormatException ;

     public abstract void logicCheck(InputVO vo) throw LogicException ;

     public abstract void preProcess(InputVO vo) throw PreProcessException;

     public abstract OutputVO process(InputVO vo) throw ProcessException;

     public abstract void postProcess(OutputVO vo) throw PostProcessException;

}

通过上述基类的定义，我们规定了子类型的处理内容（五个需要实现的抽象方法）和处理的顺序（按照execute方法定义的处理顺序执行）。

翻译：

     在软件工程领域，Singleton是一种将对象的实例限制为只有一个的一种模式。当系统的所有处理只需要某个对象的一个实例的时候可以适用这种模式。通常情况下，实例存在的越少（最好是一个）系统的性能越好。针对于Singleton的反模式是使用全局变量。

在wikipedia上Java的标准实现是：

public class Singleton
{
  // 通过私有化构造方法，防止在Singleton类之外构造类的实例。
  private Singleton() {}
 
  /**
   * SingletonHolder 在Singleton.getInstance()第一次调用的时候被初始化。
   */
  private static class SingletonHolder
  {
    private final static Singleton INSTANCE = new Singleton();
  }
 
  public static Singleton getInstance()
  {
    return SingletonHolder.INSTANCE;
  }
}

或者更常见的是：

public class Singleton {
   private final static Singleton INSTANCE = new Singleton();
 
   // 通过私有化构造方法，防止在Singleton类之外构造类的实例。
   private Singleton() {}
 
   public static Singleton getInstance() {
     return INSTANCE;
   }
 }

关于Singleton的说明

第一，必须保证在类的外部不能调用构造方法。

    在默认无构造方法的情况下，Java编译器会给类加上一个没有参数的共有的 （Public）构造方法（默认构造方法），有构造方法的情况下Java编译器保留定义的构造方法。所以在使用Singleton的时候，如果有构造参数 则需要将访问修饰符改为private的，没有构造参数的情况下，需要添加一个私有的默认构造方法。私有的默认构造方法参看上述代码。

   private Singleton() {}

第二，必须有一个类的实例

     为了避免在累得外面实例化类，所以在第一步中将构造参数设置为了私有，所以只能在类的内部实例化，参看上述代码。

   private final static Singleton INSTANCE = new Singleton();

第三，在类的外部必须能够访问到第二步中创建的实例。

     由于类不能被实例化，所以获取类内部的实例的方法必须为静态的。参看代码：

    public static Singleton getInstance() {
         return INSTANCE;
    }
    这个时候也明白了第二步中，INSTANCE实例为什么是static的了，final只是为了强调INSTANCE被初始化之后即不可改变，更见强调了singleton的含义。

关于Singleton的一些变化

如果一个Singleton类需要初始话怎么办呢？有两个方法

第一种方法，添加静态代码段

public class Singleton {
     private final static Singleton INSTANCE = new Singleton();
 

     static{

         // 在这里初始化Singleton的实例INSTANCE

     }

     // 通过私有化构造方法，防止在Singleton类之外构造类的实例。
     private Singleton() {}
 
     public static Singleton getInstance() {
       return INSTANCE;
     }
 }

第二种方法，在getInstance的时候初始化

public class Singleton {
   private static Singleton INSTANCE;
 
   // 通过私有化构造方法，防止在Singleton类之外构造类的实例。
   private Singleton() {}
 
   public static Singleton getInstance() {
        if(INSTANCE == null) {

             INSTANCE = new Singleton();

             //初始化代码

        }

     return INSTANCE;
   }
 }

另种方法采用的原则是，如果肯定会使用到这个实例，可以采用第一种方法；如果可能使用到这个实例，可以使用第二种方法。

Singleton初始化异常处理

 Singleton实例初始化的时候可能会出现一些异常，通常情况下可以不考虑，如果使用上述 的第一种方法，实例化时发生在代码装载的时候，除了日志不可能给用户反馈。如果使用第二种方法，可以在用户调用的时候处理，可以在getInstance 方法接口添加抛出异常便于用户处理。

所以如果Singleton初始化会抛出异常，且此类异常需要客户处理的时候需要使用上述的第二种方法。

《Introduction to Springframwork》

http://www.theserverside.com/tt/articles/article.tss?l=SpringFramework

Sringframework总最著名的特性要数控制反转（Inversion of Control），也叫依赖注入（Dependency Injection），详细参看Martin Flower的文章：

《Inversion of Control Containers and the Dependency Injection pattern》

http://martinfowler.com/articles/injection.html

Ioc的来源

时代的变迁：

New → 基于接口的编程 → 工厂方法 → Ioc

我们先看一个代码关系，例如：

TopLogic需要一个SecondLogic完成一定的业务。

SecondLogic需要TopDAO来完成数据库访问。

那么一定会有这样的代码：

public class TopLogic{

    private SecondLogic logic ;

    public TopLogic() {

       logic = new SecondLogic();

       //以下为初始化方法调用

       logic.XXX

       ...

    }  

    public topMethod() {

       loggic.someMethod();

    }

}

public class SecondLogic{

    private TopDAO dao ;

    public SecondLogic() {

       dao = new TopDAO();

       //以下为初始化方法调用

       dao.XXX

       ...

    }  

}

public class TopLogic{

    private SecondLogic logic ;

    public TopLogic() {

       logic = new SecondLogicImpl();

       //以下为初始化方法调用

       logic.XXX

       ...

    }  

    public topMethod() {

       loggic.someMethod();

    }

}

例如，我们会有SecondLogicFacotry工厂负责专门初始化SecondLogic的实例，代码为：

       //以下为初始化方法调用

       logic.XXX

       ...

public class TopLogic{

    private SecondLogic logic ;

    public TopLogic() {

       logic = SecondLogicFactory.createSecondLogic()

    }  

    public topMethod() {

       loggic.someMethod();

    }

}

通常上述逐步的简化代码变得越来越清楚。

public class TopLogic{

    private SecondLogic logic ;

    public TopLogic() {

    }  

    public topMethod() {

       loggic.someMethod();

    }

}

OR Mapping产生源自于面向对象的计算机语言（Object-Oriented Language，例如Java）和

关系型数据库（Relationship Database）之间的矛盾，即面向对象的操作和SQL语句之间的矛盾。

iBatis有Java版本和.NET两个版本可供选择。 

以下以Java本本为例讲解。

原理

iBatis中需要涉及到以下几部分

1. Object 面向对象的概念，表示某一类的实例（下图中的Hashtable，Java/.Net object，Primitive）。

2. Table 数据库表，用来以关系化的方式存储Object（下图中的数据库部分）。

3. Object到Table的映射信息，例如将哪个Object映射到哪个表，

    Object的哪个属性映射到表的哪个字段等（下图中的SqlMap.xml）。

4. iBatis引擎（下图中SqlMap config 和 SqlMap Statement两部分之和）。

图表如下

以Insert为例说明

第一步，SqlMap Statement根据SqlMap Config配置自己，配置信息包括数据库信息，等内容。

第二步，将Java Object传递给SqlMap Statement

第三步，SqlMap Statement根据当前传入Java Object在SqlMap.xml 文件中找到对应的配置信息

第四步，根据SqlMap.xml中的配置信息，自动生成 Insert Sql语句

第五部，针对当前配置的数据库执行第四步中生成的Sql语句，将数据插入到数据库中

以Select为例说明：

第一步，同上

第二步，将包含部分字段(查询条件)内容的Java Object传递给SqlMap Statement

第三步，同上

第四步，根据SqlMap中的配置信息，生成Select Sql语句

第五部，执行第四步中生成的Sql语句

第六步，根据SqlMap.xml 文件中的配置信息，将第五步中查询出来的ResultSet抓变为对应对象的列表，之后返回给调用端

具体使用

首先是一个SqlMap Config的配置文件，配置了数据库等信息，例如：

 <?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE sqlMapConfig     
    PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN"     
    "http://ibatis.apache.org/dtd/sql-map-config-2.dtd">

<sqlMapConfig>

    <!-- 数据库等信息 -->

  <transactionManager type="JDBC" commitRequired="false">
    <dataSource type="SIMPLE">
      <property name="JDBC.Driver" value="org.hsqldb.jdbcDriver"/>
      <property name="JDBC.ConnectionURL" value="jdbc:hsqldb:."/>
      <property name="JDBC.Username" value="sa"/>
      <property name="JDBC.Password" value="sa"/>
    </dataSource>
  </transactionManager>

    <!-- SqlMap.sql OR 映射文件的位置 -->

  <sqlMap resource="com/mydomain/data/Account.xml"/>
</sqlMapConfig>

Java Object对象

package com.mydomain.domain;

public class Account {

  private int id;
  private String firstName;
  private String lastName;
  private String emailAddress;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getFirstName() {
    return firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }

  public String getEmailAddress() {
    return emailAddress;
  }

  public void setEmailAddress(String emailAddress) {
    this.emailAddress = emailAddress;
  }

}

Account对应到数据库表的映射文件，即com/mydomain/data/Account.xml

 <?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE sqlMap     
    PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN"     
    "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="Account">

  <!-- 对类型定义的别名 -->
  <typeAlias alias="Account" type="com.mydomain.domain.Account"/>

  <!-- 数据库中的字段名和Java Object中的属性明的对应关系 -->
  <resultMap id="AccountResult" class="Account">
    <result property="id" column="ACC_ID"/>
    <result property="firstName" column="ACC_FIRST_NAME"/>
    <result property="lastName" column="ACC_LAST_NAME"/>
    <result property="emailAddress" column="ACC_EMAIL"/>
  </resultMap>

  <!-- 查询 SQL语句 -->
  <select id="selectAllAccounts" resultMap="AccountResult">
    select * from ACCOUNT
  </select>

  <!-- 基于ID的查询Sql语句 -->
  <select id="selectAccountById" parameterClass="int" resultClass="Account">
    select
      ACC_ID as id,
      ACC_FIRST_NAME as firstName,
      ACC_LAST_NAME as lastName,
      ACC_EMAIL as emailAddress
    from ACCOUNT
    where ACC_ID = #id#
  </select>
  
  <!-- 插入SQL语句 -->
  <insert id="insertAccount" parameterClass="Account">
    insert into ACCOUNT (
      ACC_ID,
      ACC_FIRST_NAME,
      ACC_LAST_NAME,
      ACC_EMAIL
    values (
      #id#, #firstName#, #lastName#, #emailAddress#
    )
  </insert>

  <!-- 更新SQL语句 -->
  <update id="updateAccount" parameterClass="Account">
    update ACCOUNT set
      ACC_FIRST_NAME = #firstName#,
      ACC_LAST_NAME = #lastName#,
      ACC_EMAIL = #emailAddress#
    where
      ACC_ID = #id#
  </update>

  <!-- 删除SQL语句 -->
  <delete id="deleteAccountById" parameterClass="int">
    delete from ACCOUNT where ACC_ID = #id#
  </delete>

</sqlMap>

使用代码：

首先装在配置文件：

try {
  Reader reader = Resources.getResourceAsReader("com/mydomain/data/SqlMapConfig.xml");
  sqlMapper = SqlMapClientBuilder.buildSqlMapClient(reader);
  reader.close();
} catch (IOException e) {
  // Fail fast.
  throw new RuntimeException("Something bad happened while building the SqlMapClient instance." + e, e);
}

各种方法的使用：

查询列表，返回List

sqlMapper.queryForList("selectAllAccounts");
查询对象

(Account) sqlMapper.queryForObject("selectAccountById", id);
插入

sqlMapper.insert("insertAccount", account);
更新

sqlMapper.update("updateAccount", account);
删除

sqlMapper.delete("deleteAccount", id);

在Struts2环境中结合Springframework使用ibatis

在Struts2环境中结合Springframework使用ibatis

想要使用ibatis必须首先定义数据源，这里使用DBCP数据源。

DBCP是apache jakarta下面的一个opensouce 名字叫做Database Connection Pool

使用DBCP需要将以下两个文件拷贝到WEB-INF/lib目录下：

commons-dbcp.jar

commons-pool.jar

在Spring配置文件中可以使用Ioc的方式配置数据库连接池（DBCP）

通常将数据库链接信息放在database.properties文件中，该文件通常放在WEB-INF目录下

文件内容为：

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/teamware
jdbc.username=teamware
jdbc.password=teamware

为了在spring配置文件中读取这些信息需要如下配置：

<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
 <property name="locations">
  <list>
      <value>WEB-INF/database.properties</value>
  </list>
 </property>
</bean>

配置数据库链接池：

<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}"/>
</bean>

其中${}部分内容引用了database.properties文件中的内容。

配置ibatis

配置ibatis需要的sqlmap-config.xml和TodoVO.xml

sqlmap-config.xml

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE sqlMapConfig     
    PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN"     
    "http://ibatis.apache.org/dtd/sql-map-config-2.dtd">

<sqlMapConfig>
 <sqlMap resource="com/jpleasure/teamware/vo/TodoVO.xml" />

</sqlMapConfig>

TodoVO.xml

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE sqlMap     
    PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN"     
    "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="TodoVO">

  <typeAlias alias="TodoVO" type="com.jpleasure.teamware.vo.TodoVO"/>

  <resultMap id="TodoVOResult" class="TodoVO">
    <result property="startDate" column="start_date"/>
    <result property="startTime" column="start_time"/>
    <result property="endDate" column="end_date"/>
    <result property="endTime" column="end_time"/>
   
    <result property="status" column="status"/>
    <result property="priority" column="priority"/>
    <result property="category" column="category"/>
   
 <result property="title" column="title"/>
 <result property="content" column="content"/>
  </resultMap>

  <select id="selectAllTodoVOs" resultMap="TodoVOResult">
    select * from todo
  </select>

</sqlMap>

package com.jpleasure.teamware.dao;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.ibatis.sqlmap.client.SqlMapClient;
import com.jpleasure.teamware.vo.TodoVO;

public class TodoDao {
 private SqlMapClient sqlMap = null;
 
 public SqlMapClient getSqlMap() {
  return sqlMap;
 }

 public void setSqlMap(SqlMapClient sqlMap) {
  this.sqlMap = sqlMap;
 }

 public List<TodoVO> listAll() {

  List todos = new ArrayList();
  try {
   todos = sqlMap.queryForList("selectAllTodoVOs");
  } catch (SQLException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }

  return todos;
 }

 public TodoVO insert(TodoVO todo) {
  return todo;
 }

 public TodoVO update(TodoVO todo) {
  return todo;
 }

 public TodoVO delete(TodoVO todo) {
  return todo;
 }
}

配置DAO

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC
 "-//SPRING//DTD BEAN//EN"
 "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
 <bean id="todo" class="com.jpleasure.teamware.action.TodoAction"
  singleton="false">
  <property name="todoLogic" ref="todoLogic"></property>
 </bean>
 <bean id="todoLogic"
  class="com.jpleasure.teamware.logic.TodoLogic">
  <property name="todoDao" ref="todoDao"></property>
 </bean>
 <bean id="todoDao" class="com.jpleasure.teamware.dao.TodoDao">
  <property name="sqlMap" ref="sqlMapClient"></property>
 </bean>

</beans>

使用DAO

package com.jpleasure.teamware.logic;

import java.util.List;

import com.jpleasure.teamware.dao.TodoDao;
import com.jpleasure.teamware.vo.TodoVO;

public class TodoLogic {
 
 /****************************************
  * TodoDao
  ****************************************/
 
 
 private TodoDao todoDao;
 
 public TodoDao getTodoDao() {
  return todoDao;
 }

 public void setTodoDao(TodoDao todoDao) {
  this.todoDao = todoDao;
 }

 /****************************************
  * Logic Method
  ****************************************/
 
 public List<TodoVO> listAll() {
  List<TodoVO> todos = todoDao.listAll();
 
  return todos;
 }
 
 public TodoVO insert(TodoVO todo) {
  return todo;
 }
 
 public TodoVO update(TodoVO todo) {
  return todo;
 }
 public TodoVO delete(TodoVO todo) {
  return todo;
 }
}

由于使用了Spring配置的DBCP，所以其中的数据库链接部分不需要再配置。

只需要配置使用的映射文件即可。

spring中配置ibatis

<bean id="sqlMapClient"
 class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">
 <property name="configLocation" value="sqlmap-config.xml"/>
 <property name="dataSource" ref="dataSource" />
</bean>

使用Ibatis做数据库访问
定义DAO

第七章 Type Convertion

（2）Collection和Map

简单List转换
//JSP代码
<%--
  Created by IntelliJ IDEA.
  User: mazhao
  Date: 2007/09/04
  Time: 12:47:40
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<head><title>Point Page</title></head>
<body>
<s:form action="point" namespace="/point" method="post">
    <s:textfield label="Point" name="point"/>

    <s:textfield label="References" name="references"/>
    <s:textfield label="References" name="references"/>
    <s:textfield label="References" name="references"/>
    <s:textfield label="References" name="references"/>
    <s:textfield label="References" name="references"/>
                   

    <s:property value="point"/>
    <s:submit/>
</s:form>
</body>
</html>

//Action代码
package com.jpleasure.action;

import com.jpleasure.conversion.Point;
import com.opensymphony.xwork2.ActionSupport;

import java.util.List;

/**
 * Created by IntelliJ IDEA.
 * User: ma.zhao@dl.cn
 * Date: 2007/09/04
 * Time: 12:45:11
 * To change this template use File | Settings | File Templates.
 */
public class PointAction extends ActionSupport {
    private Point point;
    private List references;

    public Point getPoint() {
        return point;
    }

    public void setPoint(Point point) {
        this.point = point;
    }

    public List getReferences() {
        return references;
    }

    public void setReferences(List references) {
        this.references = references;
    }

    public String execute() {

        if(references == null) {
            System.out.println("references is null");
        } else {
            System.out.println("references length is:" + references.size());
           
            for(Object s: references) {
                System.out.println("" + s);
            }
        }

        return SUCCESS;
    }
}

对象类型List转换（key-value pair 方式）
// Person 类型

package org.apache.struts2.showcase.conversion;

import java.io.Serializable;

/**
 *
 */
public class Person implements Serializable {
    private String name;
    private Integer age;

    public void setName(String name) { this.name = name; }
    public String getName() { return this.name; }

    public void setAge(Integer age) { this.age = age; }
    public Integer getAge() { return this.age; }
}

// PersionAction 类型

 package org.apache.struts2.showcase.conversion;

import java.util.List;

import com.opensymphony.xwork2.ActionSupport;

/**
 *
 */
public class PersonAction extends ActionSupport {

    private List persons;

    public List getPersons() { return persons; }
    public void setPersons(List persons) { this.persons = persons; }

    public String input() throws Exception {
        return SUCCESS;
    }

    public String submit() throws Exception {
        return SUCCESS;
    }
}
// PersonAction转化配置文件PersonAction-conversion.properties

# PersonAction中persons属性（List类型）中元素的类型

Element_persons=org.apache.struts2.showcase.conversion.Person

// JSP部分代码

 <s:iterator value="new int[3]" status="stat">
        <s:textfield    label="%{'Person '+#stat.index+' Name'}"
                        name="%{'persons['+#stat.index+'].name'}" />
        <s:textfield    label="%{'Person '+#stat.index+' Age'}"
                        name="%{'persons['+#stat.index+'].age'}" />
  </s:iterator>
其中stat记录了当前循环的信息，其中stat.index表示当前循环的下标。

所以上述代码会生成如下的代码：

<s:textfield    label="Person 1 Name"
                name="persons[0].name" />
<s:textfield    label="Person 1 Age"
                name="persons[0].age" />
<s:textfield    label="Person 2 Name"
                name="persons[1].name" />
<s:textfield    label="Person 2 Age"
                name="persons[1].age" />
<s:textfield    label="Person 3 Name"
                name="persons[2].name" />
<s:textfield    label="Person 3 Age"
                name="persons[2].age" />

对象类型List转换（value 方式）

// Address 类型 

package org.apache.struts2.showcase.conversion;

/**
 * @version $Date: 2006-11-23 12:31:52 -0500 (Thu, 23 Nov 2006) $ $Id: Address.java 478625 2006-11-23 17:31:52Z wsmoak $
 */
public class Address {

    private String id;
    private String address;

    public String getId() { return id; }
    public void setId(String id) { this.id = id; }

    public String getAddress() { return address; }
    public void setAddress(String address) { this.address = address; }

}

// AddressAction 类型

 package org.apache.struts2.showcase.conversion;

import java.util.LinkedHashSet;
import java.util.Set;

import com.opensymphony.xwork2.ActionSupport;

/**
 * @version $Date: 2006-11-23 12:31:52 -0500 (Thu, 23 Nov 2006) $ $Id: AddressAction.java 478625 2006-11-23 17:31:52Z wsmoak $
 */
public class AddressAction extends ActionSupport {

    private Set addresses = new LinkedHashSet();

    public Set getAddresses() { return addresses; }
    public void setAddresses(Set addresses) { this.addresses = addresses; }

    public String input() throws Exception {
        return SUCCESS;
    }

    public String submit() throws Exception {
        System.out.println(addresses);
        return SUCCESS;
    }
}

//AddressAction转换配置文件AddressAction-conversion.properties

KeyProperty_addresses=id
Element_addresses=org.apache.struts2.showcase.conversion.Address
CreateIfNull_addresses=true

// JSP代码 

<s:form action="submitAddressesInfo" namespace="/conversion">
  <s:iterator value="%{new int[3]}" status="stat">
   <s:textfield label="%{'Address '+#stat.index}"
        name="%{'addresses(\\'id'+#stat.index+'\\').address'}" />
  </s:iterator>
  <s:submit />
 </s:form>

 上述代码会转换为：

<s:form action="submitAddressInfo" namespace="/conversion">
  <s:textfield label="Address 0"
      name="addresses('id0')" />
  <s:textfield label="Address 1"
      name="addresses('id1')" />
  <s:textfield label="Address 2"
      name="addresses('id2')" />
  <s:submit />
 </s:form>

注意两个地方：

第一，没有向服务器提交Address的id属性，那么Address的id属性是什么呢？
KeyProperty_addresses=id表示向服务器提交的内容的key部分（"id0”， "id1”， "id2”）会被认定为Addredd的id。

第二，CreateIfNull_addresses=true表示及时客户端没有向服务器提交任何Address内容，服务器也会为AddressAction的addresses 建立一个长度为0的Set。

相关的一些经验

开发的过程中不要一味的使用String类型，使用String类型无论在处理的速度还是内 存的使用上都不是最好的方式。一般情况下，Java的模型类（JavaBean， Action等都可以视为Java模型类，因为其中表示了模型的信息），一般情况下需要和数据库中的类型一致。这样才能保证最好的性能。

那么像java.util.Date，Integer等类型需要表示到JSP页面上的时候还是需要表示为String类型的，但是Struts2都已经帮助实现了，所以请使用具体的类型吧，不要总是使用String类型。

Action里提供了五个默认的返回值：

String SUCCESS = "success";

String NONE    = "none";

String ERROR   = "error";

String INPUT   = "input";

String LOGIN   = "login";

默认的一些配置

在package下有如下配置

<result-types>

<result-type name="dispatcher"

class="org.apache.struts2.dispatcher.ServletDispatcherResult"

    default="true" />

</result-types>

如果一个Result的type没有设定的话，默认为dispthcher。Dispatcher的意思是转向一个JSP等的资源。

另外如果Result的name没有设定的话，默认为SUCCESS。

一个完整的Result的声明如下：

<result name="success" type="dispatcher">

    <param name="location">/ThankYou.jsp</param>

</result>

考虑到默认值可以写成：

<result>

    <param name="location">/ThankYou.jsp</param>

</result>

另外也可以简写为：

<result>/ThankYou.jsp</result>

另外为了方便，可以在package中设置一些全局的result，例如：

<global-results>

  <result name="error">/Error.jsp</result>

  <result name="invalid.token">/Error.jsp</result>

  <result name="login" type="redirect-action">Logon_input</result>

</global-results>

动态结果

有些时候，在Action执行完毕之后才知道Result的指向，可以使用如下的方法：

Action

private String nextAction;

public String getNextAction() {

    return nextAction;

}

public String execute() throws Exception {

  return “next”;

}

struts.xml

<action name="fragment" class="FragmentAction">

  <result name="next" type="redirect-action">${nextAction}</result>

</action>

3.4节 ActionSupport

Action类不一定非要实现Action接口或者集成ActionSupport类，也就是说Action可以是一个POJO对象，只不过提供一个返回String的方法。如果Action类不实现Action接口，也不从ActionSupport集成，则Struts框架通过Java的反射机制（Reflection）来调用Action类中的处理方法。

Action类的处理方法需要满足以下要求

1 public

2 返回String，框架根据返回值决定迁移的目的

3 （可选）抛出Exception，让Struts框架统一处理异常

3.5节 Exception Handling

Struts可以以声明的方式处理Action类抛出的异常。以声明的方式处理是指：所有的Action类的处理方法抛出的Exception会被框架统一处理，之后定向到预先定义的Result。处理这些异常的Action，Result等可以动态的配置。

Struts2自带一个默认的配置：struts-default.xml，在这个文件中预先定义了一些基本的操作，其中Exception Handling也在其中，参看下述代码：

...

<interceptors>

    ...

    <interceptor name="exception"

          class="com.opensymphony.xwork.interceptor.ExceptionMappingInterceptor"/>

    ...

</interceptors>

<interceptor-stack name="defaultStack">

    <interceptor-ref name="exception"/>

    <interceptor-ref name="alias"/>

    <interceptor-ref name="servlet-config"/>

    <interceptor-ref name="prepare"/>

    <interceptor-ref name="i18n"/>

    <interceptor-ref name="chain"/>

    <interceptor-ref name="debugging"/>

    <interceptor-ref name="profiling"/>

    <interceptor-ref name="scoped-model-driven"/>

    <interceptor-ref name="model-driven"/>

    <interceptor-ref name="fileUpload"/>

    <interceptor-ref name="checkbox"/>

    <interceptor-ref name="static-params"/>

    <interceptor-ref name="params"/>

    <interceptor-ref name="conversionError"/>

    <interceptor-ref name="validation">

        <param name="excludeMethods">input,back,cancel,browse</param>

    </interceptor-ref>

    <interceptor-ref name="workflow">

        <param name="excludeMethods">input,back,cancel,browse</param>

    </interceptor-ref>

</interceptor-stack>

...

要使用Struts2声明式异常处理，只需要将异常映射到result就可以了，可以用两种方法配置，一种方法是全局配置，针对所有的Action有效，另一种是针对具体的Action做配置，只针对具体的Action有效。

参看如下struts.xml 配置文件片段：

<package name="default">

      ...

      <global-results>

          <result name="login" type="redirect">/Login.action</result>

          <result name="Exception">/Exception.jsp</result>

      </global-results>

      <global-exception-mappings>

          <exception-mapping

exception="java.sql.SQLException" result="SQLException"/>

          <exception-mapping

exception="java.lang.Exception" result="Exception"/>

      </global-exception-mappings>

      ...

      <action name="DataAccess" class="com.company.DataAccess">

          <exception-mapping

exception="com.company.SecurityException" result="login"/>

          <result name="SQLException" type="chain">SQLExceptionAction</result>

          <result>/DataAccess.jsp</result>

      </action>

      ...

</package>

上述配置有如下结果

1 一个java.sql.SQLException异常将链接到SQLExceptionAction （上述文件中没有说明）

2 一个com.company.SecurityException将重新定位到login.action

3 其他从java.lang.Exception继承而来的Exception将会被定为到/Exception.jsp页面

3.6节 Intercepter拦截器

拦截器的运行时机在Action类运行之前和之后。拦截器使用Filter模式，将你需要执行的代码放在Action类处理方法之前或者之后执行。拦截器在开发程序的时候功能非常强大，通过使用拦截器可以完成校验，属性设置，安全，日志，程序剖析等功能。

拦截器可以彼此链接构成一个拦截器的栈，每一个拦截器本质上是一个Java类，都有一个常常的类名，为了方便使用，可以在Struts2框架中注册这些拦截器，例如：

<interceptor name="security" class="com.jpleasure.security.SecurityInterceptor"/>

  <interceptor-stack name="secureStack">

    <interceptor-ref name="security"/>

    <interceptor-ref name="defaultStack"/>

  </interceptor-stack>

</interceptors>

拦截器和拦截器栈可以混合使用来定义新的拦截器栈，在调用过程中，框架按照在拦截器栈中的顺序逐个调用这些拦截器。

可以在Package中定义默认的拦截器栈，例如：

<default-interceptor-ref name="secureStack"/>

当然每一个Action类也可以定义自己的拦截器栈，例如：

<action name="VelocityCounter"

                         class="org.apache.struts2.example.counter.SimpleCounter">

    <result name="success">...</result>

    <interceptor-ref name="defaultComponentStack"/>

</action>

3.7节 分离配置文件

可以在struts.xml中使用include标记将配置文件分离成不同的部分。

例如：

<!DOCTYPE struts PUBLIC

  "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"

  "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>

    <include file="Home.xml"/>

    <include file="Hello.xml"/>

    <include file="Simple.xml"/>

    <include file="/util/POJO.xml"/>

struts.properties文件在WEB-INF/classes目录下存放。

这个文件用来配置Struts2系统的一些基本规约，所有在struts.properties中配置的内容都可以在struts.xml中配置，或者web.xml中在struts2 filter中配置，例如：

Struts.properties中的如下配置：

struts.i18n.encoding=UTF-8

相当于struts.xml中的如下配置：

<constant name=“struts.i18n.encoding” value=“true” />

相当于web.xml中的如下配置：

<filter>

    <filter-name>struts</filter-name>

    <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>

    <init-param>

        <param-name>struts.i18n.encoding</param-name>

        <param-value>true</param-value>

    </init-param>