一、多个事务方法相互调用时，事务如何在这些方法间传播

方法A是一个事务的方法，方法A执行过程中调用了方法B，那么方法B有无事务以及方法B对事务的要求不同都会对方法A的事务具体执行造成影响，同时方法A的事务对方法B的事务执行也有影响，这种影响具体是什么就由两个方法所定义的事务传播类型所决定。

REQUIRED（Spring默认的事务传播类型）：如果当前没有事务，则自己新建一个事务，如果当前存在事务，则加入这个事务。举例说明:如果方法A所在的方法里面的sql没有事务，那么就会与方法B里面的sql事务放在一起，要么同时成功，要么同时失败。如果方法A所在的方法里面的sql有事务，那么方法B所在的方法里面的sql就会加入方法A的sql的事务，要么同时成功，要么同时失败。

SUPPORTS:当前存在事务，则加入当前事务，如果当前没有事务，就以非事务方法执行。举例说明:如果方法A所在的方法里面的sql有事务，那么方法B里面的sql则会加入方法A的事务，要么同时成功，要么同时失败。如果方法A所在的方法里面的sql没有事务，那么方法B所在的方法里面的sql就会以非事务运行。

MANDATORY:当前存在事务，则加入当前事务，如果当前事务不存在，则抛出异常。举例说明:如果方法A所在的方法里面的sql有事务，那么方法B里面的sql则会加入方法A的事务，要么同时成功，要么同时失败。如果方法A所在的方法里面的sql没有事务，那么方法B所在的方法就会抛出异常。

REQUIRES_NEW:创建一个新事物，如果存在当前事务，则挂起该事务。举例说明:如果方法A所在的方法里面的sql有事务，同时方法B所在的方法里面的sql也有事务，那么先执行方法A里面的事务，再去执行方法B里面的事务。这种情况下，A事务回滚就只是回滚A自己的事务，B亦是如此。

NOT_SUPPORTED:以非事务方式执行，如果当前存在事务，则挂起当前事务。举例说明:如果方法A所在的方法里面的sql有事务，那么方法A里面的sql单独在事务里执行，方法B里面的sql一定是以非事务运行。如果方法A里面的sql没有事务，那么方法A与方法B里面的sql都是以非事务方式执行。

NEVER:不使用事务，如果当前事务存在，则抛出异常。

NESTED:如果当前事务存在，则在嵌套事务中执行，否则REQUIRED的操作一样（开启一个事务）。举例说明:如果方法A所在的sql有事务，那么方法B所在的sql则会嵌套在方法A的事务中执行。

NESTED和REQUIRES_NEW的区别:REQUIRES_NEW是新建一个事务并且新开启的这个事务与原事务无关，而NESTED则是当前存在事务时（我们把当前事务称之为父事务）会开启一个嵌套事务（称之为一个子事务）。在NESTED情况下父事务回滚时，子事务也会回滚，而在REQUIRES_NEW的情况下，原有事务回滚，不会影响新开启的事务。

二、关于spring的事务传播特性

1、why
为什么会有事务传播机制？

场景一： serviceA 方法调用了 serviceB 方法，但两个方法都有事务，这个时候如果 serviceB 方法异常，是让 serviceB 方法提交，还是两个一起回滚。场景二：serviceA 方法调用了 serviceB 方法，但是只有 serviceA 方法加了事务，是否把 serviceB 也加入 serviceA 的事务，如果 serviceB 异常，是否回滚 serviceA 。场景三：serviceA 方法调用了 serviceB 方法，两者都有事务，serviceB 已经正常执行完，但 serviceA 异常，是否需要回滚 serviceB 的数据。
所以，我们需要有对应的事务传播机制来控制事务。

2、传播机制生效的条件
有了spring事务传播机制，那这种机制存在的条件呢？我们知道，spring的事务是基于aop的，确切来说，是基于JDK动态代理的AOP，这种AOP有什么特点呢？ 它是基于类或者接口的，也就是说，当 @Transactional写在一个方法上时，这个方法将会被spring动态代理， 生成一个动态代理类， 对原方法进行修饰增强，但是要注意！！ 原先的方法的类并没有什么不同，并没有事务，spring动态代理这个类生成的代理类才有事务，才有增强，也就是说，在同一个类里面通过this.xx()调用本类的事务方法时，事务是不会生效的，因为你调用的不是代理类。

1
2
3
4
5
6
7
8
9
10
@Transactional 
@Override 
public void method1() { this.method2(); }

 @Transactional(propagation = Propagation.REQUIRES_NEW) 
@Override 
public void method2() { 
xx 
}

解决方案：

关键在于获取类的代理对象，而不是通过this去调用，所以以下方法都是基于这个关键点去解决的。

1、最简单的，两个事务方法放在不同的service里面，这个比较简单，就不给例子了。（推荐）

2、AOP上下文。spring提供了AOP上下文AopContext，因此通过AopContext，可以很方便的获取到代理对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Myservice{ 

	@Transactional 
	@Override 
	public void method1() { 
		((Myservice)AopContext.currentProxy()).method2(); 
	} 

	@Transactional(propagation = Propagation.REQUIRES_NEW) 
	@Override 
	public void method2() { 
		xx 
	}
}

一运行，报错了，因为exposeProxy默认为false，我们要暴露代理类，就要设置为true，可以在springboot启动类上加一个注解

@EnableAspectJAutoProxy(exposeProxy = true)
3、ApplicationContext。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Myservice{ 
	@Autowired 
	ApplicationContext context; 

	Myservice service; 

	@PostConstruct //初始化时调用，不加也行 
	private void 	getMyservice() { 
		service = context.getBean(Myservice.class); 
	} 

	@Transactional 
	@Override 
	public void method1() { 
		service.method2(); 
	} 

	@Transactional(propagation = Propagation.REQUIRES_NEW) 
	@Override 
	public void method2() { 
		xx 
	}
}

第二和第三种的区别就在于，2是直接获取代理类，3是通过调用getBean间接获取代理类，总的来说，第一种是最方便的，也是最推荐的做法。

3、传播机制类型
下面的类型都是针对于被调用方法来说的，理解起来要想象成两个 service 方法的调用才可以。

PROPAGATION_REQUIRED: (默认) 支持当前事务，如果当前没有事务，则新建事务如果当前存在事务，则加入当前事务，合并成一个事务
REQUIRES_NEW: （一般用在子方法需要单独事务） 新建事务，如果当前存在事务，则把当前事务挂起这个方法会独立提交事务，不受调用者的事务影响，父级异常，它也是正常提交
（上面两个类型是常用的，下面的比较少用）

NESTED: 如果当前存在事务，它将会成为父级事务的一个子事务，方法结束后并没有提交，只有等父事务结束才提交,如果当前没有事务，则新建事务如果它异常，父级可以捕获它的异常而不进行回滚，正常提交,但如果父级异常，它必然回滚，这就是和 REQUIRES_NEW 的区别
SUPPORTS: 如果当前存在事务，则加入事务如果当前不存在事务，则以非事务方式运行，这个和不写没区别
NOT_SUPPORTED: 以非事务方式运行如果当前存在事务，则把当前事务挂起
MANDATORY: 如果当前存在事务，则运行在当前事务中如果当前无事务，则抛出异常，也即父级方法必须有事务
NEVER: 以非事务方式运行，如果当前存在事务，则抛出异常，即父级方法必须无事务