Spring 事务传播行为

最新推荐文章于 2024-04-30 15:44:58 发布
最新推荐文章于 2024-04-30 15:44:58 发布
阅读量221 收藏 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 1489
@Transactional(noRollbackFor=Exception.class)@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW) //使被调用者不受调用者的异常影响,出现异常之后,使父方法回滚,子方法不回滚@Transactional(rollbackFor = Exc...
-手写Spring注解版本&事务传播行为
weixin_34296641的博客
04-14 92
视频参考C:\Users\Administrator\Desktop\蚂蚁3期\【www.zxit8.com】 0018-(每特教育&每特学院&蚂蚁课堂)-3期-源码分析-手写Spring注解版本&事务传播行为\0018-(每特教育&每特学院&蚂蚁课堂)-3期-源码分析-手写Spring注解版本&事务传播行为 今天视频要手写一个@Transa...
@Transactional回滚问题（try catch、嵌套、事务传播）
SnowDujc的博客
03-02 1663
本文参考与https://www.cnblogs.com/pjjlt/p/10926398.html Spring 事务注解 @Transactional 本来可以保证原子性，如果事务内有报错的话，整个事务可以保证回滚，但是加上try catch或者事务嵌套，可能会导致事务回滚失败。测试一波。 准备 建两张表，模拟两个数据操作 CREATE TABLE `user` ( `id` in...
声明式事务（@Transactional）使用时需要注意的坑
最新发布
weixin_41998947的博客
04-30 565
上两篇文章已经详细分析了申明式事务的实现原理，知道了底层原理之后，现在就可以开始使用申明式事务去简化我们的代码了。但是在使用注解的时候也会经常遇到一些问题，有些问题不仔细测试观察的话还不容易发现，比如：事务失效，部分数据回滚，导致数据不一致等。这篇文章就来列一下使用注解时应该注意哪些问题。一、@Transactional事务不生效的各种场景本文主要是总结神秘式事务在使用需要我们去注意的问题，正确的使用事务是在日常开发中所必须具备的技能，不然可能会造成数据的不准备等问题。
@Transactional使用注意事项
蜗牛的博客
03-18 1425
1、@Transactional注解只能在抛出RuntimeException或者Error时才会触发事务的回滚，常见的非RuntimeException是不会触发事务的回滚的。但是我们平时做业务处理时，需要捕获异常，所以可以手动抛出RuntimeException异常。 2、只有public修饰的方法才会生效。 3、方法内自调用导致的事务不生效 /* * 情况一：都有事务注解，异常在子方法...
@Transactional 详解
weixin_45993202的博客
11-02 1645
@Transactional 是声明式事务管理 编程中使用的注解 1 .添加位置 1）接口实现类或接口实现方法上，而不是接口类中。 2）访问权限：public 的方法才起作用。@Transactional 注解应该只被应用到 public 方法上，这是由 Spring AOP 的本质决定的。 系统设计：将标签放置在需要进行事务管理的方法上，而不是放在所有接口实现类上：只读的接口就不需要事务管理，由于配置了@Transactional就需要AOP拦截及事务的处理，可能影响系统性能。 3）错误使用：
浅谈Spring事务传播行为实战
08-25
主要介绍了浅谈Spring事务传播行为实战，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Spring事务传播行为问题解决
08-25
主要介绍了Spring事务传播行为问题解决,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring中事务传播行为的介绍
08-26
今天小编就为大家分享一篇关于Spring中事务传播行为的介绍，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
深入理解Spring事务的传播行为
08-26
Spring在TransactionDefinition...下面这篇文章主要给大家介绍了关于Spring事务传播行为的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
深入理解Spring的事务传播行为
08-27
spring支持7种事务传播行为，确定客户端和被调用端的事务边界（说得通俗一点就是多个具有事务控制的service的相互调用时所形成的复杂的事务边界控制），这篇文章主要给大家介绍了关于Spring事务传播行为的相关资料，...
Spring @Transactional事务传播机制详解
endwas
04-09 3493
## 总结 本文讲解了Spring事务的七种传播机制，我们可以根据具体的类型，具体设置，避免事务的方法过于长，一个事务里面调用的库表越多，就越有可能造成死锁，所以我们要根据具体的需要拆分使用。
@Transactional注解
是木子啦~
06-20 2566
@Transactional 可以作用在接口、类、类方法。作用于类：当把@Transactional 注解放在类上时，表示所有该类的public方法都配置相同的事务属性信息。作用于方法：当类配置了@Transactional，方法也配置了@Transactional，方法的事务会覆盖类的事务配置信息。作用于接口：不推荐这种使用方法，因为一旦标注在Interface上并且配置了Spring AOP 使用CGLib动态代理，将会导致@Transactional注解失效propagation属性propagati
@Transactional注解作用范围说明
Shirley_BHU的专栏
04-18 5400
@Transactional 事务实现机制 在应用系统调用声明了@Transactional的目标方法时，Spring Framework 默认使用 AOP 代理，在代码运行时生成一个代理对象，根据@Transactional的属性配置信息，这个代理对象决定该声明@Transactional的目标方法是否由拦截器TransactionInterceptor来使用拦截，在TransactionInterceptor拦截时，会在目标方法开始执行之前创建并加入事务，并执行目标方法的逻辑, 最...
父子方法事务注解@Transactional 使用
zhangAg的博客
11-10 335
Transactional 父子方法事务注解的使用。
spring事务管理(详解和实例)
mocas_wang的博客
10-11 2535
目录 1 理解spring事务 2 核心接口 2.1 事务管理器 2.1.1 JDBC事务 2.1.2 Hibernate事务 2.1.3 Java持久化API事务（JPA） 2.1.4 Java原生API事务 2.2 基本事务属性的定义 2.2.1 传播行为 2.2.2 隔离级别 2.2.3 只读 2.2.4 事务超时 2.2.5 回滚规则 2.3 事务状态 3 编程式事务 3.1 编程式和声明式事务的区别 3.2 如何实现编程式事务？ 3.2.1 使用Transact
SpringBoot-事务
weixin_45203607的博客
09-20 451
SpringBoot-事务 事务介绍 数据库事务的存在是为了保证“多个数据库操作”的“原子性”。 举个最简单的银行汇款业务的场景，A向B汇款1000元。 这个汇款动作主要有两个，①是A的银行账户上扣去1000元，②是B的银行账户上增加两千元。假如操作①成功了，而操作②失败了， 这样A的账户上就白白少了1000元，而B的账户上却没有增加1000。 所以我们需要用技术来保证操作①和操作②整体的原子性(即让操作①和②要么同时成功，要么同时失败)，数据库的事务就是为此而生的。 在我们使用Springboot框架来开
多线程事务如何保证效率和原子性
m0_71777195的博客
02-02 200
在Spring开发时，遇到一个从Excel表导入数据到数据库的需求，当然最简单的方法就是先使用EasyExcel把数据读出到集合中，然后依次插入到数据库中。但如何保证效率，原子性呢？我们一步步优化方案。这里不会引入不必要的组件，而是自己模拟类似的思想。我们需要下面的方式进行执行这里我们使用和Volatile来解决这个问题。Volatile。
Spring事务传播行为
08-11
以下是一些常见的Spring事务传播行为： 1. REQUIRED（默认）：如果当前存在事务，则加入该事务；如果没有事务，则创建一个新的事务。这是最常用的传播行为，适合大多数情况。 2. SUPPORTS：如果当前存在事务，则...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值