写这篇文章的目的，为了使大家更好的理解和摸清事务的规律，希望对新手学习事务这块内容时有所帮助。

   在我们开发一个应用时，很多时候我们的一个业务操作会对数据库进行多次操作，有时候我们需要保证这么一系列的操作要么全部成功，要么全部失败，其实这个这个概念就是我们今天要谈论的事务。
  
   现在我们开发应用一般都采用三层结构，如果我们控制事务的代码都放在DAO(DataAccessObject)对象中，在DAO对象的每个方法当中去打开事务和关闭事务，当Service对象在调用DAO时，如果只调用一个DAO，那我们这样实现则效果不错，但往往我们的Service会调用一系列的DAO对数据库进行多次操作，那么，这个时候我们就无法控制事务的边界了，因为实际应用当中，我们的Service调用的DAO的个数是不确定的，可根据需求而变化，而且还可能出现Service调用Service的情况，看来手工来控制事务对于一个稍微严谨一点的系统来说完全是不现实的。

   那么现在我们有什么好的解决办法吗？还记得EJB引以为傲的声明式事务吗，虽然它现在已经慢慢没落，但是它的思想被后人所吸取，我们的Spring框架是一个轻量级框架，它同样的实现了声明式事务的支持，使我们能够通过配置及可插拔的方式的完成整个应用的事务的管理。

  
   谈到Sping事务，我们今天要说到的一个东东是ThreadLocal，早在JDK 1.2的版本中就提供java.lang.ThreadLocal,ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。简单的说，ThreadLocal是为每个线程保存一份变量，各个线程访问自己对应的变量，所以我们就可以不使用synchronized关键字同样可以实现线程同步，要了解关于ThreadLocal的详细信息，请参看


为了简单明了，今天我们先抛开AOP，还是先用手工的方式通过ThreadLocal来管理连接，废话不多说，先来看代码
TransactionHelper
Java代码  
  1. package com.hwadee.demo;  
  2. import java.io.IOException;  
  3. import java.io.InputStream;  
  4. import java.sql.Connection;  
  5. import java.sql.DriverManager;  
  6. import java.sql.SQLException;  
  7. import java.util.Properties;  
  8. publicfinalclass TransactionHelper {  
  9.     //使用ThreadLocal持有当前线程的数据库连接
  10.     privatefinalstatic ThreadLocal<Connection> connection_holder = new ThreadLocal<Connection>();  
  11.     //连接配置，来自connection.properties
  12.     privatefinalstatic Properties connectionProp = new Properties();  
  13.     static{       
  14.         //加载配置文件
  15.         InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("connection.properties");  
  16.         try {  
  17.             connectionProp.load(is);  
  18.             is.close();  
  19.             //加载驱动程序
  20.             Class.forName(connectionProp.getProperty("driverClassName"));  
  21.         } catch (IOException e) {  
  22.              thrownew RuntimeException(e.getMessage(),e);  
  23.         }catch(ClassNotFoundException e){  
  24.             thrownew RuntimeException("驱动未找到",e);  
  25.         }  
  26.     }  
  27.     //获取当前线程中的数据库连接
  28.     privatestatic Connection getCurrentConnection()  
  29.     {  
  30.         Connection conn = connection_holder.get();  
  31.         if(conn == null){  
  32.             conn =  createNotAutoCommitConnection();              
  33.             connection_holder.set(conn);  
  34.         }  
  35.         return conn;  
  36.     }  
  37.     //执行SQL语句
  38.     publicstaticint executeNonQuery(String sql) throws SQLException{  
  39.         Connection conn = getCurrentConnection();  
  40.         return conn.createStatement().executeUpdate(sql);  
  41.     }  
  42.     //提交事务
  43.     publicstaticvoid commit(){  
  44.         Connection conn = getCurrentConnection();  
  45.         try {  
  46.             conn.commit();  
  47.             conn.close();  
  48.             connection_holder.set(null);  
  49.         } catch (SQLException e) {  
  50.             thrownew RuntimeException(e.getMessage(),e);  
  51.         }  
  52.     }  
  53.     //回滚事务
  54.     publicstaticvoid rollback(){  
  55.         Connection conn = getCurrentConnection();  
  56.         try {  
  57.             conn.rollback();  
  58.             conn.close();  
  59.             connection_holder.set(null);  
  60.         } catch (SQLException e) {  
  61.             thrownew RuntimeException(e.getMessage(),e);  
  62.         }  
  63.     }  
  64.     //创建一个不自动Commit的数据库连接
  65.     privatestatic Connection createNotAutoCommitConnection() {  
  66.         try {  
  67.             Connection conn = DriverManager.getConnection(connectionProp.getProperty("url")+";databaseName="+ connectionProp.getProperty("databaseName")  
  68.                     ,connectionProp.getProperty("username")  
  69.                     ,connectionProp.getProperty("password"));  
  70.             conn.setAutoCommit(false);  
  71.             return conn;  
  72.         } catch (SQLException e) {  
  73.              thrownew RuntimeException(e.getMessage(),e);  
  74.         }  
  75.     }     
  76. }  
这个类实现了基本的连接管理与执行SQL语句的方法，可以在多线程环境下运行


程序入口
Java代码  
  1. package com.hwadee.demo;  
  2. import java.sql.SQLException;  
  3. publicclass MainModule {  
  4.     publicstaticvoid main(String[] args) {          
  5.         try{  
  6.             insert1();  
  7.             insert2();  
  8.             //方法1和2都无异常，提交事务,任何一个方法出现异常都将导致事务回滚。
  9.             TransactionHelper.commit();  
  10.         }catch(SQLException e){           
  11.             TransactionHelper.rollback();  
  12.             thrownew RuntimeException(e.getMessage(),e);  
  13.         }catch(RuntimeException e){            
  14.             TransactionHelper.rollback();  
  15.             thrownew RuntimeException(e.getMessage(),e);  
  16.         }  
  17.     }  
  18.     staticvoid insert1() throws SQLException{        
  19.         String sql = "insert into department values(1,'市场部')";  
  20.         TransactionHelper.executeNonQuery(sql);        
  21.     }  
  22.     staticvoid insert2() throws SQLException{        
  23.         String sql = "insert into department values(2,'研发部')";  
  24.         TransactionHelper.executeNonQuery(sql);   
  25.         //throw new RuntimeException("回滚");     
  26.     }  
  27. }  


连接字符串配置，请将此文件放入classpath根目录中
connection.properties
Java代码  
  1. url=jdbc:sqlserver://localhost:1433
  2. databaseName=pubs  
  3. username=sa  
  4. password=password  
  5. driverClassName=com.microsoft.sqlserver.jdbc.SQLServerDriver  


建表语句
Sql代码  
  1. USE [pubs]  
  2. go  
  3. CREATETABLE [Department](  
  4.     [DEPT_ID] [int] primarykey,  
  5.     [DEPT_NAME] [varchar](50)  
  6. )  
  7. GO  


   好了现在运行这个应用，可以正常的插入两条数据，接下来，取消insert2方法里面的注释，再运行看看效果。
Java代码  
  1. staticvoid insert2() throws SQLException{        
  2.         String sql = "insert into department values(2,'研发部')";  
  3.         TransactionHelper.executeNonQuery(sql);   
  4.         thrownew RuntimeException("回滚");         
  5.     }  

很重要的一点是要想实现事务，我们必须用同一个数据库连接执行这些语句，最终才能做到统一的提交和回滚。
我们可以这样假设
insert1和insert2为不同DAO的方法
仔细观察，我们的insert1和insert2并没有负责打开连接和关闭连接。而是间接的调用TransactionHelper.executeNonQuery(sql);
这样使我们执行的所有方法都是使用同一个连接进行数据库操作。

   其实这个例子只是想告诉大家要实现声明式事务的一部分内容，这个例子只能实现简单的单事务模型，要实现更复杂的事务传播模型如嵌套等，还需要我们使用更多的技术，如AOP等等。先写到这里，希望对大家有所帮助！

   感谢大家的支持，应为最近在比较忙，一直没有更新此贴，周末终于有时间可以继续来完成这篇文章了。
   
    前面我们讲到了ThreadLocal管理连接，当然这么一点内容确实和Spring的声明式事务没有多大联系，前面的例子还是由我们自己在管理事务的起点和终点，但大多数时候我们在编写一个业务逻辑时并不能确定事务的边界，而却随着系统越发复杂化，之前的一个事务可能会作为另一个业务逻辑的子事务，那要做到事务原子性，我们就根本没办法在代码里面去写事务控制的逻辑，我们需要一种能够灵活的配置的方式来管理事务，这样，我们只需要在配置文件里面配哪些对象的哪些方法需要事务，而且可以配置事务的传播特性。

这里简要的看看事务传播特性
Spring在TransactionDefinition接口中7种类型的事务传播行为，它们规定了事务方法和事务方法发生嵌套调用时事务如何进行传播：

1.PROPAGATION_REQUIRED
如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。

2.PROPAGATION_SUPPORTS
支持当前事务，如果当前没有事务，就以非事务方式执行。

3.PROPAGATION_MANDATORY
使用当前的事务，如果当前没有事务，就抛出异常。

4.PROPAGATION_REQUIRES_NEW
新建事务，如果当前存在事务，把当前事务挂起。

5.PROPAGATION_NOT_SUPPORTED
以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

6.PROPAGATION_NEVER
以非事务方式执行，如果当前存在事务，则抛出异常。

7.PROPAGATION_NESTED
如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。

   我们看到了上面的定义的7中事务传播特性，那么Spring到底是如何来实现事务传播特性呢？Proxy，使用Proxy，我们为所有需要实现事务的对象创建一个代理对象，代理对象能够在目标对象的方法被调用的前后，加入事务判断的逻辑，这样子就可以实现事务传播特性，这就是我们下面要讲的AOP。在Java下实现AOP最常用的两种方案分别为JDK动态代理和CGLib动态代理，它们各有优势。下面简单的对比一下。

JDK动态代理                    |                CGlib动态代理
JDK原生支持                    |                需要第三方库
只能针对接口代理                |               可以针对接口和类进行代理
创建代理的速度快                |             创建代理速度慢
代理对象性能一般                |             代理对象性能很好

  根据上面的这些特性，总结如下，对于Singleton的代理对象或者具有实例池的代理，因为无须频繁创建代理对象，比较适合用CGLib动态代理技术，反之适合用JDK动态代理技术。
顺便要提一点，由于CGLib采用动态创建子类的方式生成代理，所以不能对目标类中的final方法进行代理。

   这里我们来看一个JDK动态代理实现Required事务的例子，代码比较多，需要大家一点点耐心，先来看看代码。

接口 DAO 使用JDK动态代理必须要有接口
Java代码  
  1. package com.hwadee.demo.aop;  
  2. publicinterface DAO {  
  3.     void doWork();  
  4. }  

实现类 DAOImpl1
Java代码  
  1. package com.hwadee.demo.aop;  
  2. import java.sql.SQLException;  
  3. import com.hwadee.demo.TransactionHelper;  
  4. publicclass DAOImpl1 implements DAO {  
  5.     publicvoid doWork() {  
  6.         System.out.println(this.getClass().getName() + "." + "doWork  Invoke");  
  7.         String sql = "insert into department values(1,'市场部')";  
  8.         try {  
  9.             TransactionHelper.executeNonQuery(sql);  
  10.         } catch (SQLException e) {  
  11.             thrownew RuntimeException(e.getMessage(), e);  
  12.         }  
  13.         // 调用dao2
  14.         DAO dao2 = (DAO) BeanFactory.getBean("dao2");  
  15.         dao2.doWork();  
  16.     }  
  17. }  

实现类 DAOImpl2
Java代码  
  1. package com.hwadee.demo.aop;  
  2. import java.sql.SQLException;  
  3. import com.hwadee.demo.TransactionHelper;  
  4. publicclass DAOImpl2 implements DAO {  
  5.     publicvoid doWork() {  
  6.         System.out.println(this.getClass().getName() + "." + "doWork  Invoke");  
  7.         String sql = "insert into department values(2,'研发部')";  
  8.         try {  
  9.             TransactionHelper.executeNonQuery(sql);  
  10.         } catch (SQLException e) {  
  11.             thrownew RuntimeException(e.getMessage(), e);  
  12.         }  
  13.         //throw new RuntimeException("回滚");
  14.     }  
  15. }  

修改过后的 TransactionHelper
Java代码  
  1. package com.hwadee.demo;  
  2. import java.io.IOException;  
  3. import java.io.InputStream;  
  4. import java.sql.Connection;  
  5. import java.sql.DriverManager;  
  6. import java.sql.SQLException;  
  7. import java.util.Properties;  
  8. publicfinalclass TransactionHelper {  
  9.     // 使用ThreadLocal持有当前线程的数据库连接
  10.     privatefinalstatic ThreadLocal<Connection> connection_holder = new ThreadLocal<Connection>();  
  11.     // 当前是否处于事务环境
  12.     privatefinalstatic ThreadLocal<Boolean> existsTransaction = new ThreadLocal<Boolean>() {  
  13.         @Override
  14.         protected Boolean initialValue() {  
  15.             return Boolean.FALSE;  
  16.         }  
  17.     };  
  18.     // 是否必须回滚
  19.     privatefinalstatic ThreadLocal<Boolean> rollbackOnly = new ThreadLocal<Boolean>() {  
  20.         @Override
  21.         protected Boolean initialValue() {  
  22.             return Boolean.FALSE;  
  23.         }  
  24.     };  
  25.     // 连接配置，来自connection.properties
  26.     privatefinalstatic Properties connectionProp = new Properties();  
  27.     static {  
  28.         // 加载配置文件
  29.         InputStream is = Thread.currentThread().getContextClassLoader()  
  30.                 .getResourceAsStream("connection.properties");  
  31.         try {  
  32.             connectionProp.load(is);  
  33.             is.close();  
  34.             // 加载驱动程序
  35.             Class.forName(connectionProp.getProperty("driverClassName"));  
  36.         } catch (IOException e) {  
  37.             thrownew RuntimeException(e.getMessage(), e);  
  38.         } catch (ClassNotFoundException e) {  
  39.             thrownew RuntimeException("驱动未找到", e);  
  40.         }  
  41.     }  
  42.     /** 
  43.      * 是否必须回滚 
  44.      */
  45.     publicstaticboolean isRollbackOnly() {  
  46.         return rollbackOnly.get();  
  47.     }  
  48.     /** 
  49.      * 设置当前事务环境的回滚状态 
  50.      */
  51.     publicstaticvoid setRollbackOnly(boolean flag) {  
  52.         rollbackOnly.set(flag);  
  53.     }  
  54.     /** 
  55.      * 当前是否存在事务 
  56.      */
  57.     publicstaticboolean existsTransaction() {  
  58.         return existsTransaction.get();  
  59.     }  
  60.     // 设置当前事务环境
  61.     privatestaticvoid setExistsTransaction(boolean flag) {  
  62.         existsTransaction.set(flag);  
  63.     }  
  64.     /** 
  65.      * 开始一个事务 
  66.      */
  67.     publicstaticvoid beginTransaction() {  
  68.         Connection conn = createNotAutoCommitConnection();  
  69.         connection_holder.set(conn);  
  70.         setExistsTransaction(Boolean.TRUE);  
  71.     }  
  72.     // 获取当前线程中的数据库连接
  73.     privatestatic Connection getCurrentConnection() {  
  74.         return connection_holder.get();  
  75.     }  
  76.     // 执行SQL语句
  77.     publicstaticint executeNonQuery(String sql) throws SQLException {  
  78.         Connection conn = getCurrentConnection();  
  79.         return conn.createStatement().executeUpdate(sql);  
  80.     }  
  81.     /** 
  82.      * 提交事务 
  83.      */
  84.     publicstaticvoid commit() {  
  85.         Connection conn = getCurrentConnection();  
  86.         try {  
  87.             conn.commit();  
  88.             conn.close();  
  89.             connection_holder.set(null);  
  90.             setExistsTransaction(Boolean.FALSE);  
  91.         } catch (SQLException e) {  
  92.             thrownew RuntimeException(e.getMessage(), e);  
  93.         }  
  94.     }  
  95.     /** 
  96.      * 回滚事务 
  97.      */
  98.     publicstaticvoid rollback() {  
  99.         Connection conn = getCurrentConnection();  
  100.         try {  
  101.             conn.rollback();  
  102.             conn.close();  
  103.             connection_holder.set(null);  
  104.             setExistsTransaction(Boolean.FALSE);  
  105.         } catch (SQLException e) {  
  106.             thrownew RuntimeException(e.getMessage(), e);  
  107.         }  
  108.     }  
  109.     // 创建一个不自动Commit的数据库连接
  110.     privatestatic Connection createNotAutoCommitConnection() {  
  111.         try {  
  112.             Connection conn = DriverManager.getConnection(connectionProp  
  113.                     .getProperty("url")  
  114.                     + ";databaseName="
  115.                     + connectionProp.getProperty("databaseName"),  
  116.                     connectionProp.getProperty("username"), connectionProp  
  117.                             .getProperty("password"));  
  118.             conn.setAutoCommit(false);  
  119.             return conn;  
  120.         } catch (SQLException e) {  
  121.             thrownew RuntimeException(e.getMessage(), e);  
  122.         }  
  123.     }  
  124. }  

RequiredTransactionInterceptor 事务拦截器
Java代码  
  1. package com.hwadee.demo.aop;  
  2. import java.lang.reflect.InvocationHandler;  
  3. import java.lang.reflect.InvocationTargetException;  
  4. import java.lang.reflect.Method;  
  5. import com.hwadee.demo.TransactionHelper;  
  6. /** 
  7.  * 事务拦截器 代理对象执行接口的任意方法都会被拦截 对方法的调用交由本类的 invoke 方法处理 
  8.  */
  9. publicclass RequiredTransactionInterceptor implements InvocationHandler {  
  10.     // 目标对象
  11.     private Object target;  
  12.     // 在构造方法中传入目标对象
  13.     public RequiredTransactionInterceptor(Object target) {  
  14.         this.target = target;  
  15.     }  
  16.     /** 
  17.      * 在代理对象调用接口方法时的请求会被此方法拦截 
  18.      *  
  19.      * @param proxy 
  20.      *            代理对象 
  21.      * @param method 
  22.      *            目标对象当前调用的方法 
  23.      * @param args 
  24.      *            调用此方法时传递的参数 
  25.      */
  26.     public Object invoke(Object proxy, Method method, Object[] args)  
  27.             throws Throwable {  
  28.         // 在目标方法被调用前织入的逻辑,此处以Required传播属性为例
  29.         // 判断当前的事务环境，是开始一个新事务还是加入已有的事务
  30.         boolean existsTransaction = TransactionHelper.existsTransaction();  
  31.         if (existsTransaction == false) {  
  32.             TransactionHelper.beginTransaction();  
  33.             System.out.println("当前事务环境还没有事务，开启一个新事务");  
  34.         } else {  
  35.             System.out.println("当前事务环境已存在事务，加入事务");  
  36.         }  
  37.         // 目标方法的返回值
  38.         Object result = null;  
  39.         // 此处才真正调用目标对象的方法
  40.         try {  
  41.             result = method.invoke(target, args);  
  42.         } catch (InvocationTargetException e) {  
  43.             // 捕获调用目标异常，如果目标异常是运行时异常则设置回滚标志
  44.             Throwable cause = e.getCause();  
  45.             if (cause instanceof RuntimeException) {  
  46.                 TransactionHelper.setRollbackOnly(true);  
  47.                 System.out.println("出现运行时异常，事务环境被设置为必须回滚");  
  48.             } else {  
  49.                 System.out.println("出现非运行时异常，忽略");  
  50.             }  
  51.         }  
  52.         // 在目标方法被调用后织入的逻辑
  53.         System.out.println("判断当前的事务环境，是应该提交事务还是回滚事务");  
  54.         if (existsTransaction == false
  55.                 && TransactionHelper.isRollbackOnly() == false) {  
  56.             TransactionHelper.commit();  
  57.             System.out.println("事务已提交");  
  58.         } elseif (existsTransaction == false
  59.                 && TransactionHelper.isRollbackOnly() == true) {  
  60.             TransactionHelper.rollback();  
  61.             System.out.println("事务已回滚");  
  62.         } elseif (existsTransaction == true) {