Spring对事务管理的支持的发展历程（基础篇）

1、问题

Java代码  

1. Connection conn =    
2.     DataSourceUtils.getConnection();   
3.  //开启事务   
4. conn.setAutoCommit(false);   
5. try {   
6.     Object retVal =    
7.         callback.doInConnection(conn);   
8.     conn.commit(); //提交事务   
9.     return retVal;   
10. }catch (Exception e) {   
11.     conn.rollback();//回滚事务   
12.     throw e;   
13. }finally {   
14.     conn.close();   
15. }   

Connection conn = 
    DataSourceUtils.getConnection();
 //开启事务
conn.setAutoCommit(false);
try {
    Object retVal = 
        callback.doInConnection(conn);
    conn.commit(); //提交事务
    return retVal;
}catch (Exception e) {
    conn.rollback();//回滚事务
    throw e;
}finally {
    conn.close();
} 

Java代码  

1. Session session = null;   
2. Transaction transaction = null;   
3. try {   
4.     session = factory.openSession();   
5.     //开启事务   
6.     transaction = session.beginTransaction();   
7.     transation.begin();   
8.     session.save(user);   
9.     transaction.commit();//提交事务   
10. } catch (Exception e) {   
11.     e.printStackTrace();   
12.     transaction.rollback();//回滚事务   
13.     return false;   
14. }finally{   
15.     session.close();   
16. }  

Session session = null;
Transaction transaction = null;
try {
    session = factory.openSession();
    //开启事务
    transaction = session.beginTransaction();
    transation.begin();
    session.save(user);
    transaction.commit();//提交事务
} catch (Exception e) {
    e.printStackTrace();
    transaction.rollback();//回滚事务
    return false;
}finally{
    session.close();
}

   缺点：不一致的事务管理，复杂 

 

2、高层次解决方案(编程式实现事务)

Java代码  

1. public interface PlatformTransactionManager {   
2.     TransactionStatus getTransaction(TransactionDefinition definition)   
3.         throws TransactionException;   
4.     void commit(TransactionStatus status) throws TransactionException;   
5.     void rollback(TransactionStatus status) throws TransactionException;   
6. }  

public interface PlatformTransactionManager {
    TransactionStatus getTransaction(TransactionDefinition definition)
        throws TransactionException;
    void commit(TransactionStatus status) throws TransactionException;
    void rollback(TransactionStatus status) throws TransactionException;
}

 

Java代码  

1. //1.获取事务管理器   
2. PlatformTransactionManager txManager = (PlatformTransactionManager)                
3.      ctx.getBean("txManager");   
4. //2.定义事务属性   
5. DefaultTransactionDefinition td = new DefaultTransactionDefinition();   
6. td.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);   
7. //3开启事务,得到事务状态   
8. TransactionStatus status = txManager.getTransaction(td);   
9. try {   
10.     //4.执行数据库操作   
11.     System.out.println(jdbcTempate.queryForInt("select count(*) from tbl_doc"));   
12.     //5、提交事务   
13.     txManager.commit(status);   
14.        
15. }catch (Exception e) {   
16.     //6、回滚事务   
17.     txManager.rollback(status);   
18. }  

        //1.获取事务管理器
        PlatformTransactionManager txManager = (PlatformTransactionManager)             
             ctx.getBean("txManager");
        //2.定义事务属性
        DefaultTransactionDefinition td = new DefaultTransactionDefinition();
        td.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
        //3开启事务,得到事务状态
        TransactionStatus status = txManager.getTransaction(td);
        try {
            //4.执行数据库操作
            System.out.println(jdbcTempate.queryForInt("select count(*) from tbl_doc"));
            //5、提交事务
            txManager.commit(status);
            
        }catch (Exception e) {
            //6、回滚事务
            txManager.rollback(status);
        }

 

3、高层次解决方案（ 模板解决方案）

Java代码  

1. //1.获取事务管理器   
2. PlatformTransactionManager txManager = (PlatformTransactionManager)    
3.        ctx.getBean("txManager");           
4. //2、定义事务管理的模板   
5. TransactionTemplate transactionTemplate = new TransactionTemplate(txManager);   
6. //3.定义事务属性   
7. transactionTemplate.   
8.     setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);   
9. //4.回调，执行真正的数据库操作，如果需要返回值需要在回调里返回   
10. transactionTemplate.execute(new TransactionCallback() {   
11.     @Override  
12.     public Object doInTransaction(TransactionStatus status) {   
13.     //5.执行数据库操作   
14.     System.out.println(jdbcTempate.queryForInt("select count(*) from tbl_doc"));   
15.     return null;   
16.     }   
17. });  

//1.获取事务管理器
PlatformTransactionManager txManager = (PlatformTransactionManager) 
       ctx.getBean("txManager");        
//2、定义事务管理的模板
TransactionTemplate transactionTemplate = new TransactionTemplate(txManager);
//3.定义事务属性
transactionTemplate.
    setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
//4.回调，执行真正的数据库操作，如果需要返回值需要在回调里返回
transactionTemplate.execute(new TransactionCallback() {
    @Override
    public Object doInTransaction(TransactionStatus status) {
    //5.执行数据库操作
    System.out.println(jdbcTempate.queryForInt("select count(*) from tbl_doc"));
    return null;
    }
});

 

4、AOP解决方案

n Spring 框架提供了一致的事务管理抽象，这带来了以下好处：

1 ：为复杂的事务 API 提供了一致的编程模型，如 JTA 、 JDBC 、 Hibernate 、 JPA 和 JDO

2 ：支持声明式事务管理

3 ：提供比复杂的事务 API （诸如 JTA ）更简单的、更易于使用的编程式事务管理 API

4 ：非常好地整合 Spring 的各种数据访问抽象

实施事务的步骤

1 、定义 ( 资源 )DataSource/SessionFactory ……

2 、定义事务管理器（管理资源的事务）

3 、定义事务通知：定义了如何实施事务（实施事务的方法名和对应的事务属性），需 要使用事务管理器管理事务，定义了如何选择目标对象的方法及实施的事务属性

4 、定义 advisor （切入点和事务通知）：切入点选择需要实施事务的目标对象

5 、 Spring 织入事务通知到目标对象（ AOP 代理）

实施流程：