Spring事务解惑

1    引言

Spring 是一个 IOC 框架，在此 IOC 框架的基础上，提供了 DAO 集成， AOP 事务控制， JNDI 等等一系列的高级功能，个人觉得，在 Spring 中最值得称道的不仅仅他是一个非入侵的 IOC 容器，而在于其神奇的声明事务以及异常处理；

 

2    Jdbc 事务实现

为什么要使用事务，银行转账的例子都用烂了，这里就不再累赘， JDBC 的本地事务利用 Connention.setAutoCommit() 的方法来保证的；

 

Public Boolean updateAMoney(Conn){

     …………………..

}

 

Public Boolean updateAMoney(Conn){

         ………………………

}

 

分别对数据库做了两次更新

Public Boolean MoneyAToB(){

Conn.setAutoCommit(false);

Try{

     updateAMoney(conn);

     updateBMoney(conn);

     conn.commit();

}catch(){

     Conn.close();

}

}

更新 A 操作出现异常，或者更新 B 异常，代码都无法到达 conn.commit(), 如此便此处的数据永远都不可能真正提交，无论 A 操作失败还是 B 操作失败，都不会对数据库产生影响；

 

3    系统分层

我们在系统开发中，一般都会考虑系统架构分层，大致如下：

 

viewer------>control------->service-------->dao-------->infrastucture

viewer: 显示数据和接受用户输入；
control: 接受前端请求，进行逻辑处理，调用相应服务进行处理，将处理后的数据推往 UI 层进行展示；
service: 通过接口提供系统服务；
dao: 直接与数据库等基础设备进行交互，实现数据的 CURD 等操作；
infrastucture ：基础设备；

 

在之前的实例中，我们可以将 updateAMoney 和 updateBMoney 看做 Dao 中的部分，而 moneyAToB 则因为具有业务含义，按照领域模型驱动设计中，他涉及到多个实体的更改，应该是被提至服务层的；

 

在 Dao 中，因为细粒度和不直接向外提供服务的缘由，我们在此层中不涉及事务操作，而将事务都推至服务层，但此时，我们可以发现，在 Service 中出现了 connection, 他不得不和 JDBC 耦合起来，出现了代码的坏味道，但是如果不出现 Connection ，我们又怎么保证 updateAMoney 和 updateBMoney 在同一个物理 connection 从而能够保证在一个事务中呢？

“一个请求，一个连接，一个服务，一个事务”，这是数据库事务设计的最佳模式；

要在 Dao 层中，要保证 Dao 中每一个 Dao 方法可能在同一个物理连接 Connection 中，则必须将 Connection 来自外部设置：

l   从 Service 中传入参数中获取；

l   从环境中获取

为了从 Service 中解耦，我们只能选择方式 2 ，而一个请求，通常为一个线程，我们在本地环境中设置一个连接容器：

Public abstract ConnectionHolder{

         Public static ThreadLoacl<Connection> connections=new NamedThreadLocal<Connection>(“….”)

 

Public Connection getConnetion(){

     Return connections.get();

}}

 

Public Boolean commit(){

     …………………….

}

 

Public Boolean rollback(){……}

}

 

我们在 service 中

Public Boolean moneyAToB(){

  updateAMoney();

  updateBMoney();

  ConnectionHolder.commit();

}

 

 

Public Boolean updateAMoney(){

 

Connection conn=connetionHolder.getConnction();

……………………………

}

 

这样， Service 就可以不直接依赖 Connection, 但是仍然不能不依赖 ConnnectionHolder,Spring 的做法就是借助 Aop ，将这段代码搬到 Xml 文件或者 annotation 中来进行解耦，在方法结束也是 invocationAction.invoke() 后进行 commit 操作；

 

4    Spring 的事务声明实现

现在我们来看一个 Spring 的实现：

在 Spring 中，我们的 Dao 借助于扩展 JDBCDaoSupport 来实现的，他在配置的时候注入一个 DataSource ，这是一个连接池，我们可以在 Dao 方法中进行如下实现：

 

Public class CoreyDao extends JDBCDaoSupport{

 

         Public Boolean updateAMoney(){

                   getJdbcTemplate() .execute(……….)

}

}

他将数据库操作委托给了 jdbcTemplate, 而 jdbcTemplate 他的数据库物理连接时如何而来的呢？源码如下：

 

         Connection con = DataSourceUtils.getConnection(getDataSource());

他是借助于 DataSourceUtils 取得的，你可不要以为 DataSourceUtils 就是简单的从 Datasource.getConnection 从数据库连接池中获取连接，因为之前我们说过，从数据库中获取连接并不能保证一个事务的连接取自同一个，就无法保证事务的统一提交和回滚，

dataSourceUtils.getConnetion 源码如下：

public static Connection doGetConnection(DataSource dataSource) throws SQLException {

       Assert.notNull(dataSource, "No DataSource specified" );

 

       ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);

       if (conHolder != null && (conHolder.hasConnection() || conHolder.isSynchronizedWithTransaction())) {

           conHolder.requested();

           if (!conHolder.hasConnection()) {

              logger.debug( "Fetching resumed JDBC Connection from DataSource" );

              conHolder.setConnection(dataSource.getConnection());

           }

           return conHolder.getConnection();

       }

       // Else we either got no holder or an empty thread-bound holder here.

 

       logger.debug( "Fetching JDBC Connection from DataSource" );

       Connection con = dataSource.getConnection();

 

       if (TransactionSynchronizationManager.isSynchronizationActive()) {

           logger.debug( "Registering transaction synchronization for JDBC Connection" );

           // Use same Connection for further JDBC actions within the transaction.

           // Thread-bound object will get removed by synchronization at transaction completion.

           ConnectionHolder holderToUse = conHolder;

           if (holderToUse == null ) {

              holderToUse = new ConnectionHolder(con);

           }

           else {

              holderToUse.setConnection(con);

           }

           holderToUse.requested();

           TransactionSynchronizationManager.registerSynchronization(

                  new ConnectionSynchronization(holderToUse, dataSource));

           holderToUse.setSynchronizedWithTransaction( true );

           if (holderToUse != conHolder) {

              TransactionSynchronizationManager.bindResource(dataSource, holderToUse);

           }

       }

 

       return con;

    }

 

他是借助于 TransactionSynchronizationManager 取得连接，如果连接不存在，则从 dataSource 中获取连接，并且将新连接传递给 TransactionSynchronizationManager ， TransactionSynchronizationManager 又做了什么呢？

 

ThreadLocal<Map<Object, Object>> resources

 

public static void bindResource(Object key, Object value) throws IllegalStateException {

       Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);

       Assert.notNull(value, "Value must not be null" );

       Map<Object, Object> map = resources.get();

       // set ThreadLocal Map if none found

       if (map == null ) {

           map = new HashMap<Object, Object>();

           resources.set(map);

       }

       if (map.put(actualKey, value) != null ) {

           throw new IllegalStateException( "Already value [" + map.get(actualKey) + "] for key [" +

                  actualKey + "] bound to thread [" + Thread.currentThread().getName() + "]" );

       }

       if (logger.isTraceEnabled()) {

           logger.trace( "Bound value [" + value + "] for key [" + actualKey + "] to thread [" +

                  Thread.currentThread().getName() + "]" );

       }

    }

 

Resources 是一个线程变量，每个线程都有一个 Map ，这个 Map 是以每一个数据源做 Key 的，也就是每一个线程中值存在一个数据源的一个连接，保证了在此次请求线程中公用一个线程池的一个连接，其实现事务的原理跟我们在之前演示的道理是一样的；

 

<? xml version="1.0" encoding="UTF-8" ?>
< beans xmlns ="http://www.springframework.org/schema/beans"
xmlns:xsi ="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context ="http://www.springframework.org/schema/context"
xmlns:aop ="http://www.springframework.org/schema/aop"
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
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

< bean id ="sessionFactory"  
class ="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
< property name ="configLocation" value ="classpath:hibernate.cfg.xml"   />  
< property name ="configurationClass" value ="org.hibernate.cfg.AnnotationConfiguration"   />
</ bean >  

<!-- 定义事务管理器（声明式的事务） -->  
< bean id ="transactionManager"
class ="org.springframework.orm.hibernate3.HibernateTransactionManager">
< property name ="sessionFactory" ref ="sessionFactory"   />
</ bean >

< bean id ="transactionBase"  
class ="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"  
lazy-init ="true" abstract ="true">  
<!-- 配置事务管理器 -->  
< property name ="transactionManager" ref ="transactionManager"   />  
<!-- 配置事务属性 -->  
< property name ="transactionAttributes">  
< props >  
< prop key ="*"> PROPAGATION_REQUIRED </ prop >  
</ props >  
</ property >  
</ bean >    

<!-- 配置 DAO -->
< bean id ="userDaoTarget" class ="com.bluesky.spring.dao.UserDaoImpl">
< property name ="sessionFactory" ref ="sessionFactory"   />
</ bean >

< bean id ="userDao" parent ="transactionBase"   >  
< property name ="target" ref ="userDaoTarget"   />   
</ bean >
</ beans >

 

我们要享受事务的自动代理功能，就必须使用 transactionBase 代理的对象，他主要是通过了代理了 service 中的方法，如 moneyAtoB, 他被代理后生成了一个代理类，这个代理类被 TransactionInterceptor 进行了拦截，而 TransactionInterceptor 主要是对这个 Dao 方法进行了事务处理；