前言
非事务方法的调用对象是代理对象，但是spring 事务机制只查看带有@Transcational注解的方法，所有非事务方法不会以事务方法执行；事务方法的调用对象是原对象，是不会触发通知（事务）的。
Spring事务自调用失效
@Transcational在某些场景下会失效，在实际生产中，这是个要注意的问题。一个类方法A调用该类的方法B，当用代理类执行方法A时，方法A是由代理对象反射完成的，而方法B并不是反射执行的。下面是一个Spring 事务的例子，
public class TestService {
public int insertUsers(List<User> userList) {
System.out.println("insertUsers ...");
int count = 0;
for (User user: userList) {
count += insertUser(user);
}
return count;
}
@Transactional(isolation = Isolation.READ_COMMITED,
propagation = Propogation.REQUIRES_NEW)
public int insertUser(User user) {
System.out.println("insertUser ...");
return 1;
}
}
非事务方法insertUsers中调用的自身类的事务方法insertUser方法，
- 如果执行TestService.insertUser方法，insertUser方法体会走执行spring 事务。
- 如果执行TestService.insertUsers方法，insertUser方法体不会执行spring事务。
原因是，spring会扫描所有添加了@Transcational注解的方法，添加了@Transcational的类的对象都会生成一个代理对象，spring事务会判断代理类执行的方法是否是添加了@Transcational注解的，而非事务方法调用事务方法属于自调用，自调用方法并不是由代理通过反射来执行的，这里来看Spring aop的原理了。
Spring AOP原理
spring aop主要是通过代理类和反射来实现的，主要两个方式：JDK代理和cglib代理。区别在于代理类是否实现了接口，实现了接口一般用JDK实现，没有实现接口一般用cglib实现，这里主要介绍JDK代理原理。
（1）首先定义一个接口类HelloService
public interface HelloService {
void sayHello(String name);
void say(String word);
}
（2）定义一个接口实现类HelloServiceImp，也就是我们要代理的类
public class HelloServiceImp implements HelloService {
@Override
public void sayHello(String name) {
System.out.println("hello " + name);
}
@Override
public void say(String word) {
System.out.println(word);
}
}
（3）定义Interceptor接口
按照spring aop的切面来定义，分为五种
- before：前置通知
- after：后置通知
- around：环绕通知
- afterReturn：正常返回通知
- afterThrow：异常返回通知
public interface Interceptor {
boolean before();
void after();
Object around(Invocation invocation)
throws InvocationTargetException, IllegalAccessException;
void afterReturning();
void afterThrowing();
}
（4）定义Interceptor实现类
Invocation类是反射执行方法，定义见（5）Invocation
public class MyInterceptor implements Interceptor {
@Override
public boolean before() {
System.out.println("before ...");
return true;
}
@Override
public void after() {
System.out.println("after ...");
}
/**
*
* @param invocation 反射执行方法，定义见下Invocation类
* @return
* @throws InvocationTargetException
* @throws IllegalAccessException
*/
@Override
public Object around(Invocation invocation)
throws InvocationTargetException, IllegalAccessException {
System.out.println("around before ...");
Object obj = invocation.proceed();//反射执行方法
System.out.println("around after ...");
return obj;
}
@Override
public void afterReturning() {
System.out.println("afterReturning ...");
}
@Override
public void afterThrowing() {
System.out.println("afterThrowing ...");
}
}
（5）定义Invocation，用于反射执行方法
public class Invocation {
private Object[] params;//代理方法参数
private Method method;//代理方法
private Object target;//代理对象
public Invocation(Object target, Method method, Object[] params) {
this.target = target;
this.method = method;
this.params = params;
}
public Object proceed()
throws InvocationTargetException, IllegalAccessException {
//反射执行方法
return method.invoke(target, params);
}
}
（4）代理类ProxyBean
代理类的实现主要两个jdk类：Proxy类和InvacationHandler接口
先通过InvocationHandler接口的invoke方法来定义（反射方法执行和各种aop通知）
再通过Proxy.newProxyInstance方法传入InvocationHandler对象获取代理对象。这样代理对象就会执行被代理对象的方法，同时还能在代理时发出aop（5种）通知。
public class ProxyBean implements InvocationHandler {
private Object target = null;
private Interceptor interceptor = null;
public static Object getProxyBean(Object target, Interceptor interceptor) {
ProxyBean proxyBean = new ProxyBean();
proxyBean.target = target;
proxyBean.interceptor = interceptor;
Object proxy = Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), proxyBean);
return proxy;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("通过代理对象执行方法：" + method.getName());
boolean exceptionFlag = false;
Invocation invocation = new Invocation(target, method, args);
Object retObj = null;
try {
if (this.interceptor.before()) {
retObj = this.interceptor.around(invocation);
} else {
retObj = method.invoke(target, args);
}
} catch (Exception e) {
exceptionFlag = true;
}
this.interceptor.after();
if (exceptionFlag) {
this.interceptor.afterThrowing();
} else {
this.interceptor.afterReturning();
return retObj;//正常返回
}
return null;//异常返回
}
}
（4）测试
public class Test {
public static void main(String[] args) {
HelloService helloService = new HelloServiceImp();
HelloService proxy = (HelloService) ProxyBean.getProxyBean(helloService,
new MyInterceptor());
proxy.sayHello("Hinson");
}
}
结果：
通过代理对象执行方法：sayHello
before ...
around before ...
hello Hinson
around after ...
after ...
afterReturning ...
这就是spring aop的原理，如果在HelloServiceImp中的sayHello方法调用say方法，那么say方法是由代理对象来执行的，还是由原对象执行的呢？
HelloServiceImp修改如下
public class HelloServiceImp implements HelloService {
@Override
public void sayHello(String name) {
// System.out.println("hello " + name);
say("hello " + name);
}
@Override
public void say(String word) {
System.out.println(word);
}
}
执行结果：
通过代理对象执行方法：sayHello
before ...
around before ...
hello Hinson
around after ...
after ...
afterReturning ...
自调用方法，调用类是原对象，而aop中只有调用类是代理对象时，才能出发各种通知，spring 事务就是基于通知来实现的。所以spring非事务方法调用事务方法过程中，非事务方法的调用对象是代理对象，但是spring 事务机制只查看带有@Transcational注解的方法，所有非事务方法不会以事务方法执行；事务方法的调用对象是原对象，是不会触发通知（事务）的。
其他
本人也是在慢慢学习中，如有错误还请原谅、敬请指出，谢谢！
