Spring下面的@Transactional注解的讲解

摘自: https://www.cnblogs.com/xiohao/p/4808088.html

Spring下面的@Transactional注解标志的讲解

  最近在开发中对Spring中的事务标记@Transactional用的比较多,今天上网收集了一些内容,做一个简单的总结~~~

 

  在service类前加上@Transactional,声明这个service所有方法需要事务管理。每一个业务方法开始时都会打开一个事务。

  Spring默认情况下会对运行期例外(RunTimeException)进行事务回滚。这个例外是unchecked

  如果遇到checked意外就不回滚。

  如何改变默认规则:

  1 让checked例外也回滚:在整个方法前加上 @Transactional(rollbackFor=Exception.class)

  2 让unchecked例外不回滚: @Transactional(notRollbackFor=RunTimeException.class)

  3 不需要事务管理的(只查询的)方法:@Transactional(propagation=Propagation.NOT_SUPPORTED)

 

       如果在整个方法运行前就不会开启事务 
       还可以加上:@Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true),这样就做成一个只读事务,可以提高效率。

    此外需要注意: 如果异常被try{}catch{}了,事务就不回滚了,如果想让事务回滚必须再往外抛try{}catch{throw Exception}。



       各种属性的意义: 

     REQUIRED:业务方法需要在一个容器里运行。如果方法运行时,已经处在一个事务中,那么加入到这个事务,否则自己新建一个新的事务。 

       NOT_SUPPORTED:声明方法不需要事务。如果方法没有关联到一个事务,容器不会为他开启事务,如果方法在一个事务中被调用,该事务会被挂起,调用结束后,原先的事务会恢复执行。 

       REQUIRESNEW:不管是否存在事务,该方法总会自己发起一个新的事务。如果方法已经运行在一个事务中,则原有事务挂起,新的事务被创建。 

       MANDATORY:该方法只能在一个已经存在的事务中执行,业务方法不能发起自己的事务。如果在没有事务的环境下被调用,容器抛出例外。 

       SUPPORTS:该方法在某个事务范围内被调用,则方法成为该事务的一部分。如果方法在该事务范围外被调用,该方法就在没有事务的环境下执行。 

       NEVER:该方法绝对不能在事务范围内执行。如果在就抛例外。只有该方法没有关联到任何事务,才正常执行。 

       NESTED:如果一个活动的事务存在,则运行在一个嵌套的事务中。如果没有活动事务,则按REQUIRED属性执行。它使用了一个单独的事务,这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只对

     DataSourceTransactionManager事务管理器起效。

 

 

   // 如果有事务,那么加入事务,没有的话新建一个(不写的情况下)
    @Transactional(propagation=Propagation.REQUIRED) 
    // 容器不为这个方法开启事务
    @Transactional(propagation=Propagation.NOT_SUPPORTED)
    // 不管是否存在事务,都创建一个新的事务,原来的挂起,新的执行完毕,继续执行老的事务
    @Transactional(propagation=Propagation.REQUIRES_NEW) 
    // 必须在一个已有的事务中执行,否则抛出异常
    @Transactional(propagation=Propagation.MANDATORY)
    // 必须在一个没有的事务中执行,否则抛出异常(与Propagation.MANDATORY相反)
    @Transactional(propagation=Propagation.NEVER) 
    // 如果其他bean调用这个方法,在其他bean中声明事务,那就用事务.如果其他bean没有声明事务,那就不用事务.
    @Transactional(propagation=Propagation.SUPPORTS)
 @Transactional(propagation=Propagation.NESTED) 
 // readOnly=true只读,不能更新,删除 
 @Transactional (propagation = Propagation.REQUIRED,readOnly=true) 
 // 设置超时时间
 @Transactional (propagation = Propagation.REQUIRED,timeout=30)
 // 设置数据库隔离级别
 @Transactional (propagation = Propagation.REQUIRED,isolation=Isolation.DEFAULT)

  

@Transactional设置:

 

propagation:事务传播性设置,Propagation枚举类型。Spring支持的事务传播属性包括7种:

   ROPAGATION_MANDATORY:方法必须在事务中执行,否则抛出异常。

    PROPAGATION_NESTED:使方法运行在嵌套事务中,否则和PROPAGATION_REQUIRED一样。

    PROPAGATION_NEVER :当前方法永远不在事务中运行,否则抛出异常。

    PROPAGATION_NOT_SUPPORTED:定义为当前事务不支持的方法,在该方法执行期间正在运行的事务会被暂停

    PROPAGATION_REQUIRED:当前的方法必须运行在事务中,如果没有事务就新建一个事务。新事务和方法一起开始,随着方法返回或者抛出异常时终止。

    PROPAGATION_REQUIRED_NEW :当前方法必须新建一个事务,如果当前的事务正在运行则暂停。

    PROPAGATION_SUPPORTS :规定当前方法支持当前事务,但是如果没有事务在运行就使用非事务方法执行。

  

isolation:事务隔离性级别设置,Isolation枚举类型

  ISOLATION_DEFAULT :使用数据库默认的隔离级别

    ISOLATION_COMMITTED:允许其他事务已经提交的更新(防止脏读取)

    ISOLATION_READ_UNCOMMITTED:允许读取其他事务未提交的更新,会导致三个缺陷发生。执行速度最快

    ISOLATION_REPEATABLE_READ :除非事务自身更改了数据,否则事务多次读取的数据相同(防止脏数据,多次重复读取)

    ISOLATION_SERIALIZABLE:隔离级别最高,可以防止三个缺陷,但是速度最慢,影响性能。

  

readOnly:读写性事务,只读性事务,布尔型

    对数据库的操作中,查询是使用最频繁的操作,每次执行查询时都要从数据库中重新读取数据,有时多次读取的数据都是相同的,这样的数据操作不仅浪费了系统资源,还影响了系统速度。对访问量大的程序来说,节省这部分资源可以大大提    升系统速度。

   将事务声明为只读的,那么数据库可以根据事务的特性优化事务的读取操作

  

timeout:超时时间,单位秒

事务可能因为某种原因很长时间没有反应,这期间可能锁定了数据库表,影响性能。设置超时时间,如果超过该时间,事务自动回滚。

  

rollbackFor:一组异常类的实例,遇到时必须进行回滚

 

rollbackForClassname:一组异常类的名字,遇到时必须进行回滚

 

noRollbackFor:一组异常类的实例,遇到时必须不回滚

 

noRollbackForClassname:一组异常类的名字,遇到时必须不回滚

 


实例一:事务的回滚情况

  

  1、默认情况对非运行时异常不进行回滚操作

/**
 * 运行时异常默认事务回滚
 * @throws Exception
 */
@Transactional
public void updateUser_1() throws Exception {
    Map<String,String> userMap=new HashMap<String,String>();
    userMap.put("id","1");
    userMap.put("userName","测试_01");
    userMap.put("password","654321");
    userDao.updateUserByID(userMap);
    throw new RuntimeException(); //抛出运行时异常 默认情况下回滚        事务---------------------->回滚
     
}

  

2、非运行时异常默认事务不回滚

/**
 * 非运行时异常默认事务不回滚
 * @throws Exception
 */
@Transactional
public void updateUser_3() throws Exception {
    Map<String,String> userMap=new HashMap<String,String>();
    userMap.put("id","1");
    userMap.put("userName","测试_01");
    userMap.put("password","654321");
    userDao.updateUserByID(userMap);
    throw new Exception(); //抛出非运行时异常 默认情况下不回滚        事务---------------------->不回滚
     
}

  

3、对所有异常事务都进行回滚操作

/**
 * 对所有异常事务都进行回滚操作
 * @throws Exception
 */
@Transactional(rollbackFor=Exception.class)
public void updateUser_6() throws Exception {
    Map<String,String> userMap=new HashMap<String,String>();
    userMap.put("id","1");
    userMap.put("userName","测试_01");
    userMap.put("password","654321");
    userDao.updateUserByID(userMap);
    throw new Exception(); //对所有异常事务都进行回滚操作     事务---------------------->回滚
     
}

  

4、对所有异常事务都不进行回滚操作

/**
 * 对所有异常事务都不进行回滚操作
 * @throws Exception
 */
@Transactional(noRollbackFor=Exception.class)
public void updateUser_7() throws Exception {
    Map<String,String> userMap=new HashMap<String,String>();
    userMap.put("id","1");
    userMap.put("userName","测试_01");
    userMap.put("password","654321");
    userDao.updateUserByID(userMap);
    throw new RuntimeException(); //对所有异常,事务都不进行回滚操作        事务---------------------->不回滚
     
}

  


实例二:对try{} catch{}的异常不回滚

 

/**
 * 对于try{} catch{}的异常不进行回滚
 * @throws Exception
 */
@Transactional
public void updateUser_5() throws Exception {
    Map<String,String> userMap=new HashMap<String,String>();
    userMap.put("id","1");
    userMap.put("userName","测试_01");
    userMap.put("password","654321");
    userDao.updateUserByID(userMap);
    try{
    throw new RuntimeException(); //运行时异常被捕获,事务不回滚
    }
    catch(Exception e){
        System.err.println("运行时异常被捕获,事务不回滚");
    }      
}

  

 

   实例三:关于嵌套事务的回滚原则

   说实话对于嵌套事务的测试,我现在仍然有一些疑问,比如说如果内部事务设置为   

     // 不管是否存在事务,都创建一个新的事务,原来的挂起,新的执行完毕,继续执行老的事务
     @Transactional(propagation=Propagation.REQUIRES_NEW) 
     那这样的情况下,内部事务设置为Propagation.REQUIRES_NEW,外部事务设置为Propagation.REQUIRED,那么如果在内部事务执行完后之后,如果外部事务抛出了运行时异常,那么对于内部事务而言

   由于是新开的一个单独的事务,这样的情况下内部事务应该不受外部事务的影响而回退,但是事实上经过测试,内部事务也是回滚的。感兴趣的同学可以一起探讨啊~

   在网上找了一些博客,下面贴出一篇比较好嵌套事务的博客:

   http://blog.chinaunix.net/uid-10289334-id-2964925.html

 

   1、外部事务抛异常,内部事务回滚(一般来说,只要外部开启事务,内部方法无论是否开启事务,只要出现相应的运行时异常,事务都将进行回滚操作)

 /**
     * 测试事务的相关信息
     * @throws Exception
     */
    @Override
    @Transactional(propagation=Propagation.REQUIRES_NEW)
    public void updateUser() throws Exception {
        Map<String,String> userMap=new HashMap<String,String>();
        userMap.put("id","1");
        userMap.put("userName","测试_01");
        userMap.put("password","654321");
        userDao.updateUserByID(userMap);
        insideMethod_01();  //1 、异常 不捕获                     事务---------------------->回滚
//      insideMethod_02();  //2、异常 捕获                           事务---------------------->不回滚
        throw new RuntimeException(); //3、测试外部方法抛异常     事务---------------------->回滚
//      throw new Exception();//4、默认情况,非运行时异 常               事务---------------------->不回滚
         
    }
     
    /**
     * 事务测试的内部方法 内部方法抛运行时异常不捕获 </br>
     *
     * 事务会对内外方法进行回滚操作  
     */
    @Override
    @Transactional(propagation=Propagation.REQUIRES_NEW)
    public void insideMethod_01(){
        Map<String,String> userMap=new HashMap<String,String>();
        userMap.put("id","2");
        userMap.put("id","2");
        userMap.put("userName","测试_02");
        userMap.put("password","654321");
        userDao.updateUserByID(userMap);
//      int value=1/0;//运行时异常
             
    }

  

2、内部事务抛异常,外部事务回滚(一般来说,只要外部开启事务,内部方法无论是否开启事务如何配置,只要出现相应的运行时异常,内外事务都将进行回滚操作)

 

 /**
     * 测试事务的相关信息
     * @throws Exception
     */
    @Override
    @Transactional(propagation=Propagation.REQUIRES_NEW)
    public void updateUser() throws Exception {
        Map<String,String> userMap=new HashMap<String,String>();
        userMap.put("id","1");
        userMap.put("userName","测试_01");
        userMap.put("password","654321");
        userDao.updateUserByID(userMap);
        insideMethod_01();  //1 、异常 不捕获                     事务---------------------->回滚
//      insideMethod_02();  //2、异常 捕获                           事务---------------------->不回滚
//      throw new RuntimeException(); //3、测试外部方法抛异常     事务---------------------->回滚
//      throw new Exception();//4、默认情况,非运行时异 常               事务---------------------->不回滚
         
    }
     
    /**
     * 事务测试的内部方法 内部方法抛运行时异常不捕获 </br>
     *
     * 事务会对内外方法进行回滚操作  
     */
    @Override
    @Transactional(propagation=Propagation.REQUIRES_NEW)
    public void insideMethod_01(){
        Map<String,String> userMap=new HashMap<String,String>();
        userMap.put("id","2");
        userMap.put("id","2");
        userMap.put("userName","测试_02");
        userMap.put("password","654321");
        userDao.updateUserByID(userMap);
        int value=1/0;//运行时异常
             
    }

  

  注:这里还有一点在实际开发中需要注意,如果外部方法调用了远程的接口,由于它们不在一个事务控制中,类似于分布式事务,这种情况远程事务是无法进行回滚操作的~

 

上一篇:用freemark 生成word形式


下一篇:StorageClass