PROPAGATION_REQUIRED -- 支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 
PROPAGATION_SUPPORTS -- 支持当前事务，如果当前没有事务，就以非事务方式执行。 
PROPAGATION_MANDATORY -- 支持当前事务，如果当前没有事务，就抛出异常。 
PROPAGATION_REQUIRES_NEW -- 新建事务，如果当前存在事务，把当前事务挂起。 
PROPAGATION_NOT_SUPPORTED -- 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 
PROPAGATION_NEVER -- 以非事务方式执行，如果当前存在事务，则抛出异常。 
PROPAGATION_NESTED -- 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。 
前六个策略类似于EJB CMT，第七个（PROPAGATION_NESTED）是Spring所提供的一个特殊变量。 
它要求事务管理器或者使用JDBC 3.0 Savepoint API提供嵌套事务行为（如Spring的DataSourceTransactionManager） 

假如有两个业务接口 ServiceA 和 ServiceB, 其中 ServiceA 中有一个方法实现如下 
/** *//** 
* 事务属性配置为 PROPAGATION_REQUIRED 
*/ 
void methodA() { 
// 调用 ServiceB 的方法 
ServiceB.methodB(); 
} 
那么如果 ServiceB 的 methodB  如果配置了事务, 就必须配置为 PROPAGATION_NESTED 

这种想法可能害了不少人, 认为 Service 之间应该避免互相调用, 其实根本不用担心这点，PROPAGATION_REQUIRED 已经说得很明白,
如果当前线程中已经存在事务, 方法调用会加入此事务, 果当前没有事务，就新建一个事务, 所以 ServiceB#methodB() 的事务只要遵循最普通的规则配置为 PROPAGATION_REQUIRED 即可, 如果 ServiceB#methodB (我们称之为内部事务, 为下文打下基础) 抛了异常, 那么 ServiceA#methodA(我们称之为外部事务) 如果没有特殊配置此异常时事务提交 (即 +MyCheckedException的用法), 那么整个事务是一定要 rollback 的, 什么 Service 只能调 Dao 之类的言论纯属无稽之谈, spring 只负责配置了事务属性方法的拦截, 它怎么知道你这个方法是在 Service 还是 Dao 里 ?

最容易弄混淆的其实是 PROPAGATION_REQUIRES_NEW 和 PROPAGATION_NESTED, 那么这两种方式又有何区别呢? 我简单的翻译一下 Juergen Hoeller 的话 :
PROPAGATION_REQUIRES_NEW 启动一个新的, 不依赖于环境的 "内部" 事务. 这个事务将被完全 commited 或 rolled back 而不依赖于外部事务, 它拥有自己的隔离范围, 自己的锁, 等等. 当内部事务开始执行时, 外部事务将被挂起, 内务事务结束时, 外部事务将继续执行. 

    另一方面, PROPAGATION_NESTED 开始一个 "嵌套的" 事务,  它是已经存在事务的一个真正的子事务. 潜套事务开始执行时,  它将取得一个 savepoint. 如果这个嵌套事务失败, 我们将回滚到此 savepoint. 潜套事务是外部事务的一部分, 只有外部事务结束后它才会被提交.

    由此可见, PROPAGATION_REQUIRES_NEW 和 PROPAGATION_NESTED 的最大区别在于, PROPAGATION_REQUIRES_NEW 完全是一个新的事务, 而 PROPAGATION_NESTED 则是外部事务的子事务, 如果外部事务 commit, 潜套事务也会被 commit, 这个规则同样适用于 roll back.

 那么外部事务如何利用嵌套事务的 savepoint 特性呢, 我们用代码来说话

ServiceA {       
    /** *//**  
     * 事务属性配置为 PROPAGATION_REQUIRED  
     */  
    void methodA() {   
        ServiceB.methodB();    }   
 }     
ServiceB {      
    /** *//**  
     * 事务属性配置为 PROPAGATION_REQUIRES_NEW  
     */    
    void methodB() {   
    }         
}   

这种情况下, 因为 ServiceB#methodB 的事务属性为 PROPAGATION_REQUIRES_NEW, 所以两者不会发生任何关系, ServiceA#methodA 和 ServiceB#methodB 不会因为对方的执行情况而影响事务的结果, 因为它们根本就是两个事务, 在 ServiceB#methodB 执行时 ServiceA#methodA 的事务已经挂起了 (关于事务挂起的内容已经超出了本文的讨论范围, 有时间我会再写一些挂起的文章) .

ServiceA {      
    /** *//**  
     * 事务属性配置为 PROPAGATION_REQUIRED  
     */  
    void methodA() {   
        ServiceB.methodB();   
    }   
}     
ServiceB {         
    /** *//**  
     * 事务属性配置为 PROPAGATION_NESTED  
     */    
    void methodB() {   
    }         
} 

ServiceB#methodB 如果 rollback, 那么内部事务(即 ServiceB#methodB) 将回滚到它执行前的 SavePoint(注意, 这是本文中第一次提到它, 潜套事务中最核心的概念), 而外部事务(即 ServiceA#methodA) 可以有以下两种处理方式:
1. 改写 ServiceA 如下

ServiceA {      
    /** *//**  
     * 事务属性配置为 PROPAGATION_REQUIRED  
     */  
    void methodA() {   
        try {   
            ServiceB.methodB();   
        } catch (SomeException) {   
            // 执行其他业务, 如 ServiceC.methodC();   
        }   
    }    
}  

这种方式也是潜套事务最有价值的地方, 它起到了分支执行的效果, 如果 ServiceB.methodB 失败, 那么执行 ServiceC.methodC(), 而 ServiceB.methodB 已经回滚到它执行之前的 SavePoint, 所以不会产生脏数据(相当于此方法从未执行过), 这种特性可以用在某些特殊的业务中, 而 PROPAGATION_REQUIRED 和 PROPAGATION_REQUIRES_NEW 都没有办法做到这一点. (题外话 : 看到这种代码, 似乎似曾相识, 想起了 prototype.js 中的 Try 函数 )

2. 代码不做任何修改, 那么如果内部事务(即 ServiceB#methodB) rollback, 那么首先 ServiceB.methodB 回滚到它执行之前的 SavePoint(在任何情况下都会如此), 外部事务(即 ServiceA#methodA) 将根据具体的配置决定自己是 commit 还是 rollback (+MyCheckedException). 
上面大致讲述了潜套事务的使用场景, 下面我们来看如何在 spring 中使用 PROPAGATION_NESTED, 首先来看 AbstractPlatformTransactionManager

JdbcTransactionObjectSupport 告诉我们必须要满足两个条件才能 createSavepoint :
 
2. java.sql.Savepoint 必须存在, 即 jdk 版本要 1.4+
3. Connection.getMetaData().supportsSavepoints() 必须为 true, 即 jdbc drive 必须支持 JDBC 3.0

确保以上条件都满足后, 你就可以尝试使用 PROPAGATION_NESTED 了.

spring+hibernate的clob大字段处理（转载于javaeye论坛）

在spring中如何处理oracle大字段

在spring中采用OracleLobHandler来处理oracle大字段（包括clob和blob），则在程序中不需要引用oracle的特殊类，从而能够保证支持我们的代码支持多数据库。

1、首先数据表中的clob类型对应java持久化类的String类型；而blob类型对应byte[]类型
2、定义hibernate标签时，持久化类中对应clob类型的属性的hibernate type应为org.springframework.orm.hibernate.support.ClobStringType；而对应blob类型的属性的hibernate type应为org.springframework.orm.hibernate.support.BlobByteArrayType。
3、以后访问这些对应clob和blob类型的属性时，按普通属性处理，不需要特别编码。

java代码:  

 < bean  id ="mySessionFactory2"  class ="org.springframework.orm.hibernate.LocalSessionFactoryBean" >  
         < property  name ="dataSource" >  
                 < ref  bean ="myDataSource2" />  
          </ property >  
          < property  name ="lobHandler" >  
         < ref  bean ="oracleLobHandle" />  
          </ property >   
 </ bean >  
 < bean  id ="nativeJdbcExtractor"  class ="org.springframework.jdbc.support.nativejdbc.SimpleNativeJdbcExtractor" />  

 < bean  id ="oracleLobHandle"  class ="org.springframework.jdbc.support.lob.OracleLobHandler"  Lazy-init ="true" >  
 < property  name ="nativeJdbcExtractor" >  
     < ref  local ="nativejdbcExtractor" />  
 </ property >  
 </ bean > 

 JavaBean的对应的属性类型为String。

需要注意两点：(1)如果使用Oracle9i自带的class12.jar这个JDBC驱动的话是不行的，会报错，据说要升级到classes12-9i.jar，我在Oracle的网站上没找到对应的下载，下载了ojdbc14.jar就可以了。(2)对Clob或Blog的操作必须在一个事务中进行，如在Dao层测试会出错，在配置了事务的Logic层就没问题了。

经过测试,如果用Oracle10g的JDBC驱动就没这么麻烦了，Hibernate+Oracle+CLOB的读写其实只要这样做：

1.在Oracle里设置某字段为clob类型。
2.在Hibernate的配置文件里使用网上下载的Oracle 10g最新的jdbc驱动。
3.实体类里把clob字段对应的属性类型设置为String。
4.hibernate的映射文件*.hbm.xml里把该字段对应的类型该为text。

然后就可以在程序里把它当成String随便用了。

补充：按照上面的方法又写了一个测试类，能够操作Clob字段了，但是启动JBOSS后就不能用了，后来找了很久才发现，原来我用的JBOSS的default/lib目录下也有一下老版本的Class12.jar，删除它换成最新的ojdbc14.jar就可以了。

从初步分析来说，应该是hibernate解释hbm.xml时花费时间，或者可能是spring容器启动并解释所有的bean配置文件 。诊
断了一下，发现1分钟消耗的时间主要分布在hibernate解释hbm.xml花费5秒；spring容器从启动到解释bean配置文件竟然
花了58秒，真是太嚣张了。当时非常怀疑spring的效率问题。企图从网上搜索相关资料，看看有什么优化措施。

首先是找到了hibernate的启动优化 http://www.hibernate.org/194.html  里面的主要思想是通过将xml序列花到本地的
文件里，每次读取的时候根据情况，从本地文件读取并反序列化，节省了hibernate xml的解析时间。按照这个方式测试了
一下，发现hibernate的启动时间从5秒降低到3秒，但是这个优化对于整个启动过程是杯水车薪的，毫无用处。
下面是hibernate的优化代码：

public Configuration addCachableFile(String xmlFile) throws MappingException {        
        try {
            File file = new File(xmlFile);
            File lazyfile = new File(xmlFile + ".bin");
            org.dom4j.Document doc = null; 
            List errors = new ArrayList();
            if(file.exists() && lazyfile.exists() && file.lastModified()<lazyfile.lastModified()) {
                log.info("Mapping lazy file: " + lazyfile.getPath());
                ObjectInputStream oip = null;
                oip = new ObjectInputStream(new FileInputStream(lazyfile));
                doc = (org.dom4j.Document) oip.readObject();
                oip.close(); 
            } else {
                doc = xmlHelper.createSAXReader(xmlFile, errors, entityResolver).read( file );
                log.info("Writing lazy file to " + lazyfile);
                ObjectOutputStream oup = new ObjectOutputStream(new FileOutputStream(lazyfile));
                oup.writeObject(doc);
                oup.flush();
                oup.close();
            }
            
            if ( errors.size()!=0 ) throw new MappingException( "invalid mapping", (Throwable) errors.get(0) );
            add(doc);
            return this;
        }
        catch (Exception e) {
            log.error("Could not configure datastore from file: " + xmlFile, e);
            throw new MappingException(e);
        }
    }

 
不过在运行期间第一次点页面的时候，由于spring做了lazy-load，现在就需要启动一部分需要的beans，所以稍微慢2－3
 秒钟，但是明显比等几十秒要快很多，值得一鉴。

 以上是针对开发阶段的spring容器启动优化，在部署到实际环境中，倒是没必要设置为lazy-load。毕竟部署到实际环境
 中不是经常的事，每次启动1分钟倒不是大问题。

我这里要提醒的是不是说有的beans都能设置default-lazy-init成为true.对于scheduler的bean不能用lazy-init

< beans  default-lazy-init ="true" >   
     < bean  class ="org.springframework.scheduling.quartz.SchedulerFactoryBean" > 
         < property  name ="triggers" > 
             < list > 
                 < ref  bean ="buildHtmlTrigger" /> 
                 < ref  bean ="askTrigger" /> 
                 < ref  bean ="mailSenderTrigger" /> 
                 < ref  bean ="topicDetailBuildTrigger" /> 
                 < ref  bean ="forumBuildTrigger" /> 
                 < ref  bean ="topicBuildTrigger" /> 
             </ list > 
         </ property > 
     </ bean > 
</ beans > 

< beans >  
     < bean  class ="org.springframework.scheduling.quartz.SchedulerFactoryBean" > 
         < property  name ="triggers" > 
             < list > 
                 < ref  bean ="buildHtmlTrigger" /> 
                 < ref  bean ="askTrigger" /> 
                 < ref  bean ="mailSenderTrigger" /> 
                 < ref  bean ="topicDetailBuildTrigger" /> 
                 < ref  bean ="forumBuildTrigger" /> 
                 < ref  bean ="topicBuildTrigger" /> 
             </ list > 
         </ property > 
     </ bean > 
</ beans > 

假设在你的应用中Hibernate是通过spring 来管理它的session.如果在你的应用中没有使用OpenSessionInViewFilter或者OpenSessionInViewInterceptor。session会在transaction结束后关闭。
如果你采用了spring的声明式事务模式，它会对你的被代理对象的每一个方法进行事务包装（AOP的方式）。如下：

 <bean id="txProxyTemplate" abstract="true"
        class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
        <property name="transactionManager" ref="transactionManager"/>
        <property name="transactionAttributes">
            <props>
                <prop key="save*">PROPAGATION_REQUIRED</prop>
                <prop key="remove*">PROPAGATION_REQUIRED</prop>
                <prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
            </props>
        </property>
    </bean>

    <bean id="manager" parent="txProxyTemplate">
        <property name="target">
            <bean class="org.appfuse.service.impl.BaseManager">
                <property name="dao" ref="dao"/>
            </bean>
        </property>
    </bean>

目标类org.appfuse.service.impl.BaseManager 的  save *方法的事务类型PROPAGATION_REQUIRED  ，remove* 方法的事务类型PROPAGATION_REQUIRED
其他的方法的事务类型是PROPAGATION_REQUIRED,readOnly。
所以给你的感觉是调用这个名为“manager”的bean的方法之后session就关掉了。
如果应用中使用了OpenSessionInViewFilter或者OpenSessionInViewInterceptor，所有打开的session会被保存在一个线程变量里。在线程退出前通过
OpenSessionInViewFilter或者OpenSessionInViewInterceptor断开这些session。 为什么这么做？这主要是为了实现Hibernate的延迟加载功能。基于一个请求
一个hibernate session的原则。

spring中对OpenSessionInViewFilter的描述如下：
它是一个Servlet2.3过滤器，用来把一个Hibernate Session和一次完整的请求过程对应的线程相绑定。目的是为了实现"Open Session in View"的模式。
例如： 它允许在事务提交之后延迟加载显示所需要的对象。

这个过滤器和 HibernateInterceptor 有点类似：它是通过线程实现的。无论是没有事务的应用，还是有业务层事务的应用（通过HibernateTransactionManager 或
JtaTransactionManager的方式实现）它都适用。在后一种情况下，事务会自动采用由这个filter绑定的Session来进行相关的操作以及根据实际情况完成提交操作。

警告： 如果在你的应用中，一次请求的过程中使用了单一的一个HIbernate Session，在这种情况下，采用这个filter会产生一些以前没遇到的问题。特别需要注意的是通过
Hibernate Session重新组织持久化对象之间关系的相关操作需要在请求的最开始进行。以免与已经加载的相同对象发生冲突。

或者，我们可以通过指定"singleSession"="false"的方式把这个过滤器调到延期关闭模式。这样在一次请求的过程中不会使用一个单一的Session.每一次数据访问或事务相关
操作都使用属于它自己的session(有点像不使用Open Session in View).这些session都被注册成延迟关闭模式，即使是在这一次的请求中它相关操作已经完成。

"一次请求一个session" 对于一级缓存而言很有效，但是这样可以带来副作用。例如在saveOrUpdate的时候或事物回滚之后，虽然它和“no Open Session in View”同样安全。
但是它却允许延迟加载。

它会在spring的web应用的上下文根中查找Session工厂。它也支持通过在web.xml中定义的“SessionFactoryBeanName”的init-param元素 指定的Session工厂对应的bean的
名字来查找session工厂。默认的bean的名字是"sessionFactory".他通过每一次请求查找一次SessionFactory的方式来避免由初始化顺序引起的问题（当使用ContextLoaderServlet
来集成spring的时候 ，spring 的应用上下文是在这个filter 之后才被初始化的）。

默认的情况下，这个filter 不会同步Hibernate Session.这是因为它认为这项工作是通过业务层的事务来完成的。而且HibernateAccessors 的FlushMode为FLUSH_EAGER.如果你
想让这个filter在请求完成以后同步session.你需要覆盖它的closeSession方法，在这个方法中在调用父类的关闭session操作之前同步session.此外你需要覆盖它的getSession()
方法。返回一个session它的FlushMode 不是默认的FlushMode.NEVER。需要注意的是getSession()和closeSession()方法只有在single session的模式中才被调用。

在myfaces的wiki里提供了OpenSessionInViewFilter的一个子类如下：

public class OpenSessionInViewFilter extends org.springframework.orm.hibernate3.support.OpenSessionInViewFilter {
       
        /** *//**
         * we do a different flushmode than in the codebase
         * here
         */
        protected Session getSession(SessionFactory sessionFactory) throws DataAccessResourceFailureException {
                Session session = SessionFactoryUtils.getSession(sessionFactory, true);
                session.setFlushMode(FlushMode.COMMIT);
                return session;
        }
        /** *//**
         * we do an explicit flush here just in case
         * we do not have an automated flush
         */
        protected void closeSession(Session session, SessionFactory factory) {
                session.flush();
                super.closeSession(session, factory);
        }
}

/**
 * 通用DAO，用于对象的持久化、查询（分页）
 *
 * @author SunHui
 *
 */
public interface Dao {
 /**
  * 保存（持久化）一个对象
  *
  * @param object
  *            要保存的对象
  */
 public void save(Object object);

 /**
  * 更新一个对象
  *
  * @param object
  *            要修改的对象
  */
 public void update(Object object);

 /**
  * 用语句更新记录
  *
  * @param queryString
  *            查询语句
  * @param parameters
  *            参数
  */
 public void updateByQuery(final String queryString,
   final Object[] parameters);

 /**
  * 删除一个对象
  *
  * @param object
  *            要删除的对象
  */
 public void delete(Object object);

 /**
  * 根据类型和对象id删除一个对象
  *
  * @param clazz
  *            类型
  * @param id
  *            对象id
  */
 public void delete(Class clazz, Serializable id);

 /**
  * 根据类型删除全部对象
  *
  * @param clazz
  *            类型
  * @return Integer
  */
 public Integer deleteAll(final Class clazz);

 /**
  * 根据查询和参数删除全部对象
  *
  * @param queryString
  *            查询语句
  * @param parameters
  *            参数
  * @return Integer
  */
 public Integer deleteByQuery(final String queryString,
   final Object[] parameters);

 /**
  * 获得某个类型的全部对象列表
  *
  * @param clazz
  *            类型
  * @return 对象集合
  */
 public List findAll(Class clazz);

 /**
  * 根据类型和对象id载入一个对象
  *
  * @param clazz
  *            类型
  * @param id
  *            对象id
  * @return 目标对象
  */
 public Object load(Class clazz, Serializable id);

 /**
  * 根据类型和对象id从数据库取得一个对象
  *
  * @param clazz
  *            类
  * @param id
  *            对象id
  * @return 目标对象
  */
 public Object get(Class clazz, Serializable id);

 /**
  * 根据查询语句和查询参数从数据库取得一个对象
  *
  * @param queryString
  *            查询语句
  * @param parameters
  *            参数
  * @return Object 单个对象
  */
 public Object get(final String queryString, final Object[] parameters);

 /**
  * 命名查询
  *
  * @param queryName
  *            命名查询语句
  * @return 对象列表
  */
 public List findByNamedQuery(final String queryName);

 /**
  * 依据单个参数做命名查询
  *
  * @param query
  *            命名查询语句
  * @param parameter
  *            单个查询参数
  * @return 对象列表
  */
 public List findByNamedQuery(final String queryString,
   final Object parameter);

 /**
  * 依据参数数组做命名查询
  *
  * @param query
  *            命名查询语句
  * @param parameters
  *            查询参数数组
  * @return 对象列表
  */
 public List findByNamedQuery(final String queryString,
   final Object[] parameters);

 /**
  * 查询全部
  *
  * @param query
  *            查询语句
  * @return 对象列表
  */
 public List find(final String queryString);

 /**
  * 带参数查询全部
  *
  * @param queryString
  *            查询语句
  * @param parameters
  *            查询参数
  * @return 对象列表
  */
 public List find(final String queryString, final Object[] parameters);

 /**
  * 分页查询
  *
  * @param queryString
  *            查询语句
  * @param parameters
  *            参数
  * @param pageInfo
  *            分页信息
  * @return List 对象列表
  */
 public List findPageByQuery(final String queryString,
   final Object[] parameters, final PageInfo pageInfo);

}

以下为Dao的Hibernate3实现

import java.io.*;
import java.util.*;

import org.hibernate.*;
import org.springframework.orm.hibernate3.*;
import org.springframework.orm.hibernate3.support.*;

/**
 * 通用DAO的Hibernate实现
 *
 * @author SunHui
 *
 */
public class DaoImpl extends HibernateDaoSupport implements Dao {

 public void save(Object object) {
  getHibernateTemplate().save(object);
 }

 public void update(Object object) {
  getHibernateTemplate().update(object);
 }

 public void updateByQuery(final String queryString, final Object[] parameters) {
  getHibernateTemplate().execute(new HibernateCallback() {
   public Object doInHibernate(Session session) {
    Query query = session.createQuery(queryString);
    if (parameters != null) {
     for (int i = 0; i < parameters.length; i++) {
      query.setParameter(i, parameters[i]);
     }
    }
    query.executeUpdate();
    return null;
   }
  });
 }

 public void delete(Object object) {
  getHibernateTemplate().delete(object);
 }

 public void delete(Class clazz, Serializable id) {
  getHibernateTemplate().delete(load(clazz, id));
 }

 public Integer deleteAll(final Class clazz) {
  return (Integer) getHibernateTemplate().execute(
    new HibernateCallback() {
     public Object doInHibernate(Session session) {
      Query query = session.createQuery("delete "
        + clazz.getName());
      return new Integer(query.executeUpdate());
     }
    });
 }

 public List findAll(Class clazz) {
  return getHibernateTemplate().find("from " + clazz.getName());
 }

 public Object load(Class clazz, Serializable id) {
  return getHibernateTemplate().load(clazz, id);
 }

 public Object get(Class clazz, Serializable id) {
  return getHibernateTemplate().get(clazz, id);
 }

 public List findByNamedQuery(final String queryName) {
  return getHibernateTemplate().findByNamedQuery(queryName);
 }

 public List findByNamedQuery(final String queryName, final Object parameter) {
  return getHibernateTemplate().findByNamedQuery(queryName, parameter);
 }

 public List findByNamedQuery(final String queryName, final Object[] parameters) {
  return getHibernateTemplate().findByNamedQuery(queryName, parameters);
 }

 public List find(final String queryString) {
  return getHibernateTemplate().find(queryString);
 }

 public List find(final String queryString, final Object[] parameters) {
  return getHibernateTemplate().find(queryString, parameters);
 }

 public List findPageByQuery(final String queryString, final Object[] parameters,
   final PageInfo pageInfo) {
  return (List) getHibernateTemplate().execute(new HibernateCallback() {
   public Object doInHibernate(Session session)
     throws HibernateException {
    Query query = session.createQuery(queryString);
    if (parameters != null) {
     for (int i = 0; i < parameters.length; i++) {
      query.setParameter(i, parameters[i]);
     }
    }
    ScrollableResults sr = query.scroll();
    sr.last();
    int totalCount = sr.getRowNumber();
    int startIndex = (pageInfo.getPageIndex() - 1) * pageInfo.getPageSize();
    query.setMaxResults(pageInfo.getPageSize());
    query.setFirstResult(startIndex);
    int totalRec = totalCount + 1;
    pageInfo.setTotalRec(totalRec);
    int totalPage = (totalRec % pageInfo.getPageSize() == 0) ? (totalRec / pageInfo.getPageSize())
      : (totalRec / pageInfo.getPageSize()) + 1;
    int[] pageNumbers = new int[totalPage];
    for (int i = 0; i < totalPage; i++) {
     pageNumbers[i] = (i + 1);
    }
    pageInfo.setPageNumbers(pageNumbers);
    pageInfo.setTotalPage(totalPage);
    pageInfo.setPageSize(pageInfo.getPageSize());
    pageInfo.setPageIndex(pageInfo.getPageIndex());
    pageInfo.setPrePage(pageInfo.getPageIndex() - 1);
    pageInfo.setNextPage(pageInfo.getPageIndex() + 1);
    return query.list();
   }
  }, true);
 }

 public Integer deleteByQuery(final String queryString, final Object[] parameters) {
  return (Integer) getHibernateTemplate().execute(
    new HibernateCallback() {
     public Object doInHibernate(Session session) {
      Query query = session.createQuery(queryString);
      if (parameters != null) {
       for (int i = 0; i < parameters.length; i++) {
        query.setParameter(i, parameters[i]);
       }
      }
      return new Integer(query.executeUpdate());
     }
    });
 }

 public Object get(final String queryString, final Object[] parameters) {
  List list = getHibernateTemplate().find(queryString, parameters);
  if (list != null && !list.isEmpty()) {
   return list.get(0);
  }
  return null;
 }
}

/**
 * 通用分页信息类，用于承载分页信息
 *
 * @author SunHui
 *
 */
public class PageInfo {
 /**
  * 总页数
  */
 private int totalPage = 1;

 /**
  * 前一页
  */
 private int prePage = 1;

 /**
  * 下一页
  */
 private int nextPage = 1;

 /**
  * 总记录数
  */
 private int totalRec = 0;

 /**
  * 默认每页记录数
  */
 private final int defaultPageSize = 10;

 /**
  * 每页记录数
  */
 private int pageSize = defaultPageSize;

 /**
  * 当前页码
  */
 private int pageIndex = 1;

 /**
  * 全部页码，从1开始
  */
 private int[] pageNumbers;

 public int getPageIndex() {
  return pageIndex;
 }

 public void setPageIndex(int pageIndex) {
  this.pageIndex = pageIndex > 0 ? pageIndex : 1;
 }

 public int getNextPage() {
  return nextPage;
 }

 public void setNextPage(int nextPage) {
  this.nextPage = nextPage > this.totalPage ? this.totalPage : nextPage;
 }

 public int getPageSize() {
  return pageSize;
 }

 public void setPageSize(int pageSize) {
  this.pageSize = pageSize > 0 ? pageSize : 10;
 }

 public int getPrePage() {
  return prePage;
 }

 public void setPrePage(int prePage) {
  this.prePage = prePage < 1 ? 1 : prePage;
 }

 public int getTotalPage() {
  return totalPage;
 }

 public void setTotalPage(int totalPage) {
  this.totalPage = totalPage > 0 ? totalPage : 1;
 }

 public int getTotalRec() {
  return totalRec;
 }

 public void setTotalRec(int totalRec) {
  this.totalRec = totalRec > -1 ? totalRec : 0;
 }

 public int[] getPageNumbers() {
  return pageNumbers;
 }

 public void setPageNumbers(int[] pageNumbers) {
  this.pageNumbers = pageNumbers;
 }
}

如果我们想对一个bean的所有String类型的属性注入设置一个修正器，使其所有的注入内容均转换成大写，我们可以借助与Spring提供的 BeanPostProcessor接口

首先定义一个类，实现BeanPostProcessor接口，完成注入属性的大小写转换

public class UppercassModifier implements BeanPostProcessor{
    public Object postProcessBeforeInitialization(Object bean,String name) throws BeansException{
       //取得bean的field成员
       Field[] fields=bean.getClass().getDeclaredFields();
       for(int i=0;i<fields.lengtj;i++){
          //针对string类型的field成员加以修正
          if(fields[i].getType().equals(String.class)){
              fiels[i].setAccessible(true);
              try{
                   String orginal=(String)field[i].get(bean);
                   field[i].set(bean,orginal.toUpperCase());
              }catch(Exception e){
              }
          }
       }
      return bean;
    }

}

public class HelloBean{

   private String helloworld;
   setter/getter方法
}

<bean id="uppercaseModifier" class="demo.UppercaseModifier"/>

<bean id="helloBean" class="demo.HelloBean">
   <property name="helloworld" value="Hello"/>
</bean>

This article describes an easy process of implementing the observer pattern in the Spring framework (Spring Core). Also discussed in this article are a few of the Spring Core classes as well as an easy way to start the Spring Framework in any project. Finally, this article shows developers and designers that the Spring framework is a great reason to continue design pattern advocacy in your projects.

Recently, it seems when developers use the Spring framework to improve their projects they focus only on simple object oriented design techniques. Unfortunately some of the more brilliantly researched patterns are forgotten in place of a brilliant framework (Spring). Although the Factory Pattern and the Singleton Pattern are built into Spring, other patterns such as the Decorator Pattern, the Adapter Pattern, and the Observer Pattern are often forgotten because of the new ideas Spring has to offer. Fortunately, design patterns and the Spring framework can exist in the same application. In this article I show how the commonly used Observer Pattern fits nicely in the Spring Framework.

Observer Pattern

The Observer Pattern is also known as a publisher and subscriber design pattern. The pattern is useful when you have one publisher and many subscribers (one-to-many) that are interested in the publisher's state or messages. Additionally, interested subscribers have the ability to register and unregister as they please. Lastly, subscribers are notified of the publisher's messages automatically (that is, by no effort of their own). Figure 1 is an example of a typical observer pattern.

Figure 1. Observer Pattern

I chose to use a more widely accepted diagram to describe the Observer Pattern so you will notice that the aforementioned publisher is actually the Subject in this diagram. The subscriber is the Observer in the diagram. The intimate details of the Observer Pattern are far outside of the scope of this article, but a note worthy topic is how the Spring framework can be used to leverage good object oriented design techniques while creating the concrete classes of this pattern.

A normal concreteObserver class is required to have code similar to this constructor (or a similar “setter” method to achieve the registering of the Observer with the Subject):

public concreteObserver(Subject s) {
s.addListener(this);
}

Below you will see how the Spring framework wires the two concrete classes together with XML and not with code inside the classes. Ultimately, this allows the developer to avoid any unnecessary coupling of the concrete classes.

Spring Considerations

Since this article covers only the most simple implementation of the observer pattern, I utilize only the required Spring framework jars. At a minimum you need to have the spring-core.jar, the spring-context.jar, and the spring-beans.jar from the Spring framework distribution. Also to avoid any run time errors you need the commons-logging.jar from the Apache Commons project in your class path.

Each of these jars provide a specific role that make using the Spring framework possible. First is the spring-core.jar; this jar is required for all Spring applications. It includes Spring's dependency injection classes as well as other classes that are used to create Spring beans. The spring-context.jar contains the ApplicationContext interface. This interface is used to start the Spring framework in my included example project.

The last Spring jar is the spring-beans.jar. It contains the DesposibleBean interface which the FileSystemXmlApplicationContext bean sub-interfaces. I do not directly use the DesposibleBean interface but I use the FileSystemXmlApplicationContext bean to located the XML file used to configure the Spring framework. The code that implements these classes is shown in Listing 6.

Wiring The Observer Pattern with Spring

To illustrate the Observer Pattern concretely, I chose to create a Town Crier class that sends messages to any registered Town Resident class. To keep this example simple, I developed the same interfaces shown in Figure 1, but the concrete classes are TownCrier and TownResident. All four of these classes are shown in Listings 1 through 4.

After I created the TownCrier (Listing 3) and two TownResident (Listing 4) classes I created an incomplete version the ObserverContext.xml file (Listing 5). This file contains the Spring definitions of the concrete implementation beans. Since this example is simple, I chose not to use any of the more complex attributes of the bean tag.

Typical Bean tags for the shown classes:

	<bean id="townCrier" class="springobserver.TownCrier"/>
<bean id="townResident1" class="springobserver.TownResident"/>
<bean id="townResident1" class="springobserver.TownResident2"/>

At this point, I was able to run my ExampleRun class (Listing 6), but nothing eventful actually happened. This is because the TownResident classes were not “wired” into the TownCrier class.

To perform the wiring of the Observer Pattern I chose to use Spring's MethodInvokingFactoryBean class. This process is a very simple way of calling a method on a class and ultimately passing a parameter into method. In this example, the parameter is the bean definition of a townResident. A snapshot of this bean definition is:

<bean id="registerTownResident1"
class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
<property name="targetObject"><ref local="townCrier"/></property>
<property name="targetMethod"><value>addListener</value></property>
<property name="arguments">
<list>
<ref bean="townResident1"/>
</list>
</property>
</bean>

As you can see, the targetObject is the townCrier bean, the targetMethod is the addListener method and the argument is the townResident1 bean. This configuration is the only code needed to compose the concrete implementations of the TownCrier with TownResident class.

Now that I have the beans wired together using the MethodInvokingFactoryBean class, I can run my ExampleRun class and see that my TownResident classes are receiving messages from the TownCrier class. Results shown in Example 1.

Conclusion

A few lessons learned in this article include a simple way to start the Spring framework, how to use the MethodInvokingFactoryBean, and an efficient implementation the Observer Pattern in the Spring framework. Since this is a minimal approach to the Spring framework, I was able to show the relationship between the ApplicationContext and it's implementation FileSystemXmlApplicationContext class. This process for starting Spring applications is a very easy way to leverage an incredible framework.

Part of this framework is the MethodInvokingFactoryBean. When using it you are free to employ any parameter available to you such as an Integer, a String, or in our case, another Spring bean. By allowing you to expose methods in your context xml files you can be as flexible as you can dream. This article has covered the addListener() method of the Observer Pattern. I would like to extend a challenge to you to figure out how to implement the removeListener() method using strictly the Spring framework.

Lastly, the Observer Pattern is a common and very useful pattern. The practices shown in this article provide an example of how the concrete implementation of the Observer interface can be developed with no additional coupling to the concrete implementation of the Subject interface. This feature of Spring encourages good object oriented design techniques. As a final note, there is really no reason developers and designers can not find ways to marry proven design patterns with beautifully developed frameworks.

Listing 1. The Observer Interface

package springobserver;
public interface Observer {
public void update(String messageText);
}

Listing 2. The Subject Interface

package springobserver;
public interface Subject {
public void addListener(Observer o);
public void removeListener(Observer o);
public void notifyListeners();
}

Listing 3. The Town Crier

package springobserver;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class TownCrier implements Subject {
private List townResident = new ArrayList();
private String messageText;
// this message is added so I can give
// this class a reason to call notifyListener.
public void setMessage(String message){
System.out.println("I'm the Town Crier and " +
"I've got a message: " + message);
this.messageText = message;
this.notifyListeners();
}
public void addListener(Observer o) {
this.townResident.add(o);
}
public void removeListener(Observer o) {
if (this.townResident.contains(o)){
this.townResident.remove(o);
}
}
// call the update method on
// each observer (town resident)
public void notifyListeners() {
for (Iterator iter = townResident.iterator(); iter.hasNext();) {
Observer listener = (Observer) iter.next();
listener.update(messageText);
}
}
}

Listing 4. The Town Residents

package springobserver;
public class TownResident implements Observer {
public void update(String messageText) {
System.out.println("Greetings my name is: " + this);
System.out.println("I heard: " + messageText);
}
-------- new class --------
package springobserver;
public class TownResident2 implements Observer {
public void update(String messageText) {
System.out.println("Greetings my name is: " + this);
System.out.println("I heard: " + messageText);
}
}

Listing 5. The Application Context XML (ObserverContext.xml)

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<!-- This bean is the town crier.
He's responsible for notifying all town residents that are interested in his message -->
<bean id="townCrier" class="springobserver.TownCrier"/>
<!-- this bean is a town resident interested in the town criers messages -->
<bean id="townResident1" class="springobserver.TownResident"/>
<!-- this bean is another town resident interested in the town criers messages -->
<bean id="townResident2" class="springobserver.TownResident2"/>
<!-- this is a method invoking bean that registers the first town resident with
with the town crier -->
<bean id="registerTownResident1"
class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
<property name="targetObject"><ref local="townCrier"/></property>
<property name="targetMethod"><value>addListener</value></property>
<property name="arguments">
<list>
<ref bean="townResident1"/>
</list>
</property>
</bean>
<!-- this is a method invoking bean that registers the second town
resident with the town crier -->
<bean id="registerTownResident2"
class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
<property name="targetObject"><ref local="townCrier"/></property>
<property name="targetMethod"><value>addListener</value></property>
<property name="arguments">
<list>
<ref bean="townResident2"/>
</list>
</property>
</bean>
</beans>

Listing 6. Example Run

package springobserver;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
public class ExampleRun {
public static void main(String[] args) {
// launch the spring frame work.
ApplicationContext ctx = new FileSystemXmlApplicationContext(
"/config/ObserverContext.xml");
// grab the Town Crier out of the spring
// framework and send a message too all observers
TownCrier crier = (TownCrier) ctx.getBean("townCrier");
crier.setMessage("It is 1 O'Clock and all is well!");
}
}

Example 1. System Output

I'm the Town Crier and I've got a message: It is 1 O'Clock and all is well!
Greetings my name is: springobserver.TownResident@80fa6f
I heard: It is 1 O'Clock and all is well!
Greetings my name is: springobserver.TownResident2@1b9ce4b
I heard: It is 1 O'Clock and all is well!

jdbcTemplate.execute("CREATE TABLE USER (user_id integer, name varchar(100))");

使用JdbcTemplate进行查询时，可以使用queryForXXX()等方法，例如使用queryForInt()方法传回user表格中的数据数目： jdbcTemplate.quertForInt("select count(*) from user"); 也可以使用queryForObject()传回一个查询后的对象，例如传回一个String对象：

String name=(String)jdbcTemplate.queryForObject(
　　　　         "selcet name from user where id=?",
                         new Object[]{id},
                         java.lang.String.class);
)

单独查询某个数据并赋值给特定对象时：

    public BaseObj getBaseObj(final int ID) {

        String sql = "select * from " + DB_TABLE_NAME + " where NewsId=" + ID;
        BaseObj obj =(BaseObj) getJdbcTemplate().query(sql,new ResultSetExtractor(){
            public Object extractData(ResultSet rs) throws SQLException,DataAccessException {
                if (rs.next()) {
                    NewsObj news = new NewsObj();
                    news.setID(rs.getInt("NewsID"));
                    news.setTitle(rs.getString("NewsTitle"));
                    news.setBigClass(rs.getInt("BigClassId"));
                    news.setNewsContent(rs.getString("NewsContent"));
                    news.setNewsKey(rs.getString("NewsKey"));
                    news.setNewsAuthor(rs.getString("NewsAuthor"));
                    news.setImg(rs.getBoolean("isImg"));
                    news.setNewsFrom(rs.getString("NewsFrom"));
                    return news;
                }
                return null;
            }
        });
       return obj;

    }

上面两个例子都是传回单独一笔数据，如果要传回多笔数据，则可以使用queryForList()方法，例如：
List rows=jdbcTemplate().queryForList("select * from user where id="+id.intValue()); 传回的list中包括的是map对象，每个map对象代表查询结果中的一笔数据，每笔数据包括多个字段，要取得字段中的值，就要使用字段名作为key,例如：

   Iterator it=rows.iterator();
   while(it.hasNext()){
       Map result=(Map)it.next();
       System.out.println(userMap.get("id"));
       System.out.println(userMap.get("name"));
       System.out.println(userMap.get("age"));
    }

在查询的同时，你可以在返回结果之前先进行一些处理，这就要实现RowCallbackHandler接口

public User find(Integer id){
   final User user=new User();
   jdbcTemplate.query("select * from user where id=?",new Object[]{id},
                                         new RowCallBackHandler(){
                                                public void proccessRow(ResultSet rs){
                                                        user.setId(new Integer(rs.getInt("id")));
                                                        uset.setName(rs.getString("name"));    
                                                 }
                                            });
   return user;
 }

如果一次要返回多个查询结果对象，则可以实现RowMapper接口

public class UserRowMapper implements RowMapper{
       public Object MapRow(ResultSet rsmint rowNum) throws SQLException{
               User user=new User();
               user.setId(new Integer(rs.getInt("id")));
               user.setName(rs.getString("name"));
               return user;
      }
}

使用RowMapper查询单笔数据

public User find(Integer id){
        User user=(User)jdbcTemplate.queryForObject("select * from user where id=?",new Object[]{id},
                                                                                    new UserRowMapper());
         return user;

}

使用RowMapper查询多笔数据

class UserRowMapper implements RowMapper {

        public Object mapRow(ResultSet rs,int index) throws SQLException 

        {
            User u = new User();
            u.setId(rs.getString(”ID”));
            u.setName(rs.getString(”Name”));
            u.setPassword(rs.getString(”Password”));
            return u;

        }

    }

public List select(String where)

    {

        List list;        
        String sql = “select * from admin “+where;        
        list = jdbcTemplate.query(sql,new RowMapperResultReader(new UserRowMapper()));
        return list;

    }

传回的users对象中，包括了从数据库查询出来的结果，并已经封装成uer对象

还可以参阅下面链接：

by:http://opensource.atlassian.com/confluence/spring/display/DISC/AOP+Cache

I've written an AOP interceptor which allows you to specify which methods to cache for Spring beans.
Different cache providers are available: Memory HashMap, EHCache, OSCache (which is clusterable) and SwarmCache.

Example

We start by defining a bookManager object which has one method

public  List getRelated(Book);

which returns a List of Books that are related to the Book that is specified. This method is ideally suited for caching, since the related books will not change that often.

<bean id="bookManager" class="com.example.BookManager"/>

Next we define the AOP interceptor which will cache the results. This example will return a cached result (the List of Books) instead of a call to bookManager.getRelated(Book), if the method is called with the same Book argument.

Available implementations of CacheInterceptor are:

• MemoryCacheInterceptor: a simple in-memory cache that's not meant for production
• EHCacheInterceptor: uses EHCache from Hibernate and should be configured in ehcache.xml as described in the EHCache documentation.
• SwarmCacheInterceptor: a clusterable cache implementation
• OSCacheInterceptor: uses OSCache from OpenSymphony and is the one used in this example

The cache in the example is expired after 15 minutes.  
     

< bean  id ="cacheInterceptor"  
    class ="org.springframework.aop.interceptor.cache.OSCacheInterceptor" >
     < property  name ="refreshPeriods" >
         < props >
             <!--  Cache the returned related books for 15 minutes  -->
             < prop  key ="com.example.BookManager@getRelated" > 900 </ prop >
         </ props >
     </ property >
     <!--  For caches not defined under 'refreshPeriods', use this value  -->
     < property  name ="defaultRefreshPeriod" >
         < value > -1 </ value >
     </ property >
     <!--  Which method to call for non-standard objects like String, Boolean or Number.
 This method should be a simple method, like getId() or toString(), but should
 uniquely identify the object.  -->
     < property  name ="identifiers" >
         < props >
             <!--  If a method contains an argument com.example.Book,
             the generated cache key contains the value of Book.getId()  -->
             < prop  key ="com.example.Book" > getId </ prop >
         </ props >
     </ property >
</ bean >

refreshPeriods and defaultRefreshPeriod are properties that are specific for the OSCacheInterceptor. The best way to know how to configure a specific CacheInterceptor implementation is by having a look in the Javadoc (see the project.zip file).

refreshPeriods indicates how long the results will be cached in seconds. So a call to com.example.BookManager.getRelated() will be cached for 900 seconds (15 minutes).
When a method is intercepted that is not defined under refreshPeriods, the value of defaultRefreshPeriod will be used.

In order to be able to identify a call to the method with the same parameter, we use the identifiers property. Here you can list the function that needs to be called in order to get a unique identifier for this class. For each class that is used as an argument for the cached methods, specify the method name (which may not have any parameters). This is a better aproach than using the toString() method, since this method can produce long lines while most of the time a simple identifier is available. So in this example, book.getId() will be used to identify separate Book arguments. There is no need to specify arguments that are primitives (float, int), Strings or Numbers (Float, Integer, ...).

Now we wire the cacheInterceptor to the bookManager bean and we're done! Calls to bookManager.getRelated() will from now on be cached for 15 minutes.
Of course you can add as many beans to the cache as you want.

<!--  An advisor that wraps bookManager.getRelated() with the cacheInterceptor  -->
< bean  id ="bookManagerAdvisor"  
    class ="org.springframework.aop.support.RegexpMethodPointcutAdvisor" >
     < property  name ="advice" >
         < ref  bean ="cacheInterceptor" />
     </ property >
     < property  name ="patterns" >
         < list >
             < value > .*getRelated </ value >
         </ list >
     </ property >
</ bean >
< bean  id ="bookManagerCacheProxyCreator"  
    class ="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator" >
     < property  name ="beanNames" >
         < value > bookManager </ value >
     </ property >
     < property  name ="interceptorNames" >
         < list >
             < value > bookManagerAdvisor </ value >
         </ list >
     </ property >
</ bean >

<bean id="petStore" 
    class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
    <property name="transactionManager"><ref bean="transactionManager"/></property>
    <property name="target"><ref bean="petStoreTarget"/></property>
    <property name="transactionAttributes">
        <props>
            <prop key="insert*">PROPAGATION_REQUIRED,-MyCheckedException</prop>
            <prop key="update*">PROPAGATION_REQUIRED</prop>
            <prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
        </props>
    </property>
</bean>

事务代理会实现目标对象的接口：这里是id为petStoreTarget的bean。（使用 CGLIB也可以实现具体类的代理。只要设置proxyTargetClass属性为true就可以。如果目标对象没有实现任何接口，这将自动设置该属性为true。通常，我们希望面向接口而不是类编程。）使用proxyInterfaces属性来限定事务代理来代 理指定接口也是可以的（一般来说是个好想法）。也可以通过从 org.springframework.aop.framework.ProxyConfig继承或所有AOP代理工厂共享 的属性来定制TransactionProxyFactoryBean的行为。

这里的transactionAttributes属性定义在 org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource 中的属性格式来设置。这个包括通配符的方法名称映射是很直观的。注意 insert*的映射的值包括回滚规则。添加的-MyCheckedException 指定如果方法抛出MyCheckedException或它的子类，事务将 会自动回滚。可以用逗号分隔定义多个回滚规则。-前缀强制回滚，+前缀指定提交（这允许即使抛出unchecked异常时也可以提交事务，当然你自己要明白自己 在做什么）。

TransactionProxyFactoryBean允许你通过 “preInterceptors”和“postInterceptors”属性设置“前”或“后”通知来提供额外的 拦截行为。可以设置任意数量的“前”和“后”通知，它们的类型可以是 Advisor（可以包含一个切入点）， MethodInterceptor或被当前Spring配置支持的通知类型 （例如ThrowAdvice， AfterReturningtAdvice或BeforeAdvice， 这些都是默认支持的）。这些通知必须支持实例共享模式。如果你需要高级AOP特 性来使用事务，如有状态的maxin，那最好使用通用的 org.springframework.aop.framework.ProxyFactoryBean， 而不是TransactionProxyFactoryBean实用代理创建者。

也可以设置自动代理：配置AOP框架，不需要单独的代理定义类就可以生成类的 代理。

附两个spring的事务配置例子：
<prop key="add">
     PROPAGATION_REQUIRES_NEW, -MyException
</prop>
注：上面的意思是add方法将独占一个事务，当事务处理过程中产生MyException异常或者该异常的子类将回滚该事务。

<prop key="loadAll">
    PROPAGATION_SUPPORTS, ISOLATION_READ_COMMITED, Readonly
</prop>
注：表示loadAll方法支持事务，而且不会读取没有提交事务的数据。它的数据为只读（这样有助于提高读取的性能）

附A Spring中的所有事务策略

PROPAGATION_MANDATORY
PROPAGATION_NESTED
PROPAGATION_NEVER
PROPAGATION_NOT_SUPPORTED
PROPAGATION_REQUIRED
PROPAGATION_REQUIRED_NEW
PROPAGATION_SUPPORTS

附B Spring中所有的隔离策略：

ISOLATION_DEFAULT
ISOLATION_READ_UNCOMMITED
ISOLATION_COMMITED
ISOLATION_REPEATABLE_READ
ISOLATION_SERIALIZABLE

Spring事务类型祥解

大家可能在spring中经常看到这样的定义：

<prop key="load*">PROPAGATION_REQUIRED,readOnly</prop><prop key="store*">PROPAGATION_REQUIRED</prop>

估计有好多朋友还没有弄清楚里面的值的意思，仔细看完下面应该知道自己什么情况下面应该使用什么样的声明。^_^

Spring中常用事务类型：

• PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
  
• PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。
  
• PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。
  
• PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。
  
• PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
  
• PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。
  
• PROPAGATION_NESTED--如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。
  

/*
 * 创建日期 2005-3-25
 */
package org.bromon.spring.examer.student;

import java.util.List;

import org.bromon.spring.examer.pojo.Student;

/**
 * @author Bromon
 */
public interface StudentManagerInterface
{
    public void add(Student s);
    public void del(Student s);
    public void update(Student s);
    
    public List loadAll();
    public Student loadById(int id);
}

public class StudentManager extends HibernateDaoSupport implements StudentManagerInterface

<bean id="transactionManager" class="org.springframework.orm.hibernate.HibernateTransactionManager">
      <property name="sessionFactory">
         <ref bean="sessionFactory"/>
      </property>
</bean>

<bean id="transactionAttributeSource" class="org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource">
      <property name="properties">
         <props>
            <prop key="add">
               PROPAGATION_REQUIRES_NEW
            </prop>
         </props>
      </property>
   </bean>

<prop key="add">
   PROPAGATION_REQUIRES_NEW,-ExamerException
</prop

<prop key=”loadAll”>
      PROPAGATION_SUPPORTS,ISOLATION_READ_COMMITED,readOnly
   </prop>

<prop key=”load*”>
      PROPAGATION_SUPPORTS,ISOLATION_READ_COMMITED,readOnly
   </prop>

<bean id="studentManager" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
      <property name="target">
         <ref bean="studentManager"/>
      </property>
      <property name="transactionManager">
         <ref bean="transactionManager"/>
      </property>
      <property name="transactionAttributeSource">
         <ref bean="transactionAttributeSource"/>
      </property>
</bean>

public void testAdd() 
    {
        ApplicationContext ctx=new ClassPathXmlApplicationContext("springConfig.xml");
        StudentManager sm=(StudentManager)ctx.getBean("studentManager");
        
        Student s=new Student();
        s.setId(1);
        s.setName("bromon");
        s.setPassword("123");
        s.setGrade(1);
        s.setSex(0);
        
        sm.add(s);
}

spring声明式事务管理的两种方式

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.multiaction.MultiActionController;
public class ProductController extends MultiActionController {

 /**
  * Handles view
  */
 public ModelAndView view(HttpServletRequest request, HttpServletResponse response) throws Exception {

  response.getOutputStream().print("Viewing");

  return null;
 }

 /**
  * Handles index
  */
 public ModelAndView index(HttpServletRequest request, HttpServletResponse response) throws Exception {
  response.getOutputStream().print("index");
  return null;
 }
 
}
配置文件
 <bean id="productMethodNameResolver" class="org.springframework.web.servlet.mvc.multiaction.ParameterMethodNameResolver">
        <property name="paramName"><value>method</value></property>
        <property name="defaultMethodName"><value>view</value></property>
    </bean>
    <bean id="productController" class="ee.bug.ProductController">
        <property name="methodNameResolver"><ref local="productMethodNameResolver"/></property>
    </bean>
     <property name="paramName"><value>method</value></property>参数名为method 默认为action
    
输入view.do?method=view 显示Viewing
输入view.do?method=indedx 显示index
输入/view.do?method=fdsf  显示404错误