Spring对Hibernate事务管理

每次带班，讲到Spring事务这一块的时候，大家总是有很多的疑问，其实Spring事务并不难，可能初次接触的时候有的不好理解，今天我们就详细来谈一下Spring的事务管理机制，主要是对Hibernate进行的事务管理。

在谈Spring事务管理之前我们想一下在我们不用Spring的时候，在Hibernate中我们是怎么进行数据操作的。在Hibernate中我们每次进行一个操作的的时候我们都是要先开启事务，然后进行数据操作，然后提交事务，关闭事务，我们这样做的原因是因为Hibernate默认的事务自动提交是false，他是需要我们人为的手动提交事务，假如你不想每次都手动提交事务的话，你可以在hibernate.cfg.xml我文件中把它设置为事务自动提交：

<property name="hibernate.connection.autocommit">true</property>

当我们Spring对我们的Hibernate进行整合之后，我们的代码又出现了什么变化呢？整合，之后，我们不再是每次都去拿Session进行数据操作了，也不需要每次都开启事务，提交事务了，我们只需要Spring给我们提供的一个HibernateTemplate，我们直接用这个类里面给我们提供的数据操作方法就可以操作数据了。我们在也看不到关于事务的代码了，那Spring究竟有没有在他的操作方法里面封装事务处理呢？有的人直接HibernateTemplate里面提供的方法操作数据，成功了，有的人却又失败了，这到底是怎么回事呢？其实这里要看我们是怎样集成我们的Hibernate和Spring，如果在集成的过程中，我们抛弃了hibernate.cfg.xml文件，直接在Spring的的配置文件中进行配置数据源的话，那你直接用HibernateTemplate里面提供的方法是可以成功操作数据的，如果你还是用hibernate.cfg.xml来配置数据源，在Spring的配置文件中引用hibernate.cfg.xml文件，那么你不能成功，这其中的原因就是因为如果你用 hibernate.cfg.xml文件配置数据源，就像我们前面说的，Hibernate默认是手动提交事务，而HibernateTemplatel提供的方法里面并没有提供事务提交，而如果你用Spring的配置文件来配置数据源，Sping默认是自动提交的，所以就会成功，如果你想把Spring设置为手动提交你可以在起配置文件中进行配置：

<property name="defaultAutoCommit"> <value>false</value> </property>

纵然我们把它的事务提交方式设置为自动，它可以进行数据操作，但是这样并不满足我们实际的业务需求，因为有时候在我保存一个数据之后，我希望他能继续保存另一条数据，我希望在保存完两条或者多条之后一起进行事务提交，这样即使出错，我们可以回滚，取保数据的一致性，要么都成功要么都失败，这时候我们就不能每保存完一条数据之后事务就自动提交，因为这样它们不在同一个事务当中，我们不能保证数据的一致行。所以这时候我们就需要手动的来配置我们的事务，这就需要用到Spring为Hibernate提供的事务管理机制，Spring提供的事务管理可以分为两类：编程式的和声明式的，编程式，其实就是在代码里面来控制，像Hibernate操作数据一样，开启事务，提交事务，这种方式有一定的局限性，所以我们一般是用声明式来配置我们的事务。

声明式事务配置主要分以下几步：

1、声明式事务配置

• 配置事务管理器；
• 事务的传播特性；
• 那些类那些方法使用事务。

<!-- 配置事务管理器 指定其作用的sessionFactory把事务交给Spring去处理 --> <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory"> <ref bean="sessionFactory"/> </property> </bean> <!-- 配置事务的传播特性 --> <tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes> <tx:method name="save*" propagation="REQUIRED"/> <tx:method name="delete*" propagation="REQUIRED"/> <tx:method name="update*" propagation="REQUIRED"/> <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/> <tx:method name="*" read-only="true"/> </tx:attributes> </tx:advice> <!-- 那些类的哪些方法参与事务 --> <aop:config> <aop:pointcut id="allServiceMethod" expression="execution(* com.coe.service.*.*(..))"/> <aop:advisor pointcut-ref="allServiceMethod" advice-ref="txAdvice"/> </aop:config>

我们在配置事务的时候，我们一般是把事务边界设置到service层，也就是你的业务逻辑层，因为我们很多时候都是在我们的业务逻辑层来完成我们一些列的数据操作，如果放到Dao数据层，其粒度太小了。另外，如果我们把事务配置在业务逻辑层的话，对我们的二级缓存也是有好处的，这个大家以后实际操作的时候会发现。

2、编写业务逻辑方法

这时候我们就可以在我们业务逻辑层用HibernateTemplate里面提供的数据操作方法来编写我们的业务逻辑方法了，当然我们的方法必须要是以我们事务配置里面配置的一样，用save，delete，update，get做我们的方法的开头。需要注意的是，默认情况下运行期异常才会回滚（包括继承了RuntimeException子类），普通异常是不会滚的。

最后我们顺便总结一下事务的几种传播特性：

1. PROPAGATION_REQUIRED: 如果存在一个事务，则支持当前事务。如果没有事务则开启；

2. PROPAGATION_SUPPORTS: 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行；

3. PROPAGATION_MANDATORY: 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常；

4. PROPAGATION_REQUIRES_NEW: 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起；

5. PROPAGATION_NOT_SUPPORTED: 总是非事务地执行，并挂起任何存在的事务；

6. PROPAGATION_NEVER: 总是非事务地执行，如果存在一个活动事务，则抛出异常；

7. PROPAGATION_NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行。

===================================================================================================================

应用Spring AOP（五）-------XML配置方式

• 
  

Spring AOP提供了xml配置文件已经Annotation注解的方式更方便的进行AOP的配置。当然这两种方式的最大的好处是更好的降低了代码耦合性。

XML配置的示例工程代码：

 和前面的工程相比，前置通知，后置通知那几个通知类没有了，所有的通知逻辑直接放到了AllLogAdvice类的方法里：

Java代码  

1. <span style="font-size: 18px;">package com.aop;  
2.   
3. import org.apache.log4j.Logger;  
4. import org.aspectj.lang.JoinPoint;  
5. import org.aspectj.lang.ProceedingJoinPoint;  
6.   
7. public class AllLogAdvice {  
8.     private Logger logger = Logger.getLogger(AllLogAdvice.class);  
9.   
10.     // 此方法将作为前置通知  
11.     public void myBeforeAdvice(JoinPoint jionpoint) {  
12.         // 获取被调用的类名  
13.         String targetClassName = jionpoint.getTarget().getClass().getName();  
14.         // 获取被调用的方法名  
15.         String targetMethodName = jionpoint.getSignature().getName();  
16.         // 日志格式字符串  
17.         String logInfoText = "前置通知：" + targetClassName + "类的"  
18.                 + targetMethodName + "方法开始执行";  
19.         // 将日志信息写入配置的文件中  
20.         logger.info(logInfoText);  
21.     }  
22.   
23.     // 此方法将作为后置通知  
24.     public void myAfterReturnAdvice(JoinPoint jionpoint) {  
25.         // 获取被调用的类名  
26.         String targetClassName = jionpoint.getTarget().getClass().getName();  
27.         // 获取被调用的方法名  
28.         String targetMethodName = jionpoint.getSignature().getName();  
29.         // 日志格式字符串  
30.         String logInfoText = "后置通知：" + targetClassName + "类的"  
31.                 + targetMethodName + "方法开始执行";  
32.         // 将日志信息写入配置的文件中  
33.         logger.info(logInfoText);  
34.     }  
35.   
36.     // 此方法将作为异常通知  
37.     public void myThrowingAdvice(JoinPoint jionpoint, Exception e) {  
38.         // 获取被调用的类名  
39.         String targetClassName = jionpoint.getTarget().getClass().getName();  
40.         // 获取被调用的方法名  
41.         String targetMethodName = jionpoint.getSignature().getName();  
42.         // 日志格式字符串  
43.         String logInfoText = "异常通知：执行" + targetClassName + "类的"  
44.                 + targetMethodName + "方法时发生异常";  
45.         // 将日志信息写入配置的文件中  
46.         logger.info(logInfoText);  
47.     }  
48.   
49.     // 此方法将作为环绕通知  
50.     public void myAroundAdvice(ProceedingJoinPoint jionpoint) throws Throwable {  
51.         long beginTime = System.currentTimeMillis();  
52.         jionpoint.proceed();  
53.         long endTime = System.currentTimeMillis();  
54.         // 获取被调用的方法名  
55.         String targetMethodName = jionpoint.getSignature().getName();  
56.         // 日志格式字符串  
57.         String logInfoText = "环绕通知：" + targetMethodName + "方法调用前时间" + beginTime  
58.                 + "毫秒," + "调用后时间" + endTime + "毫秒";  
59.         // 将日志信息写入配置的文件中  
60.         logger.info(logInfoText);  
61.     }  
62. }</span>  

 

 4种通知功能用4个方法来完成了。aop.xml配置文件内容： 

Xml代码  

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans  
3.     xmlns="http://www.springframework.org/schema/beans"   
4.     xmlns:aop="http://www.springframework.org/schema/aop"  
5.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
6.     xmlns:p="http://www.springframework.org/schema/p"  
7.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
8.     http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
9.     http://www.springframework.org/schema/aop   
10.     http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">  
11.       
12.     <bean id="myUserService" class="com.service.UserService"></bean>  
13.           
14.     <!-- 定义日志通知，将日志切面交给Spring容器管理 -->  
15.     <bean id="allLogAdvice" class="com.aop.AllLogAdvice"></bean>      
16.       
17.     <!-- 进行aop配置 -->  
18.     <aop:config>    
19.       <!-- 配置日志切面 -->  
20.       <aop:aspect id="logaop" ref="allLogAdvice">         
21.              
22.         <aop:pointcut id="logpointcut" expression="execution(* com.service.UserService.*(..))" />  
23.           
24.         <!-- 将LogAdvice日志通知中的myBeforeAdvice方法指定为前置通知 -->  
25.         <aop:before method="myBeforeAdvice" pointcut-ref="logpointcut"/>  
26.           
27.         <!-- 将LogAdvice日志通知中的myAfterReturnAdvice方法指定为后置通知 -->  
28.         <aop:after-returning method="myAfterReturnAdvice" pointcut-ref="logpointcut"/>  
29.           
30.         <!-- 将LogAdvice日志通知中的方法指定为异常通知 -->  
31.         <aop:after-throwing method="myThrowingAdvice" pointcut-ref="logpointcut" throwing="e" />  
32.           
33.         <!-- 将LogAdvice日志通知中的方法指定为环绕通知 -->  
34.         <aop:around method="myAroundAdvice" pointcut-ref="logpointcut"/>  
35.       </aop:aspect>  
36.     </aop:config>  
37.       
38. </beans>  

 定义pointcut的这句：

Xml代码  

1. <aop:pointcut id="logpointcut" expression="execution(* com.service.UserService.*(..))" />  

 expression里的写法参考官网解释的

6.2.3.4节：http://docs.spring.io/spring/docs/2.0.8/reference/aop.html

除了用execution外，还可以用within，this等。

这篇文章解释也不错：http://blog.csdn.net/kkdelta/article/details/7441829

这儿第一个*通配符代表所有的返回值，第二个*代表所有方法，(..)表示任意的参数类型。也就是说com.service.UserService类下面的所有任意返回值，任意参数类型的方法都会被拦截。

 

再看看主测试类MainTest：

Java代码  

1. package com.test;  
2.   
3. import org.springframework.context.ApplicationContext;  
4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
5.   
6. import com.service.IUserService;  
7.   
8. public class MainTest {  
9.     public static void main(String[] args) {  
10.         ApplicationContext context = new ClassPathXmlApplicationContext(  
11.                 "aop.xml");  
12.         IUserService userService = (IUserService) context  
13.                 .getBean("myUserService");  
14.   
15.         userService.addUser("ton", 56);  
16.         userService.deleteUser("ton");  
17.     }  
18. }  

 这儿得到UserService的bean不再需要一个代理，而是直接用UserService定义的bean。这样的好处就是如果下次要删除通知里的逻辑，不再需要日志的功能了，我不再需要改java文件，直接在配置文件里的有关切面的配置段去掉就可以了，很好的做到了为代码解耦。