事务的传播机制
Posted wait疯man
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了事务的传播机制相关的知识，希望对你有一定的参考价值。
目录
事务的传播机制有7种，如下图所示：
1.形象说明：
为了更好的理解，下面我们形象的说明一下几种传播机制是什么意思：
比如你下班回家，有以下几种场景
0.REQUIRED ------ 就是如果老婆做饭了，你就吃老婆做的饭；如果老婆没有做饭，你就自己做饭吃，反正你就是要吃饭（反正要在事务中运行）；
1.SUPPORTS ------ 如果老婆做饭了，你就吃老婆做的饭；如果老婆没有做饭，你就不吃（不一定非要在事务中运行）；
2.MANDATORY ------ 非要吃老婆做的饭，老婆要是没有做饭，你就大发脾气，典型的家暴男；
3.REQUIRES_NEW ------ 劳资非要吃自己做的饭，就算老婆把饭做好了，你也不吃老婆做的；
4.NOT_SUPPORTED ------ 劳资就是不吃饭，就算老婆把饭做好了，我也不吃；
5.NEVER ------ 劳资就是不吃饭，如果老婆把饭做好了，我还要发脾气；
6.NESTED ------ 暂不做解释，后面会详解；
本文主要是想用代码实现这几种传播机制的具体使用；
2.代码演示：
有两张表：
school表
student表
我们如何去测试两个方法是否使用的同一个事务呢？就看是否共用同一个数据库连接或者共用同一个会话；
2.1 REQUIRED
支持使用当前事务，如果当前事务不存在，创建一个新事务。
2.1.1 验证共用一个事务
schoolService.updateSchool()方法：
@Transactional
public void updateSchool()
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
//更新id为1的学校名称为湖南大学，地址为湖南
schoolMapper.updateByPrimaryKeySelective(school);
//调用另一个方法更新学生信息
studentService.updateStudent();
System.out.println(1/0);
studentService.updateStudent()方法，加了事务的，默认REQUIRED：
@Transactional
public void updateStudent()
Student student = new Student();
student.setSid(1);
student.setAge(25);
//更新sid为1的学生年龄为25
studentMapper.updateByPrimaryKeySelective(student);
如上所示：updateSchool方法是加了事务的，调用完studentService.updateStudent方法后，会报错，如果updateSchool和updateStudent共用同一个事务，updateSchool报错，自身回滚，肯定会带着updateStudent一起回滚；如果不是共用同一个事务，那么updateStudent会执行成功并提交，不会回滚；
结果：
updateSchool成功回滚了
updateStudent也成功回滚了
看过我写的深入理解@Transactional注解的使用和原理就知道，两个方法会共用同一个数据库连接，也就共用同一个事务，两个方法一起提交或者回滚；
2.1.2 验证当前没有事务，就新建一个事务
schoolService.updateSchool()方法：
public void updateSchool()
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
//更新id为1的学校名称为湖南大学，地址为湖南
schoolMapper.updateByPrimaryKeySelective(school);
//调用另一个方法更新学生信息
studentService.updateStudent();
studentService.updateStudent()方法：
@Transactional
public void updateStudent()
Student student = new Student();
student.setSid(1);
student.setAge(25);
//更新sid为1的学生年龄为25
studentMapper.updateByPrimaryKeySelective(student);
//报错
System.out.println(1/0);
如上所示：updateSchool方法是没有加事务的，调用studentService.updateStudent方法，updateStudent方法加了事务，并且会报错，如果updateStudent没有新建事务的话，不会回滚，如果是建了事务，就会回滚；
结果：
1.控制台提示报错
2. updateSchool方法没有回滚（将北京大学刚改为湖南大学）
3.updateStudent方法回滚了（将age更新为25）
验证通过；
2.2 SUPPORTS
支持使用当前事务，如果当前事务不存在，则不使用事务。
2.2.1 支持使用当前事务
updateSchool方法，加事务，更新id为1的name为“湖南大学”，location为“湖南”，输出1/0，肯定会报错的；
@Transactional
public void updateSchool()
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
System.out.println(1/0);
updateStudent方法更新id为1的age为25；
@Transactional(propagation = Propagation.SUPPORTS)
public void updateStudent()
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
如上所示：updateSchool方法是加了事务的，studentService.updateStudent方法也加了事务，而且传播机制是SUPPORTS，如果updateSchool和updateStudent共用同一个事务，updateSchool报错，自身回滚，肯定会带着updateStudent一起回滚；如果不是共用同一个事务，那么updateStudent会执行成功并提交，不会回滚；
结果：
1.控制台提示报错
2. updateSchool方法回滚（将北京大学刚改为湖南大学）
3.updateStudent方法回滚（将age改为25）
显然，updateSchool和updateSchool共用同一个事务，正好验证了传播机制为supports，如果当前有事务，就支持使用当前事务；
2.2.2 如果当前事务不存在，则不使用事务
updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，将@Transactional注释掉了，没有加事务
//@Transactional
public void updateSchool()
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
updateStudent方法更新id为1的age为25，事务传播机制为SUPPORTS，打印1/0，将报错
@Transactional(propagation = Propagation.SUPPORTS)
public void updateStudent()
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
System.out.println(1/0);
如上所示：updateSchool方法没有加事务，studentService.updateStudent方法加了事务，而且传播机制是SUPPORTS，如果updateStudent没有事务，报错就不会回滚，如果有事务，就会回滚；
结果：
1.控制台报错
2.updateSchool方法没有回滚，无事务执行（无事务这个说法其实不准确，任何操作数据库肯定是有事务的）；
3.updateStudent方法也没有回滚，也是无事务执行的；
显然： 事务传播机制为SUPPORTS的方法，支持使用当前事务，如果当前事务不存在，则不使用事务。
2.3 MANDATORY
中文翻译为强制，支持使用当前事务，如果当前事务不存在，则抛出Exception。
2.3.1 支持使用当前事务
updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，打印1/0，会报错；
@Transactional
public void updateSchool()
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
System.out.println(1/0);
updateStudent方法更新id为1的age为25，事务传播机制为MANDATORY
@Transactional(propagation = Propagation.MANDATORY)
public void updateStudent()
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
如上所示：updateSchool方法加事务，studentService.updateStudent方法加了事务，而且传播机制是MANDATORY，如果两者共用一个事务，都会回滚；
结果：
1.控制台报错
2. updateSchool方法回滚（将北京大学刚改为湖南大学）
3.updateStudent方法回滚（将age改为25）
显然： 传播机制为MANDATORY，如果当前有事务，就使用当前事务；
2.3.2 如果当前事务不存在，则抛出Exception
updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，没有事务；
//@Transactional
public void updateSchool()
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
updateStudent方法更新id为1的age为25，事务传播机制为MANDATORY；
@Transactional(propagation = Propagation.MANDATORY)
public void updateStudent()
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
如上所示：updateSchool方法没有加事务，studentService.updateStudent方法加了事务，而且传播机制是MANDATORY，就看执行到updateStudent就不会报错；
结果：
1.控制台报错
org.springframework.transaction.IllegalTransactionStateException: No existing transaction found for transaction marked with propagation 'mandatory'
2.updateSchool方法没有回滚（将北京大学刚改为湖南大学）
3.pdateStudent方法直接报错： No existing transaction found for transaction marked with propagation 'mandatory'，传播机制为mandatory的，必须有当前事务存在，不存在就报错；
综上：传播机制为MANDATORY，支持使用当前事务，如果当前事务不存在，则抛出Exception。
2.4 REQUIRES_NEW
新建一个新事务；如果当前事务存在，把当前事务挂起。
2.4.1 当前事务不存在，创建一个新事务
updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，没有事务；
//@Transactional
public void updateSchool()
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
updateStudent方法更新id为1的age为25，事务传播机制为REQUIRES_NEW，打印1/0，报错；
@Transactional(propagation = Propagation.MANDATORY)
public void updateStudent()
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
System.out.println(1/0);
如上所示：updateSchool方法没有加事务，studentService.updateStudent方法加了事务，而且传播机制是REQUIRES_NEW，如果updateStudent方法新建了事务，打印1/0，报错就会回滚，如果没有新建事务，updateStudent方法就不会回滚；
结果：
1.控制台报错
2.updateSchool方法没有回滚，无事务执行（无事务这个说法其实不准确，任何操作数据库肯定是有事务的）；
3. updateStudent方法回滚（将age改为25）
显然：传播机制为REQUIRES_NEW的，当前没有事务，就新建一个事务，在事务中运行；
2.4.2 新建一个事务，当前事务存在，把当前事务挂起
updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，有事务,打印1/0，报错；
@Transactional
public void updateSchool()
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
System.out.println(1/0);
updateStudent方法更新id为1的age为25，事务传播机制为REQUIRES_NEW；
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void updateStudent()
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
如上所示：updateSchool方法有加事务，studentService.updateStudent方法加了事务，而且传播机制是REQUIRES_NEW，如果updateStudent方法新建了另一个事务，updateSchool报错，updateStudent不会回滚，如果不是新建一个事务而是共用一个事务，就会一起回滚；
结果：
1.控制台报错
2.updateSchool方法回滚（将北京大学刚改为湖南大学）
3. updateStudent没有回滚（将age改为25）
显然：updateStudent新建了另外一个事务，和updateSchool并不是共用一个事务；
总结：传播机制是REQUIRES_NEW，新建一个新事务；如果当前事务存在，把当前事务挂起。
使用场景：被调用方法，不想因为调用方出错而回滚，可以使用REQUIRES_NEW；
2.5 NOT_SUPPORTED
无事务执行，如果当前事务存在，把当前事务挂起。
2.5.1 无事务执行
updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，没有事务,打印1/0，报错；
//@Transactional
public void updateSchool()
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
updateStudent方法更新id为1的age为25，事务传播机制为NOT_SUPPORTED；
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void updateStudent()
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
System.out.println(1/0);
如上所示：updateSchool方法没有事务，studentService.updateStudent方法加了事务，而且传播机制是NOT_SUPPORTED，如果updateStudent没有事务，那么在执行打印1/0报错后，也就不会回滚；
结果：
1.控制台报错
2.updateSchool方法不回滚（将北京大学刚改为湖南大学）
3. updateStudent没有回滚（将age改为25）
显然：两个方法都没有在事务中运行，都没有回滚，所以，如果当前没有事务，NOT_SUPPORTED并不会新建一个事务，也是无事务执行；
2.5.2 如果当前事务存在，把当前事务挂起。
updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，有事务；
@Transactional
public void updateSchool()
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
updateStudent方法更新id为1的age为25，事务传播机制为NOT_SUPPORTED，打印1/0，报错；
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void updateStudent()
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
System.out.println(1/0);
如上所示：updateSchool方法有事务，studentService.updateStudent方法加了事务，而且传播机制是NOT_SUPPORTED，如果updateStudent没有事务，那么在执行打印1/0报错后，也就不会回滚，而updateSchool检测到报错，如果当前事务有效，updateSchool就会回滚；
结果：
1.控制台报错
2.updateSchool方法回滚（将北京大学刚改为湖南大学）
3. updateStudent没有回滚（将age改为25）
显然：当前有事务的情况下，传播机制为NOT_SUPPORTED的方法无事务运行；
总结：事务传播机制为NOT_SUPPORTED，无事务执行，如果当前存在事务，把当前事务挂起；
使用场景：被调用方法想无事务运行，但又不影响调用方的事务，可以用NOT_SUPPORTED；
2.6 NEVER
无事务执行，如果当前有事务则抛出Exception。
这个和MANDATORY就是两个完全相反的极端，一个强制不要事务，一个强制要事务，不满足都会报错；
2.6.1 无事务执行
updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，没有事务；
//@Transactional
public void updateSchool()
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
updateStudent方法更新id为1的age为25，事务传播机制为NEVER，打印1/0，报错；
@Transactional(propagation = Propagation.NEVER)
public void updateStudent()
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
System.out.println(1/0);
如上所示：updateSchool方法没有事务，studentService.updateStudent方法加了事务，而且传播机制是NEVER，打印1/0，会报错，如果updateStudent是无事务执行，那么就不会回滚
结果：
1.控制台报错
2.updateSchool方法不回滚（将北京大学刚改为湖南大学）
3.updateStudent没有回滚（将age改为25）
显然：updateSchool和updateStudent都没有回滚，都是无事务执行，所以，传播机制为NEVER，如果当前没有事务，则无事务执行；
2.6.2 如果当前有事务则抛出Exception
updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，有事务；
@Transactional
public void updateSchool()
School school = new School();
school.setId(1);
school.setName("湖南大学");
school.setLocation("湖南");
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
updateStudent方法更新id为1的age为25，事务传播机制为NEVER；
@Transactional(propagation = Propagation.NEVER)
public void updateStudent()
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
如上所示：updateSchool方法有事务，studentService.updateStudent方法加了事务，而且传播机制是NEVER，当前有事务，就看执行updateStudent方法时到底报不报错；
结果：
1.控制台报错
2.updateSchool方法回滚（将北京大学刚改为湖南大学）
3. updateStudent直接报错
org.springframework.transaction.IllegalTransactionStateException: Existing transaction found for transaction marked with propagation 'never'
显然：传播机制为NEVER，如果当前有事务，则报错；
总结：这种传播机制感觉没啥用途，哈哈，反正我是基本没用过；
2.7 NESTED
嵌套事务，如果当前事务存在，那么在嵌套的事务中执行。如果当前事务不存在，则表现跟REQUIRED一样。
这个直接说，如果父事务回滚，子事务也会跟着回滚；如果子事务回滚，并抛出异常，父事务肯定会跟着回滚；
如果当前没有事务，就和REQUIRED,新建一个事务运行；
关于@Transactional注解的原理和事务传播机制的原理可以看我上一篇文章：
Spring事务传播机制详解
Spring的事务，也就是数据库的事务操作，符合ACID标准，也具有标准的事务隔离级别。
但是Spring事务有自己的特点，也就是事务传播机制。
所谓事务传播机制，也就是在事务在多个方法的调用中是如何传递的，是重新创建事务还是使用父方法的事务？父方法的回滚对子方法的事务是否有影响？这些都是可以通过事务传播机制来决定的。
本文就测试一下这些事务传播机制的使用及异同
1.准备测试方法
主要是创建两个service接口（接口主要是对数据库表的操作），并创建其实现类
1）创建beans.xml，开启事务
<?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: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.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <tx:annotation-driven transaction-manager="transactionManager"/> </beans>
2）创建实体类和表（表创建读者可自定义创建）
@Data @AllArgsConstructor @NoArgsConstructor public class Blog { private int id; private String name; private String ur; }
3）创建service接口（BlogService和BlogService2，主要是对Blog的不同操作）
// BlogService package jdbc; // 主要负责Blog的添加和修改 public interface BlogService { void save(Blog blog); void update(Blog blog); } // BlogService2 package jdbc; // 主要负责Blog的删除 public interface BlogService2 { void delete(int id); }
4）创建其实现类（BlogServiceImpl，BlogService2）
@Transactional(propagation=Propagation.REQUIRED) @Component public class BlogServiceImpl implements BlogService { @Autowired private JdbcTemplate jdbcTemplate; @Autowired private BlogService2 blogService2; @Override public void save(Blog blog) { String sql = "insert into blog values(?,?,?)"; jdbcTemplate.update(sql, new Object[]{blog.getId(),blog.getName(),blog.getUr()}, new int[]{java.sql.Types.INTEGER,java.sql.Types.VARCHAR,java.sql.Types.VARCHAR}); blogService2.delete(16); // update(blog); // throw new RuntimeException("error"); } @Override public void update(Blog blog){ String sql = "update blog set name = ? where id=?"; jdbcTemplate.update(sql, new Object[]{blog.getName(),blog.getId()}, new int[]{java.sql.Types.VARCHAR,java.sql.Types.INTEGER}); } }
BlogService2.java
@Transactional(propagation=Propagation.REQUIRED) @Component public class BlogServiceImpl2 implements BlogService2 { @Autowired private JdbcTemplate jdbcTemplate; @Override public void delete(int id){ String sql = "delete from blog where id=?"; jdbcTemplate.update(sql, id); } }
注意：既然要实现多事务的传播，就需要在一个方法里调用另一个类的方法，下面的测试就是基于这种方法，在BlogService的save()方法中调用BlogService2的delete()方法
5）创建Configuration类，用于创建DataSource实现
@Configuration @ComponentScan(basePackages={"jdbc"})// 扫描BlogService实现类所在的包路径 @ImportResource(locations={"classpath:beans.xml"})// 添加事务管理 public class JdbcConfig { @Bean public JdbcTemplate jdbcTemplate(DataSource dataSource){ return new JdbcTemplate(dataSource); } @Bean public DataSourceTransactionManager transactionManager(DataSource dataSource){ return new DataSourceTransactionManager(dataSource); } @Bean public DataSource dataSource(){ try { return new SimpleDriverDataSource(new com.mysql.jdbc.Driver(), "jdbc:mysql://localhost:3306/test", "root", "root"); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } return null; } }
6）测试
public class Test { public static void main(String[] args) { AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(JdbcConfig.class); BlogService service = ac.getBean(BlogService.class); Blog b = new Blog(18,"lili","url"); service.save(b); } }
总结：大体的测试框架就如上所示，下面的测试修改主要是修改BlogServiceImpl和BlogServiceImpl2的事务传播机制@Transactional(propagation=Propagation.REQUIRED)
3.事务传播机制的测试
1）REQUIRED
定义：如果有事务则加入事务，如果没有事务，则创建一个新的（默认值）
操作1：将BlogServiceImpl和BlogServiceImpl2的事务传播机制都修改为
@Transactional(propagation=Propagation.REQUIRED)
结果1：
操作2：将BlogServiceImpl事务传播机制修改为@Transactional(propagation=Propagation.NOT_SUPPORTED)，BlogServiceImpl2的仍为@Transactional(propagation=Propagation.REQUIRED)
结果2：
总结：
当BlogServiceImpl提供事务的时候，BlogServiceImpl2的方法执行使用当前已有事务，不再新建事务；
当BlogServiceImpl不创建事务的时候，BlogServiceImpl2的方法执行发现没有事务可用，自己新建事务；
2）NOT_SUPPORTED
定义：Spring不为当前方法开启事务，相当于没有事务
操作：将BlogServiceImpl和BlogServiceImpl2的事务传播机制都
修改为@Transactional(propagation=Propagation.NOT_SUPPORTED)
结果：
总结：
NOT_SUPPORTED相当于没有Spring事务，每条执行语句单独执行，单独提交
3）REQUIRES_NEW
定义：不管是否存在事务，都创建一个新的事务，原来的方法挂起，新的方法执行完毕后，继续执行老的事务
操作：将BlogServiceImpl事务传播机制修改为@Transactional(propagation=Propagation.REQUIRED)，BlogServiceImpl2的仍为@Transactional(propagation=Propagation.REQUIRES_NEW)
结果：
总结：
REQUIRES_NEW为当前方法创建一个新的事务，并且当前事务先提交，然后再提交老的事务
4）MANDATORY
定义：必须在一个已有的事务中执行，否则报错
操作：将BlogServiceImpl事务传播机制修改为@Transactional(propagation=Propagation.NOT_SUPPORTED)，BlogServiceImpl2的仍为@Transactional(propagation=Propagation.MANDATORY)，查看是否报错
结果：
总结：
MANDATORY必须在已有事务下被调用，否则报错
NOT_SUPPORTED执行数据库层面的事务操作，故当前测试中，insert方法成功执行，delete方法的抛错并不影响insert方法的执行
5）NEVER
定义：必须在一个没有的事务中执行，否则报错
操作：将BlogServiceImpl事务传播机制修改为@Transactional(propagation=Propagation.REQUIRED)，BlogServiceImpl2的仍为@Transactional(propagation=Propagation.MANDATORY)，查看是否报错
结果：
总结：
NEVER必须在没有事务的方法中执行，否则报错；
save方法开启一个事务，还没来及提交发现delete方法报错，只能回滚事务
6）SUPPORTS
定义：如果其他bean调用这个方法时，其他bean声明了事务，则就用这个事务，如果没有声明事务，那就不用事务
操作1：将BlogServiceImpl事务传播机制修改为@Transactional(propagation=Propagation.REQUIRED)，BlogServiceImpl2的仍为@Transactional(propagation=Propagation.SUPPORTS)
结果1：
操作2：将BlogServiceImpl事务传播机制修改为@Transactional(propagation=Propagation.NOT_SUPPORTED)，BlogServiceImpl2的仍为@Transactional(propagation=Propagation.SUPPORTS)
结果2：
总结：
SUPPORTS类型的事务传播机制，是否使用事务取决于调用方法是否有事务，如果有则直接用，如果没有则不使用事务
7）NESTED
定义：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与REQUIRED类似的操作
操作1：将BlogServiceImpl事务传播机制修改为@Transactional(propagation=Propagation.REQUIRED)，BlogServiceImpl2的仍为@Transactional(propagation=Propagation.NESTED)
结果1：
操作2：将BlogServiceImpl事务传播机制修改为@Transactional(propagation=Propagation.NOT_SUPPORTED)，BlogServiceImpl2的仍为@Transactional(propagation=Propagation.NESTED)
结果2：
总结：
save方法创建一个事务，则再调用delete方法时，直接在该事务的基础上创建一个嵌套事务，本质上还是同一个事务，做一次提交；
save方法不创建事务，则调用delete方法时，直接创建一个新的事务，单独提交
4.注意事项
1）REQUIRED
当两个方法的传播机制都是REQUIRED时，如果一旦发生回滚，两个方法都会回滚
2）REQUIRES_NEW
当delete方法传播机制为REQUIRES_NEW，会开启一个新的事务，并单独提交方法，所以save方法的回滚并不影响delete方法事务提交
3）NESTED
当save方法为REQUIRED，delete方法为NESTED时，delete方法开启一个嵌套事务；
当save方法回滚时，delete方法也会回滚；反之，如果delete方法回滚，则并不影响save方法的提交
以上是关于事务的传播机制的主要内容，如果未能解决你的问题，请参考以下文章