事务原理

开启事务有两种方式，可以通过在代码里加上开启事务的代码，叫编程式事务。
还可以通过加@Transactional注解来开启事务，叫声明式事务，比较常用。

那为什么加上@Transactional就可以开启事务了呢？这么强大的。

其实它主要依靠于java的动态代理实现的，java动态代理有两种，分别式jdk动态代理和CGLib动态代理。

• 什么是代理？
  代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.

例如：春运的时候我们通过车票代售点或者黄牛去买票，其中车票代售点或者黄牛就可以算是售票大厅的代理，他们有什么特点呢？
1.代售点卖的也是售票大厅的票，它自己是没有票的，它只是行使售票大厅的权利
2.它可以有属于自己的行为特征，比如不需要排队啊，每张硬座票收5元手续费啊等等。

image.png

• 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看看

image.png

我们找到TransactionInterceptor 类，里面有一个方法invoke,

image.png
跟进去invokeWithinTransaction方法看看，此方法正式对我们的方法织入事务的代码。（源码有空再看看了）
image.png

假如有个接口，它包含两个方法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方法上的事务注解才起作用。而且必须在代理类外部调用才行，如果直接在目标类里面调用，事务照样不起作用。