事务的应用

/**
     * 学习spring事务,
     * 场景一：parent()  和child() 都具有事务，同时调用两个，如果不出现异常，都是可以插入到数据库中的。
     */
    @Transactional
    public void parent1(){
        User parent = new User("parent",19,BigDecimal.valueOf(1000));
        userMapper.insert(parent);
    }
    @Transactional
    public void child1(){
        User child = new User("child",19,BigDecimal.valueOf(1000));
        userMapper.insert(child);
    }

测试：

@Test
    public void test05(){
        userService.parent1();
        userService.child1();
    }

是没有任何问题的。可以插入到数据库中

场景二：parent()  中使用child()

 /**
     * 学习spring事务,
     * 场景二：parent()中调用child()
     */
    @Transactional
    public void parent2(){
        User parent = new User("parent",19,BigDecimal.valueOf(1000));
        userMapper.insert(parent);
        child2();
    }

    /**
     * 如果当前存在事务，则挂起当前事务并且开启一个新事物继续执行，新事物执行完毕之后，
     * 然后在缓刑之前挂起的事务，如果当前不存在事务的话，则开启一个新事物。
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void child2(){
        User child = new User("child",19,BigDecimal.valueOf(1000));
        userMapper.insert(child);
    }

测试：

@Test
    public void test06(){
        userService.parent2();
       // userService.child2();
    }

也能插入，没有任何问题。

场景三：child()这个事务 中抛出了异常

@Transactional
    public void parent3(){
        User parent = new User("parent",19,BigDecimal.valueOf(1000));
        userMapper.insert(parent);
        child3();
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void child3(){
        User child = new User("child",19,BigDecimal.valueOf(1000));
        userMapper.insert(child);
        throw new RuntimeException("此处抛出了异常");
    }

测试：

@Test
    public void test06(){
        userService.parent3();
    }

两个都没有插入到数据库中。

疑问1：场景C中child（）抛出了异常，但是parent（）没有抛出异常，按道理是不是应该parent（）提交成功而child（）回滚？

可能有的小伙伴要说了，child（）抛出了异常在parent（）没有进行捕获，造成了parent（）也是抛出了异常了的！所以他们两个都会回滚！

场景四：在parent()中捕获异常

 @Transactional
    public void parent4(){
        User parent = new User("parent",19,BigDecimal.valueOf(1000));
        userMapper.insert(parent);

        try {
            child4();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void child4(){
        User child = new User("child",19,BigDecimal.valueOf(1000));
        userMapper.insert(child);
        throw new RuntimeException("此处抛出了异常");
    }

测试：

两个都插入到数据库中了。

看到这里很多小伙伴都可能会问，按照我们的逻辑来想的话child（）中抛出了异常，parent（）没有抛出并且捕获了child（）抛出了异常！执行的结果应该是child（）回滚，parent（）提交成功的啊！

问题的本质。

Spring事务管理是通过JDK动态代理的方式进行实现的（另一种是使用CGLib动态代理实现的），也正是因为动态代理的特性造成了上述parent（）方法调用child（）方法的时候造成了child（）方法中的事务失效！简单的来说，在场景四中parent（）方法调用child（）方法的时候，child（）方法的事务是不起作用的，此时的child（）方法像一个没有加事务的普通方法，其本质上就相当于下边的代码：

@Transactional
    public void parent3(){
        User parent = new User("parent",19,BigDecimal.valueOf(1000));
        userMapper.insert(parent);
        User child = new User("child",19,BigDecimal.valueOf(1000));
        userMapper.insert(child);
        throw new RuntimeException("此处抛出了异常");
       // child3();
    }

场景4本质：

@Transactional
    public void parent4(){
        User parent = new User("parent",19,BigDecimal.valueOf(1000));
        userMapper.insert(parent);

        try {
            User child = new User("child",19,BigDecimal.valueOf(1000));
            userMapper.insert(child);
            throw new RuntimeException("此处抛出了异常");
            //child4();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

因为动态代理的特性造成了场景C和场景D的本质如上述代码。在场景C中，child（）抛出异常没有捕获，相当于parent事务中抛出了异常，造成parent（）一起回滚，因为他们本质是同一个方法；在场景D中，child（）抛出异常并进行了捕获，parent事务中没有抛出异常，parent（）和child（）同时在一个事务里边，所以他们都成功了；

动态代理是什么？为什么会使spring事务失效呢？

接口：

public interface OrderService {
    void test01();
    void test02();
}

package com.demo.proxy;

public class OrderServiceImpl implements OrderService {
    @Override
    public void test01() {
        System.out.println("===执行test01");
    }

    @Override
    public void test02() {
        System.out.println("===执行test02");
    }
}

代理类：

package com.demo.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class OrderProxy implements InvocationHandler {

    private Object target;

    public OrderProxy(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (method.getName().startsWith("test")) {
            System.out.println("===使用了动态代理");
        }
        return method.invoke(target,args);
    }

    public Object getProxy(){
        return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                target.getClass().getInterfaces(), this);
    }
}

测试：

package com.demo.proxy;

public class Test {
    public static void main(String[] args) {
        OrderService orderService = new OrderServiceImpl();
        OrderProxy orderProxy = new OrderProxy(orderService);
         orderService = (OrderService)orderProxy.getProxy();
         orderService.test01();
         orderService.test02();
    }
}

输出：

我们模拟一下场景C和场景D在test1(）中调用test2（）

 @Override
    public void test01() {
        System.out.println("===执行test01");
        test02();
    }

输出:

根本就没有走动态代理，而是一个普通的test02()方法。

只有代理对象proxy 直接调用的那一个方法才是真正的走代理的

解决方案：

通过AopProxy上下文获取代理对象：

（1）SpringBoot配置方式：注解开启 exposeProxy = true，暴露代理对象 (否则AopContext.currentProxy()) 会抛出异常。

@SpringBootApplication
@MapperScan(value = "com.demo.mapper")
@EnableAspectJAutoProxy(exposeProxy = true)
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

要添加jar包

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

修改方法parent()

/**
     * 利用AopContext 上下文获取代理对象
     */
    @Transactional
    public void parent5(){
        User parent = new User("parent",19,BigDecimal.valueOf(1000));
        userMapper.insert(parent);

        try {
            ((UserServiceImpl)AopContext.currentProxy()).child4();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

这个时候，child()有异常，回滚，parent()没有异常，执行。