@Transaction注解哪些情况下会失效

最新推荐文章于 2025-03-11 08:59:06 发布

原创最新推荐文章于 2025-03-11 08:59:06 发布 · 1.1k 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#spring #java

文章详细阐述了Spring的@Transactional注解的使用规则，包括只能作用于public方法，若需应用于非public方法需启用AspectJ代理。同时，讨论了在同一类内部方法间调用时事务生效的情况，指出必须通过代理调用有事务注解的方法才能启动事务。还提到了异常处理与事务回滚的关系，以及方法中明确抛出异常对事务的影响。

@Transtaction注解是Spring提供的注解，那自然你在加上注解的类或方法上要被spring代理。

一、首先@Transtaction注解只能作用在public的方法或者类上，如果你的类或者方法是protected或者其他，虽然都不报错，但是注解都不生效。

如下，@Transaction注解是不会生效的,因为他的修饰符不是public

@Override
    @Transactional
    protected boolean a(){
        System.out.println("开始调用b方法了");
        b();
        System.out.println("b方法完成了");
        return false;
    }

注意：@Transactional 只能用于public 的方法上，否则事务会失效，如果要用在非 public 方法上，可以开启AspectJ 代理模式

二、现有a方法和b方法，首先他们在同一个类中，并且都被spring所管理

问此时，在a方法上和b方法上都加上了@Transtaction注解，事务是否会会回滚。我们执行的是a方法。

    @Transactional
    public boolean a(){
        System.out.println("开始调用b方法了");
        b();
        System.out.println("b方法完成了");
        return false;
    }

    @Transactional
    public int b() {
        System.out.println("进入b方法了");
        User user = new User();
        user.setPhone("12314");
        System.out.println("开始insert了");
        userMapper.insert(user);
        int i = 1/0;

        return 1;
    }

答案是会会回滚。

三、同样是上面的场景

但是a上不加@Transtaction注解，异常不管是在a方法出现还是b方法出现，事务都不会生效.

场景如下:

    @Override
    public boolean a(){
        System.out.println("开始调用b方法了");
        b();
        System.out.println("b方法完成了");
        return false;
    }

    @Override
    @Transactional
    public int b() {
        System.out.println("进入b方法了");
        User user = new User();
        user.setPhone("12314");
        System.out.println("开始insert了");
        userMapper.insert(user);
        int i = 1/0;               

        return 1;
    }

原因如下:

spring 在扫描bean的时候会扫描方法上是否包含@Transactional 事务注解，如果包含，则 spring会为这个bean动态地生成一个子类（即代理类，proxy），代理类是继承原来那个bean 。

当这个有事务注解的方法被调用的时候，实际上是由代理类来调用的，代理类在调用之前就会开启事务（transaction）。

但是，如果先调用一个没有事务的方法，然通这个方法再去有事务，由于该方法的调用并没有通过代理类，而是直接通过原来的那个bean，所以就不会启动transaction，我们看到的现象就是 @Transactional 注解无效。

四、现有a方法和b方法，首先他们在同一个类中，并且都被spring所管理

a方法和b方法上都加上@Transaction，但是我们异常在b中被捕获或者在a中被捕获，事务都不会生效。但是你不在a方法或者b方法中捕获，你只在调用a方法的地方捕获异常，异常会回滚.

如下：

@Override
    @Transactional
    public boolean a(){
        System.out.println("开始调用b方法了");
        b();
        System.out.println("b方法完成了");
        return false;
    }

    @Override
    @Transactional
    public int b() {
        System.out.println("进入b方法了");
        User user = new User();
        user.setPhone("12314");
        System.out.println("开始insert了");
        userMapper.insert(user);
//        int i = 1/0;
        try {
            int i = 1/0;
        }catch (Exception e){
            e.printStackTrace();
        }

        return 1;
    }

但是你只是在controller调用这段代码，事务会回滚。

如下:

@Override
    @Transactional
    public boolean a(){
        System.out.println("开始调用b方法了");
        b();
        System.out.println("b方法完成了");
        return false;
    }

    @Override
    @Transactional
    public int b() {
        System.out.println("进入b方法了");
        User user = new User();
        user.setPhone("12314");
        System.out.println("开始insert了");
        userMapper.insert(user);
        int i = 1/0;

        return 1;
    }


调用 a的地方
@Test
    public void test111() {
        try {
            userService.a();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

五、在方法上throws 抛出异常，事务依旧会回滚

@Override
    @Transactional
    public boolean a() throws  Exception{
        System.out.println("开始调用b方法了");
        b();
        System.out.println("b方法完成了");
        return false;
    }

    @Override
    @Transactional
    public int b() throws  Exception{
        System.out.println("进入b方法了");
        User user = new User();
        user.setPhone("12314");
        System.out.println("开始insert了");
        userMapper.insert(user);
        int i = 1/0;


        return 1;
    }


     @Test
    public void test111() throws Exception {
        userService.a();
    }

简单总结:

首先@Transaction注解作用的方法上，必须要要被spring代理，@Transaction注解只能作用在public方法上，如果硬要作用在非public方法上，可以使用Aspect J 代理。