【Spring】spring事物的详细解读

╰+攻爆jí腚メ 2022-06-18 08:59 198阅读 0赞

转载于：[http://blog.sina.com.cn/s/blog\_4b5bc0110100z7jr.html][http_blog.sina.com.cn_s_blog_4b5bc0110100z7jr.html]

我们都知道事务的概念，那么事务的传播特性是什么呢？(此处着重介绍传播特性的概念，关于传播特性的相关配置就不介绍了，可以查看[spring][]的官方文档)   
在我们用SSH开发项目的时候，我们一般都是将事务设置在Service层 那么当我们调用Service层的一个方法的时候它能够保证我们的这个方法中执行的所有的对[数据库][Link 1]的更新操作保持在一个事务中，在事务层里面调用的这些方法要么全部成功，要么全部失败。那么事务的传播特性也是从这里说起的。   
如果你在你的Service层的这个方法中，除了调用了Dao层的方法之外，还调用了本类的其他的Service方法，那么在调用其他的Service方法的时候，这个事务是怎么规定的呢，我必须保证我在我方法里掉用的这个方法与我本身的方法处在同一个事务中，否则如果保证事物的一致性。事务的传播特性就是解决这个问题的，“事务是会传播的”在Spring中有针对传播特性的多种配置我们大多数情况下只用其中的一种:PROPGATION\_REQUIRED：这个配置项的意思是说当我调用service层的方法的时候开启一个事务(具体调用那一层的方法开始创建事务，要看你的aop的配置),那么在调用这个service层里面的其他的方法的时候,如果当前方法产生了事务就用当前方法产生的事务，否则就创建一个新的事务。这个工作使由Spring来帮助我们完成的。   
以前没有Spring帮助我们完成事务的时候我们必须自己手动的控制事务，例如当我们项目中仅仅使用[hibernate][spring]，而没有集成进spring的时候，我们在一个service层中调用其他的业务逻辑方法，为了保证事物必须也要把当前的hibernate session传递到下一个方法中，或者采用ThreadLocal的方法，将session传递给下一个方法，其实都是一个目的。现在这个工作由spring来帮助我们完成，就可以让我们更加的专注于我们的业务逻辑。而不用去关心事务的问题。

默认情况下当发生RuntimeException的情况下，事务才会回滚，所以要注意一下 如果你在程序发生错误的情况下，有自己的异常处理机制定义自己的Exception，必须从RuntimeException类继承 这样事务才会回滚！

文章二：

事务的传播行为和隔离级别\[transaction behavior and isolated level\]   
Spring中事务的定义：   
一、Propagation ：   
　　key属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。有以下选项可供使用：   
PROPAGATION\_REQUIRED–支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。   
PROPAGATION\_SUPPORTS–支持当前事务，如果当前没有事务，就以非事务方式执行。   
PROPAGATION\_MANDATORY–支持当前事务，如果当前没有事务，就抛出异常。   
PROPAGATION\_REQUIRES\_NEW–新建事务，如果当前存在事务，把当前事务挂起。   
PROPAGATION\_NOT\_SUPPORTED–以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。   
PROPAGATION\_NEVER–以非事务方式执行，如果当前存在事务，则抛出异常。

很多人看到事务的传播行为属性都不甚了解，我昨晚看了j2ee without ejb的时候，看到这里也不了解，甚至重新翻起数据库系统的教材书，但是也没有找到对这个的分析。今天搜索，找到一篇极好的分析文章，虽然这篇文章是重点分析PROPAGATION\_REQUIRED 和 PROPAGATION\_REQUIRED\_NESTED的   
解惑 spring 嵌套事务   
\*\*\*TransactionDefinition 接口定义\*\*\*\*\*\*\*\*\*\*\*\*\*\*

int PROPAGATION_REQUIRED = 0;   
    
    
    
     int PROPAGATION_SUPPORTS = 1;   
    
     int PROPAGATION_MANDATORY = 2;   
    
    
    
     int PROPAGATION_REQUIRES_NEW = 3;   
    
    
     int PROPAGATION_NOT_SUPPORTED = 4;   
    
    
     int PROPAGATION_NEVER = 5;   
    
    
     int PROPAGATION_NESTED = 6;

--------------------

在这篇文章里，他用两个嵌套的例子辅助分析，我这里直接引用了。   
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*sample\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*   
ServiceA \{

void methodA() {   
         ServiceB.methodB();   
     }

ServiceB \{

void methodB() {   
     }

--------------------

我们这里一个个分析吧   
1： PROPAGATION\_REQUIRED   
加入当前正要执行的事务不在另外一个事务里，那么就起一个新的事务   
比如说，ServiceB.methodB的事务级别定义为PROPAGATION\_REQUIRED, 那么由于执行ServiceA.methodA的时候，   
ServiceA.methodA已经起了事务，这时调用ServiceB.methodB，ServiceB.methodB看到自己已经运行在ServiceA.methodA   
的事务内部，就不再起新的事务。而假如ServiceA.methodA运行的时候发现自己没有在事务中，他就会为自己分配一个事务。   
这样，在ServiceA.methodA或者在ServiceB.methodB内的任何地方出现异常，事务都会被回滚。即使ServiceB.methodB的事务已经被   
提交，但是ServiceA.methodA在接下来fail要回滚，ServiceB.methodB也要回滚   
2： PROPAGATION\_SUPPORTS   
如果当前在事务中，即以事务的形式运行，如果当前不再一个事务中，那么就以非事务的形式运行   
这就跟平常用的普通非事务的代码只有一点点区别了。不理这个，因为我也没有觉得有什么区别   
3： PROPAGATION\_MANDATORY   
必须在一个事务中运行。也就是说，他只能被一个父事务调用。否则，他就要抛出异常。   
4： PROPAGATION\_REQUIRES\_NEW   
这个就比较绕口了。 比如我们设计ServiceA.methodA的事务级别为PROPAGATION\_REQUIRED，ServiceB.methodB的事务级别为PROPAGATION\_REQUIRES\_NEW，   
那么当执行到ServiceB.methodB的时候，ServiceA.methodA所在的事务就会挂起，ServiceB.methodB会起一个新的事务，等待ServiceB.methodB的事务完成以后，   
他才继续执行。他与PROPAGATION\_REQUIRED 的事务区别在于事务的回滚程度了。因为ServiceB.methodB是新起一个事务，那么就是存在   
两个不同的事务。如果ServiceB.methodB已经提交，那么ServiceA.methodA失败回滚，ServiceB.methodB是不会回滚的。如果ServiceB.methodB失败回滚，   
如果他抛出的异常被ServiceA.methodA捕获，ServiceA.methodA事务仍然可能提交。   
5： PROPAGATION\_NOT\_SUPPORTED   
当前不支持事务。比如ServiceA.methodA的事务级别是PROPAGATION\_REQUIRED ，而ServiceB.methodB的事务级别是PROPAGATION\_NOT\_SUPPORTED ，   
那么当执行到ServiceB.methodB时，ServiceA.methodA的事务挂起，而他以非事务的状态运行完，再继续ServiceA.methodA的事务。   
6： PROPAGATION\_NEVER   
不能在事务中运行。假设ServiceA.methodA的事务级别是PROPAGATION\_REQUIRED， 而ServiceB.methodB的事务级别是PROPAGATION\_NEVER ，   
那么ServiceB.methodB就要抛出异常了。   
7： PROPAGATION\_NESTED   
理解Nested的关键是savepoint。他与PROPAGATION\_REQUIRES\_NEW的区别是，PROPAGATION\_REQUIRES\_NEW另起一个事务，将会与他的父事务相互独立，   
而Nested的事务和他的父事务是相依的，他的提交是要等和他的父事务一块提交的。也就是说，如果父事务最后回滚，他也要回滚的。   
而Nested事务的好处是他有一个savepoint。

--------------------

ServiceA \{

void methodA() {   
         try {
      //savepoint   
             ServiceB.methodB();    //PROPAGATION_NESTED 级别
         } catch (SomeException) {   
             // 执行其他业务, 如 ServiceC.methodC();   
         }   
     }

--------------------

也就是说ServiceB.methodB失败回滚，那么ServiceA.methodA也会回滚到savepoint点上，ServiceA.methodA可以选择另外一个分支，比如   
ServiceC.methodC，继续执行，来尝试完成自己的事务。   
但是这个事务并没有在EJB标准中定义。

二、Isolation Level(事务隔离等级):   
1、Serializable：最严格的级别，事务串行执行，资源消耗最大；

2、REPEATABLE READ：保证了一个事务不会修改已经由另一个事务读取但未提交（回滚）的数据。避免了“脏读取”和“不可重复读取”的情况，但是带来了更多的性能损失。

3、READ COMMITTED:大多数主流数据库的默认事务等级，保证了一个事务不会读到另一个并行事务已修改但未提交的数据，避免了“脏读取”。该级别适用于大多数系统。

4、Read Uncommitted：保证了读取过程中不会读取到非法数据。   
隔离级别在于处理多事务的并发问题。   
我们知道并行可以提高数据库的吞吐量和效率，但是并不是所有的并发事务都可以并发运行，这需要查看数据库教材的可串行化条件判断了。   
这里就不阐述。   
我们首先说并发中可能发生的3中不讨人喜欢的事情   
1： Dirty reads–读脏数据。也就是说，比如事务A的未提交（还依然缓存）的数据被事务B读走，如果事务A失败回滚，会导致事务B所读取的的数据是错误的。

2： non-repeatable reads–数据不可重复读。比如事务A中两处读取数据-total-的值。在第一读的时候，total是100，然后事务B就把total的数据改成200，事务A再读一次，结果就发现，total竟然就变成200了，造成事务A数据混乱。

3： phantom reads–幻象读数据，这个和non-repeatable reads相似，也是同一个事务中多次读不一致的问题。但是non-repeatable reads的不一致是因为他所要取的数据集被改变了（比如total的数据），但是phantom reads所要读的数据的不一致却不是他所要读的数据集改变，而是他的条件数据集改变。比如Select account.id where account.name=”ppgogo\*”,第一次读去了6个符合条件的id，第二次读取的时候，由于事务b把一个帐号的名字由”dd”改成”ppgogo1”，结果取出来了7个数据。

三、readOnly   
事务属性中的readOnly标志表示对应的事务应该被最优化为只读事务。这是一个最优化提示。在一些情况下，一些事务策略能够起到显著的最优化效果，例如在使用Object/Relational映射工具（如：Hibernate或TopLink）时避免dirty checking（试图“刷新”）。   
四、Timeout   
在事务属性中还有定义“timeout”值的选项，指定事务超时为几秒。在JTA中，这将被简单地传递到J2EE服务器的事务协调程序，并据此得到相应的解释。

## 事物的配置 ##

[http://blog.csdn.net/jeamking/article/details/43982435][http_blog.csdn.net_jeamking_article_details_43982435]   
使用tx标签配置的拦截器

<?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" xmlns:tx="http://www.springframework.org/schema/tx" 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 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
    
        <context:annotation-config />  
        <context:component-scan base-package="com.bluesky" />  
    
        <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>  
    
        <tx:advice id="txAdvice" transaction-manager="transactionManager">  
            <tx:attributes>  
                <tx:method name="*" propagation="REQUIRED" />  
            </tx:attributes>  
        </tx:advice>  
    
        <aop:config>  
            <aop:pointcut id="interceptorPointCuts" expression="execution(* com.bluesky.spring.dao.*.*(..))" />  
            <aop:advisor advice-ref="txAdvice" pointcut-ref="interceptorPointCuts" />          
        </aop:config>        
    </beans>  
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41

全注解

<?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" xmlns:tx="http://www.springframework.org/schema/tx" 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 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
    
        <context:annotation-config />  
        <context:component-scan base-package="com.bluesky" />  
    
        <tx:annotation-driven transaction-manager="transactionManager"/>  
    
        <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>  
    
    </beans>  
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31

此时在DAO上需加上@Transactional注解，如下

package com.bluesky.spring.dao;  
    
    import java.util.List;  
    
    import org.hibernate.SessionFactory;  
    import org.springframework.beans.factory.annotation.Autowired;  
    import org.springframework.orm.hibernate3.support.HibernateDaoSupport;  
    import org.springframework.stereotype.Component;  
    
    import com.bluesky.spring.domain.User;  
    
    @Transactional  
    @Component("userDao")  
    public class UserDaoImpl extends HibernateDaoSupport implements UserDao {   
    
        public List<User> listUsers() {  
            return this.getSession().createQuery("from User").list();  
        }  
    
    
    }  
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21

[http://blog.csdn.net/bao19901210/article/details/41724355][http_blog.csdn.net_bao19901210_article_details_41724355]   
@Transaction用法   
@Transactional 可以作用于接口、接口方法、类以及类方法上。当作用于类上时，该类的所有 public 方法将都具有该类型的事务属性，同时，我们也可以在方法级别使用该标注来覆盖类级别的定义。

虽然 @Transactional 注解可以作用于接口、接口方法、类以及类方法上，但是 Spring 建议不要在接口或者接口方法上使用该注解，因为这只有在使用基于接口的代理时它才会生效。另外， @Transactional 注解应该只被应用到 public 方法上，这是由 Spring AOP 的本质决定的。如果你在 protected、private 或者默认可见性的方法上使用 @Transactional 注解，这将被忽略，也不会抛出任何异常。   
默认情况下，只有来自外部的方法调用才会被AOP代理捕获，也就是，类内部方法调用本类内部的其他方法并不会引起事务行为，即使被调用方法使用@Transactional注解进行修饰。

![这里写图片描述][SouthEast]

下面是几个小例子
    @Transactional(noRollbackFor=RuntimeException.class)  
        @Override  
        public void insert(Test test) {  
            dao.insert(test);  
            //抛出unchecked异常，触发事物，noRollbackFor=RuntimeException.class,不回滚 
            throw new RuntimeException("test");  
        }  
     
      
       1
       2
       3
       4
       5
       6
       7
       8
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8

@Transactional(propagation=Propagation.NOT_SUPPORTED)  
    @Override  
    public void insert(Test test) {  
        //事物传播行为是PROPAGATION_NOT_SUPPORTED，以非事务方式运行，不会存入数据库 
        dao.insert(test);  
    }

[http_blog.sina.com.cn_s_blog_4b5bc0110100z7jr.html]: http://blog.sina.com.cn/s/blog_4b5bc0110100z7jr.html
[spring]: http://lib.csdn.net/base/javaee
[Link 1]: http://lib.csdn.net/base/mysql
[http_blog.csdn.net_jeamking_article_details_43982435]: http://blog.csdn.net/jeamking/article/details/43982435
[http_blog.csdn.net_bao19901210_article_details_41724355]: http://blog.csdn.net/bao19901210/article/details/41724355
[SouthEast]: /images/20220618/041cd5a733924053a197db828a37efe8.png