事务原理
开启事务有两种方式，可以通过在代码里加上开启事务的代码，叫编程式事务。
还可以通过加@Transactional注解来开启事务，叫声明式事务，比较常用。
那为什么加上@Transactional就可以开启事务了呢？这么强大的。
其实它主要依靠于java的动态代理实现的，java动态代理有两种，分别式jdk动态代理和CGLib动态代理。
- 什么是代理？
代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.
例如：春运的时候我们通过车票代售点或者黄牛去买票，其中车票代售点或者黄牛就可以算是售票大厅的代理，他们有什么特点呢？
1.代售点卖的也是售票大厅的票，它自己是没有票的，它只是行使售票大厅的权利
2.它可以有属于自己的行为特征，比如不需要排队啊，每张硬座票收5元手续费啊等等。
- jdk动态代理和CGLib分别用在什么情况下？
JDK动态代理只能用于带接口的，CGLIB则带不带接口都行 - 下面看看怎么用代码实现动态代理
jdk动态代理实现
--接口类
public interface User {
public String say();
public String doSomething();
}
--接口实现类
public class UserImpl implements User{
@Override
public String say() {
System.out.println("user-------say-------");
doSomething();
return "1111";
}
@Override
public String doSomething() {
System.out.println("user---------doSomething--------");
return "22222";
}
}
--代理类
--实现InvocationHandler 接口
public class UserDynamicProxy implements InvocationHandler {
private Object target;
public UserDynamicProxy(Object target){
this.target=target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//方法调用前的处理事情
System.out.println("before Proxy ------------");
method.invoke(target,args);
//方法调用后的处理事情
System.out.println(" after Proxy ---------------");
return null;
}
public Object getInstance(){
//获取动态代理类
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
}
--动态代理测试类
public class ProxyTest {
public static void main(String[] args) {
User user=new UserImpl();
UserDynamicProxy proxy=new UserDynamicProxy(user);
User userproxy=(User) proxy.getInstance();
userproxy.doSomething();
userproxy.say();
}
}
//打印结果
before Proxy ------------
user---------doSomething--------
after Proxy ---------------
before Proxy ------------
user-------say-------
after Proxy ---------------
CGLib动态代理实现
--user接口和实现类同上
--代理类 实现MethodInterceptor接口
public class CglibProxy implements MethodInterceptor {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("before------------");
//注意，这里是调用invokeSuper,不是invoke
Object result =methodProxy.invokeSuper(o,objects);
System.out.println("after---------");
return result;
}
public Object getProxy(Class clazz){
return Enhancer.create(clazz,this);
}
}
--测试类
public class CglibTest {
public static void main(String[] args) {
CglibProxy cglibProxy=new CglibProxy();
User user=(User)cglibProxy.getProxy(UserImpl.class);
user.doSomething();
user.say();
}
}
spring的事务注解就是利用动态代理技术实现的，通过在代理类加上事务的处理，来达到开启事务的效果，我们通过源码来看看
我们看service,确实是生成了代理类，而且是Cglib动态代理类，我们进去CglibAopProxy看看
我们找到TransactionInterceptor 类，里面有一个方法invoke,
跟进去invokeWithinTransaction方法看看，此方法正式对我们的方法织入事务的代码。（源码有空再看看了）
假如有个接口，它包含两个方法a和b，然后有一个类实现了该接口。在该实现类里在a上标上事务注解、b上不标，此时事务是怎样的？
@Override
//@Transactional
public String save(String value,String exFlag) {
Demo demo = new Demo();
demo.setGroupId("111");
demo.setDemoField(value);
demo.setCreateTime(new Date());
demo.setAppName("ffxxbb1");
demoMapper.save(demo);
save2(value);
// if(Objects.nonNull(exFlag)){
// throw new RuntimeException("异常");
// }
return "success";
}
@Transactional
public String save2(String value) {
Test test=new Test();
test.setName("ffxxbb");
testMapper.save(test);
if(1==1){
throw new RuntimeException("异常");
}
return null;
}
按道理我们在save2上加了事务的注解，应该在出现异常的时候，会回滚业务的，可是结果却跟我们想的不一样，结果两张表都插入数据了。
我们在分析一下，我们的代理肯定是为有注解的类生成了代理，即save2是由代理增强的，有事务处理的，而save1是没有的，我们在controller调用save方法，会先通过代理类，执行事务的处理逻辑，然后进到我们的实现方法调用save,此时上下文是在我们的实现类，调用save2,所以跟save2时候有注解没关系了，因为他调用的不是代理类的save2方法了，所以事务是没效果的。
可以通过获取代理类，调用save2方法
@Override
//@Transactional
public String save(String value,String exFlag) {
Demo demo = new Demo();
demo.setGroupId("111");
demo.setDemoField(value);
demo.setCreateTime(new Date());
demo.setAppName("ffxxbb1");
demoMapper.save(demo);
//获取代理类
DemoService dempproxy=(DemoServiceImpl)AopContext.currentProxy();
dempproxy.save2(value);
// save2(value);
// if(Objects.nonNull(exFlag)){
// throw new RuntimeException("异常");
// }
return "success";
}
要在类上加上注解
@EnableAspectJAutoProxy(proxyTargetClass = true, exposeProxy = true)
这样save2就是有事务的了，异常后会回滚。
事务是由代理加进去的，所以关键就是代理如何生成。按照上面所说的代理应该具备的特点来看，只能通过继承的方式生成一个子类来充当代理.
所以，private方法不能被继承，final方法不能被重写，static方法和继承不相干，所以它们3个的事务不起作用，Spring选择让protected方法和package方法不支持事务
所以，只有public方法支持事务。
总结
只要是以代理方式实现的声明式事务，无论是JDK动态代理，还是CGLIB直接写字节码生成代理，都只有public方法上的事务注解才起作用。而且必须在代理类外部调用才行，如果直接在目标类里面调用，事务照样不起作用。
