Spring 事务传播行为

最新推荐文章于 2023-11-10 14:22:34 发布
最新推荐文章于 2023-11-10 14:22:34 发布
阅读量230 收藏 1
点赞数
分类专栏： JAVA 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43478581/article/details/121910337
版权

事务是逻辑处理原子性的保证手段，通过使用事务控制，可以极大的避免出现逻辑处理失败导致的脏数据等问题。

事务最重要的两个特性，是事务的传播行为和数据隔离级别。传播级别定义的是事务的控制范围，事务隔离级别定义的是事务在数据库读写方面的控制范围。

以下是事务的7种传播行为：

1） PROPAGATION_REQUIRED ：默认的spring事务传播级别，使用该级别的特点是，如果上下文中已经存在事务，那么就加入到事务中执行，如果当前上下文中不存在事务，则新建事务执行

测试代码:

  1. 场景一：父方法有事务，父事务抛异常，子事务不抛异常

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
}

    总结：代码回滚

  2. 场景二：父方法有事务，子事务抛异常，父事务不抛异常

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

    总结：代码回滚

  3. 场景三：父方法有事务，父事务、子事务都抛异常

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

    总结：代码回滚

  4. 场景四：父方法有事务，父事务、子事务都不抛异常

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
}

    总结：代码不回滚

  5. 场景五：父方法没有事务，父事务不抛异常、子事务抛异常

    public void transactional(){
    userManager.saveUser();
     User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

    总结：代码回滚

  6. 场景六：父方法没有事务，父方法抛异常，子事务不抛异常

    public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
}

    总结：父方法、子事务代码都不回滚

  7. 场景七：父方法没有事务，父方法、子事务都抛异常

    public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

    总结：父方法、子事务代码都回滚

  8. 场景八：父方法没有事务，父方法、子事务都不抛异常

    public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
}

    总结：父方法、子事务代码都不回滚

总结：如果上下文中已经存在事务，那么就加入到事务中执行，如果当前上下文中不存在事务，则新建事务执行

2）PROPAGATION_SUPPORTS ：该传播级别的特点是，如果上下文存在事务，则支持事务加入事务，如果没有事务，则使用非事务的方式执行。

测试代码:

  1. 场景一：父方法有事务，父事务抛异常，子事务不抛异常

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.SUPPORTS)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
}

    总结：代码回滚

  2. 场景二：父方法有事务，子事务抛异常，父事务不抛异常

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.SUPPORTS)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

    总结：代码回滚

  3. 场景三：父方法有事务，父事务、子事务都抛异常

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.SUPPORTS)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

    总结：代码回滚

  4. 场景四：父方法有事务，父事务、子事务都不抛异常

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.SUPPORTS)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
}

    总结：代码不回滚

  5. 场景五：父方法没有事务，父事务不抛异常、子事务抛异常

    public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.SUPPORTS)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

    总结：代码不回滚

  6. 场景六：父方法没有事务，父方法抛异常，子事务不抛异常

    public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.SUPPORTS)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
}

    总结：父方法、子事务代码都不回滚

  7. 场景七：父方法没有事务，父方法、子事务都抛异常

    public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.SUPPORTS)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

    总结：父方法、子事务代码都不回滚

  8. 场景八：父方法没有事务，父方法、子事务都不抛异常

    public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.SUPPORTS)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
}

    总结：父方法、子事务代码都不回滚

总结：该传播级别的特点是，如果上下文存在事务，则支持事务加入事务，如果没有事务，则使用非事务的方式执行

3）PROPAGATION_MANDATORY ：该传播级别的特点是，该级别的事务要求上下文中必须要存在事务，否则就会抛出异常！

  1. 场景一：父方法有事务，父事务抛异常，子事务不抛异常

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.MANDATORY)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
}

    总结：代码回滚

  2. 场景二：父方法有事务，子事务抛异常，父事务不抛异常

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.MANDATORY)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

    总结：代码回滚

  3. 场景三：父方法有事务，父事务、子事务都抛异常

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.MANDATORY)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

    总结：代码回滚

  4. 场景四：父方法有事务，父事务、子事务都不抛异常

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.MANDATORY)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
}

    总结：代码不回滚

  5. 场景五：父方法没有事务

    public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.MANDATORY)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

    总结：报异常

    org.springframework.transaction.IllegalTransactionStateException: No existing transaction found for transaction marked with propagation ‘mandatory’

总结：该传播级别的特点是，该级别的事务要求上下文中必须要存在事务，否则就会抛出异常！

4）PROPAGATION_REQUIRES_NEW ：该传播级别的特点是，每次都要一个新事务，该传播级别的特点是，每次都会新建一个事务，并且同时将上下文中的事务挂起，执行当前新建事务完成以后，上下文事务恢复再执行。（一个事务单独提交）

测试代码:

  1. 场景一：父方法有事务，父事务抛异常，子事务不抛异常

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
}

    总结：子事务提交、父事务回滚

  2. 场景二：父方法有事务，子事务抛异常，父事务不抛异常

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

    总结：代码回滚

  3. 场景三：父方法有事务，父事务、子事务都抛异常

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

    总结：代码回滚

  4. 场景四：父方法有事务，父事务、子事务都不抛异常

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
}

    总结：代码不回滚

  5. 场景五：父方法没有事务，父事务不抛异常、子事务抛异常

    public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

    总结：代码回滚

  6. 场景六：父方法没有事务，父方法抛异常，子事务不抛异常

    public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
}

    总结：父方法、子事务代码都不回滚

  7. 场景七：父方法没有事务，父方法、子事务都抛异常

    public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

    总结：父方法、子事务代码都回滚

  8. 场景八：父方法没有事务，父方法、子事务都不抛异常

    public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
}

    总结：父方法、子事务代码都不回滚

总结：该传播级别的特点是，每次都要一个新事务，该传播级别的特点是，每次都会新建一个事务，并且同时将上下文中的事务挂起，执行当前新建事务完成以后，上下文事务恢复再执行。（一个事务单独提交）
5）PROPAGATION_NOT_SUPPORTED ：该传播级别的特点是，上下文中存在事务，则挂起事务，执行当前逻辑，结束后恢复上下文的事务。

测试代码:

  1. 场景一：父方法有事务，父事务抛异常，子事务不抛异常

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.NOT_SUPPORTED)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
}

    总结：子事务提交、父事务回滚

  2. 场景二：父方法有事务，子事务抛异常，父事务不抛异常

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.NOT_SUPPORTED)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

    总结：子事务提交、父事务回滚

  3. 场景三：父方法有事务，父事务、子事务都抛异常

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

    总结：子事务提交、父事务回滚

  4. 场景四：父方法有事务，父事务、子事务都不抛异常

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.NOT_SUPPORTED)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
}

    总结：代码不回滚

  5. 场景五：父方法没有事务，父事务不抛异常、子事务抛异常

    public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.NOT_SUPPORTED)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

    总结：子事务提交、父事务回滚

  6. 场景六：父方法没有事务，父方法抛异常，子事务不抛异常

    public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.NOT_SUPPORTED)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
}

    总结：父方法、子事务代码都不回滚

  7. 场景七：父方法没有事务，父方法、子事务都抛异常

    public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.NOT_SUPPORTED)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

    总结：子事务提交、父事务回滚

  8. 场景八：父方法没有事务，父方法、子事务都不抛异常

    public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.NOT_SUPPORTED)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
}

    总结：父方法、子事务代码都不回滚

总结：该传播级别的特点是，上下文中存在事务，则挂起事务，执行当前逻辑，结束后恢复上下文的事务

6）PROPAGATION_NEVER ：该传播级别的特点是，上下文中不能存在事务，一旦有事务，就抛出runtime异常，强制停止执行！这个级别上辈子跟事务有仇。

测试代码:

  1. 场景一：父方法有事务

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.NEVER)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
}

    总结：报异常

    org.springframework.transaction.IllegalTransactionStateException: Existing transaction found for transaction marked with propagation ‘never’

  2. 场景二：父方法没有事务，父事务不抛异常、子事务抛异常

    public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.NEVER)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

    总结：子事务提交、父事务回滚

  3. 场景三：父方法没有事务，父方法抛异常，子事务不抛异常

    public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.NEVER)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
}

    总结：子事务提交、父事务回滚

  4. 场景四：父方法没有事务，父方法、子事务都抛异常

    public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.NEVER)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
    throw new BizCoreException("回滚测试");
}

    总结：子事务提交、父事务回滚

  5. 场景五：父方法没有事务，父方法、子事务都不抛异常

    public void transactional(){
    userManager.saveUser();
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-父事务");
    user.setPassword("123456");
    userDAO.save(user);
}

@Transactional(rollbackFor = Exception.class,propagation = Propagation.NEVER)
public void saveUser(){
    User user = new User();
    user.setOpenId(IdUtil.fastSimpleUUID());
    user.setUsername("admin-子事务");
    user.setPassword("123456");
    userDAO.save(user);
}

    总结：父方法、子事务代码都不回滚

总结：该传播级别的特点是，上下文中不能存在事务，一旦有事务，就抛出runtime异常，强制停止执行！这个级别上辈子跟事务有仇

7）PROPAGATION_NESTED ，该传播级别的特点是，如果上下文中存在事务，则嵌套事务执行，如果不存在事务，则新建事务。

°Distance.
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
springboot 事务嵌套问题_SpringBoot事务设置
weixin_28831341的博客
02-04 1499
@Transactional(noRollbackFor=Exception.class)@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW) //使被调用者不受调用者的异常影响,出现异常之后,使父方法回滚,子方法不回滚@Transactional(rollbackFor = Exc...
-手写Spring注解版本&事务传播行为
weixin_34296641的博客
04-14 95
视频参考C:\Users\Administrator\Desktop\蚂蚁3期\【www.zxit8.com】 0018-(每特教育&每特学院&蚂蚁课堂)-3期-源码分析-手写Spring注解版本&事务传播行为\0018-(每特教育&每特学院&蚂蚁课堂)-3期-源码分析-手写Spring注解版本&事务传播行为 今天视频要手写一个@Transa...
@Transactional回滚问题（try catch、嵌套、事务传播）
SnowDujc的博客
03-02 1725
本文参考与https://www.cnblogs.com/pjjlt/p/10926398.html Spring 事务注解 @Transactional 本来可以保证原子性，如果事务内有报错的话，整个事务可以保证回滚，但是加上try catch或者事务嵌套，可能会导致事务回滚失败。测试一波。 准备 建两张表，模拟两个数据操作 CREATE TABLE `user` ( `id` in...
@Transactional使用注意事项
蜗牛的博客
03-18 1446
1、@Transactional注解只能在抛出RuntimeException或者Error时才会触发事务的回滚，常见的非RuntimeException是不会触发事务的回滚的。但是我们平时做业务处理时，需要捕获异常，所以可以手动抛出RuntimeException异常。 2、只有public修饰的方法才会生效。 3、方法内自调用导致的事务不生效 /* * 情况一：都有事务注解，异常在子方法...
@Transactional 详解
weixin_45993202的博客
11-02 1678
@Transactional 是声明式事务管理 编程中使用的注解 1 .添加位置 1）接口实现类或接口实现方法上，而不是接口类中。 2）访问权限：public 的方法才起作用。@Transactional 注解应该只被应用到 public 方法上，这是由 Spring AOP 的本质决定的。 系统设计：将标签放置在需要进行事务管理的方法上，而不是放在所有接口实现类上：只读的接口就不需要事务管理，由于配置了@Transactional就需要AOP拦截及事务的处理，可能影响系统性能。 3）错误使用：
浅谈Spring事务传播行为实战
08-25
浅谈Spring事务传播行为实战 Spring框架提供了事务管理的标准实现，通过注解或者XML文件的方式声明和配置事务。事务管理是指按照给定的事务规则来执行事务的提交或者回滚操作。事务的机制实现很大一部依赖事务日志...
Spring事务传播行为问题解决
08-25
Spring事务传播行为问题解决 Spring事务传播行为问题解决是指在Spring框架中，事务传播行为的配置和使用问题。事务传播行为是指在多个事务方法之间的调用关系，如何去管理和控制事务的传播和回滚。 一、 Spring...
Spring中事务传播行为的介绍
08-26
Spring 中事务传播行为的介绍 Spring 中事务传播行为是指在分布式事务系统中，事务的边界定义和传播规则。在 Spring 框架中，定义了 7 种不同的传播行为，每种行为都有其特点和应用场景。 1. PROPAGATION_...
spring 事务传播 demo
06-05
本示例“spring 事务传播 demo”将聚焦于Spring的事务传播行为，这是在多个方法调用中控制事务边界的关键概念。下面我们将详细讨论相关知识点。 首先，事务传播行为是指当一个被@Transactional注解的方法被另一个@...
Spring中的事务传播行为示例详解
08-25
Spring中的事务传播行为示例详解 Spring 框架中事务传播行为是指在多个方法之间的调用关系中，如何处理事务的传播和rollback的机制。事务传播行为是 Spring 框架提供的一种事务管理方式，用于控制事务的传播范围和...
深入理解Spring事务的传播行为
08-26
1. `PROPAGATION_REQUIRED`: 这是最常见的事务传播行为，表示如果当前存在事务，那么方法将在这个事务中运行；如果当前不存在事务，则创建一个新的事务。如果在方法执行过程中发生异常，那么事务会被回滚，否则在...
深入理解Spring的事务传播行为
08-27
【Spring的事务传播行为详解】 在Spring框架中，事务传播行为是其事务管理的一大特色，它定义了在多个具有事务控制的服务之间相互调用时如何处理事务边界。这有助于解决在分布式系统中复杂的事务管理问题。Spring...
spring 事务传播
02-27
通过上述对Spring事务传播行为的详细介绍，我们可以看出，正确理解和应用这些传播行为对于构建健壮的事务管理机制至关重要。每种传播行为都有其特定的应用场景和限制条件，开发者应根据具体的业务逻辑和需求来合理...
Spring事务传播机制.docx
11-06
事务隔离级别的选择和事务传播行为的设定，对于确保数据一致性至关重要。例如，如果你的应用需要绝对的数据一致性，可能会选择较高的隔离级别如SERIALIZABLE，但这也可能牺牲了系统的并发性能。反之，如果你更关心...
spring事务几种传播方式
07-31
#### 二、Spring事务传播行为概述 事务传播行为定义了当一个事务方法被另一个事务方法调用时，如何处理事务的行为。以下是Spring定义的七种事务传播行为： 1. **PROPAGATION_REQUIRED** - **含义**：表示当前方法...
Spring @Transactional事务传播机制详解
endwas
04-09 3684
## 总结 本文讲解了Spring事务的七种传播机制，我们可以根据具体的类型，具体设置，避免事务的方法过于长，一个事务里面调用的库表越多，就越有可能造成死锁，所以我们要根据具体的需要拆分使用。
@Transactional注解
是木子啦~
06-20 2668
@Transactional 可以作用在接口、类、类方法。作用于类：当把@Transactional 注解放在类上时，表示所有该类的public方法都配置相同的事务属性信息。作用于方法：当类配置了@Transactional，方法也配置了@Transactional，方法的事务会覆盖类的事务配置信息。作用于接口：不推荐这种使用方法，因为一旦标注在Interface上并且配置了Spring AOP 使用CGLib动态代理，将会导致@Transactional注解失效propagation属性propagati
@Transactional注解作用范围说明
Shirley_BHU的专栏
04-18 5692
@Transactional 事务实现机制 在应用系统调用声明了@Transactional的目标方法时，Spring Framework 默认使用 AOP 代理，在代码运行时生成一个代理对象，根据@Transactional的属性配置信息，这个代理对象决定该声明@Transactional的目标方法是否由拦截器TransactionInterceptor来使用拦截，在TransactionInterceptor拦截时，会在目标方法开始执行之前创建并加入事务，并执行目标方法的逻辑, 最...
父子方法事务注解@Transactional 使用
最新发布
zhangAg的博客
11-10 394
Transactional 父子方法事务注解的使用。
Spring事务传播行为
08-11
在Spring框架中，事务传播行为用于定义一个方法调用时如何参与到已存在的事务中，或者如何创建一个新的事务。Spring框架提供了多种事务传播行为选项，可以通过@Transactional注解或者编程式事务管理来配置。 以下是一些常见的Spring事务传播行为： 1. REQUIRED（默认）：如果当前存在事务，则加入该事务；如果没有事务，则创建一个新的事务。这是最常用的传播行为，适合大多数情况。 2. SUPPORTS：如果当前存在事务，则加入该事务；如果没有事务，则以非事务的方式执行。适用于不需要强制要求事务的场景。 3. MANDATORY：如果当前存在事务，则加入该事务；如果没有事务，则抛出异常。适用于必须在一个已存在的事务中执行的场景。 4. REQUIRES_NEW：创建一个新的事务，并挂起当前的事务（如果存在）。适用于需要独立的事务执行的场景。 5. NOT_SUPPORTED：以非事务的方式执行操作，挂起当前的事务（如果存在）。适用于不需要事务支持的场景。 6. NEVER：以非事务的方式执行操作，如果当前存在事务，则抛出异常。适用于必须在没有事务的环境下执行的场景。 7. NESTED：如果当前存在事务，则在嵌套事务中执行；如果没有事务，则创建一个新的事务。嵌套事务是独立于外部事务的内部事务，它可以独立地进行提交或回滚，但是如果外部事务回滚，嵌套事务也会回滚。 通过选择合适的事务传播行为，可以确保在不同的方法调用中有效地管理事务，保证事务的一致性和可靠性。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值