spring中的事务管理

Spring对事务的解决办法其实分为2种：编程式实现事务，AOP配置声明式解决方案。 

声明式事物

1）Spring的声明式事务管理在底层是建立在AOP的基础之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明（或通过等价的基于标注的方式），便可以将事务规则应用到业务逻辑中。因为事务管理本身就是一个典型的横切逻辑，正是AOP的用武之地。Spring开发团队也意识到了这一点，为声明式事务提供了简单而强大的支持。Spring强大的声明式事务管理功能，这主要得益于Spring依赖注入容器和Spring AOP的支持。依赖注入容器为声明式事务管理提供了基础设施，使得Bean对于Spring框架而言是可管理的；而Spring AOP则是声明式事务管理的直接实现者。和编程式事务相比，声明式事务唯一不足地方是，后者的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。但是即便有这样的需求，也存在很多变通的方法，比如，可以将需要进行事务管理的代码块独立为方法等等。

2）5种配置方式

Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。

DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化，比如使用Hibernate进行数据访问时，DataSource实际为SessionFactory，TransactionManager的实现为HibernateTransactionManager。

关系图如下：

注意：sessionFactorty和transactionManager是下面5中配置方式的基本配置，

第一种方式：每个Bean都有一个代理

第二种方式：所有Bean共享一个代理基类

第三种方式：使用拦截器

第四种方式：使用tx标签配置的拦截器    

第五种方式：全注解

编程式事务

Spring的编程式事务即在代码中使用编程的方式进行事务处理，可以做到比声明式事务更细粒度。有两种方式一是使用TransactionManager，另外就是TransactionTemplate。

1）TransactionManager使用方式

public class UserDaoImpl extends HibernateDaoSupport implements UserDao {  

private HibernateTransactionManager transactionManager;  

private DefaultTransactionDefinition def;  

public HibernateTransactionManager getTransactionManager() {  

return transactionManager;  

    }  

public void setTransactionManager(HibernateTransactionManager transactionManager) {  

this.transactionManager = transactionManager;  

    }  

public void createTransactionDefinition() {  

def =new DefaultTransactionDefinition();  

        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);  

        def.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);  

    }  

public void saveOrUpdate(User user) {  

        TransactionStatus status = transactionManager.getTransaction(def);  

try {  

this.getHibernateTemplate().saveOrUpdate(user);  

}catch (DataAccessException ex) {  

            transactionManager.rollback(status);  

throw ex;  

        }  

        transactionManager.commit(status);  

    }  

}  

2）TransactionTemplate方式

ResultDto ret = null;  

ret = (ResultDto)this.transactionTemplate.execute(new TransactionCallback() {  

@Override  

public Object doInTransaction(TransactionStatus status) {  

ResultDto ret =null;  

try {  

            drillTaskDao.deleteByKey(taskid);  

}catch (Exception e) {  

logger.error("delDrillTask:" + e.getMessage(), e);  

ret = ResultBuilder.buildResult(ResultBuilder.FAIL_CODE,null, ErrorCode.COM_DBDELETEERROR);  

return ret;  

        }  

finally {  

            status.setRollbackOnly();  

        }  

ret = cleartaskrelativedata(taskid, appid,true);  

return ret;  

    }  

});  

return ret;  

由于Spring内置AOP默认使用动态代理模式实现，我们就先来分析一下动态代理模式的实现方 法。动态代理模式的核心就在于代码中不出现与具体应用层相关联的接口或者类引用，如上所说，这个代理类适用于任何接口的实现。

public class TxHandler implements InvocationHandler {

private Object originalObject;

public Object bind(Object obj) {

　this.originalObject = obj;

　return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),this);

    }

public Object invoke(Object proxy, Method method, Object[] args)

throws Throwable {

　Object result = null;

　if (!method.getName().startsWith("save")) {

　　UserTransaction tx = null;

　　try {

　　　tx = (UserTransaction) (new InitialContext().lookup("java/tx"));

　　　result = method.invoke(originalObject, args);

　　　tx.commit();

　　} catch (Exception ex) {

　　　if (null != tx) {

　　　　try {

　　　　　tx.rollback();

　　　　} catch (Exception e) {

　　　}

　　}

　}

    } else {

　result = method.invoke(originalObject, args);

    }

return result;

    }

}

下面我们来分析一下上述代码的关键所在。

首先来看一下这段代码：

return Proxy.newProxyInstance(

　obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),this);

java.lang.reflect.Proxy.newProxyInstance方法根据传入的接口类型 （obj.getClass.getInterfaces()）动态构造一个代理类实例返回，这也说明了为什么动态代理实现要求其所代理的对象一定要实现 一个接口。这个代理类实例在内存中是动态构造的，它实现了传入的接口列表中所包含的所有接口。

再来分析以下代码：

public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {

　……

　result = method.invoke(originalObject, args);

　……

　return result;

}

InvocationHandler.invoke方法将在被代理类的方法被调用之前触发。通过这个方法，我们可以在被代理类方法调用的前后进行一些处 理，如代码中所示，InvocationHandler.invoke方法的参数中传递了当前被调用的方法（Method）,以及被调用方法的参数。同 时，可以通过method.invoke方法调用被代理类的原始方法实现。这样就可以在被代理类的方法调用前后写入任何想要进行的操作。

　 　Spring的事务管理机制实现的原理，就是通过这样一个动态代理对所有需要事务管理的Bean进行加载，并根据配置在invoke方法中对当前调用的 方法名进行判定，并在method.invoke方法前后为其加上合适的事务管理代码，这样就实现了Spring式的事务管理。Spring中的AOP实 现更为复杂和灵活，不过基本原理是一致的。