注解@Transactional原理分析以及常见的坑_Java

这篇文章，会先讲述 @transactional 的 4 种不生效的 case，然后再通过源码解读，分析 @transactional 的执行原理，以及部分 case 不生效的真正原因

1项目准备

下面是 db 数据和 db 操作接口：

uid	uname	usex
1	张三	女
2	陈恒	男
3	楼仔	男

// 提供的接口
public interface userdao {
    // select * from user_test where uid = "#{uid}"
    public myuser selectuserbyid(integer uid);
    // update user_test set uname =#{uname},usex = #{usex} where uid = #{uid}
    public int updateuser(myuser user);
}

基础测试代码，testsuccess() 是事务生效的情况：

@service
public class usercontroller {
    @autowired
    private userdao userdao;

    public void update(integer id) {
        myuser user = new myuser();
        user.setuid(id);
        user.setuname("张三-testing");
        user.setusex("女");
        userdao.updateuser(user);
    }

    public myuser query(integer id) {
        myuser user = userdao.selectuserbyid(id);
        return user;
    }

    // 正常情况
    @transactional(rollbackfor = exception.class)
    public void testsuccess() throws exception {
        integer id = 1;
        myuser user = query(id);
        system.out.println("原记录:" + user);
        update(id);
        throw new exception("事务生效");
    }
}

2事务不生效的几种 case

主要讲解 4 种事务不生效的 case：

类内部访问：a 类的 a1 方法没有标注 @transactional，a2 方法标注 @transactional，在 a1 里面调用 a2；
私有方法：将 @transactional 注解标注在非 public 方法上；
异常不匹配：@transactional 未设置 rollbackfor 属性，方法返回 exception 等异常；
多线程：主线程和子线程的调用，线程抛出异常。

2.1 类内部访问会导致事务不生效

我们在类 usercontroller 中新增一个方法 testinteralcall()：

public void testinteralcall() throws exception {
    testsuccess();
    throw new exception("事务不生效：类内部访问");
}

这里 testinteralcall() 没有标注 @transactional，我们再看一下测试用例：

public static void main(string[] args) throws exception {
    applicationcontext applicationcontext = new classpathxmlapplicationcontext("applicationcontext.xml");
    usercontroller uc = (usercontroller) applicationcontext.getbean("usercontroller");
    try {
        uc.testinteralcall();
    } finally {
        myuser user =  uc.query(1);
        system.out.println("修改后的记录:" + user);
    }
}
// 输出：
// 原记录:myuser(uid=1, uname=张三, usex=女)
// 修改后的记录:myuser(uid=1, uname=张三-testing, usex=女)

从上面的输出可以看到，事务并没有回滚，这个是什么原因呢？

因为 @transactional 的工作机制是基于 aop 实现，aop 是使用动态代理实现的，如果通过代理直接调用 testsuccess()，通过 aop 会前后进行增强，增强的逻辑其实就是在 testsuccess() 的前后分别加上开启、提交事务的逻辑，后面的源码会进行剖析。

现在是通过 testinteralcall() 去调用 testsuccess()，testsuccess() 前后不会进行任何增强操作，也就是类内部调用，不会通过代理方式访问。

2.2 私有方法也会导致事务失效

在私有方法上，添加 @transactional 注解也不会生效：

@transactional(rollbackfor = exception.class)
private void testpirvatemethod() throws exception {
    integer id = 1;
    myuser user = query(id);
    system.out.println("原记录:" + user);
    update(id);
    throw new exception("测试事务生效");
}

直接使用时，下面这种场景不太容易出现，因为 idea 会有提醒，文案为: methods annotated with '@transactional' must be overridable，至于深层次的原理，源码部分会进行解读。

2.3 异常不匹配也会导致事务失效

这里的 @transactional 没有设置 rollbackfor = exception.class 属性：

@transactional
public void testexceptionnotmatch() throws exception {
    integer id = 1;
    myuser user = query(id);
    system.out.println("原记录:" + user);
    update(id);
    throw new exception("事务不生效：异常不匹配");
}

public static void main(string[] args) throws exception {
    applicationcontext applicationcontext = new classpathxmlapplicationcontext("applicationcontext.xml");
    usercontroller uc = (usercontroller) applicationcontext.getbean("usercontroller");
    try {
        uc.testsuccess();
    } finally {
        myuser user =  uc.query(1);
        system.out.println("修改后的记录:" + user);
    }
}

// 输出：
// 原记录:user[uid=1,uname=张三,usex=女]
// 修改后的记录:user[uid=1,uname=张三-test,usex=女]

@transactional 注解默认处理运行时异常，即只有抛出运行时异常时，才会触发事务回滚，否则并不会回滚，至于深层次的原理，源码部分会进行解读。

2.4 多线程也会导致事务失效

下面给出两个不同的姿势，一个是子线程抛异常，主线程 ok；一个是子线程 ok，主线程抛异常。

父线程抛出异常

父线程抛出异常，子线程不抛出异常：

public void testsuccess() throws exception {
    integer id = 1;
    myuser user = query(id);
    system.out.println("原记录:" + user);
    update(id);
}
@transactional(rollbackfor = exception.class)
public void testmultthread() throws exception {
    new thread(new runnable() {
        @sneakythrows
        @override
        public void run() {
            testsuccess();
        }
    }).start();
    throw new exception("测试事务不生效");
}

父线程抛出线程，事务回滚，因为子线程是独立存在，和父线程不在同一个事务中，所以子线程的修改并不会被回滚，

子线程抛出异常

父线程不抛出异常，子线程抛出异常：

public void testsuccess() throws exception {
    integer id = 1;
    myuser user = query(id);
    system.out.println("原记录:" + user);
    update(id);
    throw new exception("测试事务不生效");
}
@transactional(rollbackfor = exception.class)
public void testmultthread() throws exception {
    new thread(new runnable() {
        @sneakythrows
        @override
        public void run() {
            testsuccess();
        }
    }).start();
}

由于子线程的异常不会被外部的线程捕获，所以父线程不抛异常，事务回滚没有生效。