Spring下面的@Transactional注解的讲解

2024-04-05 14:14:54

摘自： 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;//运行时异常
             
    }

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

码农公寓

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

相关文章