BlogJava-Sealyu-随笔分类-Spring

getHibernateTemplate()和getSession()的区别（转）

seal — Mon, 22 Feb 2010 08:43:00 GMT

在前一篇日志中自动生成hibernate配置文件的时候，会在dao层用到getSession()方法来操作数据库记录，但是他还有个方法getHibernateTemplate()，这两个方法究竟有什么区别呢？

1.使用getSession()方法你只要继承sessionFactory，而使用getHibernateTemplate()方法必须继承 HibernateDaoSupport当然包括sessionFactory，这点区别都不是特别重要的，下面这些区别就很重要了

2.getSession()方法是没有经过spring包装的，spring会把最原始的session给你，在使用完之后必须自己调用相应的 close方法，而且也不会对声明式事务进行相应的管理，一旦没有及时关闭连接，就会导致数据库连接池的连接数溢出，getHibernateTemplate()方法是经过spring封装的，例如添加相应的声明式事务管理，由spring管理相应的连接。

在实际的使用过程中发现的确getHibernateTemplate()比getSession()方法要好很多，但是有些方法在getHibernateTemplate()并没有提供，这时我们用HibernateCallback 回调的方法管理数据库.

例如如下代码：

/**
     * 使用 hql 语句进行操作
     * @param hql HSQL 查询语句（使用回调函数访问外部变量，必须是final的）
     * @param offset 开始取数据的下标
    * @param length 读取数据记录数
    * @return List 结果集
*/
public List getListForPage ( final String hql , final int offset , final int length ) {

              List list = getHibernateTemplate().executeFind ( new HibernateCallback ( ) {
                            public Object doInHibernate ( Session session ) throws HibernateException, SQLException {
                                            Query query = session.createQuery ( hql ) ;
                                            query.setFirstResult ( offset ) ;
                                            query.setMaxResults ( length ) ;
                                            List list = query.list ( ) ;
                                            return list ;
                           }
               }) ;
               return list ;
}

seal 2010-02-22 16:43 发表评论

Spring 的 HibernateDaoSupport 类的 getSession() 导致的连接泄露问题（转）

seal — Mon, 22 Feb 2010 08:43:00 GMT

摘要: Spring+Hibernate做项目, 发现有member在不加事务的情况下就去调用 getSession() 方法, 结果导致数据库连接不能释放, 也无法正常的提交事务(只能做查询, 不能做save(), update()). 如果配合连接池使用的话, 不出几分钟就会导致连接池无法拿到新连接的情况. 不过, 只要给DAO或者Service加入了事务, 就不会出现连接泄漏的问题. 谈谈解... 阅读全文

seal 2010-02-22 16:43 发表评论

spring的DriverManagerDataSource与apache的BasicDataSource（转）

seal — Tue, 02 Feb 2010 14:04:00 GMT

情况是这样的。。。

2008-3-18 1:08:26 org.apache.tomcat.util.threads.ThreadPool logFull
严重: All threads (150) are currently busy, waiting. Increase maxThreads (150) or check the servlet status

重新启动服务器之后，问题依然存在。
分析得出以下可能情况
1.连接数达到了150的最大上限
2.服务器端响应用户请求的时间过长导致
3.连接池的配置数出了问题

分析：
1.1个用户访问是OK的，当用2个用户对localhost进行访问，所以根本不可能达到并发访问线程的150的上限，所以应该不是数据库的原因,排除了第一种可能
2.之前访问的JSP已经经过多次访问，所以不可能是第一次访问编译，运行而导致的请求时间过长的原因，第二情况也否定。

到此，经过分析可以确定的是连接池出了问题...

首先有2个知识点需要再弄的更清楚一些

DriverManager与DataSource 连接数据库有何区别?
        DriverManager传统的jdbc连接，通过Class.forName("XXX"),的办法注册之后，就可以DriverManager.getConnection()获得连接了。

        DataSource是建立在JNDI服务基础上的,需要application server配置datasource.首先需要注册一个DataSource(一般在/META-INF/context.xml下)然后在 web.xml文件中引用这个DataSource,就可以DataSource.getConnection()获得连接,具体操作参考(tomcat 目录里的JNDI Resources小节)

DataSource 与 DBCP pool(连接池) 的区别？
        J2EE 服务器启动时会建立一定数量的池连接，并一直维持不少于此数目的池连接。客户端程序需要连接时，池驱动程序会返回一个未使用的池连接并将其表记为忙。如果当前没有空闲连接，池驱动程序就新建一定数量的连接，新建连接的数量有配置参数决定。当使用的池连接调用完成后，池驱动程序将此连接表记为空闲，其他调用就可以使用这个连接。
相当于是优化了DataSource的一种工具

跟数据库连接的部分是通过Spring的DataSource JDBC连接的,配置的XML内容如下:

Xml代码

class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
/WEB-INF/classes/config/pkm/environment/jdbc.properties
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
${pkm.jdbc.driverClassName}
${pkm.jdbc.url}
${pkm.jdbc.username}
${pkm.jdbc.password}
class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close" lazy-init="false">






/WEB-INF/classes/config/pkm/environment/jdbc.properties












${pkm.jdbc.driverClassName}



${pkm.jdbc.url}


${pkm.jdbc.username}


${pkm.jdbc.password}

所以问题就出在这里,当使用BasicDataSource后问题不在出现,所以是连接数量造成的,在访问数量大,并发的情况下,毫无疑问是要选择连接池的,因为有连接池的功能,无论是效率还是在资源利用率上都优于DriverManagerDataSource

从而从根本上了解了spring的DriverManagerDataSource与apacheBasicDataSource之间的区别.

有时候可能需要配置Jndi服务

Xml代码

class="org.springframework.jndi.JndiObjectFactoryBean">

这三种连接方式常常使用，也容易混淆，选择其中的某一种，就需要看具体环境来配置了。

PS：jdbc.properties文件中的配置如下

Properties代码

pkm.jdbc.driverClassName=oracle.jdbc.OracleDriver
pkm.jdbc.url=jdbc":oracle":thin":@109.52.20.31":1521":orcl
pkm.jdbc.name=pkmuser
pkm.jdbc.password=dbl0gin
pkm.jdbc.dataSource=pkmDataSource

关于Spring整合发现的一些问题。收藏

Spring提供了两个这样的数据源（都位于org.springframework.jdbc.datasource程序包里）：
DriverManagerDataSource：在每个连接请求时都新建一个连接。与DBCP的BasicDataSource不同，DriverManagerDataSource提供的连接没有进行池管理。
SingleConnectionDataSource：在每个连接请求时都返回同一个连接。虽然它不同严格意义上的池管理数据源，但我们可以把它看作只有一个连接的池。
对两个数据源的配置都类似于配置DBCP的BasicDataSource
区别在于由于DriverManagerDataSource和SingleConnectionDataSource都没有提供连接池，所以在此没有设置池配置属性。
虽然这两个数据源都对于小程序来说是很不错的，而且还在不断发展，但把它们用于生产程序还是需要认真考虑的。

SingleConnectionDataSource只使用一个数据库连接，所以不适合用于多线程程序。而 DriverMangerDataSource虽然能够支持多线程，但它会在每次连接请求时都新建一个连接，这是以性能为代价的。由于这些限制，我们强烈建议应该使用数据源池。

在通过数据源与数据库建立连接之后，我们就要实际访问数据库了，而最基本的方式就是使用JDBC，现在我们就来看一看Spring如何让使用简单的JDBC更加简便。
Spring在第三方依赖包中包含了两个数据源的实现类包，其一是Apache的DBCP，其二是 C3P0。可以在Spring配置文件中利用这两者中任何一个配置数据源。

DBCP数据源
DBCP 类包位于 /lib/jakarta-commons/commons-dbcp.jar，DBCP是一个依赖 Jakarta commons- pool对象池机制的数据库连接池，所以在类路径下还必须包括/lib/jakarta- commons/commons-pool.jar。下面是使用DBCP配置MySql数据源的配置片断：

xml 代码
         destroy-method="close">




bean>

BasicDataSource提供了close()方法关闭数据源，所以必须设定destroy-method=”close”属性，以便Spring容器关闭时，数据源能够正常关闭。除以上必须的数据源属性外，还有一些常用的属性：
     defaultAutoCommit：设置从数据源中返回的连接是否采用自动提交机制，默认值为 true；
     defaultReadOnly：设置数据源是否仅能执行只读操作，默认值为 false；
     maxActive：最大连接数据库连接数，设置为0时，表示没有限制；
     maxIdle：最大等待连接中的数量，设置为0时，表示没有限制；
     maxWait：最大等待秒数，单位为毫秒，超过时间会报出错误信息；
     validationQuery：用于验证连接是否成功的查询SQL语句，SQL语句必须至少要返回一行数据，如你可以简单地设置为：“select count(*) from user”；
     removeAbandoned：是否自我中断，默认是 false ；
     removeAbandonedTimeout：几秒后数据连接会自动断开，在removeAbandoned为true，提供该值；
     logAbandoned：是否记录中断事件，默认为 false；

C3P0数据源
C3P0 是一个开放源代码的JDBC数据源实现项目，它在lib目录中与Hibernate一起发布，实现了JDBC3和JDBC2扩展规范说明的 Connection 和Statement 池。C3P0类包位于/lib/c3p0/c3p0-0.9.0.4.jar。下面是使用C3P0配置一个 oracle数据源：

xml 代码
         destroy-method="close">




bean>

ComboPooledDataSource和BasicDataSource一样提供了一个用于关闭数据源的close()方法，这样我们就可以保证Spring容器关闭时数据源能够成功释放。
     C3P0拥有比DBCP更丰富的配置属性，通过这些属性，可以对数据源进行各种有效的控制：
     acquireIncrement：当连接池中的连接用完时，C3P0一次性创建新连接的数目；
     acquireRetryAttempts：定义在从数据库获取新连接失败后重复尝试获取的次数，默认为30；
     acquireRetryDelay：两次连接中间隔时间，单位毫秒，默认为1000；
     autoCommitOnClose：连接关闭时默认将所有未提交的操作回滚。默认为false；
     automaticTestTable： C3P0将建一张名为Test的空表，并使用其自带的查询语句进行测试。如果定义了这个参数，那么属性preferredTestQuery将被忽略。你不能在这张Test表上进行任何操作，它将中为C3P0测试所用，默认为null；
     breakAfterAcquireFailure：获取连接失败将会引起所有等待获取连接的线程抛出异常。但是数据源仍有效保留，并在下次调    用getConnection()的时候继续尝试获取连接。如果设为true，那么在尝试获取连接失败后该数据源将申明已断开并永久关闭。默认为 false；
     checkoutTimeout：当连接池用完时客户端调用getConnection()后等待获取新连接的时间，超时后将抛出SQLException，如设为0则无限期等待。单位毫秒，默认为0；
     connectionTesterClassName：通过实现ConnectionTester或QueryConnectionTester的类来测试连接，类名需设置为全限定名。默认为 com.mchange.v2.C3P0.impl.DefaultConnectionTester；
     idleConnectionTestPeriod：隔多少秒检查所有连接池中的空闲连接，默认为0表示不检查；
     initialPoolSize：初始化时创建的连接数，应在minPoolSize与maxPoolSize之间取值。默认为3；
     maxIdleTime：最大空闲时间，超过空闲时间的连接将被丢弃。为0或负数则永不丢弃。默认为0；
     maxPoolSize：连接池中保留的最大连接数。默认为15；
     maxStatements： JDBC的标准参数，用以控制数据源内加载的PreparedStatement数量。但由于预缓存的Statement属于单个Connection 而不是整个连接池。所以设置这个参数需要考虑到多方面的因素，如果maxStatements与 maxStatementsPerConnection 均为0，则缓存被关闭。默认为0；
     maxStatementsPerConnection：连接池内单个连接所拥有的最大缓存Statement数。默认为0；
     numHelperThreads：C3P0是异步操作的，缓慢的JDBC操作通过帮助进程完成。扩展这些操作可以有效的提升性能，通过多线程实现多个操作同时被执行。默认为3；
     preferredTestQuery：定义所有连接测试都执行的测试语句。在使用连接测试的情况下这个参数能显著提高测试速度。测试的表必须在初始数据源的时候就存在。默认为null；
     propertyCycle：用户修改系统配置参数执行前最多等待的秒数。默认为300；
     testConnectionOnCheckout：因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的时候都将校验其有效性。建议使用 idleConnectionTestPeriod或automaticTestTable
等方法来提升连接测试的性能。默认为false；
     testConnectionOnCheckin：如果设为true那么在取得连接的同时将校验连接的有效性。默认为false。

读配置文件的方式引用属性：

         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

bean>
         destroy-method="close">




bean>

     在jdbc.properties属性文件中定义属性值：
     jdbc.driverClassName= com.mysql.jdbc.Driver
     jdbc.url= jdbc:mysql://localhost:3309/sampledb
     jdbc.username=root
     jdbc.password=1234
     提示经常有开发者在${xxx}的前后不小心键入一些空格，这些空格字符将和变量合并后作为属性的值。如：的属性配置项，在前后都有空格，被解析后，username的值为“ 1234 ”，这将造成最终的错误，因此需要特别小心。

获取JNDI数据源
如果应用配置在高性能的应用服务器（如WebLogic或Websphere等）上，我们可能更希望使用应用服务器本身提供的数据源。应用服务器的数据源使用JNDI开放调用者使用，Spring为此专门提供引用JNDI资源的JndiObjectFactoryBean类。下面是一个简单的配置：

xml 代码


bean>

通过jndiName指定引用的JNDI数据源名称。
Spring 2.0为获取J2EE资源提供了一个jee命名空间，通过jee命名空间，可以有效地简化J2EE资源的引用。下面是使用jee命名空间引用JNDI数据源的配置：

xml 代码
xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance
xmlns:jee=http://www.springframework.org/schema/jee
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/jee
http://www.springframework.org/schema/jee/spring-jee-2.0.xsd">

beans>

Spring的数据源实现类
Spring 本身也提供了一个简单的数据源实现类DriverManagerDataSource ，它位于 org.springframework.jdbc.datasource包中。这个类实现了javax.sql.DataSource接口，但它并没有提供池化连接的机制，每次调用getConnection()获取新连接时，只是简单地创建一个新的连接。因此，这个数据源类比较适合在单元测试或简单的独立应用中使用，因为它不需要额外的依赖类。
下面，我们来看一下DriverManagerDataSource的简单使用：当然，我们也可以通过配置的方式直接使用DriverManagerDataSource。

java 代码
DriverManagerDataSource ds = new DriverManagerDataSource ();
ds.setDriverClassName("com.mysql.jdbc.Driver");
ds.setUrl("jdbc:mysql://localhost:3309/sampledb");
ds.setUsername("root");
ds.setPassword("1234");
Connection actualCon = ds.getConnection();

小结

不管采用何种持久化技术，都需要定义数据源。Spring附带了两个数据源的实现类包，你可以自行选择进行定义。在实际部署时，我们可能会直接采用应用服务器本身提供的数据源，这时，则可以通过JndiObjectFactoryBean或jee命名空间引用JNDI中的数据源。

DBCP与C3PO配置的区别：

C3PO ：

xml 代码

         oracle.jdbc.driver.OracleDrivervalue>
     property>

         jdbc:oracle:thin:@10.10.10.6:1521:DataBaseNamevalue>
      property>

         testAdminvalue>
     property>

         123456value>
     property>
bean>

DBCP：

xml 代码


         oracle.jdbc.driver.OracleDrivervalue>
     property>

         jdbc:oracle:thin:@10.10.10.6:1521:DataBaseNamevalue>
      property>

         testAdminvalue>
     property>

         123456value>
     property>
bean>

seal 2010-02-02 22:04 发表评论

spring为ApplicationContext提供的3种实现

seal — Tue, 02 Feb 2010 06:28:00 GMT

spring为ApplicationContext提供的3种实现分别为：ClassPathXmlApplicationContext， FileSystemXmlApplicationContext和XmlWebApplicationContext，其中 XmlWebApplicationContext是专为Web工程定制的。使用举例如下：
1. FileSystemXmlApplicationContext

Java代码

eg1.
pplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml"); //加载单个配置文件

 eg1.
ApplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml"); //加载单个配置文件

Java代码

eg2.
String[] locations = {"bean1.xml", "bean2.xml", "bean3.xml"};
ApplicationContext ctx = new FileSystemXmlApplicationContext(locations ); //加载多个配置文件

eg2.
String[] locations = {"bean1.xml", "bean2.xml", "bean3.xml"};
ApplicationContext ctx = new FileSystemXmlApplicationContext(locations ); //加载多个配置文件

Java代码

eg3.
ApplicationContext ctx =new FileSystemXmlApplicationContext("D:roject/bean.xml");//根据具体路径加载文件

eg3.
ApplicationContext ctx =new FileSystemXmlApplicationContext("D:roject/bean.xml");//根据具体路径加载文件

2. ClassPathXmlApplicationContext

Java代码

eg1.
pplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");

 eg1.
ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");

Java代码

eg2.
String[] locations = {"bean1.xml", "bean2.xml", "bean3.xml"};
ApplicationContext ctx = new ClassPathXmlApplication(locations);
注：其中FileSystemXmlApplicationContext和ClassPathXmlApplicationContext与BeanFactory的xml文件定位方式一样是基于路径的。

 eg2.
String[] locations = {"bean1.xml", "bean2.xml", "bean3.xml"};
ApplicationContext ctx = new ClassPathXmlApplication(locations);
注：其中FileSystemXmlApplicationContext和ClassPathXmlApplicationContext与BeanFactory的xml文件定位方式一样是基于路径的。

3. XmlWebApplicationContext

Java代码

eg1.
ServletContext servletContext = request.getSession().getServletContext();
ApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(servletContext);

seal 2010-02-02 14:28 发表评论

spring-基于注释（Annotation）的配置(转)

seal — Sat, 16 Jan 2010 15:30:00 GMT

基于注释（Annotation）的配置有越来越流行的趋势，Spring 2.5 顺应这种趋势，提供了完全基于注释配置 Bean、装配 Bean 的功能，您可以
使用基于注释的 Spring IoC 替换原来基于 XML 的配置。本文通过实例详细讲述了 Spring 2.5 基于注释 IoC 功能的使用。
概述
注释配置相对于 XML 配置具有很多的优势：

它可以充分利用 Java 的反射机制获取类结构信息，这些信息可以有效减少配置的工作。如使用 JPA 注释配置 ORM 映射时，我们就不需要指定
PO 的属性名、类型等信息，如果关系表字段和 PO 属性名、类型都一致，您甚至无需编写任务属性映射信息——因为这些信息都可以通过 Java
反射机制获取。
注释和 Java 代码位于一个文件中，而 XML 配置采用独立的配置文件，大多数配置信息在程序开发完成后都不会调整，如果配置信息和 Java 代码
放在一起，有助于增强程序的内聚性。而采用独立的 XML 配置文件，程序员在编写一个功能时，往往需要在程序文件和配置文件中不停切换，这种思维
上的不连贯会降低开发效率。
因此在很多情况下，注释配置比 XML 配置更受欢迎，注释配置有进一步流行的趋势。Spring 2.5 的一大增强就是引入了很多注释类，现在您已经可以
使用注释配置完成大部分 XML 配置的功能。在这篇文章里，我们将向您讲述使用注释进行 Bean 定义和依赖注入的内容。
原来我们是怎么做的

在使用注释配置之前，先来回顾一下传统上是如何配置 Bean 并完成 Bean 之间依赖关系的建立。下面是 3 个类，它们分别是 Office、Car 和
Boss，这 3 个类需要在 Spring 容器中配置为 Bean：

Office 仅有一个属性：

清单 1. Office.java

package com.baobaotao;
public class Office {
    private String officeNo =”001”;

    //省略 get/setter

    @Override
    public String toString() {
        return "officeNo:" + officeNo;
    }
}

Car 拥有两个属性：

清单 2. Car.java

package com.baobaotao;

public class Car {
    private String brand;
    private double price;

    // 省略 get/setter

    @Override
    public String toString() {
        return "brand:" + brand + "," + "price:" + price;
    }
}

Boss 拥有 Office 和 Car 类型的两个属性：

清单 3. Boss.java

package com.baobaotao;

public class Boss {
    private Car car;
    private Office office;

    // 省略 get/setter

    @Override
    public String toString() {
        return "car:" + car + ""n" + "office:" + office;
    }
}

我们在 Spring 容器中将 Office 和 Car 声明为 Bean，并注入到 Boss Bean 中：下面是使用传统 XML 完成这个工作的配置文件 beans.xml：

清单 4. beans.xml 将以上三个类配置成 Bean


xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">












当我们运行以下代码时，控制台将正确打出 boss 的信息：

清单 5. 测试类：AnnoIoCTest.java

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class AnnoIoCTest {

    public static void main(String[] args) {
        String[] locations = {"beans.xml"};
        ApplicationContext ctx =
    new ClassPathXmlApplicationContext(locations);
        Boss boss = (Boss) ctx.getBean("boss");
        System.out.println(boss);
    }
}

这说明 Spring 容器已经正确完成了 Bean 创建和装配的工作。

使用 @Autowired 注释

Spring 2.5 引入了 @Autowired 注释，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。来看一下使用 @Autowired 进行
成员变量自动注入的代码：

清单 6. 使用 @Autowired 注释的 Boss.java

package com.baobaotao;
import org.springframework.beans.factory.annotation.Autowired;

public class Boss {

    @Autowired
    private Car car;

    @Autowired
    private Office office;

    …
}

Spring 通过一个 BeanPostProcessor 对 @Autowired 进行解析，所以要让 @Autowired 起作用必须事先在 Spring 容器中声明
AutowiredAnnotationBeanPostProcessor Bean。

清单 7. 让 @Autowired 注释工作起来


    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">















这样，当 Spring 容器启动时，AutowiredAnnotationBeanPostProcessor 将扫描 Spring 容器中所有 Bean，当发现 Bean 中拥有
@Autowired 注释时就找到和其匹配（默认按类型匹配）的 Bean，并注入到对应的地方中去。

按照上面的配置，Spring 将直接采用 Java 反射机制对 Boss 中的 car 和 office 这两个私有成员变量进行自动注入。所以对成员变量使用
@Autowired 后，您大可将它们的 setter 方法（setCar() 和 setOffice()）从 Boss 中删除。

当然，您也可以通过 @Autowired 对方法或构造函数进行标注，来看下面的代码：

清单 8. 将 @Autowired 注释标注在 Setter 方法上

package com.baobaotao;

public class Boss {
    private Car car;
    private Office office;

     @Autowired
    public void setCar(Car car) {
        this.car = car;
    }

    @Autowired
    public void setOffice(Office office) {
        this.office = office;
    }
    …
}

这时，@Autowired 将查找被标注的方法的入参类型的 Bean，并调用方法自动注入这些 Bean。而下面的使用方法则对构造函数进行标注：

清单 9. 将 @Autowired 注释标注在构造函数上

package com.baobaotao;

public class Boss {
    private Car car;
    private Office office;

    @Autowired
    public Boss(Car car ,Office office){
        this.car = car;
        this.office = office ;
    }

    …
}

由于 Boss() 构造函数有两个入参，分别是 car 和 office，@Autowired 将分别寻找和它们类型匹配的 Bean，将它们作为
Boss(Car car ,Office office) 的入参来创建 Boss Bean。

当候选 Bean 数目不为 1 时的应对方法

在默认情况下使用 @Autowired 注释进行自动注入时，Spring 容器中匹配的候选 Bean 数目必须有且仅有一个。当找不到一个匹配的 Bean 时，
Spring 容器将抛出 BeanCreationException 异常，并指出必须至少拥有一个匹配的 Bean。我们可以来做一个实验：

清单 10. 候选 Bean 数目为 0 时


    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd ">













由于 office Bean 被注释掉了，所以 Spring 容器中将没有类型为 Office 的 Bean 了，而 Boss 的 office 属性标注了 @Autowired，
当启动 Spring 容器时，异常就产生了。

当不能确定 Spring 容器中一定拥有某个类的 Bean 时，可以在需要自动注入该类 Bean 的地方可以使用 @Autowired(required = false)，
这等于告诉 Spring：在找不到匹配 Bean 时也不报错。来看一下具体的例子：

清单 11. 使用 @Autowired(required = false)

package com.baobaotao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Required;

public class Boss {

    private Car car;
    private Office office;

    @Autowired
    public void setCar(Car car) {
        this.car = car;
    }
    @Autowired(required = false)
    public void setOffice(Office office) {
        this.office = office;
    }
    …
}

当然，一般情况下，使用 @Autowired 的地方都是需要注入 Bean 的，使用了自动注入而又允许不注入的情况一般仅会在开发期或测试期碰到
（如为了快速启动 Spring 容器，仅引入一些模块的 Spring 配置文件），所以 @Autowired(required = false) 会很少用到。

和找不到一个类型匹配 Bean 相反的一个错误是：如果 Spring 容器中拥有多个候选 Bean，Spring 容器在启动时也会抛出
BeanCreationException 异常。来看下面的例子：

清单 12. 在 beans.xml 中配置两个 Office 类型的 Bean

…





…

我们在 Spring 容器中配置了两个类型为 Office 类型的 Bean，当对 Boss 的 office 成员变量进行自动注入时，Spring 容器将无法确定到
底要用哪一个 Bean，因此异常发生了。

Spring 允许我们通过 @Qualifier 注释指定注入 Bean 的名称，这样歧义就消除了，可以通过下面的方法解决异常：

清单 13. 使用 @Qualifier 注释指定注入 Bean 的名称

@Autowired
public void setOffice(@Qualifier("office")Office office) {
    this.office = office;
}

@Qualifier("office") 中的 office 是 Bean 的名称，所以 @Autowired 和 @Qualifier 结合使用时，自动注入的策略就从 byType
转变成 byName 了。@Autowired 可以对成员变量、方法以及构造函数进行注释，而 @Qualifier 的标注对象是成员变量、方法入参、构造函数入
参。正是由于注释对象的不同，所以 Spring 不将 @Autowired 和 @Qualifier 统一成一个注释类。下面是对成员变量和构造函数入参进行注释的
代码：

对成员变量进行注释：

清单 14. 对成员变量使用 @Qualifier 注释

public class Boss {
    @Autowired
    private Car car;

    @Autowired
    @Qualifier("office")
    private Office office;
    …
}

对构造函数入参进行注释：

清单 15. 对构造函数变量使用 @Qualifier 注释

public class Boss {
    private Car car;
    private Office office;

    @Autowired
    public Boss(Car car , @Qualifier("office")Office office){
        this.car = car;
        this.office = office ;
}
}

@Qualifier 只能和 @Autowired 结合使用，是对 @Autowired 有益的补充。一般来讲，@Qualifier 对方法签名中入参进行注释会降低代码的
可读性，而对成员变量注释则相对好一些。

使用 JSR-250 的注释

Spring 不但支持自己定义的 @Autowired 的注释，还支持几个由 JSR-250 规范定义的注释，它们分别是 @Resource、@PostConstruct 以及
@PreDestroy。

@Resource

@Resource 的作用相当于 @Autowired，只不过 @Autowired 按 byType 自动注入，面 @Resource 默认按 byName 自动注入罢了。
@Resource 有两个属性是比较重要的，分别是 name 和 type，Spring 将 @Resource 注释的 name 属性解析为 Bean 的名字，而 type
属性则解析为 Bean 的类型。所以如果使用 name 属性，则使用 byName 的自动注入策略，而使用 type 属性时则使用 byType 自动注入策略。
如果既不指定 name 也不指定 type 属性，这时将通过反射机制使用 byName 自动注入策略。

Resource 注释类位于 Spring 发布包的 lib/j2ee/common-annotations.jar 类包中，因此在使用之前必须将其加入到项目的类库中。
来看一个使用 @Resource 的例子：

清单 16. 使用 @Resource 注释的 Boss.java

package com.baobaotao;

import javax.annotation.Resource;

public class Boss {
    // 自动注入类型为 Car 的 Bean
    @Resource
    private Car car;

    // 自动注入 bean 名称为 office 的 Bean
    @Resource(name = "office")
    private Office office;
}

一般情况下，我们无需使用类似于 @Resource(type=Car.class) 的注释方式，因为 Bean 的类型信息可以通过 Java 反射从代码中获取。

要让 JSR-250 的注释生效，除了在 Bean 类中标注这些注释外，还需要在 Spring 容器中注册一个负责处理这些注释的 BeanPostProcessor：

class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"/>

CommonAnnotationBeanPostProcessor 实现了 BeanPostProcessor 接口，它负责扫描使用了 JSR-250 注释的 Bean，并对它们进行相应的操作。

@PostConstruct 和 @PreDestroy

Spring 容器中的 Bean 是有生命周期的，Spring 允许在 Bean 在初始化完成后以及 Bean 销毁前执行特定的操作，您既可以通过实现 InitializingBean/DisposableBean 接口来定制初始化之后 / 销毁之前的操作方法，也可以通过元素的 init-method/destroy-method 属性指定初始化之后 / 销毁之前调用的操作方法。关于 Spring 的生命周期，笔者在《精通 Spring 2.x—企业应用开发精解》第 3 章进行了详细的描述，有兴趣的读者可以查阅。

JSR-250 为初始化之后/销毁之前方法的指定定义了两个注释类，分别是 @PostConstruct 和 @PreDestroy，这两个注释只能应用于方法上。标注了 @PostConstruct 注释的方法将在类实例化后调用，而标注了 @PreDestroy 的方法将在类销毁之前调用。

清单 17. 使用 @PostConstruct 和 @PreDestroy 注释的 Boss.java

package com.baobaotao;

import javax.annotation.Resource;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class Boss {
    @Resource
    private Car car;

    @Resource(name = "office")
    private Office office;

    @PostConstruct
    public void postConstruct1(){
        System.out.println("postConstruct1");
    }

    @PreDestroy
    public void preDestroy1(){
        System.out.println("preDestroy1");
    }
    …
}

您只需要在方法前标注 @PostConstruct 或 @PreDestroy，这些方法就会在 Bean 初始化后或销毁之前被 Spring 容器执行了。

我们知道，不管是通过实现 InitializingBean/DisposableBean 接口，还是通过元素的 init-method/destroy-method 属性进行配置，都只能为 Bean 指定一个初始化 / 销毁的方法。但是使用 @PostConstruct 和 @PreDestroy 注释却可以指定多个初始化 / 销毁方法，那些被标注 @PostConstruct 或 @PreDestroy 注释的方法都会在初始化 / 销毁时被执行。

通过以下的测试代码，您将可以看到 Bean 的初始化 / 销毁方法是如何被执行的：

清单 18. 测试类代码

package com.baobaotao;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AnnoIoCTest {

    public static void main(String[] args) {
        String[] locations = {"beans.xml"};
        ClassPathXmlApplicationContext ctx =
            new ClassPathXmlApplicationContext(locations);
        Boss boss = (Boss) ctx.getBean("boss");
        System.out.println(boss);
        ctx.destroy();// 关闭 Spring 容器，以触发 Bean 销毁方法的执行
    }
}

这时，您将看到标注了 @PostConstruct 的 postConstruct1() 方法将在 Spring 容器启动时，创建 Boss Bean 的时候被触发执行，而标注了 @PreDestroy 注释的 preDestroy1() 方法将在 Spring 容器关闭前销毁 Boss Bean 的时候被触发执行。

使用简化配置

Spring 2.1 添加了一个新的 context 的 Schema 命名空间，该命名空间对注释驱动、属性文件引入、加载期织入等功能提供了便捷的配置。我们知道注释本身是不会做任何事情的，它仅提供元数据信息。要使元数据信息真正起作用，必须让负责处理这些元数据的处理器工作起来。

而我们前面所介绍的 AutowiredAnnotationBeanPostProcessor 和 CommonAnnotationBeanPostProcessor 就是处理这些注释元数据的处理器。但是直接在 Spring 配置文件中定义这些 Bean 显得比较笨拙。Spring 为我们提供了一种方便的注册这些 BeanPostProcessor 的方式，这就是。请看下面的配置：

清单 19. 调整 beans.xml 配置文件


    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:context="http://www.springframework.org/schema/context"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">

将隐式地向 Spring 容器注册 AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、 PersistenceAnnotationBeanPostProcessor 以及 equiredAnnotationBeanPostProcessor 这 4 个 BeanPostProcessor。

在配置文件中使用 context 命名空间之前，必须在元素中声明 context 命名空间。

使用 @Component

虽然我们可以通过 @Autowired 或 @Resource 在 Bean 类中使用自动注入功能，但是 Bean 还是在 XML 文件中通过进行定义 ——
也就是说，在 XML 配置文件中定义 Bean，通过 @Autowired 或 @Resource 为 Bean 的成员变量、方法入参或构造函数入参提供自动注入的功能
。能否也通过注释定义 Bean，从 XML 配置文件中完全移除 Bean 定义的配置呢？答案是肯定的，我们通过 Spring 2.5 提供的 @Component
注释就可以达到这个目标了。

下面，我们完全使用注释定义 Bean 并完成 Bean 之间装配：

清单 20. 使用 @Component 注释的 Car.java

package com.baobaotao;

import org.springframework.stereotype.Component;

@Component
public class Car {
    …
}

仅需要在类定义处，使用 @Component 注释就可以将一个类定义了 Spring 容器中的 Bean。下面的代码将 Office 定义为一个 Bean：

清单 21. 使用 @Component 注释的 Office.java

package com.baobaotao;

import org.springframework.stereotype.Component;

@Component
public class Office {
    private String officeNo = "001";
    …
}

这样，我们就可以在 Boss 类中通过 @Autowired 注入前面定义的 Car 和 Office Bean 了。

清单 22. 使用 @Component 注释的 Boss.java

package com.baobaotao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Required;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

@Component("boss")
public class Boss {
    @Autowired
    private Car car;

    @Autowired
    private Office office;
    …
}

@Component 有一个可选的入参，用于指定 Bean 的名称，在 Boss 中，我们就将 Bean 名称定义为“boss”。一般情况下，
Bean 都是 singleton 的，需要注入 Bean 的地方仅需要通过 byType 策略就可以自动注入了，所以大可不必指定 Bean 的名称。

在使用 @Component 注释后，Spring 容器必须启用类扫描机制以启用注释驱动 Bean 定义和注释驱动 Bean 自动注入的策略。
Spring 2.5 对 context 命名空间进行了扩展，提供了这一功能，请看下面的配置：

清单 23. 简化版的 beans.xml


    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">

这里，所有通过元素定义 Bean 的配置内容已经被移除，仅需要添加一行配置就解决所有问题了
——Spring XML 配置文件得到了极致的简化（当然配置元数据还是需要的，只不过以注释形式存在罢了）。
的 base-package 属性指定了需要扫描的类包，类包及其递归子包中所有的类都会被处理。

还允许定义过滤器将基包下的某些类纳入或排除。Spring 支持以下 4 种类型的过滤方式，通过下表说明：

表 1. 扫描过滤方式
过滤器类型说明
注释假如 com.baobaotao.SomeAnnotation 是一个注释类，我们可以将使用该注释的类过滤出来。
类名指定通过全限定类名进行过滤，如您可以指定将 com.baobaotao.Boss 纳入扫描，而将 com.baobaotao.Car 排除在外。
正则表达式通过正则表达式定义过滤的类，如下所示： com".baobaotao".Default.*
AspectJ 表达式通过 AspectJ 表达式定义过滤的类，如下所示： com. baobaotao..*Service+

下面是一个简单的例子：

expression="com".baobaotao".service"..*"/>

expression="com.baobaotao.util..*"/>

值得注意的是配置项不但启用了对类包进行扫描以实施注释驱动 Bean 定义的功能，同时还启用了注释驱动自动注入
的功能（即还隐式地在内部注册了 AutowiredAnnotationBeanPostProcessor 和 CommonAnnotationBeanPostProcessor），因此当使用

后，就可以将移除了。

默认情况下通过 @Component 定义的 Bean 都是 singleton 的，如果需要使用其它作用范围的 Bean，可以通过 @Scope 注释来达到目标，如以
下代码所示：

清单 24. 通过 @Scope 指定 Bean 的作用范围

package com.baobaotao;
import org.springframework.context.annotation.Scope;
…
@Scope("prototype")
@Component("boss")
public class Boss {
    …
}

这样，当从 Spring 容器中获取 boss Bean 时，每次返回的都是新的实例了。

采用具有特殊语义的注释

Spring 2.5 中除了提供 @Component 注释外，还定义了几个拥有特殊语义的注释，它们分别是：@Repository、@Service
和 @Controller。在目前的 Spring 版本中，这 3 个注释和 @Component 是等效的，但是从注释类的命名上，很容易看出这
3 个注释分别和持久层、业务层和控制层（Web 层）相对应。虽然目前这 3 个注释和 @Component 相比没有什么新意，
但 Spring 将在以后的版本中为它们添加特殊的功能。所以，如果 Web 应用程序采用了经典的三层分层结构的话，最好在持久层、业务层和控制层
分别采用 @Repository、@Service 和 @Controller 对分层中的类进行注释，而用 @Component 对那些比较中立的类进行注释。

如果 Bean 不是自己编写的类（如 JdbcTemplate、SessionFactoryBean 等），注释配置将无法实施，此时 XML 配置是唯一可用的方式。
注释配置往往是类级别的，而 XML 配置则可以表现得更加灵活。比如相比于 @Transaction 事务注释，使用 aop/tx 命名空间的事务配置更加灵活
和简单。
所以在实现应用中，我们往往需要同时使用注释配置和 XML 配置，对于类级别且不会发生变动的配置可以优先考虑注释配置；而对于那些第三方类以及
容易发生调整的配置则应优先考虑使用 XML 配置。Spring 会在具体实施 Bean 创建和 Bean 注入之前将这两种配置方式的元信息融合在一起。

小结

Spring 在 2.1 以后对注释配置提供了强力的支持，注释配置功能成为 Spring 2.5 的最大的亮点之一。合理地使用 Spring 2.5 的注释配置，
可以有效减少配置的工作量，提高程序的内聚性。但是这并不意味着传统 XML 配置将走向消亡，在第三方类 Bean 的配置，以及那些诸如数据源、
缓存池、持久层操作模板类、事务管理等内容的配置上，XML 配置依然拥有不可替代的地位。
spring 事务管理（Transaction）例子

##Transaction）例子
传统上， J2EE开发者有两种事务管理选择，全局和本地事务。Spring框架对事务管理的支持极大地改变传统上认为J2EE应用需要应用服务器。这种
改变不单是仅仅为了通过EJB来使用生命式事务而使用应用服务器。事实上，即使你的应用服务器有强大的JTA功能，Spring框架的声明式事务提供了
比EJB CMT（声明式事务）更强大，更高效的编程模型。一般来说，只有支持多个事务资源，才会需要应用服务器的JTA功能，而大多数应用不需要能够
处理跨多种资源。最重要的一点，使用Spring，你可以选择何时把你的应用迁移到全功能的应用服务器。使用Spring不需要像以前一样用编码实现本地
事务代替EJB CMT或JTA，现在只需要改配置问价，而不必改代码。
一. Spring事务管理

1. Spring 编程式事务管理（programmatic transaction management）
   DefaultTransactionDefinition def = new DefaultTransactionDefinition();
TransactionStatus status = transactionManager.getTransaction(def);
try {
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

jdbcTemplate.update("INSERT INTO USER VALUES('Spring008', 'caterpillar', 'M', 29)");

jdbcTemplate.update("INSERT INTO USER VALUES('Spring009', 'momor', 'F', 26)");
jdbcTemplate.update("INSERT INTO USER VALUES('Spring010, 'beckyday', 'F', 35)");

} catch (DataAccessException ex) {

transactionManager.rollback(status); // 也可以執行status.setRollbackOnly();
        throw ex;
}
transactionManager.commit(status);

见：http://www.javaworld.com.tw/confluence/pages/viewpage.action?pageId=2398

2. Spring宣告式事务管理（declarative transaction management）主要是在spring的配置文件中设置





PROPAGATION_REQUIRED



见：http://www.javaworld.com.tw/confluence/pages/viewpage.action?pageId=2402
二. Spring的@Transcation的例子

1. class 中

@Component //注释就可以将该类定义了 Spring 容器中的 Bean

public Class UserDaoImpl implements IUserDao {
@Override
//标志updateUsers（）为Transactional
@Transactional(
propagation = Propagation.REQUIRED,
isolation = Isolation.DEFAULT,
rollbackFor = Exception.class
)
public void updateUsers(List users){
for（User user ：users）{
//逻辑
}
}
}
注意：事务的属性和基本概念

Required : 如果在一个事务中调用，就将该方法加到此事务中，如果没有启动事务，就创建新事务

RequiredNew ：不管当前有没有事务，都启动新事务，如果有，会被挂起，直到此方法结束

NotSupported ：不能在事务中执行此方法，如果有事务，会被挂起，直到此方法结束

Supports ：如果有当前事务，此方法回加到当前事务，如果没有，容器不会启动新事务

Mandatory ：必须在事务中执行此方法，否则会抛出异常： TransactionRequiredException

Never ：必须不在事务中调用此方法，否则抛出RemoteException(远程调用)或EJBException(本地调用)
        2.spring配置文件加入：
           .....................

          .....................

      注意： webSerivces 是不支持事务的，如果使用事务，必须在下层的Object中实现，例如在Service层或者是Dao层实现。

1. 使用Spring注解来注入属性
1.1. 使用注解以前我们是怎样注入属性的
类的实现：
Java代码
public class UserManagerImpl implements UserManager {
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    ...
}

public class UserManagerImpl implements UserManager {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
...
}

配置文件：
Java代码






1.2. 引入@Autowired注解（不推荐使用，建议使用@Resource）
类的实现（对成员变量进行标注）
Java代码
public class UserManagerImpl implements UserManager {
    @Autowired
    private UserDao userDao;
    ...
}

public class UserManagerImpl implements UserManager {
@Autowired
private UserDao userDao;
...
}

或者（对方法进行标注）
Java代码
public class UserManagerImpl implements UserManager {
    private UserDao userDao;
    @Autowired
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    ...
}

public class UserManagerImpl implements UserManager {
private UserDao userDao;
@Autowired
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
...
}
配置文件
Java代码




@Autowired可以对成员变量、方法和构造函数进行标注，来完成自动装配的工作。以上两种不同实现方式中，@Autowired的标注位置不同，它们都会在Spring在初始化userManagerImpl这个bean时，自动装配userDao这个属性，区别是：第一种实现中，Spring会直接将UserDao类型的唯一一个bean赋值给userDao这个成员变量；第二种实现中，Spring会调用setUserDao方法来将UserDao类型的唯一一个bean装配到userDao这个属性。

1.3. 让@Autowired工作起来
要使@Autowired能够工作，还需要在配置文件中加入以下代码
Java代码

1.4. @Qualifier
@Autowired是根据类型进行自动装配的。在上面的例子中，如果当Spring上下文中存在不止一个UserDao类型的bean时，就会抛出BeanCreationException异常；如果Spring上下文中不存在UserDao类型的bean，也会抛出BeanCreationException异常。我们可以使用@Qualifier配合@Autowired来解决这些问题。
1. 可能存在多个UserDao实例
Java代码
@Autowired
public void setUserDao(@Qualifier("userDao") UserDao userDao) {
    this.userDao = userDao;
}

@Autowired
public void setUserDao(@Qualifier("userDao") UserDao userDao) {
this.userDao = userDao;
}

这样，Spring会找到id为userDao的bean进行装配。
2. 可能不存在UserDao实例

Java代码
@Autowired(required = false)
public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}

@Autowired(required = false)
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}

1.5. @Resource（JSR-250标准注解，推荐使用它来代替Spring专有的@Autowired注解）
Spring 不但支持自己定义的@Autowired注解，还支持几个由JSR-250规范定义的注解，它们分别是@Resource、@PostConstruct以及@PreDestroy。
@Resource的作用相当于@Autowired，只不过@Autowired按byType自动注入，而@Resource默认按byName自动注入罢了。@Resource有两个属性是比较重要的，分别是name和type，Spring将 @Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不指定name也不指定type属性，这时将通过反射机制使用byName自动注入策略。
@Resource装配顺序

如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常
如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常
如果指定了type，则从上下文中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常
如果既没有指定name，又没有指定type，则自动按照byName方式进行装配（见2）；如果没有匹配，则回退为一个原始类型（UserDao）进行匹配，如果匹配则自动装配；

1.6. @PostConstruct（JSR-250）
在方法上加上注解@PostConstruct，这个方法就会在Bean初始化之后被Spring容器执行（注：Bean初始化包括，实例化Bean，并装配Bean的属性（依赖注入））。
它的一个典型的应用场景是，当你需要往Bean里注入一个其父类中定义的属性，而你又无法复写父类的属性或属性的setter方法时，如：
Java代码
public class UserDaoImpl extends HibernateDaoSupport implements UserDao {
    private SessionFactory mySessionFacotry;
    @Resource
    public void setMySessionFacotry(SessionFactory sessionFacotry) {
        this.mySessionFacotry = sessionFacotry;
    }
    @PostConstruct
    public void injectSessionFactory() {
        super.setSessionFactory(mySessionFacotry);
    }
    ...
}

public class UserDaoImpl extends HibernateDaoSupport implements UserDao {
private SessionFactory mySessionFacotry;
@Resource
public void setMySessionFacotry(SessionFactory sessionFacotry) {
this.mySessionFacotry = sessionFacotry;
}
@PostConstruct
public void injectSessionFactory() {
super.setSessionFactory(mySessionFacotry);
}
...
}

这里通过@PostConstruct，为UserDaoImpl的父类里定义的一个sessionFactory私有属性，注入了我们自己定义的sessionFactory（父类的setSessionFactory方法为final，不可复写），之后我们就可以通过调用 super.getSessionFactory()来访问该属性了。

1.7. @PreDestroy（JSR-250）
在方法上加上注解@PreDestroy，这个方法就会在Bean初始化之后被Spring容器执行。由于我们当前还没有需要用到它的场景，这里不不去演示。其用法同@PostConstruct。

1.8. 使用简化配置
Spring2.1添加了一个新的context的Schema命名空间，该命名空间对注释驱动、属性文件引入、加载期织入等功能提供了便捷的配置。我们知道注释本身是不会做任何事情的，它仅提供元数据信息。要使元数据信息真正起作用，必须让负责处理这些元数据的处理器工作起来。
AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor就是处理这些注释元数据的处理器。但是直接在Spring配置文件中定义这些Bean显得比较笨拙。Spring为我们提供了一种方便的注册这些BeanPostProcessor的方式，这就是：
Java代码
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-2.5.xsd">

xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">

将隐式地向Spring容器注册AutowiredAnnotationBeanPostProcessor、 CommonAnnotationBeanPostProcessor、 PersistenceAnnotationBeanPostProcessor以及 RequiredAnnotationBeanPostProcessor这4个BeanPostProcessor。

2. 使用Spring注解完成Bean的定义
以上我们介绍了通过@Autowired或@Resource来实现在Bean中自动注入的功能，下面我们将介绍如何注解Bean，从而从XML配置文件中完全移除Bean定义的配置。

2.1. @Component（不推荐使用）、@Repository、@Service、@Controller
只需要在对应的类上加上一个@Component注解，就将该类定义为一个Bean了：
Java代码
@Component
public class UserDaoImpl extends HibernateDaoSupport implements UserDao {
    ...
}

@Component
public class UserDaoImpl extends HibernateDaoSupport implements UserDao {
...
}

使用@Component注解定义的Bean，默认的名称（id）是小写开头的非限定类名。如这里定义的Bean名称就是userDaoImpl。你也可以指定Bean的名称：
@Component("userDao")
@Component是所有受Spring管理组件的通用形式，Spring还提供了更加细化的注解形式：@Repository、@Service、@Controller，它们分别对应存储层Bean，业务层Bean，和展示层Bean。目前版本（2.5）中，这些注解与@Component的语义是一样的，完全通用，在Spring以后的版本中可能会给它们追加更多的语义。所以，我们推荐使用@Repository、@Service、@Controller来替代@Component。

2.2. 使用让Bean定义注解工作起来
Java代码
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-2.5.xsd">

这里，所有通过元素定义Bean的配置内容已经被移除，仅需要添加一行配置就解决所有问题了——Spring XML配置文件得到了极致的简化（当然配置元数据还是需要的，只不过以注释形式存在罢了）。的base-package属性指定了需要扫描的类包，类包及其递归子包中所有的类都会被处理。

还允许定义过滤器将基包下的某些类纳入或排除。Spring支持以下4种类型的过滤方式：

过滤器类型表达式范例说明
注解 org.example.SomeAnnotation 将所有使用SomeAnnotation注解的类过滤出来
类名指定 org.example.SomeClass 过滤指定的类
正则表达式 com".kedacom".spring".annotation".web"..* 通过正则表达式过滤一些类
AspectJ表达式 org.example..*Service+ 通过AspectJ表达式过滤一些类

以正则表达式为例，我列举一个应用实例：
Java代码

值得注意的是配置项不但启用了对类包进行扫描以实施注释驱动Bean定义的功能，同时还启用了注释驱动自动注入的功能（即还隐式地在内部注册了 AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor），因此当使用后，就可以将移除了。

2.3. 使用@Scope来定义Bean的作用范围
在使用XML定义Bean时，我们可能还需要通过bean的scope属性来定义一个Bean的作用范围，我们同样可以通过@Scope注解来完成这项工作：
Java代码
@Scope("session")
@Component()
public class UserSessionBean implements Serializable {
    ...
}

@Scope("session")
@Component()
public class UserSessionBean implements Serializable {
...
}

3. 参考
http://kingtai168.javaeye.com/blog/244002
http://www.javaeye.com/topic/244153
http://static.springframework.org/spring/docs/2.5.x/reference/beans.html#beans-annotation-config
http://static.springframework.org/spring/docs/2.5.x/reference/beans.html#beans-classpath-scanning

seal 2010-01-16 23:30 发表评论

Debug Google Web Toolkit with Struts/Tiles

seal — Fri, 15 Jan 2010 04:05:00 GMT

Ok, your fresh new GWT user interface is ready, it works great with GWTShell's internal Tomcat and with server-side stubs, but as you compile and deploy it on your web-app there are problems.

Of course you can debug with a JavaScript debugger (Venkman or Microsoft's Script Debugger), but generated JavaScript is really complex, for people and for those unstable debuggers.

But, wait, we have a debugger, is our state-of-the-art debugger, integrated in our IDE and GWT can use it, if only you could run client into the Shell and server side into your preferred development envinroment !!!

We could deploy our web-app into the integrated Tomcat, but it's not easy to do (and an hell to mantain) and also can be that you don't want (or you can't) use Tomcat for your Web Application.

I think that everyone should do his work, so let's Google Shell do the client, and your application server run the server side code. It's not difficult, you only need to follow these few steps.

First thing do to it's a little (I promise really little and only one) change to your GWT code, so that the client will always use absolute urls for your web-app, allowing us to use the ContextPath without problems, whatever it's the relative position of your Google client inside your root context.

To do that we have to register this way the end-point of the remote service:

	endpoint.setServiceEntryPoint( GWT.getModuleBaseURL()+"/myRemoteService" );

now we must also remember to change our servlet path inside the GWT module file (*.gwt.xml) putting the complete service name at the top, in this case /mypackage.google.GWTClient:

No other change to your client side code, I promise again.

Now let's start to modify the web-app to run our services. The first thing is to include in our WEB-INF/lib the gwt-user.jar.

Unfortunately the one supplied by Google doesn't work, because it includes the javax.servlet.* classes to simplify the automatic generation of development projects.

We must strip that out (with an ANT Task obviously):

	<property name="original.gwt.jar.lib" value="<path-to>"gwt-user.jar" />
<property name="temp.dir" value="./tempDir"/>
<target name="stripGWT-lib">
<mkdir dir="${temp.dir}"/>
<unjar src="${original.gwt.jar.lib}" dest="${temp.dir}">
<patternset>
<exclude name="javax/**/*.*"/>
</patternset>
</unjar>
<jar destfile="${web-inf.lib.dir}/gwt-user.jar" basedir="${temp.dir}"/>
<delete dir="${temp.dir}"/>
</target>

Now we can also add that to our IDE build-path.

Everything is ready to begin the configuration of our web-app, beginning with the registration of the remote service inside web.xml, remembering the module name we used in the *.gwt.xml file:

	<servlet>
<servlet-name>MyRemoteService</servlet-name>
<servlet-class>mypackage.google.server.MyRemoteServiceImpl</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>MyRemoteService</servlet-name>
<url-pattern>/mypackage.google.GWTClient/myRemoteService</url-pattern>
</servlet-mapping>

We don't have yet finished, we must also "simulate" one of the call implemented by GWTServlet, registering its path into web.xml and with the help of a JSP::

	<servlet>
<servlet-name>gwt-hosted</servlet-name>
<jsp-file>/gwt-hosted.jsp</jsp-file>
</servlet>
<servlet-mapping>
<servlet-name>gwt-hosted</servlet-name>
<url-pattern>/mypackage.google.GWTClient/gwt-hosted.html</url-pattern>
</servlet-mapping>

the gwt-hosted.jsp JSP it's only a simple script with a row of scriptlet that export our web-app context to the GWT client::

	<html>
<body>
<script>
var $wnd = parent;
var $doc = $wnd.document;
var q = location.search.substring(1);
var i = q.lastIndexOf("=");
var $moduleName = q;
var $moduleBaseURL = "<%= request.getContextPath()%>/" + $moduleName;
if (i != -1) {
$moduleBaseURL = q.substring(0, i);
$moduleName = q.substring(i+1);
}
parent.__gwt_initHostedModeModule(this, $moduleName);
</script>
</body>
</html>

We did it !!!!The good thing is that we don't even have to "Compile" our JavaScript in the destination context during debug. Infact the GWT Shell callback will always call our Java classes and not the JavaScript code.

So we have together maximum flexibility on client-side project for our debugging purposes, and only at the very finish of the development cycle we will produce the JavaScript code.

Could we be in a better position as web developer ?

Now some tips about GWT's Shell:

Are we in debug mode or not ? The answer is yes, so we should configure the Shell log to a more verbose level (if you have used GWT.log in your code):

	-logLevel ERROR|WARN|INFO|TRACE|DEBUG|SPAM|ALL

We should also disable the integrated Tomcat:

	-noserver

and configure the Shell to generate JavaScript code directly inside our web-app project:

	-out

Also can be useful to open directly the Shell browser to our web-app at startup, simply putting the http url as the last parameter of the command line that start the Shell.

But what if all this it's not enough to solve our problems, may be because the generated JavaScript is not working fine ? Well, together with much luck, we can try to switch the generation code to DETAILED:

 -style DETAILED

and use traditional JavaScript debugging tecnique.

Integrate Google Web Toolkit with Struts/Tiles

Ok, now everything it's integrated with your web-application and you're in love with GWT. You did really a great work, a prototype that it's working fine and looks pretty. But when time comes that you must put it into your old fashioned Struts/Tiles web-application it stops working and sure you can't write everything from scratch again, but do a step after another and start with a single functionality done with GWT.

Well, I don't know you, but I suffered from this problem, but at the end, thank to some little tips, I was able to let Struts and GWT not only to live together, but to cooperate to make my application look better.

It was like having an old fashioned B&W TV Set and a new HDMI on the same bench, side by side !!!

Well, to achieve this, we have to do some simple steps:

- In web.xml add another Struts action mapping, this time it must be extension based, for instance I choosed *.gwt:

		<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.gwt</url-pattern>
</servlet-mapping>

- In struts-config.xml write the new Struts action that will render the GWT page, taking care to put at the top of the path the complete GWT's module name, so that the script will be able to find internal files with no problems:

        <action path="/mypackage.google.GWTClient/GWTClient"
forward=".my.gwt.application"/>

- (only if you use Tiles as view)Add a Tiles definition that will include GWT's (in my example into the body of the layout JSP):

    <definition name=".my.gwt.application" extends=".mainLayout">
<put name="title"  value="Google Web Toolkit in Tiles" />
<put name="body"
value="/mypackage.google.GWTClient/GWTClient.html" />
<put name="header"   value="/WEB-INF/jsp/header.jsp" />
</definition>

- (if you used filters for Struts Action mapping)Update your filters so that they will be able to do their work also with the new GWT module:

	<filter-mapping>
<filter-name>AuthenticationFilter</filter-name>
<url-pattern>*.gwt</url-pattern>
</filter-mapping>

That's all, the game is made.

P.S.:the same applies if you used Spring MVC.

Integrating it also with Spring/Hibernate

The life-cycle of a GWT's Service is managed by your servlet-container, because as a design choice Google opted for the portabily and simplicity of the Servlet model.
In our code this mean that our service implementations will all inherit (indirectly) from HttpServlet. This means also that to integrate them in our Spring managed container we have to play dirty. I decided to use static property inside our Google Service implementation, so that Spring will be able to assign it at startup time.
Pratically, if we want to inject something in GWT's service mypackage.google.server.MyRemoteServiceImpl's myProperty property, it's enough to declare it static:

	private static MyProperty myProperty;

Then to let Spring works, we also need an instance setter:

	public void setMyProperty(MyProperty mp) // remember, myProperty is static, you can't use this
{
myProperty = mp;
}

In our applicationContext.xml we can inject the myPropertyBean Bean simply with a dummy bean declaration of the GWT implementation class:

	<bean id="myGWTService" class="mypackage.google.server.MyRemoteServiceImpl">
<property name="myProperty"><ref local="myPropertyBean"/></property>
</bean>

This works because at startup Spring will instantiate an instance of the MyRemoteServiceImpl class, this instance will never be used by the servlet-container, but the bean property is contained into a static variable, so every instance will have it !!!
Now, if your business bean myPropertyBean uses Hibernate and you usually use Spring's OpenSessionInViewFilter/Interceptor to manage your Session, you need a further step and use an AOP Interceptor. But we are lucky in this, because all is done by Spring out-of-the-box only with few lines of configuration::

	<!-- Our Propagation policy -->
<bean id="matchAllWithPropReq"
class="org.springframework.transaction.interceptor.MatchAlwaysTransactionAttributeSource">
<property name="transactionAttribute"><value>PROPAGATION_REQUIRED</value></property>
</bean>
<!-- Match them all interceptor -->
<bean id="matchAllTxInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
<property name="transactionManager"><ref bean="transactionManager"/></property>
<property name="transactionAttributeSource"><ref bean="matchAllWithPropReq"/></property>
</bean>
<!-- This AutoProxyCreator bean will let us declaratively decide which beans will have the transaction
managed with PROPAGATION_REQUIRED -->
<bean id="autoProxyCreator" class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="interceptorNames">
<list>
<idref local="matchAllTxInterceptor"/>
<idref bean="myHibernateInterceptor"/>
</list>
</property>
<property name="beanNames">
<list>
<idref local="myPropertyBean"/>
</list>
</property>
</bean>
<!--  This is the bean that, if it doesn't exist, create and then close Hibernate Session -->
<bean id="myHibernateInterceptor" class="org.springframework.orm.hibernate3.HibernateInterceptor">
<property name="sessionFactory"><ref local="sessionFactory"/></property>
</bean>
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory"><ref local="sessionFactory"/></property>
</bean>

With this configuration, if myPropertyBean is used outside a transaction scope, a new Hibernate transaction will be created and assigned to it. In our case this is also the span of the Hibernate's Session (thanks to HibernateTransactionManager). The myHibernateInterceptor will also take charge of eventually close the Session at the end of the business method.

continue here...

seal 2010-01-15 12:05 发表评论

Integrating GWT with Spring Security

seal — Fri, 15 Jan 2010 01:39:00 GMT

摘要: Yesterday, I wrote about How to do cross-domain GWT RPC with a ProxyServlet. Today I'll be discussing how to modify the ProxyServlet to authenticate with Spring Security. For the application I'm work... 阅读全文

seal 2010-01-15 09:39 发表评论

Spring Security 2 中动态角色实现的讨论（转）

seal — Mon, 11 Jan 2010 14:03:00 GMT

安全框架的主体包括两部分即验权和授权。Spring Security2可以很好的实现这两个过程。Spring Security2对其前身acegi最大的改进是提供了自定义的配置标签，通过Security的命名空间定义了http和 authentication-provider等标签，这样做的好处是极大地简化了框架的配置，并很好地隐藏了框架实现的细节，在配置的表述上也更清晰，总体上提高了框架的易用性。

然而，该框架默认的权限配置方式在xml中，又因为新版本隐藏了实现细节，在动态权限的扩展上，能力变小了。在验权过程中，遇到的问题不多。但在授权时，如果是acegi，人们可以通过继承AbstractFilterInvocationDefinitionSource类实现在授权（即资源角色和用户角色的匹配）前，针对资源的角色的获取。而新版本因为用新标签进行了整合，这个过程被默认的类实现隐藏掉了，包括过滤器，资源获取和角色定义等过程都由框架来实现，于是很多人在使用Spring Security2时也想通过改动DefaultFilterInvocationDefinitionSource对资源的获取来实现数据库或文件中的动态的角色。不过这样的改动侵入性比较高，而且还保留了acegi的痕迹，也违背了开闭的原则。

其实，我们完全可以通过Spring Security2 accessManager提供的自定义投票机制来解决这个问题，这样既不影响现有的基于URL的配置，还可以加入自己的动态的权限配置。

其实现策略如下：

1 定义类DynamicRoleVoter实现AccessDecisionVoter，注入实现接口DynamicRoleProvider（用来定义获取角色的方法）的提供动态角色的类

2 在两个supports方法中返回true

3 在vote方法中，有三个参数(Authentication authentication, Object object,ConfigAttributeDefinition config) 通过第一个获取用户的权限集合，第二个可以获取到资源对象，进而通过DynamicRoleProvider获取到角色集合进行匹配。

4 在配置文件中加入DynamicRoleVoter，如下：

<beans:bean id="accessDecisionManager" class="org.springframework.security.vote.AffirmativeBased">
<beans:property name="decisionVoters">
<beans:list>
<beans:bean class="org.springframework.security.vote.RoleVoter" />
<beans:bean class="org.springframework.security.vote.AuthenticatedVoter" />
<beans:bean class="DynamicRoleVoter">
    <beans:property name="dynamicRoleProvider">
         <beans:ref local="dynamicRoleProvider"/>
beans:property>
beans:bean>
beans:list>
beans:property>
beans:bean>
<beans:bean id=” dynamicRoleProvider” class=”…”>
     ……
>

http://hszdz.javaeye.com/blog/337652















……

seal 2010-01-11 22:03 发表评论

SpringSide 3 中的安全框架

seal — Fri, 08 Jan 2010 09:01:00 GMT

在SpringSide 3的官方文档中，说安全框架使用的是Spring Security 2.0。乍一看，吓了我一跳，以为Acegi这么快就被淘汰了呢。上搜索引擎一搜，发现原来Spring Security 2.0就是Acegi 2.0。悬着的心放下来了。虽然SpringSide 3中关于Acegi的配置文件看起来很不熟悉，但是读了Acegi 2.0的官方文档后，一切都释然了。

先来谈一谈Acegi的基础知识，Acegi的架构比较复杂，但是我希望我下面的只言片语能够把它说清楚。大家都知道，如果要对Web资源进行保护，最好的办法莫过于Filter，要想对方法调用进行保护，最好的办法莫过于AOP。Acegi对Web资源的保护，就是靠Filter实现的。如下图：

一般来说，我们的Filter都是配置在web.xml中，但是Acegi不一样，它在web.xml中配置的只是一个代理，而真正起作用的Filter是作为Bean配置在Spring中的。web.xml中的代理依次调用这些Bean，就实现了对Web资源的保护，同时这些Filter作为Bean被 Spring管理，所以实现AOP也很简单，真的是一举两得啊。

Acegi中提供的Filter不少，有十多个，一个一个学起来比较复杂。但是对于我们Web开发者来说，常用的就那么几个，如下图中的被红圈圈标记出来的：

从上到下，它们实现的功能依次是1、制定必须为https连接；2、从Session中提取用户的认证信息；3、退出登录；4、登录；5、记住用户；6、所有的应用必须配置这个Filter。

一般来说，我们写Web应用只需要熟悉这几个Filter就可以了，如果不需要https连接，连第一个也不用熟悉。但是有人肯定会想，这些Filter怎么和我的数据库联系起来呢？不用着急，这些Filter并不直接处理用户的认证，也不直接处理用户的授权，而是把它们交给了认证管理器和决策管理器。如下图：

对于这两种管理器，那也是不需要我们写代码的，Acegi也提供了现成的类。那么大家又奇怪了：又是现成的，那怎么和我的数据库关联起来呢？别着急，其实这两个管理器自己也不做事，认证管理器把任务交给了Provider，而决策管理器则把任务交给了Voter，如下图：

现在我要告诉你们，这里的Provider和Voter也是不需要我们写代码的。不要崩溃，快到目标了。Acegi提供了多个Provider的实现类，如果我们想用数据库来储存用户的认证数据，那么我们就选择DaoAuthenticationProvider。对于Voter，我们一般选择 RoleVoter就够用了，它会根据我们配置文件中的设置来决定是否允许某一个用户访问制定的Web资源。

而DaoAuthenticationProvider也是不直接操作数据库的，它把任务委托给了UserDetailService，如下图：

而我们要做的，就是实现这个UserDetailService。图画得不好，大家不要见笑，但是说了这么多总算是引出了我们开发中的关键，那就是我们要实现自己的UserDetailService，它就是连接我们的数据库和Acegi的桥梁。UserDetailService的要求也很简单，只需要一个返回org.springframework.security.userdetails.User对象的 loadUserByUsername(String userName)方法。因此，怎么设计数据库都可以，不管我们是用一个表还是两个表还是三个表，也不管我们是用户-授权，还是用户-角色-授权，还是用户-用户组-角色-授权，这些具体的东西Acegi统统不关心，它只关心返回的那个User对象，至于怎么从数据库中读取数据，那就是我们自己的事了。

反过来再看看上面的过程，我们发现，即使我们要做的只是实现自己的UserDetailService类，但是我们不得不在Spring中配置那一大堆的 Bean，包括几个Filter，几个Manager，几个Provider和Voter，而这些配置往往都是重复的无谓的。好在Acegi 2.0也认识到了这个问题，所以，它设计了一个标签，让Acegi的配置得到了简化。下面是SpringSide 3中的配置的截图，大家可以看看：

下图是官方文章中的传统Filter设置和元素之间的对应关系：

下面的代码是SpringSide 3中实现UserDetailService的范例，在SpringSide 3的范例中，白衣使用了三个表User、Role、Authority。但是Acegi不关心你用了几个表，它只关心UserDetails对象。而决定用户能否访问指定Web资源的，是RoleVoter类，无需任何修改它可以工作得很好，唯一的缺点是它只认ROLE_前缀，所以搞得白衣的 Authority看起来都象角色，不伦不类。

package personal.youxia.service.security;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Required;
import org.springframework.dao.DataAccessException;
import org.springframework.security.GrantedAuthority;
import org.springframework.security.GrantedAuthorityImpl;
import org.springframework.security.userdetails.UserDetails;
import org.springframework.security.userdetails.UserDetailsService;
import org.springframework.security.userdetails.UsernameNotFoundException;
import personal.youxia.entity.user.Authority;
import personal.youxia.entity.user.Role;
import personal.youxia.entity.user.User;
import personal.youxia.service.user.UserManager;

/**
* 实现SpringSecurity的UserDetailsService接口,获取用户Detail信息.
*
* @author calvin
*/
public class UserDetailServiceImpl implements UserDetailsService {

     private UserManager userManager;

     public UserDetails loadUserByUsername(String userName) throws UsernameNotFoundException, DataAccessException {
        User user = userManager.getUserByLoginName(userName);
         if (user == null )
             throw new UsernameNotFoundException(userName + " 不存在 " );

        List < GrantedAuthority > authsList = new ArrayList < GrantedAuthority > ();

         for (Role role : user.getRoles()) {
             for (Authority authority : role.getAuths()) {
                authsList.add( new GrantedAuthorityImpl(authority.getName()));
            }
        }

         // 目前在MultiDatabaseExample的User类中没有enabled, accountNonExpired,credentialsNonExpired, accountNonLocked等属性
         // 暂时全部设为true,在需要时才添加这些属性.
        org.springframework.security.userdetails.User userdetail = new org.springframework.security.userdetails.User(
                user.getLoginName(), user.getPassword(), true , true , true , true , authsList
                        .toArray( new GrantedAuthority[authsList.size()]));

         return userdetail;
    }

    @Required
     public void setUserManager(UserManager userManager) {
         this .userManager = userManager;
    }
}

最后再来说说这个命名的问题，我对Authentication和Authority这两个单词比较反感，两个原因，一是因为它们太生僻了，二是因为它们长得太像了，明明一个是认证，一个是授权，意思相差很远，外貌却如此相似，确实很烦人。如果让我来选择，我喜欢Privilege这个单词，在我刚使用 MySQL的时候就跟它很熟了，所以在我的项目中，我可能会用Privilege来代替Authority。如果我们只使用User-Role两级关系，使用RoleVoter默认的ROLE_前缀当然没有关系，如果是像白衣这样是用三层关系，最好还是把这个前缀改一改，以免混淆。

seal 2010-01-08 17:01 发表评论

Spring Security 2 配置精讲(转)

seal — Fri, 08 Jan 2010 08:58:00 GMT

摘要: 论坛上看了不少Spring Security的相关文章。这些文章基本上都还是基于Acegi-1.X的配置方式，而主要的配置示例也来自于SpringSide的贡献。众所周知，Spring Security针对Acegi的一个重大的改进就在于其配置方式大大简化了。所以如果配置还是基于Acegi-1.X这样比较繁琐的配置方式的话，那么我们还不如直接使用Acegi而不要去升级了。所以在这... 阅读全文

seal 2010-01-08 16:58 发表评论

关于Spring MVC I18N 的配置问题(转)

seal — Thu, 07 Jan 2010 07:18:00 GMT

《Spring MVC I18N 配置说明》

一、基于浏览器语言的国际化配置

使用Spring的MVC，并且配置中有配置Resource文件

	

            "messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">

            "basename" value="message-info" />

            "useCodeAsDefaultMessage" value="true" />

其中，message-info是你的properties文件的通用名。如：我的配置文件叫message-info.properties,message-info_zh_CN.properties等等

只要有了这个配置，然后配置JSP渲染器为JSTL支持的，那么在你的JSP文件中使用fmt标记就可以实现客户浏览器语言国际化了。
如：
其中的info.login.title和你的资源文件对应

二、基于动态加载的国际化配置

1、基于请求的国际化配置

基于请求的国际化配置是指，在当前请求内，国际化配置生效，否则自动以浏览器为主。

配置方式如下：
首先配置拦截器

	

            "localeChangeInterceptor" class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor" />

这个配置呢，是不论请求级别的国际化，还是Cookie级别的国际化，再或者Session级别的国际化，都必需有配置这个拦截器，否则会不能使用。

配好上面的拦截器之后，就将拦截器注入到你的UrlHandlerMapping中，例如:

	"defaultUrlMapping" class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping">

            "interceptors" ref="localeChangeInterceptor" />

            "order">

            1

这个时候，但凡有了符合UrlMapping的请求，就会被拦截，并且开始配置国际化参数

1 2	"localeResolver" class="org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver">

默认的参数名为locale主意大小写。里面放的就是你的提交参数。如:en_US，zh_CN之类的，这个时候，你在页面上加一句

1	"?locale=zh_CN">简体中文

如果你的资源中，饱含建议中文的配置，那么就会变成你确定的简体中文拉。

2、基于Session的国际化配置

拦截器和基于请求的相同

Session的配置如下：

	"localeResolver" class="org.springframework.web.servlet.i18n.SessionLocaleResolver">

在你的处理的Controller中，将提交上来的locale字段信息生成真正的Locale对象，然后将对象保存在Session中，默认保存的ID是

1	SessionLocaleResolver.LOCALE_SESSION_ATTRIBUTE_NAME

这样，当你的Session不过期，那么语言种类始终保持正确的说。我一直是这样子用的，我觉得还是Session的好，老外们用了很满意。

3、基于Cookie的国际化配置

这个我就不说了，反正用的不多，至少我做的项目能不用Cookie就不用Cookie，所以，基于Cookie的国际化配置我就不细说了，如果想知道怎么配置，那么下载一个Spring，其中的例子程序就是用Cookie配置的，你自己读代码就OK了。

三、注意事项

如果不用默认的浏览器语言国际化方式，那么拦截器一定要配置，如果你有多个UrlMapping，那么就每个都配上拦截器。
至于配置的LocaleResolver的名字，一定要用上面的配置中的名字localeResolver当然了，这个是默认的名字来的，自己设置成别的也可以，但是就是麻烦，反正我用默认的就感觉不错。

好啦，说了这么多，应该大家会配置了吧，表说你不知道Locale对象怎么生成哦～

seal 2010-01-07 15:18 发表评论

Simple web application with Spring Security

seal — Thu, 24 Dec 2009 09:01:00 GMT

After given a demo to the customer, they wished to modify the specification so that after login, the page always shows the name of the user logged in. Also they would prefer if the navigation was customized to the type of user that has logged in. e.g. standard users with ROLE_USER should not see the link to the admin page on the common navigation.

The specification has been updated as follows:

User Story 7: Create common navigation that all secure pages will contain.
Note: There will be links to home, admin pages and a logout link.
Note: only admin users should see the admin link on the common navigation.

User Story 10: A common information bar should exist on all secure pages that displays whether the user is logged in or not.

The solution

To customize the common navigation per user role type and display the logged in username, we are going to use spring security’s tag libs, specifically the authorize and authentication tags.

Add spring security taglibs as dependency

Add spring-security-taglibs-2.0.4.jar to our WAR projects lib folder.

The implementation

The first step is to update our acceptance tests that verify behavior on the common navigation:

@Test

public void shouldNotBeAbleToSeeAdminLinkOnCommonNavigationWhenNotLoggedInAsStandardUser() {



driver.get("http://localhost:8080/springsecuritywebapp/home.htm");

login(driver);



// verify

assertThat(driver.getTitle(),

is("Home: Spring Security Web Application"));



try {

driver.findElement(By.linkText("Admin"));

fail("should not be able to see a link to admin page when logged in as standard user");

} catch (final NoSuchElementException e) {

assertNotNull(e);

}



}



@Test

public void shouldBeAbleToViewUsernameOfUserOnAdminPageWhenSuccessfullyAuthenticated() {

loginAsUser(driver, withAdminRole());



// state verification

assertThat(driver.getTitle(),

is("Admin: Spring Security Web Application"));

assertThat(driver.findElement(By.id("loginstatus")).getText(),

containsString("Logged in as: admin"));



}



@Test

public void shouldBeAbleToViewUsernameOfUserOnHomePageWhenSuccessfullyAuthenticated() {

login(driver);



// state verification

assertThat(driver.getTitle(),

is("Home: Spring Security Web Application"));

assertThat(driver.findElement(By.id("loginstatus")).getText(),

containsString("Logged in as: username"));



}

Next step is to create a userinfobar.jsp file that will be included in each secure page:

Logged in as:

Things to note:

we are using the authentication tag from spring security’s tag libs (which will be included at top of each jsp that includes this file)

Next this should be included in the home.jsp and admin.jsp pages. Here is home.jsp:

<%@ page session="true"%>

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

<%@ taglib prefix='security' uri='http://www.springframework.org/security/tags' %>







Home: Spring Security Web Application











<%@ include file="/WEB-INF/jsp/navigation.jsp" %>

<%@ include file="/WEB-INF/jsp/userinfobar.jsp"%>



home page: only logged in users should see this page.

Things to note:

The spring security tablib is included at top of page
The userinfobar.jsp file is included so will display username of logged in users.

Build, deploy and run all acceptance tests.

Getting the code

The code for this part is tagged and available for viewing online at: http://code.google.com/p/spring-security-series/source/browse/#svn/tags/SpringSecuritySeriesWAR-Part8

SVN Url: https://spring-security-series.googlecode.com/svn/tags/SpringSecuritySeriesWAR-Part8

seal 2009-12-24 17:01 发表评论

Springing Around with ExtJS

seal — Thu, 19 Nov 2009 07:21:00 GMT

While playing around more with ExtJS and Spring, I ran in to one of my favorite annoyances — setting up a new project. I can create a new webapp in IDEA (or Eclipse) and add some dependencies, but it is still pretty empty. Maven can go a bit farther, but I don’t like how it handles transitive dependencies. None of these will really give me a good starting point out of the box without either copying a bunch of stuff over from other projects or writing a lot from scratch.

To finally scratch that itch, and move further along the Spring & ExtJS path, I turned my demo project into a basic template. The zip archive that you can grab at the bottom is a fully-configured Spring web application, including Tiles, Spring Security, Spring MVC, custom JSON view, Transactions and a Datasource.

To get started, grab the file, extract it to some directory. Open a shell, navigate to the Template directory and run the ant command ant dist. This will compile the whole project and create a Template.war file in the dist directory. Note, I use Java 6 for all development, so if you’re not at least at Java 5, you won’t be able to use this.

Before you drop the war file into Tomcat’s webapp directory, you’ll need to setup the database. First, copy the jar files in lib/tomcat into Tomcat’s lib directory. This is the MySQL JDBC driver and the JTA files for transactions. You’ll then need to create a new database on your local MySQL instance called tomcat. For simplicity in development, create a user with all rights to the tomcat database. Here’s the code to run from a MySQL shell:

create database tomcat; use tomcat; grant all on tomcat.* to tomcat@localhost identified by 'apache';
Your other option is to just put in your MySQL root username and password. To do that, or change the connection string completely, edit context.xml under web/META-INF. If you don’t use MySQL, you will have to edit this file and also put the correct driver in Tomcat’s lib directory.

Once you have the database setup, drop the Template.war file into your Tomcat webapps directory and startup Tomcat. Assuming Tomcat is configured to listen on port 8080, you can open the sample by browsing to http://localhost:8080/Template

The application only has a couple pages. First, the login page:

Spring Security is configured to route unauthenticated requests through this page for login. You can take a look at the applicationContext-security.xml file in WEB-INF to see how this was done. There are two users configured for now. User scott with a password of tiger and user bob with a password of password. Yes, not very clever, but it works. Scott is in both the ROLE_ADMIN and ROLE_USER roles, while Bob is only in ROLE_USER.

If you login with scott, you’ll be taken to the index page, which looks like this:

The index page simply contains a text box with a button. Entering a message and pressing the button results in an Ajax call to the server which echos the message back to the page. An HTML element in the middle of the page is updated with the result via JavaScript.

You’ll notice in the footer of the page you can see the currently logged in user on the left, and a link to log out on the right. Clicking the log out link takes you to the logout page, which looks like this:

Again, nothing fancy. Just a message saying you have logged out and a link to login again. Use the login link to login as bob and try the echo functionality again. This time you get a different result:

This demonstrates what happens with Spring Security via annotations. Here’s the echo method in the service layer:

As you can see, the method is secured with an annotation indicating the user must be in the ROLE_ADMIN role to use the method. Bob is only in the ROLE_USER role, so the call to this service fails.

The application makes use of a ResourceBundleMessageSource for the pages mapped through the htmlDispatch servlet. The login.jsp and logout.jsp don’t go through the dispatch servlet, so they can’t use the message bundle for the window and page title.

There is way too much to this simple application to cover completely now, but I’ll give the highlights of what to go look at in the major configuration files. Paths are relative to the project root:

web/WEB-INF/web.xml - notice that I configure two dispatch servlets. One catching *.htm and one *.json. This sets things up to treat Ajax requests differently. Spring Security is also configured here.
web/WEB-INF/applicationContext.xml – typical application context for a Spring application. I turn on annotation handling with package scanning under the sample.core package. Apache Tiles is configured in this file, and I have also configured a Transaction Manager around the JDBC DataSource. You should tweak this based on your underlying persistence preferences. I’m a RowMapper fan, but you can plug in Hibernate or JPA.
web/WEB-INF/htmlDispatch-servlet.xml - the context for web (*.htm) requests. This sets up the ResourceBundle for messages and a typical ViewResolver mapping the *.htm requests to jsp files under web/WEB-INF/jsp. Also configures component scanning for the sample.web package.
web/WEB-INF/jsonDispatch-servlet.xml – the context for Ajax (*.json) requests. Configures component scanning for the sample.json package and specifies a custom Ajax ViewResolver. This will automagically serialize all ModelMaps returned out of the Controller responded to *.json requests to JSON.
web/WEB-INF/applicationContext-security.xml – so simple to look at, yet so painful to figure out. This is the Spring Security configuration file. Although it looks deceptively simple, it was a beating to figure it all out. It enables annotation-driven security, which you saw on the EchoService above. It also sets up the form login and locks down all the pages. Note I leave the /resource directory open. This is where I put all my javascript, stylesheets and images. If you want to secure those resources, you’ll need to get more specific on the intercept-urls.
Users are declared at the bottom. Passwords are clear text, which is fine for a trivial demo, but you would want to replace this with something more industrial-strength in a real application.
web/WEB-INF/tiles-config.xml – the Apache Tiles configuration. I only setup one definition here to keep it simple.
web/WEB-INF/jsp/layouts/baseLayout.jsp – the base layout used for tiles. I’m only inserting content at two locations in the template. In the HTML head section, I allow for an optional insert of headerContent. I use this to include JavaScripts specific to a page. The other content is within the center div called mainContent.
Note that the body is pretty empty and that the divs all have the x-hidden class. This means they are not normally visible. I use an ExtJS Viewport for layout, which uses the contents of these divs.
web/resources/javascripts/layout.js – this JavaScript file was included in the baseLayout.jsp above. It creates the Viewport using a border layout.
web/resources/javascripts/index.js – the JavaScript file included for the index.jsp page. It decorates the plain HTML inputs on the page to do the cool Ajax stuff. Note towards the bottom how I use ExtJS to set focus on a form field and to bind the ENTER key to the submit button.
web/resources/javascripts/login.js – the JavaScript file use for the login.jsp page. If you look at login.jsp, you’ll notice there is no form. Everything is created by ExtJS from the login.js file, including the cool box effect. One trick is that Spring Security wants a normal form POST for the login form. I override the form to do a standard submit instead of an Ajax submit and set the form action explicitly.

This covers the major features. I’ll be using this as a base for other projects and will be expanding out my ExtJS demo. Since there are pretty much zero examples out there of tying together this stack, I hope this can be of use to some folks.

Project Template

2/28/2009 – upgrade to ExtJS 2.2.1, fixed compile issue on Linux, added in iBatis for ORM
3/26/2009 – I’ve setup a dev server with the latest version of the template at CodeZombie.com so you can check it out without having to install. User scott/tiger for credentials. I’ll be updating this install with a more feature-rich demo application shortly
3/28/2009 – changed around the project structure and build.xml to use Ivy for dependency management. Check the README.txt file in the root directory for the details.
4/28/2009 – updated the included JSON encoder to be able to return JSON arrays by using the key _root in the model map. If this key is found, its content will be used as the root element of the return JSON instead of encoding the whole map. Also removed the unicode characters from StringScrubber to make the compiler on Linux happy.

p.s. this pulls together a lot of jars and pieces from different folks to build the demo. If you use this for more than playing around, you need to make sure you respect whatever licenses the authors have in place.

seal 2009-11-19 15:21 发表评论

OSGi原理与最佳实践（精选版）（转）

seal — Fri, 30 Oct 2009 01:12:00 GMT

作者林昊发布于 2009年10月16日上午5时47分

社区: Architecture,; Java
主题: 开放源代码,; 应用服务器,; 平台,; 企业架构
标签: OSGi,; 图书

OSGi 在Java业界正是风生水起。几乎所有的JEE Server，比如IBM Websphere、Oracle Weblogic和Sun glassfish，都采用了OSGi作为基础平台，甚至推崇实用主义的SpringSource也挟Spring DM之势，推出了基于OSGi的应用服务器——Spring DM Server。山雨欲来风满楼，乘着这股东风，在BlueDavy发布了《OSGi实战》以及《OSGi进阶》之后，国内第一本OSGi的专业书—— 《OSGi原理与最佳实践》刚刚面世。InfoQ中文站精选了其中的两章，特做成迷你书，供各位读者免费下载。

免费下载迷你书

如果你喜欢本书，请通过购买原版《OSGi原理与最佳实践》支持出版商和InfoQ中文站。

点击这里：免费下载这本书（PDF）免费下载这本书（PDF） 。

迷你书目录

《OSGi原理与最佳实践》原书详细信息

前言
目录

第1章 OSGi框架简介

1.1 Equinox

1.1.1 简介
1.1.2 环境搭建
1.1.3 HelloWorld
1.1.4 开发传统类型的应用
1.1.5 从外部启动Equinox

1.2 Felix

1.2.1 简介
1.2.2 环境搭建
1.2.3 应用部署
1.2.4 在Eclipse中调试Felix

1.3 SpringDM

1.3.1 简介
1.3.2 环境搭建
1.3.3 HelloWorld
1.3.4 Web版HelloWorld

第2章基于SpringDM实现Petstore

2.1 即插即用的Petstore

2.2 新一代Petstore的实现

2.2.1 环境准备
2.2.2 Utils模块
2.2.3 Bootstrap模块
2.2.4 ProductDal模块
2.2.5 ShoppingCartDal模块
2.2.6 ProductList模块
2.2.7 ShoppingCast模块
2.2.8 ProductManagement模块

2.3 部署

2.4 Petstore的扩展

BlueDavy《OSGi原理与最佳实践》采访

InfoQ中文站就这次出版邀请BlueDavy对OSGi的近况、在具体项目上应用OSGi应该注意的问题和解决方法，以及如何在OSGi开发过程中结合使用敏捷实践的问题进行了一番访谈。

InfoQ：自从你上一次发布后，OSGi联盟最近有什么新进展？OSGi社区发展如何？

BlueDavy：OSGi联盟目前正在制定4.2的规范，并已发布公开草稿版本。在草稿版本中，我很欣慰的看到了OSGi联盟对 OSGi所做出的众多改进，包括了OSGi使用者们期待已久的对于Declarative Services的细节改进，并将其版本定为1.1，目前Equinox也已推出1.1版本Declarative Service的实现；除了对DS的改进外，在Core部分也可以看到提出了Framework Lunch这样的新规范部分，这对于按照标准使用OSGi和嵌入OSGi至其他容器提供了很大的帮助。除了以上这些外，还有其他很多的改进，在《OSGi 原理与最佳实践》一书中对OSGi R4.2的公众草稿版做了更多详细的分析。

但由于公布的公众草稿版本并不涉及企业应用领域，也就是EEG小组的工作，因此尽管大家期待的RFC 119: Distributed OSGi以及RFC 66: OSGi web container出现在了Early Draft中，但并没有出现在公众草稿版中，这两个最受大家关注的规范内容应该会被列入EEG出版的规范中。

对于社区这一块，OSGi尽管已经发展这么多年了，到目前为止确实仍然没有非常成熟的社区，但其相关的maillist，例如equinox maillist、OSGi-Dev maillist以及Spring-DM maillist都相当的活跃，业界的OSGi的使用者们根据自己的经验提出了不少OSGi的最佳实践，其中Bea的最佳实践总结以及Peter和BJ Hargrave在2007 JavaOne做的OSGi最佳实践总结给大家提供了很大的帮助。

InfoQ：相信很多人都想在真实项目中使用OSGi。请问如果要基于OSGi开发新系统时需要注意什么问题？如何设计系统的架构才能充分利用OSGi的好处？

BlueDavy：基于OSGi开发新系统时最值得注意的问题就是如何合理地划分模块的粒度，以及遵循OSGi框架的实现方式来构建真正的模块化、动态化的系统。

由于OSGi的强项在于模块化以及动态化，如果想在系统中充分发挥这两个优势，一方面是要让系统真正的模块化，把握好每个模块需要对外提供的功能，充分合理地使用OSGi提供的模块化交互的方式，例如import-package以及OSGi。

Service另一方面则是要让系统真正的动态化，这包括了基于OSGi框架支持的Bundle生命周期管理以及服务组件生命周期管理合理构建动态化的模块，同时也需要合理处理动态化时所带来的影响，例如引用的服务的注销、对象状态的保留与恢复等。在《OSGi原理与最佳实践》一书中提供了一些构建模块化和动态化系统的实践建议以及为什么要如此做的分析。

InfoQ：我们也看到在现实中存在着大量的遗留项目。那么，对于把传统的遗留系统改造成基于OSGi的架构，一般需要注意什么问题？

BlueDavy：突出的问题一般是模块ClassLoader隔离后带来的问题，对于OSGi的入门者来说，ClassNotFoundException或者ClassCastException这类异常会成为常见的现象，这就要求使用者能够对 ClassLoader以及OSGi模块隔离和交互这两方面的知识有充分的掌握，就如BEA的microServices的开发者们总结的一样：当你不使用OSGi来构建模块化系统时，你根本就不知道什么是真正的模块化系统，他们在移植原有的BEA的产品到OSGi上时花了一年多的时间，这也意味着要将传统系统改造为OSGi架构确实有不小的难度，无论是OSGi知识方面的学习还是设计思想方面的转变。

InfoQ：Oracle收购了Sun，这两家公司势必要在很多方面整合，比如双方对OSGi的态度。我们知道，虽然有很多JEE Server都选择架构在OSGi之上，但是Oracle Fushion 11G里面却没有采用OSGi，请问你认为Oracle收购Sun对OSGi会产生什么影响？

BlueDavy：从我2005年接触OSGi而言，对OSGi的前景一直非常的看好，也许在2005、2006年时OSGi的前景看似一片迷茫，但进入2008、2009后，无论从Java主流应用服务器都基于OSGi来看，还是从Java将从语言级提供对模块化的支持来看，OSGi已经逐步的得到认可并成为事实性标准。

Oracle在很久之前就开始关注OSGi，并且Oracle也是OSGi联盟的成员之一，尽管Oracle Fushion 11G没有采用OSGi，但我认为这并不表示Oracle否定OSGi，或者不愿意采用OSGi，也许Oracle只是认为目前采用OSGi会对其原有积累的技术产生不小的冲击，毕竟BEA为了移植到OSGi花了一年多的时间，从另外的角度来看，提供模块化的支持已经成为Java语言发展的必然，OSGi 是目前仅有的已投入实际商业产品使用的模块化规范，另一方面从OSGi对JSR277产生的影响来看，可见OSGi在Java模块化规范方面的领先地位，因此也许不久后我们就能看到Oracle对OSGi的态度，相信很大概会是好消息。

InfoQ：应用系统开发引入OSGi之后，又如何应用TDD、自动构建等敏捷实践？

BlueDavy：OSGi Service为POJO方式，再加上OSGi和Spring一样支持方法方式的依赖注入，因此对于依赖关系不复杂的OSGi Service的TDD和自动构建没有问题。

对于依赖状况复杂的而言，在Spring中多数仍然会采用配置文件编写依赖注入关系，启动Spring容器，获取相应的bean进行测试的方式。在这种情况下，目前OSGi容器的支持则不是很好，较Spring容器的单元测试而言复杂很多。一方面是由于OSGi采用的为Bundle部署机制，这就要求在测试时将所有需要依赖的Bundle部署至OSGi容器中，在目前的情况下这需要通过编写程序来安装。这个状况等到OBR进入使用阶段后会好很多，原因在于通过OBR可以很容易的自动安装所需依赖的Bundle；另外一方面则是由于OSGi并不直接提供在外部获取OSGi Service的方法，就像Spring可以通过ApplicationContext来获取Bean。但是，也不是没有办法，如何在外部获取OSGi Service的方法在《OSGi原理与最佳实践》一书中有进行讲解。除了书中讲解的方法外，在OSGi R4.2中新提供的Framework launch也将有助于在OSGi容器外部获取OSGi Service。

鉴于上面的两个原因，在目前的情况下只能自行实现一个单元测试框架，OSGi China User Group最近会公布一个OSGi单元测试框架以方便大家对OSGi程序进行TDD和自动构建。

seal 2009-10-30 09:12 发表评论

OpenSessionInViewFilter 的两个异常:Illegal attempt to associate a collection with two open sessions; Write operations are not allowed in read-only mode (FlushMode.NEVER/MANUAL)

seal — Thu, 29 Oct 2009 14:23:00 GMT

使用 Spring 整合 Hibernate, 在懒加载的情况下, 有时候需要在 JSP/View 层显示数据, 这时候就要用到Spring内置的: OpenSessionInViewFilter, 一般来说配置如下(web.xml):

<filter>

<filter-name>hibernateFilterfilter-name>

<filter-class>

org.springframework.orm.hibernate3.support.OpenSessionInViewFilter

    filter-class>

<init-param>

<param-name>singleSessionparam-name>

        <param-value>trueparam-value>

init-param>

 filter>

<filter-mapping><filter-name>hibernateFilterfilter-name><url-pattern>*.dourl-pattern>-- *.jsp, *.do-->filter-mapping>

不过, 这时候又会导致更新数据时抛出如下异常:

Write operations are not allowed in read-only mode (FlushMode.NEVER/MANUAL): Turn your Session into FlushMode.COMMIT/AUTO or remove 'readOnly' marker from transaction definition.

这时候再去网上找解决方案, 会有人说: 把参数 singleSession改为false, 就行了. 不过, 改完后, 估计不久就会遇到另一个郁闷的异常:

org.hibernate.HibernateException: Illegal attempt to associate a collection with two open sessions

这下完了, 两个方案都不行, 到底怎么办? 还好, 在http://xuliangyong.javaeye.com/blog/144818的主页上, 给了一个方案, 就是改写 OpenSessionInViewFilter 的代码, 非常感谢, 下面给出的就是最终方案:

web.xml

< filter-name >hibernateFilterfilter-name>

< filter-class > org.springframework.orm.hibernate3.support.OurOpenSessionInViewFilter filter-class>

OurOpenSessionInViewFilter.java 代码:

package org.springframework.orm.hibernate3.support;







import org.hibernate.*;







/** * 单session模式下, 默认会发生无法提交的错误: * Write operations are not allowed in read-only mode (FlushMode.NEVER/MANUAL): Turn your Session into FlushMode.COMMIT/AUTO or remove 'readOnly' marker from transaction definition. * 需要设置FlushMode并刷新session. * 参考: http://xuliangyong.javaeye.com/blog/144818 * @author 刘长炯 */publicclass OurOpenSessionInViewFilter extends OpenSessionInViewFilter {







public OurOpenSessionInViewFilter() {



super.setFlushMode(FlushMode.AUTO);



}







protectedvoid closeSession(Session session, SessionFactory sessionFactory) {



session.flush();







try {



session.getTransaction().commit();



} catch (HibernateException e) {



// TODO Auto-generated catch block//e.printStackTrace();



}







super.closeSession(session, sessionFactory); 



} 



}

如果各位有更好的解决方案, 欢迎讨论哦!!!

题外话:

感觉 Spring + Hibernate 的健壮性还是不够啊! 容易抛异常, 这是事实, 也许这是开源软件的通病吧.

seal 2009-10-29 22:23 发表评论

Spring MVC集成Tiles时候的属性值国际化(转)

seal — Sat, 24 Oct 2009 13:16:00 GMT

在使用Tiles时候, 一般会有类似以下配置:

默认情况下, 如果value值一"/"开头, 则认为是URL, 其他则任务是字符串, 而如果想让title实现国际化, 如何配置呢?
以下有两种解决方案, 一种就是准备多个tiles配置文件,如tiles_def_zh_CN.xml, tile_def_en_US.xml, 这个优点麻烦了(个人觉得).
第二种方法就是使用标签, 如果spring:message或者fmt等等, 具体如下:
修改tiles配置文件中的title对应的值为资源文件中的key:

然后修改页面需要渲染的地方:

<spring:message code="${key}"/>
或者

<fmt:message key="${key}"/>title></span> <br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/sealyu/" target="_blank">seal</a> 2009-10-24 21:16 <a href="http://www.blogjava.net/sealyu/archive/2009/10/24/299590.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div> </article> <article> <h1>Spring 2.5 与 Tiles2.1.X系列的兼容性</h1> <p>seal — Fri, 23 Oct 2009 07:28:00 GMT</p> 郁闷了差不多一天，终于在一篇文章中发现，原来spring2.5系列与Tiles2.1.X系列不兼容，目前只可以使用Tiles2.0.X和Tiles1.x系列。<br /> <br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/sealyu/" target="_blank">seal</a> 2009-10-23 15:28 <a href="http://www.blogjava.net/sealyu/archive/2009/10/23/299482.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div> </article> <article> <h1>Annotation-Based Validation with the Spring Bean Validation Framework</h1> <p>seal — Wed, 21 Oct 2009 15:19:00 GMT</p> <h1 style="margin: 0pt 0pt 10px;">Annotation-Based Validation with the Spring Bean Validation Framework</h1> <div>by Willie Wheeler</div> <div>2008?7?17? ???</div> <div id="deck">Use Java annotations to validate your Spring WebMVC form beans.</div> <div> <p>The Spring Bean Validation Framework, which is part of the <a href="https://springmodules.dev.java.net/">Spring Modules</a> project, allows you to perform validation declaratively using Java annotations. I've always liked the declarative approach, which we saw for instance in Commons Validator, but annotation-based validation is especially convenient.</p> <p><a href="http://jcp.org/en/jsr/detail?id=303">JSR 303 (Bean Validation)</a> specifies some standards around bean validation, though the Spring Bean Validation Framework does not adopt those standards. The <a href="http://www.hibernate.org/412.html">Hibernate Validator</a> project, on the other hand, aims to provide an implementation of the emerging JSR 303 standard.</p> <p>While it very well could be subpar Googling skills on my part, there doesn't seem to be much detailed how-to information out there on actually using the Bean Validation Framework. Hence this article.</p> <p>I'm using Spring 2.5.x (specifically, Spring 2.5.5) and Spring Modules 0.9. I assume that you already know Spring and Spring WebMVC in particular.</p> <p>If you want to download the code, you can do so here:</p> <div><a href="http://wheelersoftware.s3.amazonaws.com/articles/spring-bean-validation-framework/contact-example.zip">contact-example.zip</a></div> <p>You'll have to download the dependencies separately though.</p> <h2>Dependencies</h2> <p>Here's what you'll need (again, I'm using Spring 2.5.x and Spring Modules 0.9):</p> <ul> <li><code>commons-collections.jar</code></li> <li><code>commons-lang.jar</code></li> <li><code>commons-logging.jar</code></li> <li><code>spring.jar</code></li> <li><code>spring-modules-validation.jar</code></li> <li><code>spring-webmvc.jar</code></li> </ul> <h2>Java Sources</h2> <p>I'm going to do things a little differently than I normally do, and start with the Java first. We're going to build a very simple "Contact Us" form of the sort that you might use to ask a question, complain about lousy service, or whatever. Since we're just showing how validation works, I've left out the service and persistence tiers. We're going to do everything with a form bean and a controller.</p> <p>Here's the form bean:</p> <div> Code listing: <code>contact.UserMessage</code> <div> <div> <div><a href="http://wheelersoftware.com/articles/spring-bean-validation-framework.html#" onclick="dp.sh.Toolbar.Command('ViewSource',this);return false;">view plain</a><a href="http://wheelersoftware.com/articles/spring-bean-validation-framework.html#" onclick="dp.sh.Toolbar.Command('CopyToClipboard',this);return false;">copy to clipboard</a><a href="http://wheelersoftware.com/articles/spring-bean-validation-framework.html#" onclick="dp.sh.Toolbar.Command('PrintSource',this);return false;">print</a><a href="http://wheelersoftware.com/articles/spring-bean-validation-framework.html#" onclick="dp.sh.Toolbar.Command('About',this);return false;">?</a></div> </div> <ol start="1"> <li>package contact; </li> <li> </li> <li>import org.springmodules.validation.bean.conf.loader.annotation.handler.Email; </li> <li>import org.springmodules.validation.bean.conf.loader.annotation.handler.Length; </li> <li>import org.springmodules.validation.bean.conf.loader.annotation.handler.NotBlank; </li> <li> </li> <li>public final class UserMessage { </li> <li> </li> <li> @NotBlank </li> <li> @Length(max = 80) </li> <li> private String name; </li> <li> </li> <li> @NotBlank </li> <li> @Email </li> <li> @Length(max = 80) </li> <li> private String email; </li> <li> </li> <li> @NotBlank </li> <li> @Length(max = 4000) </li> <li> private String text; </li> <li> </li> <li> public String getName() { </li> <li> return name; </li> <li> } </li> <li> </li> <li> public void setName(String name) { </li> <li> this.name = name; </li> <li> } </li> <li> </li> <li> public String getEmail() { </li> <li> return email; </li> <li> } </li> <li> </li> <li> public void setEmail(String email) { </li> <li> this.email = email; </li> <li> } </li> <li> </li> <li> public String getText() { </li> <li> return text; </li> <li> } </li> <li> </li> <li> public void setText(String text) { </li> <li> this.text = text; </li> <li> } </li> <li>} </li> </ol> </div> <pre style="display: none;" name="code" class="java">package contact; import org.springmodules.validation.bean.conf.loader.annotation.handler.Email; import org.springmodules.validation.bean.conf.loader.annotation.handler.Length; import org.springmodules.validation.bean.conf.loader.annotation.handler.NotBlank; public final class UserMessage { @NotBlank @Length(max = 80) private String name; @NotBlank @Email @Length(max = 80) private String email; @NotBlank @Length(max = 4000) private String text; public String getName() { return name; } public void setName(String name) { this.name = name; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } public String getText() { return text; } public void setText(String text) { this.text = text; } } </pre> </div> <p>The bean itself is pretty uninteresting—I have field for the user's name, e-mail address, and the message text. But the cool part is that I've included annotations that specify validation constraints. It's probably self-explanatory, but I've specified that none of the fields is allowed to be blank, and I've also specified the maximum lengths for each. (You can also specify minimum lengths, which one could use instead of <code>@NotBlank</code>, but I'm using <code>@NotBlank</code> instead for a reason I'll explain in just a bit.) Finally, I've specified that <code>email</code> needs to be a valid e-mail address. It's that simple!</p> <p>Here are <a href="https://springmodules.dev.java.net/docs/reference/0.8/html_single/#d0e9699">the rest of the validation rules</a> you can use.</p> <p>Now here's the Spring MVC controller, which I've implemented as a POJO controller:</p> <div> Code listing: <code>contact.ContactController</code> <div> <div> <div><a href="http://wheelersoftware.com/articles/spring-bean-validation-framework.html#" onclick="dp.sh.Toolbar.Command('ViewSource',this);return false;">view plain</a><a href="http://wheelersoftware.com/articles/spring-bean-validation-framework.html#" onclick="dp.sh.Toolbar.Command('CopyToClipboard',this);return false;">copy to clipboard</a><a href="http://wheelersoftware.com/articles/spring-bean-validation-framework.html#" onclick="dp.sh.Toolbar.Command('PrintSource',this);return false;">print</a><a href="http://wheelersoftware.com/articles/spring-bean-validation-framework.html#" onclick="dp.sh.Toolbar.Command('About',this);return false;">?</a></div> </div> <ol start="1"> <li>package contact; </li> <li> </li> <li>import org.springframework.beans.factory.annotation.Autowired; </li> <li>import org.springframework.stereotype.Controller; </li> <li>import org.springframework.ui.ModelMap; </li> <li>import org.springframework.validation.BindingResult; </li> <li>import org.springframework.validation.Validator; </li> <li>import org.springframework.web.bind.annotation.ModelAttribute; </li> <li>import org.springframework.web.bind.annotation.RequestMapping; </li> <li>import org.springframework.web.bind.annotation.RequestMethod; </li> <li> </li> <li>@Controller </li> <li>public final class ContactController { </li> <li> </li> <li> @Autowired </li> <li> private Validator validator; </li> <li> </li> <li> public void setValidator(Validator validator) { </li> <li> this.validator = validator; </li> <li> } </li> <li> </li> <li> @RequestMapping(value = "/form", method = RequestMethod.GET) </li> <li> public ModelMap get() { </li> <li> </li> <li> // Because we're not specifying a logical view name, the </li> <li> // DispatcherServlet's DefaultRequestToViewNameTranslator kicks in. </li> <li> return new ModelMap("userMessage", new UserMessage()); </li> <li> } </li> <li> </li> <li> @RequestMapping(value = "/form", method = RequestMethod.POST) </li> <li> public String post(@ModelAttribute("userMessage") UserMessage userMsg, </li> <li> BindingResult result) { </li> <li> </li> <li> validator.validate(userMsg, result); </li> <li> if (result.hasErrors()) { return "form"; } </li> <li> </li> <li> // Use the redirect-after-post pattern to reduce double-submits. </li> <li> return "redirect:thanks"; </li> <li> } </li> <li> </li> <li> @RequestMapping("/thanks") </li> <li> public void thanks() { </li> <li> } </li> <li>} </li> </ol> </div> <pre style="display: none;" name="code" class="java">package contact; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; import org.springframework.ui.ModelMap; import org.springframework.validation.BindingResult; import org.springframework.validation.Validator; import org.springframework.web.bind.annotation.ModelAttribute; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; @Controller public final class ContactController { @Autowired private Validator validator; public void setValidator(Validator validator) { this.validator = validator; } @RequestMapping(value = "/form", method = RequestMethod.GET) public ModelMap get() { // Because we're not specifying a logical view name, the // DispatcherServlet's DefaultRequestToViewNameTranslator kicks in. return new ModelMap("userMessage", new UserMessage()); } @RequestMapping(value = "/form", method = RequestMethod.POST) public String post(@ModelAttribute("userMessage") UserMessage userMsg, BindingResult result) { validator.validate(userMsg, result); if (result.hasErrors()) { return "form"; } // Use the redirect-after-post pattern to reduce double-submits. return "redirect:thanks"; } @RequestMapping("/thanks") public void thanks() { } } </pre> </div> <p>The Bean Validation Framework includes its own <code>Validator</code> implementation, called <code>BeanValidator</code>, and I'm making that injectable here. Also, note that we're going to autowire it in.</p> <p>It may be that there's a standard, predefined interceptor to apply <code>BeanValidator</code> (as opposed to injecting the <code>Validator</code> into the controller), but if there is, I haven't seen it. I'd be interested to hear if you, gentle reader, know of one.</p> <p>The noteworthy method here is the second <code>post()</code> method, which contains the validation code. I just call the standard <code>validate()</code> method, passing in the form bean and the <code>BindingResult</code>, and return the current logical view name if there's an error. That way the form shows the validation error messages, which we'll see below. If everything passes validation, I just redirect to a "thank you" page.</p> <p>Now let's look at how we define the validation messages that the end user sees if his form submission fails validation.</p> </div> <div> <h2>Validation Messages</h2> <div> Code listing: <code>/WEB-INF/classes/errors.properties</code> <div> <div> <div><a href="http://wheelersoftware.com/articles/spring-bean-validation-framework-2.html#" onclick="dp.sh.Toolbar.Command('ViewSource',this);return false;">view plain</a><a href="http://wheelersoftware.com/articles/spring-bean-validation-framework-2.html#" onclick="dp.sh.Toolbar.Command('CopyToClipboard',this);return false;">copy to clipboard</a><a href="http://wheelersoftware.com/articles/spring-bean-validation-framework-2.html#" onclick="dp.sh.Toolbar.Command('PrintSource',this);return false;">print</a><a href="http://wheelersoftware.com/articles/spring-bean-validation-framework-2.html#" onclick="dp.sh.Toolbar.Command('About',this);return false;">?</a></div> </div> <ol start="1"> <li>UserMessage.name[not.blank]=Please enter your name. </li> <li>UserMessage.name[length]=Please enter no more than {2} characters. </li> <li>UserMessage.email[not.blank]=Please enter your e-mail address. </li> <li>UserMessage.email[email]=Please enter a valid e-mail address. </li> <li>UserMessage.email[length]=Please enter no more than {2} characters. </li> <li>UserMessage.text[not.blank]=Please enter a message. </li> <li>UserMessage.text[length]=Please enter no more than {2} characters. </li> </ol> </div> <pre style="display: none;" name="code" class="java">UserMessage.name[not.blank]=Please enter your name. UserMessage.name[length]=Please enter no more than {2} characters. UserMessage.email[not.blank]=Please enter your e-mail address. UserMessage.email[email]=Please enter a valid e-mail address. UserMessage.email[length]=Please enter no more than {2} characters. UserMessage.text[not.blank]=Please enter a message. UserMessage.text[length]=Please enter no more than {2} characters. </pre> </div> <p>The keys should be fairly self-explanatory given <code>UserMessage</code> above. Each key involves a class, a field and an annotation. The values are parametrizable messages, not unlike Commons Validator messages if you're familiar with those. In the three <code>length</code> messages, I'm using <code>{2}</code> to indicate argument #2—viz., <code>max</code>—for the <code>length</code> validation rule. Argument #1 happens to be <code>min</code>, and argument #0 in general appears to be the form bean itself. I can imagine that it would be nice to be able to use the form bean to get at the specific submitted value so you could say things like "You entered 4012 characters, but the limit is 4000 characters." And I think there's actually a way to do that though I don't myself know how to do it yet. (This is another one of those areas where I'd appreciate whatever information you may have.)</p> <p>I mentioned above that I chose <code>@NotBlank</code> instead of <code>@Length(min = 1, max = 80)</code>. The reason is that I wanted to use a specific error message ("Please enter your name") if the message is blank. I could have just used "Please enter a name between 1-80 characters" but that sounds slightly silly compared to "Please enter your name", and since I'm a usability guy I care about such things.</p> <h2>The JSPs</h2> <p>We have two JSPs: the form itself, and a basic (really basic) "thank you" page.</p> <div> Code listing: <code>/WEB-INF/form.jsp</code> <div> <div> <div><a href="http://wheelersoftware.com/articles/spring-bean-validation-framework-2.html#" onclick="dp.sh.Toolbar.Command('ViewSource',this);return false;">view plain</a><a href="http://wheelersoftware.com/articles/spring-bean-validation-framework-2.html#" onclick="dp.sh.Toolbar.Command('CopyToClipboard',this);return false;">copy to clipboard</a><a href="http://wheelersoftware.com/articles/spring-bean-validation-framework-2.html#" onclick="dp.sh.Toolbar.Command('PrintSource',this);return false;">print</a><a href="http://wheelersoftware.com/articles/spring-bean-validation-framework-2.html#" onclick="dp.sh.Toolbar.Command('About',this);return false;">?</a></div> </div> <ol start="1"> <li><%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %> </li> <li> </li> <li><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" </li> <li> "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> </li> <li> </li> <li><html xmlns="http://www.w3.org/1999/xhtml"> </li> <li> <head> </li> <li> <title>Contact Us

Contact Us

<%-- Give command object a meaningful name instead of using default name, 'command' --%>

Your name:

Your e-mail address:

Your message:

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>



Contact Us



Contact Us
<%-- Give command object a meaningful name instead of using default name, 'command' --%>


Your name:




Your e-mail address:




Your message:

This is just a standard Spring WebMVC form, so I'll invoke my "I assume you know Spring WebMVC" assumption here. The cssErrorClass attribute is kind of fun if you don't already know about it. It indicates the CSS class to use in the event of a validation error. You can combine that with the cssClass attribute (which applies in the non-error case) though I haven't done that here.

Now here's the basic "thank you" page:

Code listing: /WEB-INF/thanks.jsp

view plain copy to clipboard print ?

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
Thank You
Thank You




Thank You


Thank You

(I told you it was basic...)

OK, now we're ready to move onto application configuration. Almost done!

Servlet and Spring Configuration

Here's our completely standard web.xml:

Code listing: /WEB-INF/web.xml

view plain copy to clipboard print ?

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
version="2.5">
contact
org.springframework.web.servlet.DispatcherServlet
contact
/contact/*




contact

org.springframework.web.servlet.DispatcherServlet



contact
/contact/*

Though I said I'm assuming you already know Spring WebMVC, I'll just point out that since I didn't specify a custom location for the application context file, I have to put it at /WEB-INF/contact-servlet.xml. If you want the file to live elsewhere, or if you want it to be associated with the servlet context instead of the DispatcherServlet, you'll have to set that up in web.xml accordingly.

Here's the Spring application context:

Code listing: /WEB-INF/contact-servlet.xml

view plain copy to clipboard print ?

xmlns:context="http://www.springframework.org/schema/context"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
class="org.springmodules.validation.bean.conf.loader.annotation
.AnnotationBeanValidationConfigurationLoader"/>
p:configurationLoader-ref="configurationLoader"/>
class="org.springframework.context.support.ResourceBundleMessageSource"
p:basenames="errors"/>
p:prefix="/WEB-INF/"
p:suffix=".jsp"/>

(IMPORTANT: In the configurationLoader definition, make sure you put the class name on a single line. I had to break it up for formatting purposes.)

If you're not familiar with it, I'm using the p namespace here for syntactic sugar—it allows me to specify properties using a nice shorthand.

The first two beans basically create the BeanValidator instance we're going to use. It turns out that instead of defining these two beans explicitly, you can use a special element from a special namespace:

namespace is xmlns:vld="http://www.springmodules.org/validation/bean/validator";
purported schema location is http://www.springmodules.org/validation/bean/validator-2.0.xsd;
element is

But when I do it, Eclipse complains (even though the code works when you run it) since there isn't at the time of this writing actually an XSD at the specified location. (At least there's a JIRA ticket for it.) So I'll just use the two beans for now.

The other stuff is mostly normal Spring WebMVC stuff. I put the message source on the app context, scan for the controller (which is why I'm autowiring the validator into the controller), and put a view resolver on the context too.

Finis

Build and deploy your WAR, and then point your browser to your web app; for example:

http://localhost:8080/contact-example/contact/form

Try submitting the form with empty fields, or an invalid e-mail address, or fields that are too long. If things are working correctly, you ought to see error messages and even field highlighting when validation fails.

And that, my friends, is it! Feel free to post a comment if you run into problems getting it to work and I'll try to help if I can.

Again, if you want to download the sample code (minus dependencies; see above), here it is:

contact-example.zip

Have fun!

seal 2009-10-21 23:19 发表评论

Spring 2.5.1 MVC + Tiles 2.0.5 基本配置（转）

seal — Tue, 20 Oct 2009 09:02:00 GMT

摘要: 从sourceforge下载spring-framework-2.5.1-with-dependencies.zip，并从中拉出以下jar文件（最小化依赖） #spring 2.5.1 commons-logging.jar log4j-1.2.14.jar spring-beans.jar spring-core.jar spring-context.jar spring-web.... 阅读全文

seal 2009-10-20 17:02 发表评论

Spring MVC framework深入分析（转）

seal — Tue, 20 Oct 2009 07:36:00 GMT

Spring MVC framework深入分析之一--总体分析

leopallas | 08 九月, 2005 14:54

在当今的MVC framework里，似乎Webwork2逐渐成为主流， Webwork2+SpringFramework的组合变得越来越流行。这似乎意味着Spring自带的MVC framework远比Webwork2差，所以大家纷纷用Webwork2来代替。确实，Spring的MVC framework不算是整个Spring的核心部件，但它的威力却超过了很多人的想象。很多人包括xiecc认为Spring的MVC framework是非常优秀的，甚至比Webwork2更优秀。
下面列举一下Spring的MVC framework在设计时做出的一些重要的决定，并将之和相关的MVC framework如Webwork2或struts进行对比：

一、 Spring的整个MVC配置是基于IOC容器的
与 struts或webwork2相比，这是一个ms有点奇怪的决定，看一下Spring MVC的配置文件，最先看到的不是action或者form，而是一些有着特定名字的bean，Bean下面的配置是一些简单或有点复杂的属性。我们看到的是机器更容易的数据结构，而不是人更容易理解的元素。
但是这恰恰是Spring的MVC强大的根源！因为它的配置就是Spring的核心IOC 容器的配置，这意味着所有IOC容器的威力都可以在这里展现，我们可以为所欲为地对Spring MVC进行扩展和增强，我们可以完成在其它MVC framwork中很多难以想象的任务。想扩展新的URL映射方式吗？要换一个themeResolver或LocalReolver的实现吗?想在页面中显示新类型的View（比如说RDF，呵呵，一个小秘密：xiecc是研究语义网的，虽然成天不务正业，不写论文，只写八卦）？甚至想直接在 Controller里定义AOP吗？这些对Spring的MVC来说都是小菜一碟。
我没有仔细研究过Webwork2的扩展机制，我知道通过 Webwork2的interceptor机制，可以进行很多的扩展，甚至有一个简单简单的IOC容器。但不管它有多强大，提供了多少扩展点。它的威力都很难和真正的IOC容器相比。而struts的plugin功能则是出名的滥，虽然它也提供了plugin机制。
Spring采用IOC配置的另一个原因是使Spring的MVC与Spring的IOC容器的整合变得非常的容易。Spring提供了与struts与webwork2的整合，但是这样整合都需要在进行间接的包装，感觉总不是很自然。而且还会导致一个概念多个配置，webwork2就需要在Spring里配置bean，再配置自己的 xwork文件。想象一下吧，我们的bean直接就是一个controller,直接可以完成MVC的所有任务,这是多少爽的感觉。
Rod Johnson采用IOC容器来实现的另一个原因是这会减少好多开发工作量。看一下urlMapping吧，它提供的property本身就是一个 HashMap，只有配置完成，我们的bean里的数据就自然存在了，哈哈，好爽吧。不用象struts那样解析XML，再把它的内容一项一项地读到 HashMap里。
虽然这样的配置会有点怪异，但假如我们对Spring的IOC容器非常熟悉的话，会发现它非常的亲切，也非常的简单。
最后是一个简单的小秘密，Spring怎么知道某个bean的配置就是urlMapping？另一个bean的配置就是viewResolver？其实很简单，把所有的bean全部读到内存里，然后通过bean的名字或类型去找就行了。通过名字去找就是简单的getBean方法，通过类型去找则使用了 BeanFactoryUtils.beansOfTypeIncludingAncestors的静态方法。

二、 Spring提供了明确的Model, View概念和相应的数据结构
在Spring里有一个有趣的数据类型叫做ModelAndView，它只是简单地把要显示的数据和显示的结果封装在一个类里。但是它却提供了明确的MVC概念，尤其是model概念的强化，使程序的逻辑变得更清晰了。
记得以前在Struts里写程序里的时候，为了显示数据经常自己把东西放到HttpSession或HttpServletRequest里（或set到 form里，虽然不太有用），这造成了model概念的模糊，而且也导致了struts与JSP页面的紧耦合。假如我们要替换成Veloctiy,就得另外加一个plugin,因为在velocity里数据是不需要不放到request里的。
Webwork2里强调的是与Web framework解耦和它的command模式的简单性，因此在它的action里只有简单的get或set方法，假如返回数据，也只是简单地返回一个 String。当然这样的实现有它的好处，但是它淡化了model和view的概念。Rod Johnson认为Webwork2里的Action同时包含了Action和Model的职责，这样一个类的职责太多，不是一个很好的设计。当然 Jason Carreira不太认同这种观点，因为Action里的model对象完成可以delege给其它对象。但不管怎样，这种争论的根源在于 Webwork2里淡化了model, view甚至web的概念。仁者见仁，智者见智，最后的结果还是看个人喜欢好吧。

三、 Spring的Controller是Singleton的，或者是线程不安全的
和 Struts一样，Spring的Controller是Singleton的，这意味着每个request过来，系统都会用原有的instance去处理，这样导致了两个结果：我们不用每次创建Controller，减少了对象创建和垃圾收集的时间；由于只有一个Controller的 instance，当多个线程调用它的时候，它里面的instance变量不是线程安全的。
这也是Webwork2吹嘘的地方，它的每个 Action都是线程安全的。因为每过来一个request，它就创建一个Action对象。由于现代JDK垃圾收集功能的效率已经不成问题，所以这种创建完一个对象就扔掉的模式也得到了好多人的认可。Rod Johnson甚至以此为例证明J2EE提供的object pool功能是没多大价值的。
但是当人们在吹嘘线程安全怎么怎么重要的时候，我想请问有多少人在多少情况下需要考虑线程安全？Rod Johnson在分析EJB的时候也提出过其它问题，并不是没有了EJB的线程安全魔法，世界就会灭亡的，大多数情况下，我们根本不需要考虑线程安全的问题，也不考虑object pool。因为我们大多数情况下不需要保持instance状态。
至少我写了那么多的struts Action，写了那么多的Spring Controller，几乎没有碰到需要在instance变量保持状态的问题。当然也许是我写的代码不够多，Struts的设计者Craig R. McClanahan曾经说当时他设计struts时有两个条件不成熟：当时没有测试驱动开发的概念；当时JVM的垃圾收集性能太次。假如现在重新设计的话，他也会采用每个request生成一个新对象的设计方法，这样可以解决掉线程安全的问题了。

四、 Spring不象Webwork2或tapestry那样去隐藏Servlet相关的元素如HttpServletRequest或HttpServletResponse
这又是一个重要的设计决定。在Webwork2里我们没有HttpServletRequest或者HttpServletResponse，只有 getter, setter或ActionContext里数据，这样的结果导致一个干净的Action，一个与Web完全无关的Action，一个可以在任何环境下独立运行的bean。那么Webwork2的这样一个基于Command模式的Action究竟给我们带来了什么?我想主要有两点：
1、它使我们的Action可以非常容易地被测试。
2、用户可以在Action里添加业务逻辑，并被其它类重用。
然而仔细跟Spring比较一下，我们就会发现这两点功能所带来的好处其实并不象我们想象的那么显著。Spring的Controller类也可以非常轻松被测试，看一下spring-mock下面的包吧，它提供的MockHttpServletRequest, MockHttpServletResponse还有其它一些类让测试Controller变得异常轻松。再看一下Action里的业务逻辑吧，Jason Carreira曾经说我们可以尽情地在Webwork2的Action里加业务逻辑，因为Action是不依赖于Web的。但是有多少人真正往 Action里加业务逻辑的？大多数人都会业务逻辑delegate给另一个Service类或Manager类。因为我们很清楚，往Action里加业务逻辑会使整个体系的分层架构变得不清晰，不管怎样，Web层就是Web层，业务层就是业务层，两者的逻辑混在一起总会带来问题的。而且往Action里加业务逻辑会使用这个Action类变得庞大，Webwork2的Action是每个request都创建实例的，尽管带来的性能影响不太大，但并不表示每次都要把业务逻辑再new出来，业务逻辑在大多数的情况下应该是单例的。
不把request和response展现给用户当然还会带来功能上的损失，也许一般的场合，用用webwork2提供的接口已经足够了，但有时我们必须要知道request和response才能发挥出更大的威力。比如我以前的一个项目里有一个通过递归动态生成的树状结构的页面，在jsp页面上显示递归是痛苦或不可能的，因此我用response直接write出页面，这在spring里很easy，但在webwork里可能比较难了（偶不敢肯定，偶研究得不够深，也许高手是有办法的）。

五、 Spring提供了不错但不够充分的interceptor机制
回头看一下struts，它在架构里甚至没有给我们提供hook point的机会，我们没有任何机会加入自己的interceptor。我们只能通过重载struts的RequestProcessor类来进行一点有限的扩展。
到了Webwork2，似乎interceptor一下子成了整个Framework的核心，除了Action的核心部件，其它所有的东西都是 interceptor。它的超强的interceptor功能使们扩展整个架构变得非常方便。有人称这种interceptor为AOP，Jason Carreira则自豪地宣称这个叫做pragamtic AOP。我不认同这是AOP，它只是简单的interceptor机制。但不管如何，它的interceptor确实有强大的功能。
Spring 也提供了它的interceptor机制，它的HandlerInterceptor三个interceptor方法：peHandle, postHandle, afterCompletion。分别对应Controller执行前，Controller执行后和page render之后。虽然大多数情况下已经够用，但是从功能上来说显然它没有Webwork2强大。从AOP的角度来看，它没有提供around interceptor，而只有before与after interceptor。这意味着我们无法在interceptor前后保持状态，最简单的情况假如我们要计算一个Controller的执行时间，我们必须在执行完before后把begintime这个状态保持住，再在after里把它调出来，但是显然这个状态保持会是个问题，我们不能把它放到 instance变量里，因为interceptor不是线程安全的。也许通过ThreadLocal可以解决这个问题，但是如此简单的功能要用到这样的方法来处理，显然这个Interceptor本身设计上还是有点问题的。
六、 Spring提供了MultiActionController，使它可以在一个类里包含多个Action
这个设计和struts的DispatchAction有点类似，只不过提供了更灵活的机制。当我们的项目变大的时候，把功能类似的方法放到同一个 Action里完全值得的！Webwork2缺少这样的机制。假如看一下Spring的源代码，会发现其实实现 MultiActionController的工作量相当的少，只不过是用反射机制把解析出来的方法名执行一下就完事了。其实Webwork2也完全可以提供这样的机制。虽然从设计上来说确实不是很优雅，但是它确实很有用。

七、 Spring提供了更多的选择方式
看看Spring里提供的Controller吧，它提供了好多不同的Controller类。要生成Wizard吗？要专门用于提交form的Controller吗?要执多个方法的类吗?Spring提供了丰富的子类来扩展这些选择。当然我们还可以很轻松地自己扩展这些功能。
再看看Spring的 ViewResolver吧，它提供了无数不同类型的ViewResolver。更重要的是我们自定义我们的页面映射方式。看看strtus，看看webwork2，都会存在页面与 forward name的一层间接转换，我们必须在配置文件里配置好某个字符串（典型的是success）对应的是那个页面。但是Spring里我们有了更大的自由度，我们可以采用webwork2的策略，也可以采用更简单的策略，如将JSP文件名去掉扩展名的映射方法。也许有人认为这种映射方式很幼稚，但是我觉得它是非常有用的方式，即使在大项目里。
还有新的扩展吗？看看Spring Web Flow吧，它是SpringFramework的子项目。它为一长串的基于页面流的Wizard页面提供了可配置的实现方式。在Spring 1.3里，它将是SpringFramework的一部分。

八、 Spring的tag
尽管Spring的tag数量上少得可怜，但它却是精心设计的。它的目标很简单：让美工可以轻松地编辑页面。因为在Spring的页面里Text仍然是 Text，checkbox仍然是CheckBox，而不象在struts或webwork2中的Tag。它只是用Springbind对输入内容进行了一下包装。所以尽管页面显示代码上会比Webwork2多，但这绝对是有价值的。

在接下来的几章里，我会分析一下Spring是如何让我们的Web应用不需要知道ApplicationContext就能够访问IOC容器的，然后会对Spring的设计和执行过程进行简单的源码分析，然后给出几个扩展Spring MVC的方法。

Spring MVC framework深入分析之二--ApplicationContext之谜

leopallas | 09 九月, 2005 20:25

假如我们在写一个基于Spring的普通应用程序，不管我们用了多么精妙的设计模式，进行了如何巧妙的设计，我们必须在某个地方执行这样的代码：

ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(
new String[] {"applicationContext.xml", "applicationContext-part2.xml"});
appContext.getBean("…");

也许这样的代码算不上丑陋，但是它无疑破坏了程序的纯洁性和透明性。我们的应用程序开始显式地依赖SpringFramework，我们必须清楚地知道 Spring的配置文件有哪几个，每个配置文件的加入或修改源代码，我们必须在某些代码模块里调用丑陋的getBean方法来创造对象。

但是所有的这些丑陋的事情似乎在我们的Web应用程序里消失啦，所有的代码都是那么干净，只有简单的get与set及接口之间的调用，我们不需要知道 ApplicationContext，我们甚至不需要知道Spring。但是我们所有的对象却又是通过Spring的 ApplicationContext来创造的！

看上去似乎很神奇，但是假如我们稍微思考一下，就会发现这是一件合情合理又如此简单的事情，呵呵，只有第一个想到这个方法的人才是伟大的。让我们仔细想一下普通应用程序和Web应用程序的最大区别在哪里？

其实真正的区别只有一个，普通应用程序是一个主动执行的程序，而Web应用程序却是被动的组件。这意味着Web应用程序无法自己主动去生成自己的线程去执行某项任务，而必须借用Web容器中的一个线程。想象一下一个简单的任务：我们想每隔一段时间执行一个任务，比如说在Console里打印出一行文字。在我们的Web应用程序里应该怎么完成？在我不知道Servlet Listener或Spring里提供的Schedule之前（其实Spring就是利用Servlet Listner初始化Application Context时启动schedule的），这么简单的任务在一个Web应用程序里竟然是不可想象。还记得我当时采用的是最傻的做法：写了一个单独的应用程序，在这应用程序的main函数里启动了timetask。

但是如果换一种角度来看，整个Web应用程序生活在容器里也给我们带来了额外的好处，当我们让出了对应用程序的控制权之后，我们可以让容器帮我们完成很多本来很难处理的事情。其实IOC容器的真正作用也在于此，当我们把我们的对象创建工作移交给IOC容器之后，我们发现整个程序变得如此清晰，如此透明，对象之间的关联、哪些类需要事务处理或AOP功能、哪些类要远程访问，所有这些复杂的事情在我们的程序里都不见了，我们只看到了简单的get和set。

也许废话太多，但我觉得经过这样分析，其实 ApplicationContext之谜已经不再是谜了。真正的关键在于当我们的Web应用程序是被动的组件时，它除了可以错用容器的线程之外还可以错用其它一些东西。我们可以让容器来帮我们创建ApplicationContext，然后把它放在某个地方，然后在需要使用时让容器从这个地方把 ApplicationContext读出来，并执行相应的Controller就可以了。
这个"某个地方"就是ServletContext，而这个创建ApplicationContext的地方就是Servlet Listner，而取到ApplicationContext的地方是我们的DispatcherServlet。

仔细想一下，其实Web服务器并没有什么了不起的地方，它只是一个Java程序，它只是会在启动的时候去ClassLoad某些指定文件夹下的lib或 classes，它会读某个在WEB-INF下面一个叫做web.xml的配置文件，再做一些初始化工作。Servlet Listener就是这个初始化工作的重要一步，服务器会读出web.xml里配置好的所有listner，然后调用每个Listner的 contextInitialized方法（它还会去调每个Servlet的init方法，不过把初始化方法写在Listner里才是天经地义的）。哈哈，这也正是Spring MVC创建ApplicationContext的最好时机，当我们在web.xml里配置好ContextLoaderListener的时候，Spring就完成了ApplicationContext的创建过程，如果有人想研究源代码的话可以去看一下，不过这个创建过程并不象想象中的那么有趣，只是通过Class.forName和BeanUtils.instantiateClass创建出一个 WebApplicationContext，然后再读了一下IOC容器的配置文件。
接下来的一个问题是我们要把创建的 ApplicationContext放在哪里？答案是ServletContext，其实没必须对ServletContext进行深究，它只是可以一个可以全局存放Web应用程序的场所，我们只要想象成一个全局的HashMap就可以了，我们可以要把它put进去，就可以在Servlet或其它地方把它get出来。

Web服务器还要干的一件事件当然是在某个request到来时，它会启动一个单独的线程（这也是为何 Webwork可以把Context放到ThreadLocal里的原因），根据web.xml里的配置和request的URI匹配去执行相应的 Servlet。由于Servlet可以很轻松地读到ServletContext，当然也可以很轻松地读到ApplicationContext啦。接下来的事情就比想象中要简单啦，经过一些准备工作之后ApplicationContext中的URLMapping里配置好的某个 Controller，执行一下再rend某个view就可以了。其实struts或webwork2的执行过程也是如此，所以MVC framwork分析透了其实真没什么了不起，远比O/R Mapping或其它的framework简单。虽然MVC的执行过程如此简单，但是我们还需要了解一些细节上的事件，所以让我们下次来讨论一下 Spring MVC framework的执行过程吧。

Spring MVC framework深入分析之三--执行过程

leopallas | 10 九月, 2005 22:24
其实每个MVC framework的执行过程都是大同小异的，当个request过来时，它都通过一个Servlet来响应request，再根据request的路径名和配置将这个request dispatch给一个Controller执行，最后将之返回配置文件里对应的页面。在Spring MVC里，这个Servlet的名字叫DispatchServlet。稍看一下它的源码会发现这是一很简单的类。

下面是DispatchServlet的类图:

简单吧，这是典型的Template Method模式。每个类都会完成一些自己的本职工作，把不属于自己的工作延迟到子类来完成。这些类的子职责在下面会有分析。其实整个SpringFramework用的最多的模式就是Template Method（Strategy也挺多，呵呵），也许任何Framework用的最多的都是Template Method模式。Why?看看Expert One on One J2EE Design and Development吧，至少Template Method和Strategy模式的分析这本书甚至比Head first Design Pattern还好。

我们先来看DispatchServlet的初始化执行过程分析吧：

我们知道每个Servlet在Web服务器启动时都会有一个初始化的机会，这就是Servlet的init过程，这是配置Servlet的最好机会。我们可以在这个阶段干些啥事情呢？

1、把初始化的那些init-param读到Servlet的属性里。我们知道Servlet的init-param是放在ServletConfig里的，我们可以用循环去取这些属性。但是每次都这么干实在太累了，干吗不把在Servlet里增加几个property，再这些init-param直放到Servlet的property里呢？呵呵，以后那些初始参数都可以直接拿来用啦，真方便。DispatchServlet的一个祖先类叫做HttpServletBean就是专门干这个的。以后假如我们要写自己的Servlet也可以直接继承HttpServletBean这个类，这样读ServletConfig的操作都省掉了，哈哈！

2、从ServletContext里取出ApplicationContext，并扩展成自己的ApplicationContext.

在ApplicationContext之谜里我们已经提到我们可以用Servlet Listner执行的机会把ApplicationContext放到ServletContext中去。但是不是直接拿这个ApplicationContext就足够了呢？no。我们先问一个简单的问题吧：在Spring MVC里我们是不是只能配置一个Servlet呢？Struts就是那么干的，所以在Struts里所有的request过来都会交给一个Servlet去处理。但是在Spring MVC里，我们却可以有好多个Servlet！它们可以处理不同类型的request，而且更重要的是它们的ApplicationContext不是相同的，它们共享了一个父ApplicationContext，也就是从ServletContext里取出来的那个，但是它们却会根据自己的配置作扩展，形成这个Servlet特有的ApplicationContext。这个子的ApplicationContext里有自己的namespace，也就是将一个叫做（假如servlet名称叫xiecc） xiecc-servlet.xml的配置文件读进来，行成一个自己的ServletContext。所以这些过程全是在DispatchSevlet的一个父类FrameworkServlet里干的。

3、初始化接来要干的一件最重要的事情是初始DispatchServlet里的接口。如果用IOC容器的角度来说，其实是将ApplicationContext里定义好的接口注入到一个叫做DispatchServlet的bean里，只不过这个注入过程是手动的。注入的代码大致如果下（部分角色的含义和作用以后会解释）：

initMultipartResolver();

initLocaleResolver();

initThemeResolver();

initHandlerMappings();

initHandlerAdapters();

initHandlerExceptionResolvers();

initViewResolvers();

每个init方法其实是属性设置的过程，因为我们可以拿到自己的ApplicationContext，所以这一切都变得很轻松啦。比如说multipartResolver，直接用getWebApplicationContext().getBean(MULTIPART_RESOLVER_BEAN_NAME);就能拿到了。

不过很多东西在配置文件里是不需要写的，比如说multipartResolver，如果在xml里取不到，Spring会初始化默认的MultipartResolver。

接下来我们分析一下DispatchServlet怎么处理Request的执行流程吧：

看一下DispatchServlet的源码会发现它出奇的简单。简单的原因是类Template Method的Strategy模式，呵呵，这是我取的一个怪名字。因为DispatchServlet是不负责任何具体的操作的，它将具体的操作都delegate给了相应的接口，这是典型的Strategy模式。但是DispatchServlet里的doDispatch方法却控制了执行流程，所有的request过来，我们都会按这样的一个流程处理，这和Template Method里的由父类控制流程不谋而合。所以它仍然是Strategy模式，只不过主类还多了个控制流程的职责。

所以DispatchServlet本身的doService方法只是负责控制执行流程，而将所有具体的实现细节全都delegate给相应接口，难怪会那么简单。整个流程也异常的简单，我们甚至找不到循环跳转，所有的东西都是一直线下来的，撇开一些细节不说，剩下的就是这以几步了：

序号	步骤	具体内容	Delegate给谁干？
1	准备工作	设置theme, locale之类的东西。看看Request里是不是要上传文件，如果需要就转成MultipartRequest。
2	从request中取到HandlerExecutionChain	这个过程其实是提交给配置文件里定义的HandlerMapping 来做。HandlerExecutionChain是一个很有趣的东西，它包括就是我们要执行的Controller和一组interceptor，我们把它想象成一个执行单元就行啦。（细节上略有不同，下面会有分析）	HandlerMapping
3	执行HandlerExecutionChain	其实HandlerExecutionChain里已经包括了要执行的一切东西啦，我们只要把它分解开来执行就行啦。这有点象AOP或Webwork的执行方法pre interceptorsàControlleràpostInterceptors。	HandlerExecutionChain，它再delegate给一组interceptor和一个Controller
4	执行完的结果拿去显示，也就是所谓的render	通过ViewResolver的转换后，最后我们会delegate给一个View来完成最后的任务	ViewResolver View
5	Render完后还有interceptor	Spring提供了三个interceptor的机会，前两个Controller方法执行前后	HandlerExecutionChain里的interceptor

OK.是不是写得很乱？我自己都觉得惭愧啦，没办法，只好让我们再回头分析一下我们碰到几个角色吧：

1、HandlerMapping

HandlerMapping这个接口的定义非常简单：

public interface HandlerMapping {

HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;

}

不就是根据request的URL path来取得相应的HandlerExecutionChain。

例如：我的URL是http://localhost:8080/blog/xiecc.htm

RequestURL的字符串一截，拿到了”/xiecc.htm”，再去每个HandlerMapping里一查（还记得初始化时我们已经将所有的HandlerMapping都从配置文件里注入进来了吧），假如我们在某个SimpleUrlHandlerMapping里找到了”/xiecc.htm”，我就立刻可以拿到它对应Controller和一组intercetpors了，拿过来组装一下就是一个HandlerExecutionChain啦。

下面是HandlerMapping的类图：

看上去有点麻烦，其实挺简单，具体的类我就不分析啦。它的核心是：it’s all about HashMap。

还记得我们在Spring MVC最常用的HandlerMapping吗？是SimpleUrlHandlerMapping，我们在配置它的时候，最核心的结构就是HashMap，哈哈！东西都在HashMap里，只要通过URL分析找到HashMap的key，比如说”/xiecc.htm”，用个get方法不就啥都取到了。

在Spring的配置文件里我们可以配置多个HandlerMapping，它会一个一个去找到的，直到找到跟URL匹配的那个Controller，要不然就返回null啦。

2、HandlerExecutionChain

我前面说了HandlerExecutionChain就是一个Controller和一组interceptors。这是我们执行一个request最基本的单元啦。

不过现实情况会稍有些出入，HandlerExecutionChain实际上包括的一个Object和一组interceptor。这个Object是Adaptor，它可以是Controller的Adaptor，也可以是其它类的Adaptor。但现实中我们一般用到的都是Controller，因此不详细分析啦，这里用了Adaptor后大大降低了代码的可读性，来换取与Controller非紧耦合的灵活性。至少我现在认为这样做不是太值。

3、Controller

Controller是Spring MVC执行的核心单元，也是程序员需要自完成的重要部分。用过Spring MVC的人应该都对它非常熟悉啦。所以不做太具体的分析。以下是它的类图：

看一下类图就知道啦，这又是Template Method的典型应用。Controller最大的优势也正是利用Template Method，把Controller分解成不同功能的子类。想要把request里的东西populate到一个bean里吗？直接继承SimpleFormController就行啦。想要在Controller里写多个方法吗？用MultiActionController。这些Controller设计得面面俱到，但因为Controller的类层次太多，有的人会觉得烦。呵呵，随个人喜好啦。

不过最核心的是不管这些Controller如何千变万化，它们都实现了统一的Controller接口，这使DispatchAction调它时候根据不需要知道Controller的细节，嗯，the power of interface。

Controller里的数据绑定也是一个值得研究的东西，挺好玩的，不过这次没空写啦。

4、interceptor

Interceptor的接口定义如下：

public interface HandlerInterceptor {

boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)

throws Exception;

void postHandle(

HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)

throws Exception;

void afterCompletion(

HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)

throws Exception;

}

具体的我就不展开分析啦，我们只要记住interceptor的三个hook point（在AOP里叫join point，哈哈）：Controller执行前，Controller执行后，页面显示完成后。

5、ViewResolver

ViewResolver是一个有趣的角色，它本身完成两个功能：一是完成了View与实际页面名称对应关系的配置，二是View的工厂（这可是标准的工厂模式啊，每个ViewResolver负责生产自己的View）。

以下是ViewResolver接口的定义：

public interface ViewResolver {

View resolveViewName(String viewName, Locale locale) throws Exception;

}

用过Spring MVC的人都配置过ViewResolver，因此这里不详细展开。

我将它对属性分成两类：一类是页面文件配置，包括prefix, suffix；另一类是作为view的工厂注入到View里的属性，如ContentType之类的。

以下是ViewResolver的类图：

6、View

View是真正负责显示页面的地方。它的接口如下：

public interface View {

void render(Map model, HttpServletRequest request, HttpServletResponse response) throws Exception;

}

其实这是一个简单任务，给我一个HashMap，再给个页面URI，把这个页面显示出来还不是小Case。不过不同的View显示到页面上的区别还是挺大的，如果是JSP，我只要把HashMap里的东西填到request里，再交给RequestDispatcher来forward一下就行了；如果是Velocity，那就把HashMap里的东西填到Veloticy的Context里，再把模板生成的东西merge到response的writer里就完事了。当然还有pdf或xls的View，我还没空研究它，哪天有兴趣了再看看吧，以下是View的类图：

写完这篇文章后，终于明白了什么叫做眼高手低。本来很希望写得抽象些，最后却发现我写的东西跟一般的流水帐式的源码分析其实区别不太大。呜呜，从具体到抽象很难，再把抽象的东西转化成具体更难，但只有经过这样的一层转换，我们的认识才能有很大的提高，我们的水平才能进步。

seal 2009-10-20 15:36 发表评论

在Spring中使用tiles2

seal — Mon, 19 Oct 2009 06:32:00 GMT

Spring Tiles Integration

In this example you will learn how to integrate Spring with Tiles 2. The directory structure of the example is shown below.

Add the following library files to the lib directory.

01.antlr-runtime-3.0

02.commons-logging-1.0.4

03.org.springframework.asm-3.0.0.M3

04.org.springframework.beans-3.0.0.M3

05.org.springframework.context-3.0.0.M3

06.org.springframework.context.support-3.0.0.M3

07.org.springframework.core-3.0.0.M3

08.org.springframework.expression-3.0.0.M3

09.org.springframework.web-3.0.0.M3

10.org.springframework.web.servlet-3.0.0.M3

11.

12.commons-beanutils-1.7.0

13.commons-digester-1.8

14.commons-logging-api-1.1

15.jstl

16.standard

17.tiles-api-2.0.4

18.tiles-core-2.0.4

19.tiles-jsp-2.0.4

You will see how to create a simple classic tile layout with a header, menu, body and footer regions.

In Spring to use Tiles, configure the following Tile definition in the Spring configuration file.

01.xml version="1.0" encoding="UTF-8"?>


02.<beans xmlns="http://www.springframework.org/schema/beans"
03.    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
04.    xmlns:p="http://www.springframework.org/schema/p"
05.    xmlns:context="http://www.springframework.org/schema/context"
06.    xsi:schemaLocation="
07.    http://www.springframework.org/schema/beans 
08.    http://www.springframework.org/schema/beans/spring-beans.xsd
09.    http://www.springframework.org/schema/context 
10.    http://www.springframework.org/schema/context/spring-context.xsd">
11.     
12.    <bean id="viewResolver" class="org.springframework.web.servlet.view. ResourceBundleViewResolver" p:basename="views" />
13.     
14.    <context:component-scan base-package="com.vaannila.web" />
15.     
16.    <bean id="tilesConfigurer" class="org.springframework.web.servlet.view.tiles2. TilesConfigurer" p:definitions="/WEB-INF/tiles-defs.xml" />    
17.         
18.beans>



Using the definitions attribute specify the location of the tiles definition file. Here the location is "/WEB-INF/tiles-defs.xml". The tiles definition file is shown below.



01.xml version="1.0" encoding="UTF-8" ?>

02. 
03.

04.       "-//Apache Software Foundation//DTD Tiles Configuration 2.0//EN"
05.       "http://tiles.apache.org/dtds/tiles-config_2_0.dtd">
06. 
07.<tiles-definitions>
08. 
09.  <definition name="baseLayout" template="/WEB-INF/tiles/baseLayout.jsp">
10.      <put-attribute name="title"  value="Template"/>
11.      <put-attribute name="header" value="/WEB-INF/tiles/header.jsp"/>
12.      <put-attribute name="menu"   value="/WEB-INF/tiles/menu.jsp"/>
13.      <put-attribute name="body"   value="/WEB-INF/tiles/body.jsp"/>
14.      <put-attribute name="footer"   value="/WEB-INF/tiles/footer.jsp"/>
15.  definition>

16.   
17.  <definition name="welcome" extends="baseLayout">
18.      <put-attribute name="title"  value="Welcome"/>
19.      <put-attribute name="body"   value="/WEB-INF/jsp/welcome.jsp"/>      
20.  definition>

21.   
22.  <definition name="friends" extends="baseLayout">
23.      <put-attribute name="title"  value="Friends"/>
24.      <put-attribute name="body"   value="/WEB-INF/jsp/friends.jsp"/>      
25.  definition>

26.   
27.  <definition name="office" extends="baseLayout">
28.      <put-attribute name="title"  value="Office"/>
29.      <put-attribute name="body"   value="/WEB-INF/jsp/office.jsp"/>      
30.  definition>

31.   
32.tiles-definitions>



Here we first define a base layout, later we extend the base layout
and create three more tile definitions by changing only the title and
the body regions.
To dispaly views we use the ResourceBundleViewResolver. By default the views.properties file will be used to store the key value pairs, we specify this using the basename attribute.


01.welcome.(class)=org.springframework.web.servlet.view.tiles2.TilesView
02.welcome.url=welcome
03. 
04.friends.(class)=org.springframework.web.servlet.view.tiles2.TilesView
05.friends.url=friends
06. 
07.office.(class)=org.springframework.web.servlet.view.tiles2.TilesView
08.office.url=office
09. 
10.about.(class)=org.springframework.web.servlet.view.JstlView
11.about.url=/WEB-INF/jsp/about.jsp


The welcome, friends and office refers to the tile definition names (the one to right side of the = sign). For tile views we use "org.springframework.web.servlet.view.tiles2. TilesView" class. You can also have other views together with the tile views. The about url is mapped to the about.jsp page with is a org.springframework.web.servlet.view.JstlView.
The baseLayout.jsp file contains the table structure to hold the different regions.
<%@ taglib uri="http://tiles.apache.org/tags-tiles" prefix="tiles" %>


"http://www.w3.org/TR/html4/loose.dtd">









<tiles:insertAttribute name="title" ignore="true" />





















































Here we use annotated controller handler mapping to handle the request. In the redirect.jsp page we forward the request to the welcome.htm url.

<% response.sendRedirect("welcome.htm"); %>




The welcome.htm url will be handled by the WelcomeController class, where we forward it to the welcome tile page.
package com.vaannila.web;



import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestMapping;



@Controller

public class WelcomeController {



@RequestMapping("/welcome.htm")

public String redirect()

{

return "welcome";

}

}






You can download and try the example here.


    
        
            
            
            Source  :Download
            
        
        
            
            
            War :Download
            
        
    





seal 2009-10-19 14:32 发表评论



Spring MVC中的两种验证方式（转）
seal — Mon, 20 Apr 2009 01:21:00 GMT
1. Commons Validator


    
        
            
            Important
        
        
            
            
            In version 0.4, the commons validator support was moved from the commons module to the validation module. As a
            consequence, all related classes in the commons module were deprecated and will be removed in version 0.5.
            
            
            Please note that due to this change, the packages were renamed. Apart from that, the functionality stayed more
            or less the same with the exception of some bug fixes and small improvements. Also note that all bug fixes and
            maintenance will be done on the validation module solely.
            
            
        
    



The Commons Validator is a library that allows you to perform
validation based on rules specified in XML configuration files.


TODO: Describe the concepts of Commons Validator in more details.





1.1. Configure an Validator Factory




Firstly you need to configure the Validator Factory which is the
factory to get Validator instances. To do so, the support provides the
class DefaultValidatorFactory in the package org.springmodules.validation.commons


You need to specify with the property validationConfigLocations the
file containing the Commons Validator rules and the file containing the
validation rules specific to the application.


The following code shows how to configure this factory.


class="org.springmodules.validation.commons.DefaultValidatorFactory">





/WEB-INF/validator-rules.xml

/WEB-INF/validation.xml











1.2. Use a dedicated validation-rules.xml




The file validation-rules.xml must contain
Commons Validator elements based on classes provided by the support of
this framework in Spring Modules.


For example, the configuration of the entities "required" and
"requiredif" must be now in the validation-rules.xml
file.


classname="org.springmodules.validation.commons.FieldChecks"

method="validateRequired"

methodParams="java.lang.Object,

org.apache.commons.validator.ValidatorAction,

org.apache.commons.validator.Field,

org.springframework.validation.Errors"

msg="errors.required">




(...)

]]>






classname="org.springmodules.validation.commons.FieldChecks"

method="validateRequiredIf"

methodParams="java.lang.Object,

org.apache.commons.validator.ValidatorAction,

org.apache.commons.validator.Field,

org.springframework.validation.Errors,

org.apache.commons.validator.Validator"

msg="errors.required">



The validation sample of the distribution provides a complete
validation-rules.xml based on the classes of the
support.


You must note that the support of validwhen is
not provided at the moment in the support. However, some codes are
provides in JIRA. For more informations, see the issues
MOD-38 and
MOD-49.






1.3. Configure a Commons Validator




Then you need to configure the Validator itself basing the previous
Validator Factory. It corresponds to an adapter in order to hide Commons
Validator behind a Spring Validator.


The following code shows how to configure this validator.











1.4. Server side validation




Spring MVC provides the implementation SimpleFormController
of the interface Controller in order to process HTML forms.
It allows a validation of informations processing by the controller by using the
property validator of the controller. In the case of
Commons Validator, this property must be set with the bean beanValidator
previously configured.


The following code shows how to configure a controller which validates a form on
the server side using the support of Commons Validator.



(...)







(...)



The beanValidator bean uses the value of the property
commandClass of the controller to select the name of
the form tag in the validation.xml file. The configuration
is not based on the commandName property. For example, with
the class name org.springmodules.sample.MyForm,
Commons Validator must contain a form tag with myForm
as value of the name property. The following code shows the contents of this file.




"-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.1//EN"

"http://jakarta.apache.org/commons/dtds/validator_1_1.dtd">































1.5. Partial Bean Validation Support




Partial validation support enables partial validation of beans where not all properties are validated
but only selected ones.


Commons validator enables partial validation by specifying the page attribute
for each field in the form configuration:

































test

(*this* == password)







The org.springmodules.validation.commons.ConfigurablePageBeanValidator and
org.springmodules.validation.commons.DefaultPageBeanValidator classes support
partial validation by setting their page property. The value of this property will
be matched with the page attribute in the form configuration, and only the fields with the appropriate
page configured will be validated.


The following is an example of a partial validation support usage within a wizard controller:







personPage0

personPage1





















































...





The controller will look like this:

public class PersonWizardController extends AbstractWizardFormController {



...



protected void validatePage(Object command, Errors errors, int page) {

Validator[] validators = getValidators();

for (int i=0; i
Validator validator = validators[i];

if (validator instanceof PageAware) {

if (((PageAware)validator).getPage() == page) {

validator.validate(command, errors);

}

}

}

}

}





1.6. Client side validation




The support of Commons Validator in Spring Modules provides too the
possibility to use a client side validation. It provides a dedicated
taglib to generate the validation javascript code. To use this taglib, we
firstly need to declare it at the beginnig of JSP files as following.

<%@ tglib uri="http://www.springmodules.org/tags/commons-validator" prefix="validator" %>

You need then to include the generated javascript code in the JSP file as
following by using the javascript tag.


staticJavascript="false" xhtml="true" cdata="false"/>

At last, you need to set the onSubmit attribute
on the form tag in order to trigger the validation on
the submission of the form.







2. Valang




Valang (Va-lidation Lang-uage), provides a simple and
intuitive way for creating spring validators. It was initially create with three goals in mind:



    
    
    Enables writing validation rules quickly, without the need of writing classes or even any java code.
    
    
    
    
    Ease the use of Spring validation tools.
    
    
    
    
    Make validation rules compact, readable and easily maintainable.
    
    



Valang is built upon two major constructs - The valang expression
language and valang validators. The former is a generic boolean
expression language that enables expressing boolean rule in a "natural
language"-like fashion. The later is a concrete implementation of the
Spring Validator interface that is built around the expression
language.


Before going into details, lets first have a look at a small example, just to have
an idea of what valang is and how it can be used. For this example, we'll assume a Person class
with two properties - firstName and lastName. In addition, there are two main validation rules that
need to be applied:



    
    
    The first name of the person must be shorter than 30 characters.
    
    
    
    
    The last name of the person must be shorter than 50 characters.
    
    



One way of applying these validation rules (and currently the most common one) is to implement the Validator
interface specifically for the Person class:

public class PersonValidator implements Validator {



public boolean supports(Class aClass) {

return Person.class.equals(aClass);

}



public void validate(Object person, Errors errors) {

String firstName = ((Person)person).getFirstNam();

String lastName = ((Person)person).getLastName();

if (firstName == null || firstName.length() >= 30) {

errors.reject("first_name_length", new Object[] { new Integer(30) },

"First name must be shorter than 30");

}

if (lastName == null || lastName.length() >= 50) {

errors.reject("last_name_length", new Object[] { new Integer(50) },

"Last name must be shorter than 50");

}

}

}

While this is a perfectly valid approach, it has its downsides. First,
it is quite verbose and time consuming - quite a lot of code to write
just for two very simple validation rules. Second, it required an
additional class which clutters the code (in case it is an inner-class)
or the design - just imagine having a validator class for each of the
domain model objects in the application. 

The following code snippet shows how to create a valang validator to apply the same rules as above:








{ firstName : length(?) < 30 : 'First name too long' : 'first_name_length' : 30}

{ lastName : length(?) < 50 : 'Last name too long' : 'last_name_length' : 50 }

]]>







There are a few things to notice here. First, no new class is created -
with valang, one can reuse a predefined validator class (as shown
here). Second, This validator is not part of the java code, but put in
the application context instead - In the above case, the ValangValidator
is instantiated and can be injected to other objects in the system.
Last but not least, The validation rules are defined using the valang
expression language which is very simple and quick to define. 

The following two sections will elaborate on the expression language and the use of the Valang validator in greater details.





2.1. Valang Syntax




The valang syntax is based on the valang expression language and the
valang validation rule configuration. As mentioned above, the former is
a boolean expression language by which the validation rules predicates
(conditions) are expressed. The later binds the rule predicates to a
key (usually a bean property), error message, and optionally error code
and arguments. 




2.1.1. Rule Configuration




Here is the basic structure of the valang rule configuration:

{  :  :  [:  [:  ]] }


    
     - The key to which the validation error will be bound to. (mandatory)
    
    
     - A valang expression that defines the predicate (condition) of the validation rule. (mandatory)
    
    
    
     - The error message of the validation rule. The message
    is mandatory but can be an empty string if not used. This message is
    also used as the default message in case the error code could not be
    resolved. (mandatory)
    
    
    
     - An error code that represents the validation error. Used to support i18n. (optional)
    
    
    
     - A comma separated list of arguments to associate with
    the error code. When error codes are resolved, this arguments may be
    used in the resolved message. (optional)
    
    







2.1.2. Expression Language




As mentioned, the valang expression language is used to define the
predicate to be associated with the validation rule. The expression is
always evaluated against a context bean. The expression can be defined
as follows: 
 ::=  ( ( "AND" | "OR" )  )+ | 

The  in an evaluation that is composed of operators,
literals, bean properties, functions, and mathematical expressions. 




Operators




The following are the supported operators:



    
    Binary Operators:
    
    
        
        String, boolean, date and number operators:
        
        
            
            = | == | IS | EQUALS
            
            
            != | <> | >< | IS NOT | NOT EQUALS
            
        
        
        
        
        Number and date operators:
        
        
            
            > | GREATER THAN | IS GREATER THAN
            
            
            < | LESS THAN | IS LESS THAN
            
            
            >= | => | GREATER THAN OR EQUALS | IS GREATER THAN OR EQUALS
            
            
            <= | =< | LESS THAN OR EQUALS | IS LESS THAN OR EQUALS
            
        
        
        
    
    
    
    
    Unary Operators:
    
    
        
        Object operators:
        
        
            
            NULL | IS NULL
            
            
            NOT NULL | IS NOT NULL
            
        
        
        
        
        String operators:
        
        
            
            HAS TEXT
            
            
            HAS NO TEXT
            
            
            HAS LENGTH
            
            
            HAS NO LENGTH
            
            
            IS BLANK
            
            
            IS NOT BLANK
            
            
            IS UPPERCASE | IS UPPER CASE | IS UPPER
            
            
            IS NOT UPPERCASE | IS NOT UPPER CASE | IS NOT UPPER
            
            
            IS LOWERCASE | IS LOWER CASE | IS LOWER
            
            
            IS NOT LOWERCASE | IS NOT LOWER CASE | IS NOT LOWER
            
            
            IS WORD
            
            
            IS NOT WORD
            
        
        
        
    
    
    
    
    Special Operators:
    
    
        
        BETWEEN
        
        
        NOT BETWEEN
        
        
        IN
        
        
        NOT IN
        
        
        NOT
        
    
    
    



These operators are case insensitive. Binary operators have a left and a right side.
Unary operators only have a left side.


Value types on both sides of the binary operators must always match. The following expressions will
throw an exception:

name > 0

age == 'some string'





BETWEEN / NOT BETWEEN Operators




The BETWEEN and NOT BETWEEN operators have the following special syntax:

 ::=  BETWEEN  AND 

 ::=  NOT BETWEEN  AND 

Both the left side and the values can be any valid combination of literals, bean properties,
functions and mathematical operations.

Examples:
width between 10 and 90

length(name) between minLength and maxLength





IN / NOT IN Operators




The IN and NOT IN operators have the following special syntax:

 ::=  IN  ( ","  )*

 ::=  NOT IN  ( ","  )*

Both the left side and the values can be any valid combination of literals, bean properties,
functions and mathematical operations.


There's another special syntax where a java.util.Collection, java.util.Enumeration,
java.util.Iterator
or object array instance can be retrieved from a bean property. These
values are then used as right side of the operator. This feature
enables to create dynamic sets of values based on other properties of
the bean. 
 ::=  IN "@"

 ::=  NOT IN "@"
Examples:
size in 'S', 'M', 'L', 'XL'

size in @sizes





NOT Operator




The not operator has the following special syntax:

 ::= "NOT" 

This operator inverses the result of one or a set of predicates.






Literals




Four type of literals are supported by valang: string,
number, date, and boolean.


Strings are quoted with single quotes:

'Bill', 'George', 'Junior'

Number literals are unquoted and are parsed by java.math.BigDecimal:

0.70, 1, 2000, -3.14

Date literals are delimited with square brackets and are parsed upon each evaluation by a special date parser.
[TODO: write documentation for date parser]

[T

Boolean literals are not quoted and have the following form:

 ::= ( "TRUE" | "YES" | "FALSE" | "NO" )





Bean Properties




As mentioned above, the valang always evaluates the expressions against a context bean. Once can
access this bean's properties directly within the expression. To better understand how this works
lets assume a Person class with the following properties:



    
    name (String)
    
    
    address (Address)
    
    
    specialFriends (Map)
    
    
    friends (Person[])
    
    
    enemies (List)
    



The Address class has the following properties:



    
    street (String)
    
    
    city (String)
    
    
    Country (String)
    



The context bean properties can be accessed directly by using their names:

name, address, attributes

Accessing nested properties is also supported by using a dot-separated expression. For example,
accessing the street of the person can be done as follows:

address.street

List and/or array elements can be access by their index number as follows:

friends[1].name

enemies[0].address.city

Map entries can also be accessed by their keys:

specialFriends[bestFriend].name





Functions




Valang expressions can contain functions. A function is basically an
operation which accepts arguments and returns a result. Functions can
accept one or more arguments where each may be either a literal, bean
property, or a function as described in the following definition: 
function ::=  "("  [ ","  ]* ")"

 ::=  |  | 

Valang ships with the following predefined functions:


Table 11.1. Functions

    
    
        
            Name Description
        
    
    
        
            length
            
            Returns the size of the passed in collection or array. If the passed in argument
            is neither, the length of the string returned from the toString() call on
            the passed in argument.
            
        
        
            len
            See length above
        
        
            size
            See length above
        
        
            count
            See length above
        
        
            match
            
            Matches the given regular expression (first argument) to the
            string returned from the toString() call on the passed
            in value (second argument).
            
        
        
            matches
            See match above.
        
        
            email
            
            Returns true if the string returned from the
            toString() call on the passed in argument represents
            a valid email
            
        
        
            upper
            
            Converts the string returned from the toString() call on the argument
            to upper case.
            
        
        
            lower
            
            Converts the string returned from the toString() call on the argument
            to lower case.
            
        
        
            !
            Not operation on a boolean value.
        
        
            resolve
            Wrap string in org.springframework.context.support.DefaultMessageSourceResolvable.
        
        
            inRole
            
            Accepts a role name as an argument and returns true if the current user has this role.
            This function uses Acegi to fetch the current user.
            
        
    



Examples:

length(?)

size(upper('test'))

upper(address.city)

One of the more powerful features in Valang expression language is that it is extensible with custom
functions. To add a custom function one first needs to implement the
org.springmodules.validation.valang.functions.Function interface or extend the
org.springmodules.validation.valang.functions.AbstractFunction. Then, when using
the ValangValidatorFactoryBean or ValangValidator,
register the new function with the customFunctions property using the
function name as the key.
[TODO: show an example of a custom function]






Mathematical Expressions




The following mathematical operators are supported:



    
    +
    
    
    -
    
    
    *
    
    
    / | div
    
    
    % | mod
    



Parentheses are supported and expression are parsed left to right so that

2 - 3 + 5 = 4

Values in the mathematical expression can be literals, bean properties, and functions.


Examples:

(2 * (15 - 3) + ( 20 / 5 ) ) * -1

(22 / 7) - (22 div 7)

10 % 3

length(?) mod 4







2.2. Valang Validator Support




As we saw in the previous chapter, Valang offers quite a reach and powerful expression language to
represent the validation rules. Language that for most cases relieves the user from creating custom
Validator classes.


The only missing piece of the puzzle now is to see how this expression language and the validation rule
configuration integrate with Spring validation support.


The 2 most important constructs of Spring validation are the
org.springframework.validation.Validator and org.springframework.validation.Errors
classes. The Errors class serves as a registry for validation errors that are associated with
an object (a.k.a the target object). The Validator interface provides a mechanism to validate objects
and register the various validation error within the passed in Errors.


Valang ships with some support classes that leverage the power of the Valang expression language and validation
rule configuration, and integrates nicely with Spring validation. The most important of them all is the
org.springmodules.validation.valang.ValangValidator class.





2.2.1. ValangValidator




The org.springmodules.validation.valang.ValangValidator class is a concrete
implementation of Spring's Validator interface. The most important property of
this validator is the valang property.


The valang property is of type java.lang.String and holds a
textual representation of the validation rules that are applied by the validator. We saw in the previous
section that a single validation rule is represented in valang using the following format:

{  :  :  [:  [:  ]] }

Since, a validator may apply more then just one rule, the valang property accepts
a set of such rule definitions.


Example:

{ firstName : length(?) < 30 : 'First name too long' : 'first_name_length' : 30}

{ lastName : length(?) < 50 : 'Last name too long' : 'last_name_length' : 50 }

There are two ways to use the valang validator. It can be explicitly instantiated and initialized with
the rule definitions by calling the setValang(String) method on it. But the recommended
way is actually to let the Spring IoC container do this job for you. The valang validator was design
as a POJO specifically for that reason - to easily define it within Spring application context and inject
it to all other dependent objects in the application.


Here is an example of how to define a simple valang validator within the application context:








{ firstName : length(?) < 30 : 'First name too long' : 'first_name_length' : 30}

{ lastName : length(?) < 50 : 'Last name too long' : 'last_name_length' : 50 }

]]>







This validator defines two validation rules - one for the maximum size of the first name of the person and
the other for the maximum size of the last name of the person.


Also notice that the above validator is unaware of the object type it validates. The valag validator is
not restricted to a specific class to be validated. It will always apply the defined validation rules as
long as the validated object has the validated properties (firstName and lastName in this case).


This configuration should be enough for most cases. But there are some
cases in which you need to apply extra configuration. With ValangValidator it is possible to register custom
function (thus, extend the valang expression language). This can be done by registering the functions within
the customFunctions property, where the function name serves as the registration key.


Here is an example of a valang validator configuration with a custom function:









org.springmodules.validation.valang.functions.DoItFunction












{ firstName : doIt(?) and length(?) < 30 : 'First name too long' : 'first_name_length' : 30}

{ lastName : length(?) < 50 : 'Last name too long' : 'last_name_length' : 50 }

]]>







It is also possible to register extra property editors and custom date parsers for valang to use. For
more details about valang validator configuration options, please refer to the class javadoc.



NOTE: Until version 0.3 the org.springmodules.validation.valang.ValangValidatorFactoryBean
class served the same purpose as the ValangValidator. In version 0.4, this class was deprecated
and is planned to be removed in version 0.5.







seal 2009-04-20 09:21 发表评论


Valang Validator 攻略(转)
seal — Mon, 20 Apr 2009 01:13:00 GMT

    
        
            
            
            
                
                    
                        文档选项
                    
                
            
            
                
                    
                        
                    
                        
                        
                            
                                
                                
                                
                                打印本页
                                
                            
                            
                            
                            
                                
                                
                                
                                将此页作为电子邮件发送
                                
                            
                        
                    
                    
                
            
        
        

        
    


级别： 初级
胡 键 (jianhgreat@hotmail.com), 西安交通大学硕士


2007 年  4 月  12 日
Valang
是 Validation Language 的缩写，Valang Validator
的字面含义就是“使用验证语言的验证器”，是一种支持声明的验证器。本文详细的介绍了 ValangValidator
的使用和相关所需的配置。作为一种新型的验证工具，它提供的验证语言（valang）具有简单、易学，易扩展等特点。
Valang 是 Validation Language 的缩写，Valang Validator 的字面含义就是“使用验证语言的验证器”，它是一种支持声明的验证器。作为新出的验证工具，它拥有不同于现有其它相似工具的特点：

    基于声明的验证工具包，大多数情况下可以避免手工书写代码。
    提供了一套精巧的 DSL（Domain Specific language），支持表达式语言。语法非常简洁，且支持扩展方便。
    配置精简，可读性高、易维护。
    包含在 Spring Module 中，简化了 Spring Framework 的 Validator 使用。
    支持 JavaScript，对于 Web 应用，支持客户端的验证。

本文将带领读者对以上特点一一寻访，在进一步阅读本文之前，请确保读者具有 Spring Framework 的使用经验，如果有 Spring MVC 的经验更佳。
使用概览
Valang
Validator 属于 Spring Module 的 Validation 模块。Spring Module 是一组扩展 Spring
Framework 功能的工具集，当前的版本是 0.6。它作为独立于 Spring Framework 的项目而存在，其目的非常单纯：方便
Spring Framework 与其它框架的集成，避免为此修改 Spring Framework 的核心。
使用 Valang Validator 必须先了解它的两个重要组件：

    valang，即验证语法，使用者使用它将约束定义转化为 ValangValidator 能解析的验证规则。
    ValangValidator，它是 Spring Validator 接口的具体实现。负责验证规则解析，完成实际的验证工作。

了解了这些关于 Valang Validator 的信息之后，不妨从一个例子来了解它的使用。本例使用的环境：JDK 1.5、Spring Framework2.0 和 Spring Module 0.6。
问题描述
为
了尽可能的体现 Valang Validator 的特点，例子中需要验证的对象有意地被设计得稍微有些复杂：首先，属性是最常见的 3
种类型，而且其中还有一个是在 Java 中有些烦人的Date；其次，它还包含了一个成员类属性。关于类结构和相关的约束如下表：

    
        
            类结构 约束
        
        
            public class User {
            private String name;
            private int age;
            private Date birthday;
            private Address address;
            ……
            }
            public class Address {
            private String state;
            private String town;
            private String street;
            ……
            }
            name，必填，且长度不超过 50。

            	age，非必填，必须大于等于 0，小于等于 60。

            	birthday，非必填，必须在 2000-01-01 之后。

            	address.state，必填，长度不超过 50。

            	address.town，必填，长度不超过 50。

            	address.street，必填，长度不超过 200。
        
    


实现 Validator
实
现 Valang Validator 就是要完成两部分工作：定义 valang 描述和 Validator 创建。Validator
的创建可以使用 Java 代码进行，也可使用 Spring DI 完成。本例采用后一种方法，Bean 定义如下（文件名：valang.xml）：

    
        
            
            

            

            

            
            { name  : ? is not null and ? has text and length(?)<= 50 

            : 'Name is empty or too long.'}

            { age : ? between 0 and 60 : 'Age should between 0 and 60.'}

            |-------10--------20--------30--------40--------50--------60--------70--------80--------9|

            |-------- XML error:  The previous line is longer than the max of 90 characters ---------|

            { birthday : ? is null or ? >[20000101]

            : 'Birthday should be after 2000-01-01.'}

            { address : ? is not null : 'Address is empty.'}

            { address.state : address is null or ( ? is not null and

            ? has text and length(?)<=50 )

            : 'state is empty or too long.'}

            { address.town : address is null or ( ? is not null and  

            ? has text and length(?)<=50 )

            : 'town is empty or too long.'}

            { address.street : address is null or ( ? is not null and

            ? has text and length(?)<=50 )

            : 'street is empty or too long.'}	

            ]]>

            

            

            

            

            

            

            

            

            
            
        
    



瞧，没有一行 Java 代码，居然完成了一个 Validator 的定义。这其中的秘密就是 valang 属性，它定义了验证规则。再看看它的语法，是不是很酷？！另一个属性 dateParsers 定义了日期转换的格式。关于它们的解释在后面有详细的介绍。
技巧：
如
果 Adress 对象被多个对象引用，且对于 Address 的验证约束相同，那么以上的 address
相关的约束规则就需要重复书写。这样，既繁且不利于维护。此时，可以将 address 相关的约束组织成一个
validator，实现约束的复用。具体步骤：
a)	抽取 Address 的约束到 addressValidator。

    
        
            
            

            

            

            
            { state : ? is not null and  ? has text and length(?)<=50

            : 'state is empty or too long.'}

            { town : ? is not null and  ? has text and length(?)<=50

            : 'town is empty or too long.'}

            { street : ? is not null and  ? has text and length(?)<=50

            : 'street is empty or too long.'}

            ]]>			

            

            

            

            
            
        
    



b)	实现继承 ValangValidator 的 UserValidator，包含 addressValidator：

    
        
            
            public class UserValidator extends ValangValidator {

            private Validator addressValidator;

            

            public void setAddressValidator(Validator addressValidator) {

            this.addressValidator = addressValidator;

            }

            

            public void validate(Object target, Errors errors){

            super.validate( target, errors);

            Address address= ((User)target).getAddress();

            // address 为 null 时，不进行进一步的验证。

            if( null!= address){

            //注意与 popNestedPath 成对使用

            errors.pushNestedPath("address");

            //验证 address

            addressValidator.validate( address, errors);

            errors.popNestedPath();

            }

            }

            }

            
            
        
    



c)	修改 userValidator 的配置。

    
        
            
            

            

            

            

            
            { name : ? is not null and ? has text and length(?)<= 50

            : 'Name is empty or too long.'}

            { age : ? between 0 and 60 : 'Age should between 0 and 60.'}

            { birthday : ? is null or ? >[20000101] : 'Birthday should be after 2000-01-01.'}

            |-------10--------20--------30--------40--------50--------60--------70--------80--------9|

            |-------- XML error:  The previous line is longer than the max of 90 characters ---------|

            { address : ? is not null : 'Address is empty.'}

            ]]>			

            

            

            

            

            

            

            

            

            
            
        
    



单元测试
对
ValangValidator 进行单元测试非常简单，需要注意的是它的实例化。这里使用 BeanFactory 来创建待测的
Validator。Spring 提供了测试用例基类
AbstractDependencyInjectionSpringContextTests，使得手工创建完全避免：

    
        
            
            public class UserValidatorTest extends AbstractDependencyInjectionSpringContextTests {

            private Validator userValidator;

            

            public UserValidatorTest(){

            super();

            //缺省是AUTOWIRE_BY_TYPE，当Bean文件有2个以上的同类型

            //Bean定义时就应该采用AUTOWIRE_BY_NAME方式。

            setAutowireMode(AUTOWIRE_BY_NAME);

            }

            

            protected String[] getConfigLocations() {

            //指明配置文件的位置

            return new String[]{"file:文件路径/valang.xml"};

            }

            //基类调用该方法完成依赖注入（DI）

            public void setUserValidator(Validator userValidator) {

            this.userValidator = userValidator;

            }

            

            public void testEmptyObject(){

            User user= new User();

            BindException errors= new BindException(user, "target");

            userValidator.validate( user, errors);

            assertTrue( errors.getAllErrors().size()== 2);

            ObjectError error1= (ObjectError)(errors.getAllErrors().get(0));

            assertEquals(error1.getDefaultMessage(), "Name is empty or too long.");

            ObjectError error2= (ObjectError)(errors.getAllErrors().get(1));

            assertEquals(error2.getDefaultMessage(), "Address is empty.");

            }

            ……

            }

            
            
        
    



使用 Validator
上面的单元测试已经展示了 ValangValidator 的使用，除此之外，也可使用 BeanFactory 将它注入某个控制器中使用：

    
        
            
            

            ……

            

            

            
            
        
    



从上面的例子来看，ValangValidator
的使用相当简单。尤其对于有过 Spring 经验的用户来说，除了需要掌握 valang 语法之外，其余的根本就和 Spring
Validator 使用一样。而且，例子中 valang 的语法所展示的简洁、直观给人留下了深刻的印象。



    
        
            

            
        
    


    
        
            

            
                
                    
                        

                        
                        回页首
                    
                
            
            
        
    





Valang 语法
很
酷！这是我看到 valang 的第一印象。Spring
数据绑定语法相同的属性表达式，灵活、便捷、易学的语法。这些，都使得另一个被广泛使用的声明性验证工具 Commons Validator
显得相形见绌。虽然作为早期的声明性验证工具的实现，Commons Validator 的功绩不可磨灭，但是其配置的繁琐也使人厌烦不已。
“以数据为中心”是 ValangValidator 的设计思路，此处的数据就是 valang 描述。valang 由一系列的规则组成，对于每个规则，它的结构如下：

    
        
            
            {  :  :  [:  [:  ]] }
            
        
    



其中：

    ，属性表达式。它是要验证的属性名，必填。
    ，谓词表达式。期望满足的条件，必填。
    ，缺省消息。当不满足预期表达式时显示的消息，必填。
    ，错误码。国际化时使用的消息键值，当它存在时缺省消息被忽略，可选。
    ，参数。逗号分隔的参数值，用于替换错误码中定义的站位符，可选。

这些参数，除了谓词表达式之外，都可以在 Spring 中见到它们的踪影。而它们的含义、用法也丝毫没有发生变化。因此，让我们把关注的焦点集中在谓词表达式上。
表达式语法
valang 将谓词表达式定义成如下结构：

    
        
            
             ::=  ( ( "AND" | "OR" )  )+ | 
            
        
    



其中的谓词（），是由操作符、文字常量、bean 属性、数学表达式和函数组成的可计算实体。

1.操作符

valang 的操作符有三种：一元操作符，二元操作符和其他操作符。支持的操作符如下表：

    
        
            类型
            支持类型
            操作符
            说明
        
        
            一元
            对象
            NULL | IS NULL
            为空
        
        
            NOT NULL | IS NOT NULL
            非空
        
        
            字符串
            HAS TEXT
            包含非空格的字符
        
        
            HAS NO TEXT
            null或只有空格字符
        
        
            HAS LENGTH | IS NOT BLANK
            长度>0
        
        
            HAS NO LENGTH | IS BLANK
            null或长度=0
        
        
            IS UPPERCASE | IS UPPER CASE |
            

            IS UPPER
            所有字母大写
        
        
            IS NOT UPPERCASE |
            

            IS NOT UPPER CASE |
            

            IS NOT UPPER
            不是所有字母大写
        
        
            IS LOWERCASE | IS LOWER CASE | IS LOWER
            所有字母小写
        
        
            IS NOT LOWERCASE |
            

            IS NOT LOWER CASE |
            

            IS NOT LOWER
            不是所有字母小写
        
        
            IS WORD
        
        
            IS NOT WORD
        
        
            二元
            字符串、日期、布尔和数字
            = | == | IS | EQUALS
            相等
        
        
            != | <> | >< | IS NOT | NOT EQUALS
            不等
        
        
            数字、日期
            >|GREATER THAN |

            IS GREATER THAN
            大于
        
        
            < | LESS THAN | IS LESS THAN
            小于
        
        
            >= | => |
            

            GREATER THAN OR EQUALS |
            

            IS GREATER THAN OR EQUALS
            大于等于
        
        
            <= | =< | LESS THAN OR EQUALS | IS LESS THAN OR
            EQUALS
            小于等于
        
        
            其他
            数字、日期
            BETWEEN A AND B
            大于等于A，且小于等于B
        
        
            NOT BETWEEN A AND B
            小于A，或大于B
        
        
            字符串、日期、布尔和数字
            IN  (, )*
            在值列表中
        
        
            NOT IN  (, )*
            不在值列表中
        
        
            布尔表达式
            NOT
            取反
        
    

这些操作符是大小写非敏感的，另外在使用时需要注意：

    避免在验证时出现 NullException，这一点可以在 userValidator 的例子中看到。
    二元操作符两边的操作数类型必须一致。



2.文字常数

Valang 支持 4 种文字常数：字符串、数字、日期和布尔。这四种类型的文字常数如下表：

    
        
            
            类型
            
            说明
            
        
        
            字符串
            字符串使用单引号包含，如 ’foxgem’。
        
        
            数字
            数字被转换为 java.math.BigDecimal。
        
        
            布尔
            布尔值必须是：TRUE、YES、FALSE、NO 中的一个，且不要使用单引号。
        
        
            日期
            日期值使用 [] 包含，如 [2000-01-01]。
        
    

valang 对于日期类型的处理非常特殊，而且有趣：

    使用 T 来代表当前时间， 如 [T]。
    
    提供了移位操作，语法是：日期 > 时间单位，日期 < 时间单位。前者表示将日期中对应的单位部分向后滚动到该时间单位的最大值；后者表示将日期中对应的单位部分向前滚动到该时间单位的最小值。支持的时间单位和对应范围：
    
    1)	秒（s）：0~999 毫秒

    2)	分钟（m）：0秒0毫秒 ~ 59秒999毫秒

    3)	小时（H）：0分0秒0毫秒 ~ 59分59秒999毫秒

    4)	天（d）：0时0分0秒0毫秒 ~ 23时59分59秒999毫秒

    5)	星期（w）：周一0时0分0秒0毫秒 ~ 周日23时59分59秒999毫秒

    6)	月（M）：月第一天0时0分0秒0毫秒 ~ 月最后一天23时59分59秒999毫秒

    7)	年（y）：年第一天0时0分0秒0毫秒 ~ 年最后一天23时59分59秒999毫秒

    
    如：[T>d]，表示当天的 23 时 59 分 59 秒 999 毫秒。
    
    
    支持日期的增减运算。增减分别对应：“+”和“-”；数量对应：i 时间单位，i 表示整数。如：[T>d-1d+2H]，表示先将当前时间后滚至当天的最后时刻，再减去一天，再加上 2 个小时。
    日期格式在 valang 中也有很好的支持，可以很方便的定义自己的格式。日期解析过程如下：
    
    1)	取出日期字符串，在 dateParsers 中定义 Map 的正则表达式键集合中进行匹配。

    2)	当找到符合的正则表达式时，以它为键值获取对应的日期格式串。

    3)	使用 SimpleDateFomat，将日期字符串按照日期格式串转化为对应的 Date 类型。

    
    
    因此，如果要在 valang 中使用 yyyy-MM-dd 的格式时，那么使用以下的定义：
    
        
            
                
                

                
                
            
        
    
    

    


3. bean 属性

bean 属性的用法和属性表达式的用法一样，在运行时它的值会被取出。另外，valang 使用“?”来表示在规则中定义的属性表达式的值。

4. 数学表达式

valang 支持的数学运算符有：+、-、*、/（或 div）、%（或 mod）。

5.函数

valang 内置的函数如下：

    
        
            函数
            说明
        
        
            length | len | size |count
            如果传入参数是集合或数组，那么返回它们的大小；否则，返回传入参数的 toString 所返回字符串的长度。

            使用例子：length(?)<50
        
        
            match | matches
            传入参数（参数 2）的 toString 返回的字符串是否匹配给定的正则表达式（参数1）。

            使用例子：match('^""d{2}$', ?) is true
        
        
            email
            传入参数的 toString 返回的字符串是有效的 email。

            使用例子：email(?) is true
        
        
            upper
            将传入参数的 toString 返回的字符串转换为大写。

            使用例子：upper(?)=='VALANG'
        
        
            lower
            将传入参数的 toString 返回的字符串转换为小写。

            使用例子：lower(?)=='valang'
        
        
            !
            布尔值取反

            使用例子：!(?) is true。

            

            注意：它不能内嵌表达式，如“!(length(?)<= 50) is true”将会出错。
            
        
        
            resolve
            解析消息码。
        
        
            inRole
            传入参数是角色名，如果当前用户有这个角色，则返回 true。
        
    

valang 对于函数的支持并不是只仅仅提供几个简单的函数，它还允许用户自定义函数。这大大的扩展了它的表现力。



    
        
            

            
        
    


    
        
            

            
                
                    
                        

                        
                        回页首
                    
                
            
            
        
    





自定义函数
org.springmodules.validation.valang.functions.AbstractFunction
是 valang 函数的基类，所有的内置函数都是它的子类，自定义函数也必须从它继承。AbstractFunction 有几个重要的方法需要注意：

    构造函数，子类必须实现，不要忘了先调用 super。
    definedExactNumberOfArguments、
    definedMaxNumberOfArguments、definedMinNumberOfArguments，分别是定义函数的参数个数，函数的
    最大参数个数、函数的最小参数个数。它们在构造函数中被调用。
    init，在所有属性被设置后调用，负责初始化。
    isAutowireByName 和 isAutowireByType，分别指定了函数的属性被 BeanFactory 自动装配采用的方法。
    doGetResult，返回函数的结果。

下面通过实现一个自定义版本的 length 函数来了解自定义函数的编写和配置：
函数定义：

    
        
            
            public class AnotherLengthFunction extends AbstractFunction {

            

            public AnotherLengthFunction(Function[] functions, int line, int column) {

            super(functions, line, column);

            //AnotherLengthFunction只支持一个参数

            definedExactNumberOfArguments(1);

            }

            

            protected Object doGetResult(Object target) throws Exception {

            //返回参数1的toString的值。如果有多个参数，那么：

            //参数2：getArguments()[1].getResult(target).toString();以此类推。

            //另外getArguments()的个数就是实际传入的参数个数。

            String value= getArguments()[0].getResult(target).toString();

            return new Integer(value.length());

            }

            

            }

            
            
        
    



函数配置：

    
        
            
            

            

            

            

            

            

            
            
        
    



当自定义的函数需要外部的资源，如数据库连接、网络连接、文件等，可以通过 BeanFactory 自动装配来完成。此时需要覆盖 isAutowireByName 或 isAutowireByType，指定自动装配的类型，这两个函数不能同时覆盖。



    
        
            

            
        
    


    
        
            

            
                
                    
                        

                        
                        回页首
                    
                
            
            
        
    





客户端验证
对于 Web 应用程序来说，服务器的验证固然是必须的，但如果提供了客户端验证的话，那无疑是锦上添花的事情。幸运的是，Valang Validator 已经做到了这一点。要使用这一功能，需要先了解 2 个组件：

1. org.springmodules.validation.valang.javascript.taglib.ValangRulesExportInterceptor

这个拦截器的作用是输出被当前请求处理器所使用的 valang 验证规则到 ModelAndView 中，使  可以利用这些信息。
在以下情况下之一时，该拦截器不做任何事情：

    当被拦截的请求处理器不是 BaseCommandController。
    请求处理器使用的 Validator 不是 ValangValidator 实例。
    请求处理器不输出一个 Command 对象到 model 中。


2. valang 标签库

valang 标签库完成客户端脚本的产生，并进行实际的客户端验证。它包含了 2 个标签：

    
        
            标签
            作用
            属性
            说明
        
        
            codebase
            产生被翻译的 javascript 验证规则执行所需要的代码。它应该每页包含一次，且在被产生的验证规则之前。
            includeScriptTags
            非必须，指示产生的 javascript 代码是否被

Name	Description
length	Returns the size of the passed in collection or array. If the passed in argument is neither, the length of the string returned from the toString() call on the passed in argument.
len	See length above
size	See length above
count	See length above
match	Matches the given regular expression (first argument) to the string returned from the toString() call on the passed in value (second argument).
matches	See match above.
email	Returns true if the string returned from the toString() call on the passed in argument represents a valid email
upper	Converts the string returned from the toString() call on the argument to upper case.
lower	Converts the string returned from the toString() call on the argument to lower case.
!	Not operation on a boolean value.
resolve	Wrap string in org.springframework.context.support.DefaultMessageSourceResolvable.
inRole	Accepts a role name as an argument and returns true if the current user has this role. This function uses Acegi to fetch the current user.

类型	支持类型	操作符	说明
一元	对象	NULL \| IS NULL	为空
	对象	NOT NULL \| IS NOT NULL	非空
	字符串	HAS TEXT	包含非空格的字符
		HAS NO TEXT	null或只有空格字符
		HAS LENGTH \| IS NOT BLANK	长度>0
		HAS NO LENGTH \| IS BLANK	null或长度=0
		IS UPPERCASE \| IS UPPER CASE \| IS UPPER	所有字母大写
		IS NOT UPPERCASE \| IS NOT UPPER CASE \| IS NOT UPPER	不是所有字母大写
		IS LOWERCASE \| IS LOWER CASE \| IS LOWER	所有字母小写
		IS NOT LOWERCASE \| IS NOT LOWER CASE \| IS NOT LOWER	不是所有字母小写
		IS WORD
		IS NOT WORD
二元	字符串、日期、布尔和数字	= \| == \| IS \| EQUALS	相等
	字符串、日期、布尔和数字	!= \| <> \| >< \| IS NOT \| NOT EQUALS	不等
	数字、日期	>\|GREATER THAN \| IS GREATER THAN	大于
		< \| LESS THAN \| IS LESS THAN	小于
		>= \| => \| GREATER THAN OR EQUALS \| IS GREATER THAN OR EQUALS	大于等于
		<= \| =< \| LESS THAN OR EQUALS \| IS LESS THAN OR EQUALS	小于等于
其他	数字、日期	BETWEEN A AND B	大于等于A，且小于等于B
	数字、日期	NOT BETWEEN A AND B	小于A，或大于B
	字符串、日期、布尔和数字	IN (, )*	在值列表中
	字符串、日期、布尔和数字	NOT IN (, )*	不在值列表中
	布尔表达式	NOT	取反

类型	说明
字符串	字符串使用单引号包含，如 ’foxgem’。
数字	数字被转换为 java.math.BigDecimal。
布尔	布尔值必须是：TRUE、YES、FALSE、NO 中的一个，且不要使用单引号。
日期	日期值使用 [] 包含，如 [2000-01-01]。

函数	说明
length \| len \| size \|count	如果传入参数是集合或数组，那么返回它们的大小；否则，返回传入参数的 toString 所返回字符串的长度。使用例子：length(?)<50
match \| matches	传入参数（参数 2）的 toString 返回的字符串是否匹配给定的正则表达式（参数1）。使用例子：match('^""d{2}$', ?) is true
email	传入参数的 toString 返回的字符串是有效的 email。使用例子：email(?) is true
upper	将传入参数的 toString 返回的字符串转换为大写。使用例子：upper(?)=='VALANG'
lower	将传入参数的 toString 返回的字符串转换为小写。使用例子：lower(?)=='valang'
!	布尔值取反使用例子：!(?) is true。注意：它不能内嵌表达式，如“!(length(?)<= 50) is true”将会出错。
resolve	解析消息码。
inRole	传入参数是角色名，如果当前用户有这个角色，则返回 true。

标签	作用	属性	说明
codebase	产生被翻译的 javascript 验证规则执行所需要的代码。它应该每页包含一次，且在被产生的验证规则之前。	includeScriptTags	非必须，指示产生的 javascript 代码是否被

BlogJava-Sealyu-随笔分类-Spring

getHibernateTemplate()和getSession()的区别（转）

Spring 的 HibernateDaoSupport 类的 getSession() 导致的连接泄露问题（转）

spring的DriverManagerDataSource与apache的BasicDataSource（转）

关于Spring整合发现的一些问题。 收藏

spring为ApplicationContext提供的3种实现

spring-基于注释（Annotation）的配置(转)

Debug Google Web Toolkit with Struts/Tiles

Integrate Google Web Toolkit with Struts/Tiles

Integrating it also with Spring/Hibernate

Integrating GWT with Spring Security

Spring Security 2 中动态角色实现的讨论（转）

SpringSide 3 中的安全框架

Spring Security 2 配置精讲(转)

关于Spring MVC I18N 的配置问题(转)

Simple web application with Spring Security

The solution

Add spring security taglibs as dependency

The implementation

Getting the code

Springing Around with ExtJS

OSGi原理与最佳实践（精选版）（转）

免费下载迷你书

迷你书目录

BlueDavy《OSGi原理与最佳实践》采访

OpenSessionInViewFilter 的两个异常:Illegal attempt to associate a collection with two open sessions; Write operations are not allowed in read-only mode (FlushMode.NEVER/MANUAL)

Spring MVC集成Tiles时候的属性值国际化(转)

Contact Us

Contact Us

Thank You

Thank You

Servlet and Spring Configuration

Finis

Spring 2.5.1 MVC + Tiles 2.0.5 基本配置（转）

Spring MVC framework深入分析（转）

Spring MVC framework深入分析之一--总体分析

Spring MVC framework深入分析之二--ApplicationContext之谜

Spring MVC framework深入分析之三--执行过程

在Spring中使用tiles2

Spring Tiles Integration

Spring MVC中的两种验证方式（转）

1. Commons Validator

1.1. Configure an Validator Factory

1.2. Use a dedicated validation-rules.xml

1.3. Configure a Commons Validator

1.4. Server side validation

1.5. Partial Bean Validation Support

1.6. Client side validation

2. Valang

2.1. Valang Syntax

2.1.1. Rule Configuration

2.1.2. Expression Language

Operators

BETWEEN / NOT BETWEEN Operators

IN / NOT IN Operators

NOT Operator

Literals

Bean Properties

Functions

Mathematical Expressions

2.2. Valang Validator Support

2.2.1. ValangValidator

Valang Validator 攻略(转)

关于Spring整合发现的一些问题。收藏