本文将给出一个基本的Spring入门示例，并演示如何使用Spring的AOP将复杂的业务逻辑分离到每个方面中。

1．开发环境配置
2．编写Bean接口及其实现
3．在Spring中配置Bean并获得Bean的实例
4．编写Advisor以增强ServiceBean
5．总结

1．开发环境配置
首先，需要正确配置Java环境。推荐安装JDK1.4.2，并正确配置环境变量：

JAVA_HOME=<JDK安装目录>
CLASSPATH=.
Path=%JAVA_HOME%\bin;……

我们将使用免费的Eclipse 3.1作为IDE。新建一个Java Project，将Spring的发布包spring.jar以及commons-logging-1.0.4.jar复制到Project目录下，并在Project > Properties中配置好Java Build Path：

点击查看大图

2．编写Bean接口及其实现
我们实现一个管理用户的业务Bean。首先定义一个ServiceBean接口，声明一些业务方法：

/** * Copyright_2006, Liao Xuefeng * Created on 2006-3-9 * For more information, please visit: http://www.crackj2ee.com */package com.crackj2ee.example.spring;
/** * Interface of service facade. *  * @author Xuefeng */public interface ServiceBean {    void addUser(String username, String passWord);    void deleteUser(String username);    boolean findUser(String username);    String getPassword(String username);}
然后在MyServiceBean中实现接口：

/** * Copyright_2006, Liao Xuefeng * Created on 2006-3-9 *  * For more information, please visit: http://www.crackj2ee.com */package com.crackj2ee.example.spring;
import java.util.*;
public class MyServiceBean implements ServiceBean {
    private String dir;    private Map map = new HashMap();
    public void setUserDir(String dir) {        this.dir = dir;        System.out.println("Set user dir to: " + dir);    }
    public void addUser(String username, String password) {        if(!map.containsKey(username))            map.put(username, password);        else            throw new RuntimeException("User already exist.");    }
    public void deleteUser(String username) {        if(map.remove(username)==null)            throw new RuntimeException("User not exist.");    }
    public boolean findUser(String username) {        return map.containsKey(username);    }
    public String getPassword(String username) {        return (String)map.get(username);    }}

为了简化逻辑，我们使用一个Map保存用户名和口令。

现在，我们已经有了一个业务Bean。要测试它非常容易，因为到目前为止，我们还没有涉及到Spring容器，也没有涉及到任何Web容器（假定这是一个Web应用程序关于用户管理的业务Bean）。完全可以直接进行Unit测试，或者，简单地写个main方法测试：

/** * Copyright_2006, Liao Xuefeng * Created on 2006-3-9 * For more information, please visit: http://www.crackj2ee.com */package com.crackj2ee.example.spring;
public class Main {
    public static void main(String[] args) throws Exception {        ServiceBean service = new MyServiceBean();        service.addUser("bill", "hello");        service.addUser("tom", "goodbye");        service.addUser("tracy", "morning");        System.out.println("tom's password is: " + service.getPassword("tom"));        if(service.findUser("tom")) {            service.deleteUser("tom");        }    }}
执行结果：

3．在Spring中配置Bean并获得Bean的实例
我们已经在一个main方法中实现了业务，不过，将对象的生命周期交给容器管理是更好的办法，我们就不必为初始化对象和销毁对象进行硬编码，从而获得更大的灵活性和可测试性。

想要把ServiceBean交给Spring来管理，我们需要一个XML配置文件。新建一个beans.xml，放到src目录下，确保在classpath中能找到此配置文件，输入以下内容：

<?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="service" class="com.crackj2ee.example.spring.MyServiceBean" /></beans>
以上XML声明了一个id为service的Bean，默认地，Spring为每个声明的Bean仅创建一个实例，并通过id来引用这个Bean。下面，我们修改main方法，让Spring来管理业务Bean：

/** * Copyright_2006, Liao Xuefeng * Created on 2006-3-9 * For more information, please visit: http://www.crackj2ee.com */package com.crackj2ee.example.spring;
import org.springframework.beans.factory.xml.XmlBeanFactory;import org.springframework.core.io.ClassPathResource;
public class Main {
    public static void main(String[] args) throws Exception {        // init factory:        XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("beans.xml"));        // use service bean:        ServiceBean service = (ServiceBean)factory.getBean("service");        service.addUser("bill", "hello");        service.addUser("tom", "goodbye");        service.addUser("tracy", "morning");        System.out.println("tom's password is \"" + service.getPassword("tom") + "\"");        if(service.findUser("tom")) {            service.deleteUser("tom");        }        // close factory:        factory.destroySingletons();    }}

执行结果：
 

由于我们要通过main方法启动Spring环境，因此，首先需要初始化一个BeanFactory。红色部分是初始化Spring的BeanFactory的典型代码，只需要保证beans.xml文件位于classpath中。

然后，在BeanFactory中通过id查找，即可获得相应的Bean的实例，并将其适当转型为合适的接口。

接着，实现一系列业务操作，在应用程序结束前，让Spring销毁所有的Bean实例。

对比上一个版本的Main，可以看出，最大的变化是不需要自己管理Bean的生命周期。另一个好处是在不更改实现类的前提下，动态地为应用程序增加功能。

4．编写Advisor以增强ServiceBean
所谓AOP即是将分散在各个方法处的公共代码提取到一处，并通过类似拦截器的机制实现代码的动态织入。可以简单地想象成，在某个方法的调用前、返回前、调用后和抛出异常时，动态插入自己的代码。在弄清楚Pointcut、Advice之类的术语前，不如编写一个最简单的AOP应用来体验一下。

考虑一下通常的Web应用程序都会有日志记录，我们来编写一个LogAdvisor，对每个业务方法调用前都作一个记录：

/** * Copyright_2006, Liao Xuefeng * Created on 2006-3-9 * For more information, please visit: http://www.crackj2ee.com */package com.crackj2ee.example.spring;
import java.lang.reflect.Method;import org.springframework.aop.MethodBeforeAdvice;
public class LogAdvisor implements MethodBeforeAdvice {    public void before(Method m, Object[] args, Object target) throws Throwable {        System.out.println("[Log] " + target.getClass().getName() + "." + m.getName() + "()");    }}
然后，修改beans.xml：

<?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="serviceTarget" class="com.crackj2ee.example.spring.MyServiceBean" />
    <bean id="logAdvisor" class="com.crackj2ee.example.spring.LogAdvisor" />
    <bean id="service" class="org.springframework.aop.framework.ProxyFactoryBean">        <property name="proxyInterfaces"><value>com.crackj2ee.example.spring.ServiceBean</value></property>        <property name="target"><ref local="serviceTarget"/></property>        <property name="interceptorNames">            <list>                <value>logAdvisor</value>            </list>        </property>    </bean></beans>
注意观察修改后的配置文件，我们使用了一个ProxyFactoryBean作为service来与客户端打交道，而真正的业务Bean即MyServiceBean被声明为serviceTarget并作为参数对象传递给ProxyFactoryBean，proxyInterfaces指定了返回的接口类型。对于客户端而言，将感觉不出任何变化，但却动态加入了LogAdvisor，关系如下：
 

运行结果如下，可以很容易看到调用了哪些方法：
 

要截获指定的某些方法也是可以的。下面的例子将修改getPassword()方法的返回值：

/** * Copyright_2006, Liao Xuefeng * Created on 2006-3-9 * For more information, please visit: http://www.crackj2ee.com */package com.crackj2ee.example.spring;
import org.aopalliance.intercept.MethodInterceptor;import org.aopalliance.intercept.MethodInvocation;
public class PasswordAdvisor implements MethodInterceptor {    public Object invoke(MethodInvocation invocation) throws Throwable {        Object ret = invocation.proceed();        if(ret==null)            return null;        String password = (String)ret;        StringBuffer encrypt = new StringBuffer(password.length());        for(int i=0; i<password.length(); i++)            encrypt.append('*');        return encrypt.toString();    }}
这个PasswordAdvisor将截获ServiceBean的getPassword()方法的返回值，并将其改为"***"。继续修改beans.xml：

<?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="serviceTarget" class="com.crackj2ee.example.spring.MyServiceBean" />
    <bean id="logAdvisor" class="com.crackj2ee.example.spring.LogAdvisor" />
    <bean id="passwordAdvisorTarget" class="com.crackj2ee.example.spring.PasswordAdvisor" />
    <bean id="passwordAdvisor" class="org.springframework.aop.support.RegeXPMethodPointcutAdvisor">        <property name="advice">            <ref local="passwordAdvisorTarget"/>        </property>        <property name="patterns">            <list>                <value>.*getPassword</value>            </list>        </property>    </bean>
    <bean id="service" class="org.springframework.aop.framework.ProxyFactoryBean">        <property name="proxyInterfaces"><value>com.crackj2ee.example.spring.ServiceBean</value></property>        <property name="target"><ref local="serviceTarget"/></property>        <property name="interceptorNames">            <list>                <value>logAdvisor</value>                <value>passwordAdvisor</value>            </list>        </property>    </bean></beans>

利用Spring提供的一个RegexMethodPointcutAdvisor可以非常容易地指定要截获的方法。运行结果如下，可以看到返回结果变为"******"：
 

还需要继续增强ServiceBean？我们编写一个ExceptionAdvisor，在业务方法抛出异常时能做一些处理：

/** * Copyright_2006, Liao Xuefeng * Created on 2006-3-9 * For more information, please visit: http://www.crackj2ee.com */package com.crackj2ee.example.spring;
import org.springframework.aop.ThrowsAdvice;
public class ExceptionAdvisor implements ThrowsAdvice {    public void afterThrowing(RuntimeException re) throws Throwable {        System.out.println("[Exception] " + re.getMessage());    }}
将此Advice添加到beans.xml中，然后在业务Bean中删除一个不存在的用户，故意抛出异常：

service.deleteUser("not-exist");
再次运行，注意到ExceptionAdvisor记录下了异常：
 

5．总结
利用Spring非常强大的IoC容器和AOP功能，我们能实现非常灵活的应用，让Spring容器管理业务对象的生命周期，利用AOP增强功能，却不影响业务接口，从而避免更改客户端代码。

为了实现这一目标，必须始终牢记：面向接口编程。而Spring默认的AOP代理也是通过Java的代理接口实现的。虽然Spring也可以用CGLIB实现对普通类的代理，但是，业务对象只要没有接口，就会变得难以扩展、维护和测试。

欢迎来信与作者交流：asklxf@163.com

完整的Eclipse工程：springbasic.rar

（出处：http://www.knowsky.com）

前两章介绍了使用异常的基本概念，重点讨论了处理方式和理由，阐述了工作原理，分析如何在代码中处理异常。本章介绍更高级的主题，具体内容如下：

●       如何创建和使用自定义异常。

●       异常支持链表和本地化。

●       抽象类和接口中的异常用法。

●       覆盖方法的异常要求。

●       如何用字节码表示异常处理代码。

●       应用程序中异常处理操作的效率。

在处理异常时，上述主题并不常用。简单项目根本不使用它们。但在编写较复杂的程序时，这些主题的作用便显示出来了。

3.2  自定义异常

前面讨论了如何处理调用Java API的方法时产生的异常。根据需要，还可创建和使用自定义异常——自我构建表示错误的类。可创建全新异常，并将它们用于应用程序。

使用自定义异常有什么好处呢？为何要定义新异常类型？创建自定义异常是为了表示应用程序的一些错误类型，为代码可能发生的一个或多个问题提供新含义。可以显示代码多个位置之间的错误的相似性，也可区分代码运行时可能出现的相似问题的一个或多个错误，或给出应用程序中一组错误的特定含义。

例如，考虑任何类型的服务器。服务器的基本作用是处理与客户机的通信。若使用标准Java API(如java.io和java.net包中的类)来编写服务器，则可使编写的代码在多个位置抛IOException。 在设置服务器、等待客户机连接和获取通信流时，可抛出IOExceptions；在通信期间及试图断开连接时，也可抛出IOExceptions。简言之，服务器的各个部分都可能引发IOException。

对服务器而言，这些IOException意义不尽相同。虽然由同一异常类型表示，但与各个异常相关的业务含义存在差异，报告和恢复操作亦有不同。可以将一个异常集与服务器配置和启动问题关联，将另一个异常集与客户机通信的实际行动关联，将第三个异常集与服务器关闭任务关联。使用自定义异常，可采用对应用程序有意义的方式来灵活地表示错误。

创建和使用自定义异常并不难。遵循以下3个步骤即可。

3.2.1  定义异常类

一般要定义新类来表示自定义异常。多数情况下，只需创建已有异常类的子类。

1  public class CustomerExistsException extends Exception{

2    public CustomerExistsException(){}

3    public CustomerExistsException(String message){

4      super(message);

5    }

6  }

至少要继承Throwable或Throwable的子类。经常需要定义一个或多个构造函数，以在对象中存储错误消息。如第2-4行所示。在继承任何异常时，将自动继承Throwable类的一些标准特性，如：

●       错误消息

●       栈跟踪

●       异常包装

若要在异常中添加附加信息，则可以为类添加一些变量和方法：

1  public class CustomerExistsException extends Exception{

2    private String customerName;

3    public CustomerExistsException(){}

4     public CustomerExistsException(String message){

5       super(message);

6     }

7     public CustomerExistsException(String message, String customer){

8       super(message);

9       customerName = customer;

10     }

11     public String getCustomerName(){

12       return customerName;

13     }

14  }

由本例可知，可修改CustomerExistsException类，以支持其他属性。例如，可将customerName字符串(引发异常的记录的客户名)与异常联系起来。

3.2.2  声明方法抛出自定义异常

这实际上是“处理或声明”规则的“声明”部分。为了使用自定义异常，必须通知调用代码的类：要准备处理这个异常类型。为此，声明一个或多个方法抛出异常：

public void insertCustomer(Customer c) throws CustomerExistsException{

// The method stores customer information in the database.

// If the customer data already exists, the method creates

// and throws the CustomerExistsException.

}

3.2.3  找到故障点，新建异常并加上关键字throw

最后一步实际上是创建对象，并通过系统传送该对象。为此，需要了解代码将在方法的哪个位置出现故障。根据情况，可能要使用以下部分或所有条件，来指示代码中的故障点。

1. 外部问题

●       应用程序中产生的异常

●       其他方法返回的故障代码

2. 内部问题

●       应用程序状态不一致

●       应用程序中的处理问题

在本例中，当不能新建一个客户时会遇到一个故障场景。结果，创建一个异常来表示问题并抛出该问题。如下面的示例方法所示：

1  public void insertCustomer(Customer c)

2    throws CustomerExistsException, SQLException {

3    String selectSql =

4      "SELECT * FROM Customer WHERE first_name=? AND last_name=?";

5    String insertSql = "INSERT INTO Customer VALUES(?, ?)";

6    try{

7      Connection conn = dbmsConnectionFactory.getConnection();

8      PreparedStatement selStmt = conn.prepareStatement(selectSql);

9      selectStmt.setString(1, c.getFirstName());

10      selectStmt.setString(2, c.getLastName());

11      ResultSet rs = selStmt.executeQuery();

12      if (rs.next()){

13        // In this case, the failure condition is produced if you

14        //  can already locate a metching record in the database.

15       throw new CustomerExistsException("Customer exists:" + c, c);

16      }

17      else{

18        PreparedStatement insStmt = conn.prepareStatement(insertSql);

19        insStmt.setString(1, c.getFirstName());

20        insStmt.setString(2, c.getLastName());

21        int status = insStmt.executeUpdate();

22      }

23   }

24   catch (SQLException exc){

Java关键字throw将这个新异常对象传给该方法的调用者。在执行完这3个步骤后，就创建了自定义异常。除非派生一个非检测异常类(如RuntimeException或Error)，否则调用方法的任何对象随后将按照“处理或声明”规则解决该异常。

这引出了一个有趣的问题：在自定义异常时，应如何派生？必须在Throwable类层次结构中派生，否则将不能在应用程序中传播异常。另外，不能从Throwable直接派生。Throwable为两类主要问题(Exception和Error)提供行为基础，不能为这棵继承树定义新分支。一般也不要直接继承Error或其任何子类，因为自定义异常通常不符合错误标准(即适当应用程序不应试图捕获的严重问题)。

需要从Exception类层次结构中派生。一般地，应将自定义异常定义为故障状态更一般的异常类型的子类。例如，ServerConnectionException是java.io.IOException的子类，因为Server- Connec tionException是java.io.IOException的更具体类型。

如果定义的异常从RuntimeException树继承，是否属于正确的编码实践？若如此，就回避了异常机制，即使声明了异常，类也不必显式处理异常。

1.使用方法：
ec:table标签内 增加
listHeight="数字" 属性 （指定列表体的高度）
同时把要指定 width="数字" 不能省略 同时要使用绝对大小而不要使用百分比

请教楼主，下了你的代码试了一下，如果把默认DEFAULT_PAGE_SIZE改为别的数字，比如每页显示5条，分页错误，点击下一页，显示还是10条，

你的jsp页面里的 ec:table的 rowsDisplayed 属性也要修改 改为5

bjwulin 写道

fins 写道

没太看明白　　:(

reload第一个表格　你是在怎么reload的？？

我描述不清楚，这样说吧，如果表格有21条数据，每页10条，现在在第三页，如果我在数据库里面手工删除1条数据，然后调用EcUtil.reload(...)的话，怎么让它显示第二页的数据。因为我在后台得到的还是pageNo=3

我不明白的就是
为什么"后台得到的还是pageNo=3"??

你后台是怎么计算页数的?
我怀疑可能是你没有调用EccnUtil.refresh(...)
如果数据数目发生变化了
建议 先
EccnUtil.refresh(...)
再
EccnUtil.reload(...)

1)     实现了灵活的可定制的“可编辑列表”功能 （详见help.txt 200行左右的描述 以及示例）
支持多种编辑方式（文本框 下拉框将来还会支持更多），可自定义模版（使用自定义的文本框下拉框），还提供了：
对可编辑列进行标识，对编辑过的cell进行标识（默认为改变单元格背景色），
使用ajax技术提交后台，提交成功的cell将清除编辑标识等贴心设计。
2) 增加了 高亮显示选种行的功能，使用 ec:table属性: selectlightRow="true"
3) 去掉了 fullnavigation导航条，将其与navigation导航条合并
改为为ec:table增加属性 nearPageNum="数字" 用来设置导航条前后显示的邻近页数 等于0时 为不使用邻近页。
4) 为ec:table增加了 maxRowsExported="数字" 属性，用来限制导出大最大条数，如果数据超过这个数目，则不执行导出操作。
5) 为之前增加的ec:table的pageSizeList属性 增加了特性
pageSizeList="max:200,10,15,30,50,100,all" 如果 10--100以及all中，某一项大过了max的200则不在列表中显示。
也可以只使用pageSizeList="max:200" 此时将使用默认设置，并进行max控制。
6) 解决了pdf中文编码问题，终于支持pdf导出了。
7) 恢复了对sitemesh的支持，用法见原版ec文档（我没有亲自没有测试,因为我不会用sitemesh ）。
8) Ajax翻页优化，同时增加了 ECSide.findAjaxZoneAtClien 属性，可设置客户端 还是 服务端进行 html代码剪裁。
默认推荐使用 服务器端。
9) 再次对js和java代码进行了较大规模的重构,清理了一些无用代码，添加了必要的协议信息。
10) 还有一些细节的修改(例如对滚轮的支持更自然) 和对一些小bug的修正，但是由于变化较大，肯定还会带来一些新bug。
11) 整个示例的应用逐步发展为 ecside 的最佳实践，加入了hsqldb（hsqldb的使用参考了springside），全新的例子。
当然还不够好 会在以后的日子里继续完善。
12) 做了一个简单的logo 。

使用方法：
ec:table标签内 增加
listHeight="数字" 属性 （指定列表体的高度）
同时把要指定 width="数字" 不能省略 同时要使用绝对大小而不要使用百分比

smalldeer 写道

一直关注ecside，谢谢你们的无私奉献，真的增强好多。
有一个问题请教，我在一个页面中，要使用2个表格，
如果不写request.setAttribute("totalRows", new Integer(rowc));
就会报 You need to specify the totalRows (as an Integer) to use the org.extremecomponents.table.callback.LimitCallback.
如果写，但是有2个table，参数只有一个totalRows，我如何为2个表格分别指定它的totalRows呢

请教一下，十分感谢。

说来惭愧啊
我虽然一直在研究ec的代码 并做出改造
但是 有几个地方我一直没有深入的涉及
其中就包括 同一叶面显示多表格的设计

因为我一直认为这不是一个好的实现方式

其实代码是这样的
他先去找 tableId+"_totalRows"
找不到了 才去找 totalRows
我的那个例子对你有误导 我的错

ecside介绍：

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

ecside是一个开源的列表组件。

他源自著名开源列表组件 eXtremeComponents （http://www.extremecomponents.org），

但现在已经脱离eXtremeComponents,独立发展（仍有大量代码来自 eXtremeComponents）。

由于各种协议和各种授权的问题，目前还不能独立成为一个开源项目，但“做最实用易用的列表组件”是ecside最终的目标。

作者： fins ( name: Wei Zijun    email:fins@163.com   blog:http://fins.javaeye.com )

(详见readme.txt)

基础功能的使用请参考 eXtremeComponents 官方网站(http://www.extremecomponents.org)的wiki（有中文版）

增强的功能简介：

1  ec:table属性增加  toolbarLocation

 用来控制工具条在上还是在下显示

 可选值 "bottom" "top" "none"（不显示）

2  ec:table属性增加  toolbarContent

 可自定义工具条显示那些内容，以及排列顺序

默认： toolbarContent="navigation|pagejump|pagesize|export|extend|status"

例子    toolbarContent="pagejump|navigation|export|extend|status"

此时 工具条将不显示"页面行数调整"框同时顺序也会和默认的发生变化

navigation 导航条

pagejump 页面跳转

pagesize 页面行数设置

export 导出按钮区

extend 自定义扩展区

status 数据信息区

同时 为ec:table增加属性 nearPageNum="数字",

用来设置导航条前后显示的邻近页数,不设置将使用默认值，设置为0则不显示邻近页

3  ec:table属性增加  pageSizeList

可用来设置“页面行数选择列表”中的具体数值

默认：pageSizeList="10,20,50,100,1000,2000,all"

其中的all为增加全部显示功能。

例子   pageSizeList="10,20,50"

此时列表里将只显示 10 20 50供选择

max:数字 特性 :

pageSizeList="max:200,10,15,30,50,100,all"

如果 10--100以及all中，某一项大过了max的200则不在列表中显示。

也可以只使用pageSizeList="max:200" 此时将使用默认设置，并用max限制。

4 ec:table属性增加 xlsFileName  和 pdfFileName

用来快捷的实现导出xls文件

如果你只是想使用默认的方式导出 xls 和 pdf文件 不用再使用 ec:exportXls  ec:exportPdf标签了

直接在ec:table里使用这个属性就ok.

使用方法 xlsFileName="文件名.xls"

5  ec:table属性增加  showPrint

显示打印按钮，该功能只能在ie 5.5以上浏览器中使用没有使用第三方组件 使用了ie内置组件

使用方法： showPrint="true"

打印按钮将作为导出的一种类型而存在

6 ec:table属性增加  resizeColWidth 和 minColWidth

默认：  resizeColWidth="false"  minColWidth="20"

用来实现手动调节列宽的功能 在ie 5.5+ 和ff 2.0下测试通过

resizeColWidth="true" 实现列宽调整

minColWidth="20" 调整时列的最小宽度

目前不能和过滤功能一同使用(当filterable="true"时候不可以用)

7 为ec:row 添加更多的html事件支持，现支持：onmouserover onmouserout onclick ondbclick

8 为ec:column 添加更多的html事件支持，现支持：onmouserover onmouserout onclick ondbclick

9 为ec:table ec:row ec:column 增加了 tagAttributes属性

该属性用来为元素增加一些自定义的html属性

例如  ec:column 现在并不支持  onmouseup事件

可以通过下面的方式实现

<ec:column tagAttributes="onmouseup=\"alert('test mouse up');\" " .......

10 ec:column属性增加 ellipsis

实现单元格内数据过长的时候 自动截短并加"..."的功能 ie only

因为ff不支持 text-overflow: ellipsis;

使用 ellipsis="true"

使用时 还要为ec:table加上 style="table-layout:fixed;" (如果您已经使用了调整列宽功能 则不用添加)

11 ec:column属性增加  headerSpan

实现表头的跨列显示

使用

<ec:column  headerSpan="2" ...

<ec:column  headerSpan="0" ...

注意当把 一个column 的 headerSpan=设置为 n的时候

那么他下面的 n-1个 column 的 headerSpan 一定要为 0 (这个以后会想办法修正现在这么处理太麻烦了)

12 ec:column属性增加  calcSpan

 实现统计行的标题跨列显示

 使用 

 <ec:column  calc="total" calcTitle= "合计" calcSpan="2" ....

 13 增加 ec:extendrow 标签

在列表前/后加一行或多行 取决于你的html代码怎么写因为这个是绝对自由的 连tr标签都要自己写

 before="true"  (true top false(默认))

 当 before="top"的时候 所加行会出现在 列表表头的上面

 这样你可以做多行表头了  （但这时候 不支持列宽调整 想支持需要自己做些动作详见示例文件demo2.jsp）

例如

    <ec:extendrow before="true">

    <tr>

    <td style="background-color:#ffeedd" >*列表前扩展行</td>

    <td style="background-color:#ffeedd">可以在这里加一些自定内容</td>

    <td style="background-color:#ffeedd" colspan="2">该行与ectable在同一table内</td>

    </tr>

    </ec:extendrow>

    <ec:extendrow>

    <tr>

    <td style="background-color:#eeddff"> </td>

    <td style="background-color:#eeddff">*列表后扩展行</td>

    <td style="background-color:#eeddff">可以在这里加一些自定内容</td>

    <td style="background-color:#eeddff">该行与ectable在同一table内</td>

    </tr>

    </ec:extendrow>

 14 增加 ec:extend 标签

用来在toolbar内增加一些自定义的html代码属性

例如 <ec:extend><a href="#">自定义扩展内容</a></ec:extend>

这时该连接 将会出现在 toolbarContent 中的 extend所在位置

 15 增加 ec:extendbar 标签

在列表前/后加些html代码  属性  before="true"  (true top false(默认))

如果要加的东西比较多  建议使用这个而不要使用ec:extend

ec:extendbar 添加的内容不会和组件自带的tool放到一行

 当 before="top"的时候 所加内容会出现在 列表和列表标题之间

例如

    <ec:extendbar before="true" >

        <span style="color:#999999">*工具条 前扩展块:可以在工具条前加些你自己想加的东西，<b>所加内容和ectable在同一form内</b></span>

        </ec:extendbar>

    <ec:extendbar>

        <span style="color:#999999">*工具条 后扩展块:可以在工具条后加些你自己想加的东西，<b>所加内容和ectable在同一form内</b></span>

    </ec:extendbar>

16 增加了cell类型

复选框 cell="checkbox"  headerCell="checkbox"

单选框 cell="radiobox"  headerCell="riadiobox"

例如

<ec:column cell="checkbox"  headerCell="checkbox"

alias="chkBoxNameXXX" value="chkValue${pre.nickname}"

width="22" viewsAllowed="html" />

注意 value对应生成的 checkBox 的 value ,alias 对应生成的 checkBox 的name

17 增加页面变量 ${TOTALROWCOUNT} 用来标示当前纪录在全部记录中的行数

（${ROWCOUNT}用来标示当前纪录在当前页中的行数）

例子

<ec:column property="name" title="姓名" width="160">${TOTALROWCOUNT},${pre.name}</ec:column>

18 增加了“固定列表头，滚动列表体”(“列表内部滚动条”)的功能

这个功能实现起来比我一开始想像的复杂

不是简单的使用一个 div overflow:scroll就可以搞定的

虽然功能是支持了但是代码肯定还有很多bug或者是可以改进的地方

欢迎大家积极的提出宝贵的意见谢谢了

使用方法：

ec:table标签内增加

listHeight="数字" 属性 （指定列表体的高度）

同时把要指定 width="数字" 不能省略同时要使用绝对大小 而不要使用百分比

详见例子:

demo0.jsp

19 增加shadowRow功能

shadowRow我自己瞎起的名字解释如下：

每行下面可以再加一个子行这个行里显示什么可以由大家自己定义

常见的应用是在有些论坛论坛主题列表里当你点击行开头的小加号的时候 会在这行下面展开一个区域那里面显示的是主帖的内容.

我们可以把这个扩展一下利用ajax从后台去读取我们想读取的信息,这样我们就可以做任何我们想做的事情了)

该功能是不通过标签或java代码实现 纯js实现。

详见例子 demo0.jsp （大家一定要注意看demo0.jsp里的注释啊 呵呵）

其实有了这个功能，大家已经可以自己比较容易的实现可编辑表格的功能了呵呵过一阵我会发一个例子上来

20 ec:table 增加了 excludeParameters 和 includeParameters 属性

使用后，ecside将自动排除或保留属性中所指定的“表单属性”

这个如果你理解了 autoIncludeParameters 的用处就不难理解这两个属性的用处了

注意: excludeParameters 比 includeParameters 有更高的优先级

即 excludeParameters="a"  includeParameters ="a" 时 a仍然将被排除

建议尽量使用 excludeParameters 不要使用 includeParameters ，除非你非常明确自己要包含的东西。

includeParameters 使用不当会使你忘记包含一些必须包含的东西.

excludeParameters="表单属性名称1,表单属性名称2"    (表单属性名称不能含有半角的逗号)

includeParameters="表单属性名称3,表单属性名称4"

    public static void main(String args[]){ 
         java.util.Date current=new java.util.Date();
           java.text.SimpleDateFormat sdf=new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
           String c=sdf.format(current);
           System.out.println(c);
    }
} 
 

12小时制时间显示:

public class Datetime {

    public static void main(String args[]){
         java.util.Date current=new java.util.Date(); 
           java.text.SimpleDateFormat sdf=new java.text.SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
           String c=sdf.format(current); 
           System.out.println(c);
    }
}

两者区别:yyyy-MM-dd HH:mm:ss ;  yyyy-MM-dd hh:mm:ss

如下:

字母  日期或时间元素  表示  示例 
G  Era 标志符  Text  AD 
y  年  Year  1996; 96 
M  年中的月份  Month  July; Jul; 07 
w  年中的周数  Number  27 
W  月份中的周数  Number  2 
D  年中的天数  Number  189 
d  月份中的天数  Number  10 
F  月份中的星期  Number  2 
E  星期中的天数  Text  Tuesday; Tue 
a  Am/pm 标记  Text  PM 
H  一天中的小时数（0-23）  Number  0 
k  一天中的小时数（1-24）  Number  24 
K  am/pm 中的小时数（0-11）  Number  0 
h  am/pm 中的小时数（1-12）  Number  12 
m  小时中的分钟数  Number  30 
s  分钟中的秒数  Number  55 
S  毫秒数  Number  978 
z  时区  General time zone  Pacific Standard Time; PST; GMT-08:00 
Z  时区  RFC 822 time zone  -0800 

起源

JPA的优势

JPA的供应商

JavaServer Pages Standard Tag Libray(1.1),其中文名字为JSP标准标签函数库。JSTL是一个标准的已
制定好的标签库，可以应用于各种领域，如:基本输入输出，流程控制，循环，XML文件剖析，数据库查
询以及国际化和文字格式标准化的应用等。JSTL所提供的标签库分为以下五大类:
 核心标签库(Core tag Liabry)
 I18N格式标签库(I18N-capable formatting tag libary)
 SQL标签库(SQL tag Libary)
 XML标签库(XML tag Libary)
 函数标签库(Functions tag Libary)

核心标签库(Core tag Liabry)主要有:基本输入输出，流程控制，迭代操作和URL操作。
 ----------------------------------------------------------------------------
      分类            功能分类                 标签分类
                                                             out
                                                              set
                          表达式操作                     remove
                                                                   catch
  
     Core                                                      if
                                                                   choose
                           流程控制                            when
                                                                       outherwise

                                                                    forEach
                              迭代操作                      forTokens

                                                                       import
                                                                          param
                                                                       url
                                 URL操作                          param
                                                                     redirect
                                                                           param
------------------------------------------------------------------------------------------
在JSP中使用JSTL中的标签库时，必须使用<%@taglib%>指令，并且设定prefix和uri的值得，通常设定:
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
这样就可以使用核心标签库了。

.表达式操作
 表达式操作分类中包含四个标签: <c:out>,<c:set>,<c:remove>和<c:catch>
<c:out>：重要用来显示数据的内容，类似与<%=scripting-language%>。它的语法如下:
语法1: 没有body内容
<c:out value="value" [escapeXml="{true|false}"] [default="defaultValue"]/>

语法2: 有body内容
<c:out value="value"  [escapeXml="{true|false}"]>
  default value
</c:out>

Attribute
-----------------------------------------------------------------------------------------------------------------------
 名称                      说明                                                               EL     类型     必须       默认值
value                  需要显示的值                                                     Y      Object    是          无
default               如果value值为null,则显示default的值                  Y      Object    否          无
escapeXml        是否转换特殊字符，如: <转换为&It                 Y      Object    否          true
----------------------------------------------------------------------------------------------------------------------
Null和错误说明
假若value为null,会显示default的值；假若没有设定default的值，则会显示一个空的字符串。

<c:set>:主要用来把变量存储至JSP范围或是JavaBean的属性中。
语法1: 没有body
将value的值存储至范围为scope的varName变量之中
<c:set value="value" var="varName" [scope="{page|request|session|application}"]/>

语法2: 有body
将body内容存储至范围为scope的varName变量之中
<c:set value="value" [scope="{page|request|session|application}"]>
  body.....
</c:set>

语法3: 将value的值存储至target对象属性中
<c:set value="value" target="target" property="propertyNmae"/>

语法4: 将body内容的数据存储至target对象属性中
<c:set target="target" property="propertyNmae">
 body....
</c:set>

Attribute
----------------------------------------------------------------------------------------
 名称                    说明                                              EL     类型      必须      默认值
value             要被存储的值                                      Y      Object      否          无
var                欲存入的变量名                                  N      String        否          无
scope            var变量的JSP范围                               N      String        否         page
target            为一JavaBean或java.util.Map对象        Y      Object       否          无
property        指定target对象属性                              Y      String        否          无
------------------------------------------------------------------------------------------
Null 和 错误处理:
语法3和语法4会产生异常错误,有以下两种情况:
 .target 为null
 .target 不是java.util.Map或JavaBean对象
假若value为null时:将由存储变量改为移除变量
 .语法1: 由var和scope所定义的变量，将被移除
    .若scope已指定时，则PageContext.removeAttribute(varName,scope);
    .若scope未指定时，则PageContext.removeAttribute(varName);
 .语法3:
    .假若target为Map时，则Map.remove(property);
    .假若target为JavaBean时，propertye指定的属性为null
注意: var和scope这两个属性不能使用表达式来表示，我们不能写成 scope="${ourScope}"或var="${a}"

<c:remove>:主要用来移除变量。
语法:
<c:remove var="varName" [scope="{page|request|session|application}"]/>

Attribute
----------------------------------------------------------------------------------------
 名称                 说明                                     EL     类型     必须       默认值
 var             欲移除变量的名称                     N      String     是              无
 scope           var变量的JSP范围                    N      String     否             page
----------------------------------------------------------------------------------------
说明:
<c:remove>必须要有var属性，即要被移除的属性名称，scope则可有可无，如:
<c:remove var="username" scope="session"/>
将username变量从session范围移除。若我们不设定scope，则<c:remove>会移除所有范围名称为username
的数据。

<c:catch>:主要用来处理产生错误的异常情况，并且将信息保存起来。
语法:
<c:catch [var="varName"]>
 ...欲抓取错误的部分...
</c:catch>

Attribute
----------------------------------------------------------------------------------------
 名称                 说明                                           EL     类型     必须       默认值
 var           用来存储错误信息的变量                 N      String       否          无
-----------------------------------------------------------------------------------------
说明:
<c:catch>主要将可能发生错误的部分放在<c:catch>和</c:catch>之间。如果真的发生错误，可将错误
信息保存至变量varName标量中，如:
<c:catch var="message">
    //可能发生错误的部分
</catch>
另外，当错误发生<c:catch>和</c:catch>之间时，只有<c:catch>和</c:catch>之间的程序会被中止忽
略，但整个网页不会被中止。

流程控制
流程控制分类中包含四个标签:<c:if>,<c:choose>,<c:when>和<c:otherwise>。

<c:if>:的用途和我们在一般程序中写的if一样。
语法:
语法1：没有body
<c:if test="testCondition" var="varName" [scope="{page|request|session|application}"]/>

语法2: 有body
<c:if test="testCondition" [var="varName"] [scope="{page|request|session|appliation}"]>
  ...body....
</c:if>

Attribute
------------------------------------------------------------------------------------------------------------------------
 名称                           说明                                                                           EL     类型        必须       默认值
test                   如果表达式的结果为true则执行body,false则相反              Y      boolean       是           无
var                   用来存储test运算后的结果，即true或false                           N     String          否           无
scope               var变量的JSP范围                                                                  N     String          否          page
------------------------------------------------------------------------------------------------------------------------
说明:
<c:if>标签必须要有test属性，body里除了能是静态文本之外可以是任何JSP代码，标签或HTML代码。

<c:choose>:本身只当作<c:when>和<c:otherwise>的父标签。
语法:
<c:choose>
  body(<when>和<otherwise>)
</c:choose>
限制:
<c:choose>的本地内容只能有:
 .空白
 .1或多个<c:when>
 .0或多个<c:otherwise>
如:
<c:choose>

 <c:when test="${condition1}">
   condition1 为 true
 </c:when>

 <c:when test="${condition2}">
   condition2 为 true
 </c:when>

 <c:otherwise>
   condition1和conditon2都为false
 </<c:otherwise >
 
</c:choose>
说明:
在同一个<c:choose>中，假如所有的<c:when>的test都不为true时，则执行<c:otherwise>的本体内容。
在同一个<c:choose>中，假若有好几个<c:when>都会true时，只能有一个<c:when>成立。

迭代操作
迭代(Iterator)操作主要包含两个标签: <c:forEach>和<c:forTokens>。

<c:forEach>为循环控制，它可以将集合(Collection)中的成员循序浏览一遍。运做方式为当条件符合
时，就会持续重复执行<c:forEach>的body内容。
语法:
语法1: 迭代一集合对象之所有成员
<c:forEach [var="varName"] items="collection" [varStatus="varStatusName"]
           [begin="begin"] [end="end"] [step="step"]>
 ...body内容.....
<c:forEach>

语法2: 迭代指定的次数
<c:forEach [var="varName"] [varStatus="varStatusName"]
           begin="begin" end="end" [step="step"]>
 ...body内容.....
<c:forEach>

Attribute
--------------------------------------------------------------------------------------------------------------------------
 名称                 说明                                                   EL     类型             必须       默认值
 var          用来存放现在指到的成员                          N      String               否           无

                                                                                               Arrays
                                                                                              Collection
                                                                                               Iterator             否           无
items         被迭代的集合对象                                    Y        Enumeration            
                                                                                               Map
                                                                                                String

varStatus     用来存放到指到的相关成员信息          N        String               否           无
begin           开始的位置                                             Y          int                    否           0
end              结束的位置                                             Y          int                   否           最后一个成员
setp             每次迭代的间隔数                                 Y          int                   否            1
-------------------------------------------------------------------------------------------------------------------------
Null 和 错误处理
.假若items为null时，则表示为一空的集合对象
.假若begin大于或等于items时，则迭代不运算
注意:
varName的范围只存在<c:forEach>的本体中，如果超出了本题，则不能取得varName的值。如:
<c:forEach items="${atts}" var="item">
</c:forEach>
${item}</br>
${item}则不会显示item的内容。<c:forEach>除了支持数组之外，还有标准的J2SE的结合类型，例如:
ArrayList,List,LinkedList,Vector,Stack和Set等等；另外包括java.util.Map类的对象，例如:
HashMap,Hashtable,Properties,Provider和Attributes。

另外<c:forEach>还提供了varStatus属性，主要用来存放现在指到成员的相关信息。例如：我们写成
varStatus="s",那么就会把信息存放到名称为s的属性当中。varStatus属性还提供另外四个属性:index,
count,fist和last，它们个自的意义如下:
------------------------------------------------------------------------------------------
   属性                    类型                                   意义
   index                   number                      现在指到成员的索引
   count                   number                      总共指到成员的总和
   first                     boolean                     现在指到成员是否为第一个
   last                     boolean                     现在指到成员是否为最后一个
-------------------------------------------------------------------------------------------
如下例子:
<%@page contentType="text/html;charset=gb2312"%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%
 String atts[] = new String[5];
 atts[0]="hello";
 atts[1]="this";
 atts[2]="is";
 atts[3]="a";
 atts[4]="girl";
 request.setAttritue("atts",atts);
%>
<c:forEach items="${atts}" var="item" varStatus="s">
<h2><c:out value="${item}"/>的四种属性></h2>
 index: ${s.index}</br>
 count: ${s.count}</br>
 first: ${s.first}</br>
 last:  ${s.last}</br>
</c:forEach>

<c:forTokens>
<c:forTokens>:用来浏览一字符串中所有的成员，起成员是由定义符号(delimiters)所分隔的。
语法:
<c:forTokens items="stringFoTokens" delims="delimmmmiters" [var="varName"]
             [varStatus="varStatusName"] [begin="begin"] [end="end"] [step="step"]>
 ...body内容....
</c:forTokens>

Attribute
--------------------------------------------------------------------------------------------------------------------
 名称                                    说明                                               EL     类型      必须       默认值
 var                   用来存放现在指到的成员                                Y      String       否          无
 items                被迭代的字符串                                                Y      String       是          无
 delims              定义用来分割字符串的字符                            N      String       是          无
 varStatus          用来存放现在指到的相关成员信息                N      String       否          无
 begin               开始的位置                                                         Y       int           否           0
 end                 结束的位置                                                          Y       int          否           最后一个成员
 step                每次迭代间隔数                                                  Y       int           否           1
---------------------------------------------------------------------------------------------------------------------
限制:
.假若有begin属性时，begin必须大于等于0
.假若有end属性时，必须大于begin
.假若有step属性时，step必须大于等于1

Null 和 错误处理
.假如itmes为null时,则表示为有空的集合对象
.假若begin大于等于items的大小时，则迭代不运算

例子:
<c:forToken items="A,B,C,D,E,F,G" delims="," var="item>
${item}
</c:forToken>
items属性也可以用EL，例如:
<%
 String phonenumber="123-456-7899";
 request.setAttribute("userPhone",phonenumber);
%>
<c:forTokens items="${userPhone}" delims="-" var="item">
${item}
</c:forTokens>

URL操作
JSTL包含三个URL操作有关的标签,分别是: <c:import>,<c:redirect>和<c:url>。它们的主要功能是：
用来将其他文件的内容包含起来，网页的向导，还有url的产生。

你可以通过这个链接引用该篇文章:http://shijian0916nunu.bokee.com/viewdiary.12079441.html

出现错误如下:

<2007-9-30 下午12时03分03秒 CST> <Error> <WebLogicServer> <BEA-000337> <ExecuteThread: '13' for queue: 'weblogic.kernel.Default' has been busy for "901" seconds working on the request "Http Request: /admin/school.do", which is more than the configured time (StuckThreadMaxTime) of "600" seconds.>

关键词： 协议 原理 实现 cas

CAS(Central Authentication Service) 是 Yale 大学发起的一个开源项目，据统计，大概每 10 个采用开源构建 Web SSO 的 Java 项目，就有 8 个使用 CAS 。对这些统计，我虽然不以为然，但有一点可以肯定的是， CAS 是我认为最简单实效，而且足够安全的 SSO 选择。
       本节主要分析 CAS 的安全性，以及为什么 CAS 被这样设计，带着少许密码学的基础知识，我希望有助于读者对 CAS 的协议有更深层次的理解。
从结构体系看， CAS 包含两部分：
l         CAS Server
CAS Server 负责完成对用户的认证工作， CAS Server 需要独立部署，有不止一种 CAS Server 的实现， Yale CAS Server 和 ESUP CAS Server 都是很不错的选择。
CAS Server 会处理用户名 / 密码等凭证 (Credentials) ，它可能会到数据库检索一条用户帐号信息，也可能在 XML 文件中检索用户密码，对这种方式， CAS 均提供一种灵活但同一的接口 / 实现分离的方式， CAS 究竟是用何种认证方式，跟 CAS 协议是分离的，也就是，这个认证的实现细节可以自己定制和扩展。
l         CAS Client
CAS Client 负责部署在客户端（注意，我是指 Web 应用），原则上， CAS Client 的部署意味着，当有对本地 Web 应用的受保护资源的访问请求，并且需要对请求方进行身份认证， Web 应用不再接受任何的用户名密码等类似的 Credentials ，而是重定向到 CAS Server 进行认证。
目前， CAS Client 支持（某些在完善中）非常多的客户端，包括 Java 、 .Net 、 ISAPI 、 Php 、 Perl 、 uPortal 、 Acegi 、 Ruby 、 VBScript 等客户端，几乎可以这样说， CAS 协议能够适合任何语言编写的客户端应用。
 剖析协议就像剖析设计模式，有些时候，协议让人摸不着头脑。 CAS 的代理模式要相对复杂一些，它引入了一些新的概念，我希望能够在这里描述一下其原理，有助于读者在配置和调试 CAS SSO 有更清晰的思路。
如果没记错， CAS 协议应该是由 Drew Mazurek 负责可开发的，从 CAS v1 到现在的 CAS v3 ，整个协议的基础思想都是基于 Kerberos 的票据方式。
       CAS v1 非常原始，传送一个用户名居然是 ”yes david.turing” 的方式， CAS v2 开始使用了 XML 规范，大大增强了可扩展性， CAS v3 开始使用 AOP 技术，让 Spring 爱好者可以轻松配置 CAS Server 到现有的应用环境中。
CAS 是通过 TGT(Ticket Granting Ticket) 来获取 ST(Service Ticket) ，通过 ST 来访问服务，而 CAS 也有对应 TGT ， ST 的实体，而且他们在保护 TGT 的方法上虽然有所区别，但是，最终都可以实现这样一个目的——免去多次登录的麻烦。
       下面，我们看看 CAS 的基本协议框架：
基础协议

                                                 CAS 基础模式
       上图是一个最基础的 CAS 协议， CAS Client 以 Filter 方式保护 Web 应用的受保护资源，过滤从客户端过来的每一个 Web 请求，同时， CAS Client 会分析 HTTP 请求中是否包请求 Service Ticket( 上图中的 Ticket) ，如果没有，则说明该用户是没有经过认证的，于是， CAS Client 会重定向用户请求到 CAS Server （ Step 2 ）。 Step 3 是用户认证过程，如果用户提供了正确的 Credentials ， CAS Server 会产生一个随机的 Service Ticket ，然后，缓存该 Ticket ，并且重定向用户到 CAS Client （附带刚才产生的 Service Ticket ）， Service Ticket 是不可以伪造的，最后， Step 5 和 Step6 是 CAS Client 和 CAS Server 之间完成了一个对用户的身份核实，用 Ticket 查到 Username ，因为 Ticket 是 CAS Server 产生的，因此，所以 CAS Server 的判断是毋庸置疑的。
       该协议完成了一个很简单的任务，就是 User(david.turing) 打开 IE ，直接访问 helloservice 应用，它被立即重定向到 CAS Server 进行认证， User 可能感觉到浏览器在 helloservcie 和 casserver 之间重定向，但 User 是看不到， CAS Client 和 CAS Server 相互间的 Service Ticket 核实 (Validation) 过程。当 CAS Server 告知 CAS Client 用户 Service Ticket 对应确凿身份， CAS Client 才会对当前 Request 的用户进行服务。
CAS 如何实现 SSO
       当我们的 Web 时代还处于初级阶段的时候， SSO 是通过共享 cookies 来实现，比如，下面三个域名要做 SSO ：
http://www.blogjava.net
http://www.matrix.org.cn
http://www.csdn.net
如果通过 CAS 来集成这三个应用，那么，这三个域名都要做一些域名映射，
http://blogjava.cas.org
http://matrix.cas.org
http://csdn.cas.org
因为是同一个域，所以每个站点都能够共享基于 cas.org 的 cookies 。这种方法原始，不灵活而且有不少安全隐患，已经被抛弃了。
CAS 可以很简单的实现跨域的 SSO ，因为，单点被控制在 CAS Server ，用户最有价值的 TGC-Cookie 只是跟 CAS Server 相关， CAS Server 就只有一个，因此，解决了 cookies 不能跨域的问题。
回到 CAS 的基础协议图，当 Step3 完成之后， CAS Server 会向 User 发送一个 Ticket granting cookie (TGC) 给 User 的浏览器，这个 Cookie 就类似 Kerberos 的 TGT ，下次当用户被 Helloservice2 重定向到 CAS Server 的时候， CAS Server 会主动 Get 到这个 TGC cookie ，然后做下面的事情：
1，              如果 User 的持有 TGC 且其还没失效，那么就走基础协议图的 Step4 ，达到了 SSO 的效果。
2，              如果 TGC 失效，那么用户还是要重新认证 ( 走基础协议图的 Step3) 。
 CAS 的代理模式
 模式 1 已经能够满足大部分简单的 SSO 应用，现在，我们探讨一种更复杂的情况，即用户访问 helloservice ， helloservice 又依赖于 helloservice2 来获取一些信息，如同：
User à helloservice à helloservice2
这种情况下，假设 helloservice2 也是需要对 User 进行身份验证才能访问，那么，为了不影响用户体验（过多的重定向导致 User 的 IE 窗口不停地 闪动 ) ， CAS 引入了一种 Proxy 认证机制，即 CAS Client 可以代理用户去访问其它 Web 应用。
代理的前提是需要 CAS Client 拥有用户的身份信息 ( 类似凭据 ) 。 与其说之前我们提到的 TGC 是用户持有对自己身份信息的一种凭据，则这里的 PGT 就是 CAS Client 端持有的对用户身份信息的一种凭据。凭借 TGC ， User 可以免去输入密码以获取访问其它服务的 Service Ticket ，所以，这里，凭借 PGT ， Web 应用可以代理用户去实现后端的认证，而无需前端用户的参与。
如下面的 CAS Proxy 图所示， CAS Client 在基础协议之上，提供了一个额外的 PGT URL 给 CAS Server, 于是， CAS Server 可以通过 PGT URL 提供一个 PGT 给 CAS Client 。


       初学者可能会对上图的 PGT URL 感到迷惑，或者会问，为什么要这么麻烦，要通过一个额外的 URL( 而且是 SSL 的入口 ) 去传递 PGT ？如果直接在 Step 6 返回，则连用来做对应关系的 PGTIOU 都可以省掉。 PGTIOU 设计是从安全性考虑的，非常必要， CAS 协议安全性问题我会在后面一节介绍。
于是， CAS Client 拿到了 PGT( PGTIOU-85…..ti2td ) ，这个 PGT 跟 TGC 同样地关键， CAS Client 可以通过 PGT 向后端 Web 应用进行认证。如下图所示， Proxy 认证与普通的认证其实差别不大， Step1, 2 与基础模式的 Step 1,2 几乎一样，唯一不同的是， Proxy 模式用的是 PGT 而不是 TGC ，是 Proxy Ticket （ PT ）而不是 Service Ticket 。
最终的结果是， helloservice2 明白 helloservice 所代理的客户是 David. Turing 同学，同时，根据本地策略， helloservice2 有义务为 PGTURL=http://helloservice/proxy 服务 (PGTURL 用于表示一个 Proxy 服务 ) ，于是它传递数据给 helloservice 。这样， helloservice 便完成一个代理者的角色，协助 User 返回他想要的数据。


   代理认证模式非常有用，它也是 CAS 协议 v2 的一个最大的变化，这种模式非常适合在复杂的业务领域中应用 SSO 。因为，以前我们实施 SSO 的时候，都是假定以 IE User 为 SSO 的访问者，忽视了业务系统作为 SSO 的访问者角色。

2、主动域对象模式 
主动域对象是实体域对象的一种形式，它在实现中封装了关系数据模型和数据访问的细节。在 J2EE 架构中，EJB组件分为会话EJB和实体EJB。会话EJB通常实现业务逻辑，而实体EJB表示业务实体。实体EJB又分为两种：由EJB本身管理持久化，即BMP（Bean-Managed Persistence）；由EJB容器管理持久化，即CMP（Container-Managed Persistence）。BM P就是主动域对象模式的一个例子，BMP 表示由实体 EJB 自身管理数据访问细节。 
主动域对象模式有以下优点： 
(1)、在实体域对象中封装自身的数据访问细节，过程域对象完全负责业务逻辑，使程序结构更加清晰。 
(2)、如果关系数据模式发生变化，只需要修改主动域对象的代码，不需要修改过程域对象的业务方法。 
主动域对象模式有以下缺点： 
(1)、在实体域对象的实现中仍然包含SQL语句。 
(2)、每个实体域对象都负责自身的数据访问实现。把这一职责分散在多个对象中，这会导致实体域对象重复实现一些共同的数据访问操作，从而造成重复编码。 
主动域对象本身位于业务逻辑层，因此采用主动域对象模式时，整个应用仍然是三层应用结构，并没有从业务逻辑层分离出独立的持久化层。 
3．CMP模式 
在J2EE架构中，CMP（Container-Managed Persistence）表示由EJB容器来管理实体EJB 的持久化，EJB容器封装了对象-关系的映射及数据访问细节。CMP 和ORM的相似之处在于，两者都提供对象-关系映射服务，都把对象持久化的任务从业务逻辑中分离出来。区别在于CMP负责持久化实体EJB组件，而ORM负责持久化 POJO，它是普通的基于 Java Bean 形式的实体域对象。 
CMP模式的优点在于： 
(1)、他是基于EJB技术，是SUN J2EE体系的核心部分，获得了业界的普遍支持，包括各大厂商和开源组织等。如果选择它作企业级开发，技术支持会非常完备。 
(2)、功能日趋完善，包括了完善的事务支持，EJBQL查询语言，透明的分布式访问等等 
CMP模式的缺点在于： 
(1)、开发人员开发的实体必须遵守复杂的J2EE规范，而多少ORM中间件没有类似要求。 
(2)、实体域EJB只能运行在EJB容器中，而POJO可以运行在任何一种Java环境中。 
(3)、尽管按照J2EE的规范，EJB应该是一种可移植组件，实际应用时确受到很大限制。而ORM中间件就不存在这样的问题。 
4．ORM模式 
ORM-Object/Relational Mapper，即“对象-关系型数据映射组件”。对于O/R，即 Object（对象）和 Relational（关系型数据），表示必须同时使用面向对象和关系型数据进行开发。建模领域中的 ORM 为 Object/Role Modeling（对象角色建模）。另外这里是“O/R Mapper”而非“O/R Mapping”。相对来讲，O/R Mapping 描述的是一种设计思想或者实现机制，而 O/R Mapper指以O/R原理设计的持久化框架（Framework），包括 O/R机制、SQL自生成、事务处理和Cache管理等。 
一般把基于 Java Bean 形式的实体域对象称为 POJO（Plain Old Java Object），意为又普通又古老的 Java 对象的意思。随着各种 ORM 映射工具的日趋成熟和流行，POJO有重现光彩，它和基于 CMP 的实体 EJB 相比，既简单又具有很高的可移植性，因此联合使用ORM 映射工具和 POJO，已经成为一种越来越受欢迎的且用来取代 CMP 的持久化方案。POJO的缺点就是无法做远程调用，不支持分布式计算。 
常用的ORM中间件有：Hibernate、Apache OJB、Cayenne、Jaxor、TopLink等。其中 Hibernate 的轻量级 ORM 模型逐步确立了在 Java ORM 架构中领导地位，甚至取代复杂而又繁琐的 EJB 模型而成为事实上的 Java ORM 工业标准。而且其中的许多设计均被 J2EE 标准组织吸纳而成为最新 EJB 3.0 规范的标准。 
5．JDO模式 
JDO是近几年新兴的数据持久性技术，Java Data Objects（JDO）是 SUN 公司制定的描述对象持久化语义的标准API。严格的说，JDO 并不是对象-关系映射接口，因为它支持把对象持久化到任意一种存储系统中，包括关系数据库、面向对象的数据库、基于XML的数据库，以及其他专有存储系统。由于关系数据库是目前最流行的存储系统，许多JDO的实现都包含了对象-关系映射服务。 JDO模式的优点是： 
(1)、简单易用，不需要写大量无用的接口，不需要继承什么特殊的类，唯一所要做的就是对你的class文件做一下enhance。 
(2)、真正面向对象。用了JDO的java程序是真正的面向对象，无需再理会数据库里面有什么表格，存取都是以java　object为对象，所有数据库表格都是自动生成的。 
(3)、方便的数据库移植。应用程序换数据库时候除了换一个JDBC　driver,　换一下数据库URL,无需对程序做任何改动。 
JDO模式的缺点是： 
由于是新兴技术，一些IT巨头还没有给予足够的支持，其中包括IBM、Oracle、BEA。 
四. 总结 
关于这些技术优劣之争从它们刚刚出生那天起从来就没有停止过，而各家各派也从来没有能够说服过对方。对于应用开发者而言，撇开应用纯粹来争论技术优劣并没有多大意义。没有最好的，只有最合适的。在做开发的时候能够选择一个最合适于自己应用的技术，那就足够了。总的来说，JDBC面向RDBMS,比较适合关系数据库模式驱动的应用，例如统计表格数据，生成报表之类的应用。EJB　技术以J2EE应用服务器为中心，如果应用确实需要灵活的可声明的事务边界，需要支持大容量的访问和不间断的服务，需要应用服务器的集群，那么选EJB吧。JDO则面向对象，对于以域对象为中心的应用，包含图，树模型的应用，JDO是首选。

作者 Michael Yuan译者 包亮 发布于 2007年11月2日 上午1时3分

社区

Java

主题

Web框架

本文节选了Michael Yuan和Thomas Heute所著的即将出版JBoss Seam: Power and Flexibility Beyond Java EE 5.0第一章和第二章，内容有所删减。

什么是Seam？

JBoss Seam是“Java EE 5.0的一个轻量级的框架”。这是什么意思？难道Java EE(Enterprise Edition) 5.0本身不是一套“框架吗”？为什么在官方规范之外，还需要另外一个框架？好吧，我们就将seam看作是本应该被包括在Java EE 5.0中的一个“遗漏的框架”吧。它在Java EE 5.0框架的上层，为所有的在企业Web应用中的组件提供了一个统一的、易于理解的编程模型。它同样使基于状态的应用和业务流程驱动的应用的开发易如反掌。换句话说，Seam致力于开发者生产力和应用扩展性。

1. 整合和强化Java EE框架

Java EE5.0的核心框架是EJB(Enterprise JavaBeans)3.0和JSF(JavaServer Faces)1.2。EJB 3.0(以下简称EJB3)是基于一个POJO(Plain Old Java Objects)的业务服务和数据库持久化的轻型框架。JSF是一个基于MVC(Model-View-Controller)的Web应用框架。大多数的Web应用都将包含有业务逻辑的EJB3组件和Web应用前端显示的JSF组件。EJB3和JSF虽然互补，但是他们是根据各自的理念设计的独立的框架。例如，EJB3使用注解（annotation）来配置服务，而JSF使用的是XML文件。更进一步讲，EJB3和JSF组件在框架层面上是互不敏感的。要整合EJB3和JSF，开发者必须手动地构造facade对象（如：JSF支持bean），将业务组件与Web页面和样板代码（又称plumbing代码）联结起来，以便能跨框架调用方法。将这些技术粘合起来是Seam的职责之一。

Seam打破了EJB3和JSF之间的人工层，它为整合EJB3和JSF提供了一个一致的，基于注解的途径。只需要个别简单的注解，Seam中的EJB3业务组件就能直接被用来支持JSF Web表单或者处理Web UI事件。Seam允许开发者将“同一种东西”——有注解的POJOs——应用与所有的应用组件。与其他Web框架开发的应用相比，Seam应用概念简洁，同样的功能却需要较少的代码（在JAVA和XML中）。如果没有耐心，或者想要快速预览，一个Seam到底有多简单，你可以现看看本文描述的hello world一例。

在JSP来说困难的任务，Seam可以轻易的完成。例如，JSF头疼的一个问题就是过分依赖HTTP POST。这使得将一个添加到书签中的JSF网页，通过HTTP GET访问相当困难。但是有了Seam，生成一个REST网页是非常容易的。Seam提供了一系列JSF组件标签和注解，增加了“web友好”和JSF应用的网页效率。

同时，Seam拓展了EJB3到POJO的组件模式, 从web层到业务层都有了状态上下文。进一步说，Seam整合了一系列主要的其他开放源代码框架，例如jBPM、JBoss Rules(又名Drools)、JBoss Portal、JBoss Microcontainer等等。Seam不仅能将它们“有机结合”起来，而且可以像整合JSF和EJB3一样强化原有的框架。

Seam位于Java EE 5.0底层，但它的应用并不局限与Java EE 5.0服务器。一个Seam应用可以部署在J2EE 1.4应用服务器和Tomcat服务器上。这意味着现在能在Seam应用中得到产品化支持。

1 + 1 > 2

或许有这样一种误解，认为Seam仅仅是将各种不同框架串起来的另外一个集成框架。Seam提供了它自身管理的状态上下文，允许框架通过注解和EL（表达式语言）表达式与其他框架进行深度整合。整合的程序来自于Seam开发者对第三方框架的认知。

2. 一个为ORM设计的Web框架

对象关系映射(ORM)解决方案在当今企业应用中广为使用。但是，大多数当前的业务和web框架并不是为ORM设计的，它们并不在整个Web交互生命周期——从请求来临到响应完成——管理持久上下文。这就导致了包括可怕的LazyInitializationException在内的各种ORM异常，带来了如“数据传输对象（DTO）”等丑陋的伎俩（ugly hacks）。

Gavin King发明了Seam，同时他也发明了在世界上广为使用的ORM解决方案Hibernate。为了继承和发扬ORM的最佳实践，Seam进行了重新设计。有了Seam，就不必再写DTO，你所做的就是延迟加载。因为扩展后的持久上下文就如同一个自然的高速缓存，可以减少和数据库的交互，ORM的性能就会被极大地改进。

进一步讲，因为Seam整合了ORM层、业务层和表示层，开发者就能够在表示层直接展示ORM对象，也能把数据库验证注解用于输入表单，以及重新定向ORM例外到定制的错误页面。

3.专为有状态Web应用而设计

Seam是专为有状态Web应用而设计的。Web应用是天生的多用户应用，电子商务应用天生也是有状态的和有事务的。但是，大多数已有Web应用框架是面向无状态应用的。开发者必须操作HTTP会话（session）对象来管理用户状态，与核心业务逻辑无关的代码不仅会混乱你的应用，而且带来了一系列的性能问题。

在Seam中，所有的基础应用组件天生地有状态。它们使用起来要比HTTP session容易，因为它们的状态由Seam公开管理。没有必要在Seam应用中编写引起麻烦的状态管理代码——只需在其组件上注解其做用域、生命周期方法以及其他状态属性，Seam就会掌管其他[译者注：指这些组件的生命周期]。Seam状态组件要比HTTP会话（session）能更好的管理用户状态。例如，你能有多个“会话”进行，每个“会话”由在一个HTTP会话（session）中一系列的Web请求和业务方法调用组成。

进一步说，在Seam中，数据库缓存和事务能自动与应用的状态相连。Seam在内存中自动保存数据库更新，等到对话结束后提交到数据库。内存中的缓存能大大减轻复杂状态应用中数据库的负载。

除了以上这些，Seam支持整合开源JBoss jBPM业务程序引擎，大大提升了Web应用中的状态管理。你现在能为一个机构中不同工作人员（诸如客户、经理、技术支持人员等等）的指定工作流程，利用工作流程来驱动应用，而不是依赖用户界面事件处理和数据库。

4. 支持Web 2.0

Seam为Web2.0应用进行了充分的优化。它给AJAX（异步JavaScript和XML，增加网页交互的一种技术）提供了多种支持——从内置“零Javascript”的AJAX组件到有AJAX支持的JSF组件，再到定制的JavaScript库，Seam为浏览器端的Javascript对象提供了直接访问Seam服务器组件的途径。Seam提供了一个先进的并发模型，有效的管理来自同一用户的多个AJAX请求。

对于AJAX应用，不断增长的数据库负载是一个巨大的挑战。与一个非AJAX应用相比，一个AJAX应用要向服务器发送的更频繁的请求。一但数据库必须响应这些AJAX请求，那么数据库就不堪重荷。Seam中的状态持久上下文正如一个内存中的缓存，它能在会话始末保存信息，最终帮助减少数据库交互。

Web2.0应用往往为其数据使用复杂关系模型（例如，一个网络交际站点所做的就是处理和显示“用户”之间的关系），对于这些站点，延迟加载对于ORM层至关重要。否则，一个简单的查询就能级联地加载整个数据库。正如我们前面所讨论过的，Seam是现今唯一一个正确支持Web应用延时加载的Web框架。

5.依赖双向映射的Pojo服务

Seam是一个“轻量级”框架，因为它使用POJO（plain old Java objects）作为服务组件。在应用中，POJO没有使用接口或抽象类来"钩住"组件。当然，问题是如何使POJO交互来组成这个应用？它们如何与容器服务（例如，数据库持久化服务）交互？

Seam通过使用一个流行的、被称作依赖注入(DI)的设计模式联结所有POJO组件。在这个模式下，Seam框架管理着所有组件的生命周期。当一个组件需要使用另外一个时，它通过注解（annotation）向Seam声明此依赖。Seam依据应用当前状态得到这个依赖组件，并将它注入到所需求的组件中。

通过拓展依赖注入概念，一个Seam组件A不但可以构造另外一个组件B，而且把此组件B“抛还”给Seam以备其他组件（例如组件C）以后使用。

这类双向依赖管理甚至都广泛的应用于简单的Seam web应用中（例如第二章的hello world一例）。在Seam术语中，我们称这个为“依赖双向映射”。

6.非常规的配置

使Seam易用的主要设计原则是“非常规的配置”。其思想是为这些组件提供一系列默认行为，开发者只需要在预期行为非默认的时候，显示地配置组件。例如, 当Seam将组件A作为属性注入到组件B时，默认地，组件A刚会以组件B被注入的属性的名称命名。Seam里还有很类似的细节。总的结果是Seam中配置元数据要比其他Java框架简单的多。因此，大多数的Seam应用能通过一系列简单的Java注解进行充分配置。开发者从减化的复杂度中受益匪浅，最后，与其他Java框架相比，用更少的代码实现同样的功能。

7.避免滥用XML

或许你已经注意到，Java注解在表述和处理Seam配置元数据时扮演着重要的角色。通过这样的设计使框架更易于操作。

在J2EE发展早期，XML曾经被看作配置管理的“圣杯”。框架设计者将所有的配置信息，包括Java类和方法名称都统统丢进XML文档，而不考虑对开发者所带来的后果。反省后，发现这是个严重的错误。XML配置文档太过重复。开发者必须重复代码中已有的信息，从而将配置和代码联结起来。这些重复使应用易于出错（例如，一个拼写错误的类名可能在运行时显示为一个难于调试错误）。缺少合理的默认配置进一步使这一问题复杂化。事实上，在一些框架中，相当数量的样板代码伪装为XML，可能相当于或者超过实际应用中JAVA代码的数量。对于J2EE开发者，XML的滥用通常被称为“XML地狱”。

Java社区认识到了XML的滥用问题，并且已经非常成功地用Java代码中的注解取代了XML。EJB3是Java官方标准化机构促进Java企业组件中注解使用的一项成果。EJB3完全可选择的使用XML文档，它向正确方向迈出了积极的一步。Seam加入了EJB3的注解，为整个web应用拓展了基于注解的编程模型。

当然，XML对于配置数据并非完全不利。Seam设计者认识到XML适用于指定页面流程或者定义业务流程的web应用。XML文档使开发者集中地管理整个web应用的工作流程成为可能，同时也反对将配置信息分散于java源文件中。工作流程很少能与源代码耦合，因此XML文档中并不需要重复键入已存在于代码中的信息。

8.为测试而设计

Seam为了易于测试而重新设计。因为所有的Seam组件都是注解过的POJO，它们易于进行单元测试。开发者仅仅通过利用常规的Java new关键词来构造实例，然后在测试框架（例如JUnit 或者TestNG）中运行任何方法。如果需要测试多个Seam组件的交互，开发者则逐个实例化这些组件，然后手动建立它们的相互关系（也就是显示地使用setter 方法，而不是依靠Seam依赖注入功能）。

集成测试整个Seam应用比较复杂，因为开发者必须在Seam容器中运行应用。Seam用嵌入的轻量级容器来帮助该类测试。在测试框架中，开发者能按步骤地加载Seam容器，然后运行测试。

9. 卓越的工具支持

对于一个聚焦于开发者生产力的应用框架，开发工具的支持至关重要。Seam发布了一个基于命令行的生成器，称作 SeamGen。SeamGen类似于Ruby-On-Rails中的生成器，它支持诸如从一个数据库生成完整CRUD应用的功能，聪明的开发者会通过诸如“编辑/保存/在浏览器重新载入”的步骤、有测试支持的特性，来改进web应用。

但更重要的是，SeamGen生成项目不依赖于主流的Java集成开发环境，如Eclipse和NetBeans。有了SeamGen，开发者可以随时入门。

10. 让我们开始编码吧

总而言之，Seam为JavaEE应用削减了开发费用，同时，增加了Java EE 5.0不具有的强大的新功能。在下节（节选自本书第二章），我们将给您展示一些实际代码例子来阐述Seam如何工作的。你能通过网站http://www.michaelyuan.com/seam/下载到本书中所有的例子的源代码。

Seam Hello World

JBoss Seam是EJB3和JSF中间的粘合剂，这是Jboss Seam最基本的和最广泛的应用。通过被Seam管理的组件，Seam允许这两个框架之间无缝(不是有意双关的)的集成。它为整个web应用拓展了基于注解的EJB3 POJO编程模型。在层与层之间，没有了必需的手动JNDI查找，没有了冗长的JSF支持bean的声明，没有了过多facade方法，没有了艰辛的对象传递，快哉！

继续在Seam中使用JavaEE模式

在传统的java EE应用中，一些设计模式，例如JNDI查找、XML声明组件、值对象、facade是被强制使用的。Seam用基于注解的POJO消除了这些人为的需求。但是，当Seam应用中真正需要它们的时候，仍然可以自由地使用这些模式。

编写一个Seam web应用概念上很简单。你只需要编码出下列组件：

• 实体对象代表数据模型。实体对象可能是JPA或者Hibernate中的POJO对象。它们自动地映射到关系数据库表。
• SF web页面展示了用户界面。页面通过表单捕获用户的输入，并且显示结果。表单域与其数据显示数据库表，这些表被映射到实体bean或者实体bean的集合上。
• EJB3 会话bean或者注解过的Seam POJO可以作为JSF Web页面的UI事件处理器。它们处理封装在实体bean中的用户输入，为下一步（或者页面）生成显示的数据对象。

所有以上组件均由Seam自行管理，它们在运行时被自动注入到正确的页面或者对象。例如，当用户单击按钮提交一个JSF表单，Seam就会自动解析表单域并构造一个实体bean。然后，Seam将实体bean传入同样被Seam构造的事件处理器会话bean中来处理。开发者不需要在代码中管理组件的生命周期和组件之间的相互关系。依赖处理过程中，没有样板代码和XML文件。

本章中，我们使用hello world一例来明确展示Seam如何粘合一个web应用。该例子工作如下：用户能在web表单中输入其名字来“问候”Seam。一旦她提交了表单，应用则保存她的名字到一个关系数据库中，并且显示所有已经“问候”过Seam的用户。该项目示例在该书下载的源代码中的HelloWorld文件夹中。为了建立它，你必须安装Apache ANT 1.6版本以上 (http://ant.apache.org/)。进入HelloWorld目录，运行命令ant，则会生成build/jars/helloworld.ear文件，可以直接拷贝该文件到Jboss AS实例的server/default/deploy目录下。现在，启动JBoss AS并且打开网址http://localhost:8080/helloworld/。

为了运行本书中的例子，我们建议您使用JEMS GUI安装程序安装一个与Seam兼容的JBoss AS。您可以从http://labs.jboss.com/portal/jemsinstaller/downloads下载JEMS安装程序。如果您需要更多安装JBoss AS和应用部署帮助，请参见附录A，“安装和部署JBoss AS”

欢迎使用示例作为模板，快速开始你自己Seam项目（参见附录B “使用应用示例作为模板”）。或者，你能使用命令行工具Seam Gen (参见第四章“快速应用开发工具”)自动生成项目模板，包括所有的配置文件。本章中，我将花少量的时间来阐释源代码项目中的目录结构。相反，我们将集中讨论代码和配置，这也是开发者建立一个Seam 应用必需的。如此，我们就能将知识应用到任何一个项目结构，而不需要受模板的限制。

源代码目录

一个Seam应用由java类和XML或文本配置文件组成。本书的项目例子中，java源代码文件在src目录中，网页在view 目录中，所有的配置文件都在resources目录中。更多信息请看附件B,使用应用示例作为模板。

1. 创建一个数据模型

Helloworld应用中的数据模型仅仅是一个有name和id属性的person 类。注解@Entity告诉容器映射该类到一个关系数据库表，每个属性对应表中一个字段，每个person实例相当于表中的一条记录。因为Seam采用非常规的配置方式，容器为表名和字段中仅仅使用类名和属性名。属性id上的@Id和@GeneratedValue注解暗示id字段是主键，它的值是应用服务器为每个保存到数据库的peron对象自动生成。

@Entity

@Name("person")

public class Person implements Serializable {



private long id;

private String name;



@Id @GeneratedValue

public long getId() { return id;}

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



public String getName() { return name; }

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

}

Person类中最重要的注解是@Name，它为这个将要注册于Seam中的Person bean指定了名称。在其他Seam组件中（例如，页面和会话bean）中，开发者能指直接使用“person”来引用被管理的Person bean。

2. 将数据模型映射到web表单

在JSF页面中，我们使用Person bean来支持表单输入文本域。#{person.name}符号指代名为“person”的Seam组件的name属性，名为“person”的Seam组件是Person实体bean的一个实例。

<h:form>

Please enter your name:<br/>

<h:inputText value="#{person.name}" size="15"/><br/>

<h:commandButton type="submit" value="Say Hello"

action="#{manager.sayHello}"/>

</h:form>

通过以下的实体表单，JSF页面显示了数据库中所有已经向Seam说“hello”的用户。用户名单列表存储在一个名为“fans”的Seam组件中，它是一个List 对象。JSFdataTable通过遍历列表，每一行显示一个Person对象。Fan标记是fans列表的迭代子。

<h:dataTable value="#{fans}" var="fan">

<h:column>

<h:outputText value="#{fan.name}"/>

</h:column>

</h:dataTable>

图2.1显示了Hello World网页

当用户点击“Say Hello”按钮提交表单，Seam用输入数据构造了该person组件。然后它调用了名为“manager”的Seam 组件的sayhello()的方法(像这样，#{manager.sayHello}是表单提交按钮的UI事件处理器)，这就在数据库中保存了person对象并且刷新了fans列表。名为manager的组件是一个EJB3的会话bean, 我们将在下节讨论该话题。

2. 处理web事件

Seam 中的名为manager的组件是会话bean ManagerAction，正如该类中@Name注解指定的。ManagerAction类有person和fans两个属性，这两个属性被@In和@Out所注解。

@Stateless

@Name("manager")

public class ManagerAction implements Manager {



@In @Out

private Person person;



@Out

private List <Person> fans; 

注解@In和@Out在Seam编程模型中处于核心。因此，让我们看看到底它们在这里是做什么的。

注解@In告诉Seam，在此会话bean中，执行任何一个方法之前，Seam就会把由JSF表单构造的名为person组件赋给该person字段（通过依赖注入）。开发者能为@In中的注入的组件指定一个任意的名称，但是如果没有指定，如这里所示，Seam会将同类型以及同名称的组件注入到该字段中。注解@Out告诉Seam，在执行任何方法后，Seam会将属性fans值和属性person的值都赋给被Seam管理的同名的组件。在Seam中，我们将这个操作称作 “依赖抛出”。以此，在ManagerAction.sayHello()方法中，我们仅仅需要更新属性fans和属性person的值，它们会自动显示在页面上。

什么是双向映射

在Seam 文件中，有时你就会看到术语“双向映射”。它指的是被Seam管理的组件和Seam管理上下之间的注入和抛出。

因为person属性已经通过注入持有了表单数据，sayHello()方法仅仅是通过JPA EntityManager将它保存到数据库中，JPA EntityManager也是通过@PersistenceContext注入的。当方法返回之后，它便更新了fans和person对象并且把这两个对象抛出。方法sayHello()一般会返回null，预示着在调用之后，更新的数据模型将在当前的JSF页面显示。

  @PersistenceContext

private EntityManager em;



public String sayHello () {

em.persist (person);

person = new Person ();

fans = em.createQuery("select p from Person p")

.getResultList();



return null;

}

除了一些细节，我们基本完成了。可能你已经注意到，ManagerAction bean类实现了Manager接口。为了符合EJB3会话bean 规范，我需要一个能列出bean中所有业务方法的方法。下面是接口Manager代码，幸运的是，用任何高级IDE工具都能轻松地自动生成这个接口。

@Local

public interface Manager {

public String sayHello ();

}

这就是在Hello World例子中需要的所有代码。后面两章小节将涵盖Seam应用的其他方法和配置。如果开发者为了自己的小型数据库应用想立即编码和定制helloworld项目，那么现在就可以跳过本章的剩余部分。

4. 更易于理解的seam编程模型

现在我们已经大致了解了Hello World的应用。但是我们还有一些重要的话题继续，例如其他折中途径以及前面代码没有涉及到重要特性，我们将在本节讨论这些话题。它们能帮助开发者对seam更深刻的理解，但是如果你没有耐心，可以直接跳过本节，需要的时再来阅读。

4.1 Seam POJO组件

上例中，我们用一个EJB3会话bean实现了应用逻辑，但是我们并不局限于EJB3组件。事实上，Seam中任何一个有@Name注解的POJO都能被转化为一个可管理的组件。

例如，我们能将ManagerAction转化为一个 POJO，而不是一个EJB3 session bean。

@Name("manager")

public class ManagerAction {



@In (create=true)

private EntityManager em;



... ...

} 

使用POJO取代EJB3 bean有正反两方面意见，使用POJO编程时很简单，因为它们不需要EJB3特有的注解和接口（参见上文）。如果你的所有业务组件都是Seam POJO, 那么你就能不依赖EJB3应用服务器，运行你的Seam 应用（参见23章，没有EJB3的Seam)。

但是，POJO比EJB3的功能少，因为POJO不能获得EJB3容器服务。在不依赖EJB3的Seam 中丧失的EJB3服务就包括以下几点：

• @PersistenceContext注入在POJO中不在管用。为了在一个Seam POJO中得到EntityManager，开发者不得不在Seam配种文件中初始化EntityManager，然后使用Seam注解@In将它注入到POJO中。
• POJOs中将不在支持方法级别事务声明（declarative method-level transaction）。相反，你可以配置Seam来划分事务，可以从收到web请求开始直到响应页面产生结束。
• Seam POJO不是消息驱动组件。
• 不支持注解为@Asynchronous的方法。
• 不支持容器安全管理。
• 没有事务或者组件级别的持久上下文。Seam POJO中的所有的持久上下文都是经过拓展的（更多细节请参见7.1 “默认的对话作用域”）。
• 没有集成容器管理的体系结构（例如，JMX控制台服务）。
• Seam POJO方法中没有Java RMI。
• Seam POJO不能是注解为@WebService组件。
• 没有JCA集成。

所以当在EJB3容器中进行部署时，为什么每个人都想使用POJO组件？答案就是，POJO组件对于纯“业务逻辑”组件非常有益。POJO为其他组件代理了数据访问、消息传递和其他基本功能。例如，我们能使用POJO组件操纵Seam数据访问对象，这对“业务逻辑”POJO是非常有用的，因为它们可以在需要的时候，在其他框架中被重用。但是总的来说，它们的应用要比EJB3组件少，特别是在中小型应用中。所以，本书的大多数例子我们都使用EJB3组件。

4.2 易于测试

我们已经在第一章中提到，Seam为了不依赖容器的方便的测试，进行了重新设计。在helloworld项目中，我们在测试文件夹中包括了单元测试和集成测试这两个测试用例。在纯Java SE环境下，Seam 测试体系模拟了数据库、JSF、Seam上下文以及其他应用服务器服务，只要运行ant test命令就能运行所有的测试。

4.3 基于Getter和Setter的双向映射

在Hello World一例中，我们已经展示了通过成员变量对Seam组件进行的双向映射，你也能通过Getter和Setter方法对组件进行双向映射。例如，以下代码就工作的很好。

private Person person;

private List <Person> fans;



@In

public void setPerson (Person person) {

this.person = person;

}

@Out

public Person getPerson () {

return person;

}

@Out

public List <Person> getFans () {

return fans;

}

虽然以上的getter和setter方法看似轻微，利用getter和setter方法的双向映射真正的价值在于能其加入定制逻辑来操纵双向映射的过程。例如，你可以验证被注入的对象或者快速地从数据库重新得到被抛出的对象。

4.4避免过度的双向映射

在Hello World一例中 ,通过将数据组件作为业务组件的属性，可以轻易的减少或者消除双向映射。在JSF页面中，通过这种方式，开发者只需要引用业务组件，而不需要在业务组件和数据组件之间的双向映射。例如，开发者可以修改 ManagerAction类为以下所述。

依赖双向映射是一个非常实用的设计模式。但是，正如其他设计模式，过度使用就会有害。过度的依赖双向映射让代码变得难以阅读，因为开发者必须理解每个注入的组件出自何处。过度的依赖双向映射也能增加性能消耗，因为双向映射是在运行时进行。

@Stateless

@Name("manager")

public class ManagerAction implements Manager {



private Person person;

public Person getPerson () {return person;}

public void setPerson (Person person) {

this.person = person;

}



private List <Person> fans;

public List<Person> getFans () {return fans;}



...  ...

}

接下来，我们在页面上引用的属性如下：

<h:form>



Please enter your name:<br/>



<h:inputText value="#{manager.person.name}"/>

<br/>

<h:commandButton type="submit" value="Say Hello"

action="#{manager.sayHello}"/>

</h:form>

... ...

<h:dataTable value="#{manager.fans}" var="fan">

<h:column>

<h:outputText value="#{fan.name}"/>

</h:column>

</h:dataTable>

最后，具有了依赖管理的Seam是多用的。通常用数据访问业务组件封装数据是一项好的实践，特别是针对有状态业务组件。

4.5 JSF中的页面导航

本例中，只有一个页面。每次点击按钮后，JSF页面会重新显示更新过的数据模型。显然，大多数web应用多于一个页面。在JSF中，一个用户界面事件处理器能通过返回导航规则名称，决定下一步该显示哪个页面。例如，开发者可以在navigation.xml中定义以下导航规则。

<navigation-case>

<from-outcome>anotherPage</from-outcome>

<to-view-id>/anotherPage.jsp</to-view-id>

</navigation-case>

之后，如果sayHello()方法返回一个名为“another page”的字符串，JSF下一步就该展示anotherPage.jsp。UI事件处理器决定了接下来要显示哪个页面，从而为我们带来了有步骤的控制。

4.6 通过EntityManager访问数据库

JPA（Java Persistence API）EntityManager管理着关系数据库表与实体bean 之间的映射。EntityManager 在运行时由应用服务器创建。你能使用注解@PersistenceContext，注入一个EntityManager的实例。

EntityManager.persist()方法将实体bean存为与之对应数据表的一条记录。EntityManager.query()方法运行SQL化的查询，并以实体bean集合形式从数据库返回数据。更多细节请参考JPA文件中关于如何使用EntityManager和查询语言。在本书中，我们只用最简单的查询语句。

默认地，EntityManager将数据存于嵌入的HSQL数据库中。如果在本机上运行Jboss AS，可以通过以下步骤，为HSQL数据库开启一个GUI控制台：访问http://localhost:8080/jmx-console/，点击database=localDB,service=Hypersonic MBean服务，之后，点击在startDatabaseManager方法下方的“invoke”按钮。你就可以从控制台执行任意SQL指令。

5. 配置和打包

下面，我们将转移话题，讨论配置文件和应用程序打包。实际上，你可以通过Seam Gen命令行工具，生成几乎所有的配置文档和构造脚本文件。或者你也可以简单的重用在示例中的源文件。所以，如果你想首先学习Seam编程技术，但又担心接下来的配置和部署，这个是很正常的。你可以完全放心地跳过本节，需要的时候可以再次阅读。

本节中，我们集中探讨Seam EJB3组件配置，JBoss AS外的Seam POJO配置和部署当然是可行的。

大多数Seam配置文件都是XML文档。但是等等！我们刚才不是承诺Seam能让我们摆脱J2EE和Spring中的XML地狱吗？为什么它又有了XML文档呢? 是的，XML文档确实有很多用处。XML文档非常适合部署阶段的配置（例如web应用的根URL和后台数据库的定位）。因为它允许我们在部署阶段改变配置而不需要改变和重新编译源代码。它也适合粘合应用服务器中的不同子系统（例如，配置如何让JSF组件与Seam EJB3组件交互）。XML文档也非常适合表示层相关内容（例如网页和页面导航流程）。

我们反对在XML文档中重复已经存在于Java源代码中的信息。开发者很快就会发现，这个简单的SeamEJB3 应用有多个XML配置文档，每个文档那个都非常简短，并且没有一个包含存在于Java代码中的信息。换句话说，Seam中没有“XML代码”。

进一步讲，XML文档中的大多数内容都是静态的。所以开发者能在自己的Seam应用中轻松地重用这些文档。如何使用示例作为自己的应用模板的介绍，请参见附录B——使用应用示例作为模板。

我们将用下面几页来详细讲解示例应用的配置文档和打包后的目录结构。如果你没有耐心看下去，而且很满意这个应用模板，你可以跳过以下内容。不管怎样，不再罗嗦, 我们一起来了解hello world示例是如何进行配置和打包的。为了构建一个JBoss AS的部署Seam 应用，我们必须将以上所有java 类和配置文档打包为企业应用程序归档(EAR)。该例中，EAR文件是helloworld.ear。它包含了三个JAR文件那个和两个XML配置文档。

helloworld.ear

|+ app.war        //包含Web页面等

|+ app.jar        //包含Seam组件

|+ jboss-seam.jar // Seam库

|+ META-INF

|+ application.xml

|+ jboss-app.xml  

源代码目录

在此项目的源代码中，resources/WEB-INF目录包含属于app.war/WEB-INF目录的配置文档。resources/META-INF目录包含属于app.jar/META-INF和helloworld.ear/META-INF的文档。Resources根目录包含属于根目录app.jar的文档。

application.xml文档列出了在EAR中的JAR文件，并为该应用指定了根URL。

<application>

<display-name>Seam Hello World</display-name>



<module>

<web>

<web-uri>app.war</web-uri>

<context-root>/helloworld</context-root>

</web>

</module>



<module>

<ejb>app.jar</ejb>

</module>



<module>

<java>jboss-seam.jar</java>

</module>



</application>

jboss-app.xml文档为该应用指定了类加载器，每个EAR应用的类加载器应该有一个唯一的名称。这里我们使用应用程序名作为类加载器的名称，以避免重复。

<jboss-app>

<loader-repository>

helloworld:archive=helloworld.ear

</loader-repository>

</jboss-app>

jboss-seam.jar是Seam发布Seam类库。app.war和app.jar文档由我们来建构。所以，下面我们要研究app.war和app.jar。

5.1. WAR文件

app.war是按照Web应用程序归档规范打包的JAR文件，它包含页面和标准的JSF/Seam配置文档。你还可以将JSF特有的类库文件放入WEB-INF/lib目录 (例如jboss-seam-ui.jar)。

app.war

|+ hello.jsp

|+ index.html

|+ WEB-INF

|+ web.xml

|+ faces-config.xml

|+ components.xml

|+ navigation.xml

web.xml文档是所有java EE web应用必需的。JSF用它来配置JSF servlet控制器，Seam用它来拦截所有的web请求。该配置文档的相当标准。

<web-app version="2.4"

xmlns="http://java.sun.com/xml/ns/j2ee"

xmlns:xsi="..."

xsi:schemaLocation="...">



<!-- Seam -->

<listener>

<listener-class>

org.jboss.seam.servlet.SeamListener

</listener-class>

</listener>



<!-- MyFaces -->

<listener>

<listener-class>

org.apache.myfaces.webapp.StartupServletContextListener

</listener-class>

</listener>



<context-param>

<param-name>

javax.faces.STATE_SAVING_METHOD

</param-name>

<param-value>client</param-value>

</context-param>



<servlet>

<servlet-name>Faces Servlet</servlet-name>

<servlet-class>

javax.faces.webapp.FacesServlet

</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>



<!-- Faces Servlet Mapping -->

<servlet-mapping>

<servlet-name>Faces Servlet</servlet-name>

<url-pattern>*.seam</url-pattern>

</servlet-mapping>

<context-param>

<param-name>javax.faces.CONFIG_FILES</param-name>

<param-value>/WEB-INF/navigation.xml</param-value>

</context-param>

</web-app>

faces-config.xml文档是JSF标准的配置文档，Seam用它来将其拦截器添加到JSF生命周期中。

<faces-config>



<lifecycle>

<phase-listener>

org.jboss.seam.jsf.SeamPhaseListener

</phase-listener>

</lifecycle>



</faces-config>

navigation.xml文档为多页面应用包含JSF页面导航规则。因为hello world示例只有一个简单的页面，因此该文档是空的。

components.xml文档包含Seam特有的配置选项，除jndi-pattern属性以外，其他都不依赖于应用。该属性必须包括EAR文档的名称，以便Seam通过其的JNDI全名访问EJB3 bean。

<components ...>



<core:init

jndi-pattern="helloworld/#{ejbName}/local"

debug="false"/>



<core:manager conversation-timeout="120000"/>



</components>

5.2. Seam组件JAR包

app.jar文档包含所有的EJB3bean 类（实体bean和会话bean）以及EJB3相关的配置文档。

app.jar

|+ Person.class        // entity bean

|+ Manager.class       // session bean interface

|+ ManagerAction.class // session bean

|+ seam.properties     // empty file but needed

|+ META-INF

|+ ejb-jar.xml

|+ persistence.xml

seam.properties文档这儿是空但必需的，因为Jboss要通过它知道此JAR文件包含Seam EJB3 bean类，并且相应地处理注解。

ejb-jar.xml文档包含额外的配置信息，这些信息能重载或者增补EJB3 bean上的注解。在一个Seam应用中，它能将所有的EJB3 类加入Seam拦截器。我们能在所有的Seam应用中重用该文档。

<ejb-jar>

<assembly-descriptor>

<interceptor-binding>

<ejb-name>*</ejb-name>

<interceptor-class>

org.jboss.seam.ejb.SeamInterceptor

</interceptor-class>

</interceptor-binding>

</assembly-descriptor>

</ejb-jar>

persistence.xml文档为EJB3 实体bean配置了后台数据源。本例中，我们只是使用了被嵌入到JBoss AS中默认的HSQL数据库(也就是java:/DefaultDS数据源)。

<persistence>

<persistence-unit name="helloworld">

<provider>

org.hibernate.ejb.HibernatePersistence

</provider>

<jta-data-source>java:/DefaultDS</jta-data-source>

<properties>

<property name="hibernate.dialect"

value="org.hibernate.dialect.HSQLDialect"/>

<property name="hibernate.hbm2ddl.auto"

value="create-drop"/>

<property name="hibernate.show_sql" value="true"/>

</properties>

</persistence-unit>

</persistence>

这样，以上就是一个简单Seam应用所需的所有配置和打包。我们将在以后讨论到本书的更高级的主题时，涵盖更多的配置选项和类库。再次强调一下，Seam应用入门最简单的方法就是，不要担心这些配置文件，只需要从已有的应用模板做起。

6. 为何这么简单？

这就是hello world 应用，三个简单的Java类，一个JSF页面，一组静态配置文件。我们已经有了一个完整的数据库驱动的web应用。整个应用只需要的是少于30行的Java代码，没有一处“XML代码”。但是如果开发者有PHP背景，你可能仍然会问“何以这么简单？我能在php中使用更少的代码吗？”

好吧，答案就是Seam应用在理论上要比PHP（或者其他任何一种脚本语言）应用简单的多。Seam 组件模式允许我们，有所控制地，可维护地给应用增加更多的功能。我们很快就会发现，Seam组件使开发有状态的和有事务的web应用变得易如反掌。对象关系映射框架（例如：实体bean）允许我们将注意力放在抽象数据模型上，而不需要处理数据库特有的SQL语句。

本文是基于该书的第一章和第二章。后面的章节中，我们继续讨论如何使用Seam组件继续开发复杂的Seam 应用。参见本书目录来查看本书的所有主题。

请看Gavin King的两个访谈录来查看以往关于Seam的话题。

• JBoss Seam 1.1 Indepth: An Interview with Gavin King
• JBoss Seam 1.0: rethinking web application architecture

关于作者

Dr. Michael Yuan是JBoss Seam: Simplicity and Power Beyond Java EE 5.0一书的作者。该书探讨了下一代web应用框架。他同时也是Nokia Smartphone Hacks一书和其他三本技术读物的作者。Michael潜心研究轻量级企业web应用，终端对终端的移动应用开发。你可以通过他的博客联系他。

2.4  决策3：访问数据库

无论怎样组织和封装业务逻辑，最终你必须从数据库存取数据。在标准J2EE应用程序里，你主要有两种选择：JDBC，这需要进行大量低层的编码；实体bean，难用而且缺少有分量的特性。相比之下，使用轻量级框架最令人兴奋的是，你可以选择新的更强大的方式访问数据库，能显著减少必须编写的数据库访问相关代码量。下面，让我们来具体分析一下。

2.4.1  直接使用JDBC存在什么问题

近来，对象/关系型数据库映射框架（如JDO和Hibernate）和SQL映射框架（如iBATIS）的异军突起并非毫无根据。实际上，它们是Java社区反复受挫于JDBC的产物。为了理解新近框架产生的动因，让我们先探讨一下直接使用JDBC存在的问题。对多数应用程序来说，直接使用JDBC并非上佳选择，主要有如下3个原因。

n  开发和维护SQL困难而且耗时——一些开发人员发现编写大型、复杂的SQL语句相当困难。为反映数据库模式的变化，及时更新SQL语句也可能相当耗时。你需要仔细权衡，为了使用JDBC，损失可维护性是否值得。

n  SQL缺少可移植性——由于常常需要使用数据库专有的SQL，应用程序如要处理多种数据库，你就必须编写多个版本的SQL语句，维护可能成为噩梦。即使实际应用中你

的应用程序只用到一种数据库，但由于SQL缺少可移植性，有可能因此妨碍你使用更简单、更快捷的内存数据库，如对Hypersonic结构化查询语言数据库引擎（HSQLDB）进行测试。

n  编写JDBC代码耗时而且容易出错——为获取连接、创建和初始化制备语句（Prepared Statement），并通过关闭连接和制备语句进行清理，你必须编写大量样板代码。你还必须编写代码实现Java对象和SQL语句之间的映射。JDBC代码编写起来枯燥无味，而且容易出错。

如果你的应用程序必须直接执行SQL语句，那么前两个问题就不可避免。有时，为取得最佳性能，你必须用上SQL的十八般武艺，甚至包括厂商提供的专有特性。或者，出于各种业务上的原因，你的DBA可能要求完全控制应用程序执行的SQL语句，这样一来，你就无法使用那些即时（on the fly）生成SQL语句的持久层框架。通常，公司在其关系型数据库上的投入非常巨大，以致于与数据库协作的应用程序反倒显得不那么重要了。引用iBATIS in Action作者的一段话，有时“数据库，甚至SQL本身的生命周期比应用程序源代码还长，甚至在应用程序经历了多个版本后，它们仍然健在。有些情况下，应用程序已经用另一种语言重新编写，而SQL和数据库却仍变化不大”。如果直接使用SQL把你搞得焦头烂额，算你走运，有个框架可以直接执行SQL，而且比JDBC更易使用。当然了，那就是iBATIS。

2.4.2  使用iBATIS

我开发过的所有企业Java应用程序都直接执行SQL。早期的应用程序只使用SQL，后来则使用了持久层框架，并在一些组件里使用SQL。一开始，我使用普通的JDBC执行SQL语句，不过后来，我通常自己编写小型框架处理JDBC使用中比较枯燥的部分。Spring的JDBC类我也用过一段时间，它们可以消除大量样板代码。但是无论是我自己编写的框架还是Spring类，在将Java类映射成SQL语句时都存在问题，这正是我与iBATIS不期而遇时激动不已的原因。

除了能让应用程序与连接和制备语句彻底隔绝外，iBATIS还能用XML描述符文件把JavaBean映射成SQL语句。它使用Java bean的内省机制将bean属性映射到制备语句占位符，并从ResultSet构建bean。iBATIS还支持数据库生成主键，自动加载相关对象，实现缓存及延迟加载。这样一来，

iBATIS就消除了执行SQL语句带来的大量苦差事。在后面几章，包括第9章里，你会发现iBATIS可以显著简化执行SQL语句的那部分代码。你不必再编写大量低层JDBC代码，只需编写XML描述符文件，并调用一些iBATIS API即可。

2.4.3  使用持久层框架

当然，iBATIS无法解决开发和维护SQL带来的开销，也不能弥补SQL缺少可移植性的不足。要避免这些问题，只有使用持久层框架，它可以将领域对象映射到数据库上。持久层框架提供创建、获取和删除对象的API。当应用程序游历对象之间的关系时，它能自动从数据库加载对象，并在事务结束时自动更新数据库。持久层框架通过对象/关系映射可以自动生成SQL，一般这种映射由XML文档指定，该文档定义怎样将类映射到表，属性映射到字段，以及怎样将关系映射成外键和连接表。

EJB 2也有持久层框架的功能有限的形式：实体bean。不过，EJB 2实体bean的不足实在太多，并且开发和测试也极其枯燥乏味。因此，应该尽量少用EJB 2实体bean。此外，正如我在第10章里描述的，目前还不确定EJB 3将解决多少不足。

两种最流行轻量级持久层框架是Sun公司标准JDO[JSR12][JSR243]和开源项目Hibernate。两者都提供POJO类的透明持久化。你可以直接使用POJO类开发和测试自己的业务逻辑，不用担心持久化，然后把这些类映射到数据库模式。此外，这两种框架都可以在应用服务器里面和外面运行，从而进一步简化开发。用Hibernate和JDO进行开发比用旧式的EJB2的实体bean要舒服得多。

本书有好几章描述怎样有效使用JDO和Hibernate。在第5章，你将学习如何使用JDO持久化领域模型。第6章则讨论如何使用Hibernate持久化领域模型。在第11章，你将学习如何使用JDO和Hibernate高效查询大型数据库及处理庞大的结果集。

除了决定怎样访问数据库外，你还必须决定如何处理数据库并发。下面让我们分析一下并发处理为何重要，以及可用的选项。


原文：http://book.csdn.net/bookfiles/367/10036714013.shtml