Spring @Transactional注解失效的情况及解决方法

最新推荐文章于 2024-05-13 14:06:19 发布

一叶飘零_sweeeet

最新推荐文章于 2024-05-13 14:06:19 发布

阅读量5.5k

点赞数 2

分类专栏： java 文章标签： spring java 后端

本文链接：https://blog.csdn.net/jam_yin/article/details/131393727

版权

java 专栏收录该内容

189 篇文章 4 订阅

订阅专栏

Spring框架中的@Transactional注解是非常常用的注解，它可以将一个方法标记为事务性方法，使得在方法执行过程中发生异常时，可以自动回滚事务，保证数据的一致性。然而，在某些情况下，@Transactional注解可能会失效，本文将会介绍这些情况及其解决方法。

一、@Transactional注解的原理

在介绍@Transactional注解失效的情况之前，我们先来了解一下@Transactional注解的原理。

@Transactional注解的实现是基于Spring框架中的AOP（面向切面编程）机制，它通过代理模式在运行时动态地为标记了@Transactional注解的方法生成一个代理对象，这个代理对象会拦截方法的调用，并在方法执行前后开启和提交事务。

具体来说，当一个标记了@Transactional注解的方法被调用时，Spring框架会在运行时为这个方法生成一个代理对象，这个代理对象会在方法执行前开启一个新的事务，并将这个事务与当前线程绑定。当方法执行完成后，代理对象会根据方法的执行结果决定是提交事务还是回滚事务，并将事务与当前线程解绑。

需要注意的是，@Transactional注解只对public方法有效，对于private、protected或者默认访问级别的方法是不起作用的。

二、@Transactional注解失效的情况

虽然@Transactional注解是非常方便的，但是在某些情况下，它可能会失效。下面我们将介绍一些常见的情况。

1. 方法内部调用

如果在一个标记了@Transactional注解的方法内部调用另一个标记了@Transactional注解的方法，那么内部方法的事务将会失效。这是因为Spring框架默认使用基于代理的AOP实现，而代理对象的调用是通过Java反射机制实现的，因此在一个方法内部调用另一个方法时，实际上是在同一个对象中调用方法，而不是通过代理对象调用方法，因此事务无法生效。

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Transactional
    public void updateUser(User user) {
        // 更新用户信息
        userDao.updateUser(user);

        // 调用另一个标记了@Transactional注解的方法
        updateUserScore(user.getId(), 100);
    }

    @Transactional
    public void updateUserScore(Long userId, int score) {
        // 更新用户积分
        userDao.updateUserScore(userId, score);
    }
}

上面的代码中，updateUser方法和updateUserScore方法都标记了@Transactional注解，但是当updateUser方法调用updateUserScore方法时，updateUserScore方法的事务将会失效。

2. 异常被捕获

如果一个标记了@Transactional注解的方法抛出了异常，并且这个异常被捕获了，那么事务将不会回滚。这是因为Spring框架默认只对未捕获的异常进行回滚，如果异常被捕获了，那么Spring框架就认为这个异常已经被处理了，不需要回滚事务。

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Transactional
    public void updateUser(User user) {
        // 更新用户信息
        userDao.updateUser(user);

        try {
            // 抛出异常
            throw new RuntimeException("updateUserScore error");
        } catch (Exception e) {
            // 异常被捕获
            e.printStackTrace();
        }
    }
}

上面的代码中，updateUser方法标记了@Transactional注解，并且在方法中抛出了一个RuntimeException异常，并且这个异常被捕获了。在这种情况下，即使抛出了异常，事务也不会回滚。

3. 非public方法

如果一个标记了@Transactional注解的方法的访问级别不是public，那么事务将不会生效。这是因为Spring框架默认只对public方法进行代理，对于非public方法不会进行代理，因此事务无法生效。

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Transactional
    void updateUser(User user) {
        // 更新用户信息
        userDao.updateUser(user);
    }
}

上面的代码中，updateUser方法标记了@Transactional注解，但是它的访问级别不是public，因此事务无法生效。

4. 自调用

如果一个标记了@Transactional注解的方法自己调用自己，那么事务将不会生效。这是因为Spring框架默认使用基于代理的AOP实现，而代理对象的调用是通过Java反射机制实现的，因此在一个方法内部调用自己时，实际上是在同一个对象中调用方法，而不是通过代理对象调用方法，因此事务无法生效。

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Transactional
    public void updateUser(User user) {
        // 更新用户信息
        userDao.updateUser(user);

        // 自调用
        updateUser(user);
    }
}

上面的代码中，updateUser方法标记了@Transactional注解，并且在方法内部自调用了自己。在这种情况下，事务将不会生效。

5. 异常类型不匹配

如果一个标记了@Transactional注解的方法抛出了一个不是RuntimeException或Error的异常，那么事务将不会回滚。这是因为Spring框架默认只对RuntimeException和Error类型的异常进行回滚，对于其他类型的异常不会进行回滚。

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Transactional
    public void updateUser(User user) throws Exception {
        // 更新用户信息
        userDao.updateUser(user);

        // 抛出异常
        throw new Exception("updateUser error");
    }
}

上面的代码中，updateUser方法标记了@Transactional注解，并且抛出了一个Exception异常，而不是RuntimeException或Error异常。在这种情况下，事务将不会回滚。

三、@Transactional注解失效的解决方法

针对上面介绍的@Transactional注解失效的情况，我们可以采取以下的解决方法。

1. 方法内部调用

如果在一个标记了@Transactional注解的方法内部调用另一个标记了@Transactional注解的方法，我们可以通过将内部方法抽取到一个单独的类中，并在这个类上标记@Transactional注解来解决这个问题。

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Autowired
    private UserScoreService userScoreService;

    @Transactional
    public void updateUser(User user) {
        // 更新用户信息
        userDao.updateUser(user);

        // 调用另一个标记了@Transactional注解的方法
        userScoreService.updateUserScore(user.getId(), 100);
    }
}

@Service
public class UserScoreServiceImpl implements UserScoreService {

    @Autowired
    private UserDao userDao;

    @Transactional
    public void updateUserScore(Long userId, int score) {
        // 更新用户积分
        userDao.updateUserScore(userId, score);
    }
}

上面的代码中，我们将updateUserScore方法抽取到了一个单独的类UserScoreServiceImpl中，并在这个类上标记了@Transactional注解，这样在updateUser方法中调用userScoreService.updateUserScore方法时，事务就能够生效了。

2. 异常被捕获

如果一个标记了@Transactional注解的方法抛出了异常，并且这个异常被捕获了，我们可以通过在catch块中重新抛出异常来解决这个问题。

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Transactional
    public void updateUser(User user) {
        // 更新用户信息
        userDao.updateUser(user);

        try {
            // 抛出异常
            throw new RuntimeException("updateUserScore error");
        } catch (Exception e) {
            // 异常被捕获
            e.printStackTrace();
            // 重新抛出异常
            throw e;
        }
    }
}

上面的代码中，在catch块中重新抛出了异常，这样事务就能够回滚了。

3. 非public方法

如果一个标记了@Transactional注解的方法的访问级别不是public，我们可以将它的访问级别改为public来解决这个问题。

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Transactional
    public void updateUser(User user) {
        // 更新用户信息
        userDao.updateUser(user);
    }
}

上面的代码中，我们将updateUser方法的访问级别改为了public，这样事务就能够生效了。

4. 自调用

如果一个标记了@Transactional注解的方法自己调用自己，我们可以将自调用的逻辑抽取到一个单独的方法中，并在这个方法上标记@Transactional注解来解决这个问题。

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Transactional
    public void updateUser(User user) {
        // 更新用户信息
        userDao.updateUser(user);

        // 调用自己
        updateUserInternal(user);
    }

    @Transactional
    private void updateUserInternal(User user) {
        // 更新用户信息
        userDao.updateUser(user);
    }
}

上面的代码中，我们将自调用的逻辑抽取到了一个单独的方法updateUserInternal中，并在这个方法上标记了@Transactional注解，这样在updateUser方法中调用updateUserInternal方法时，事务就能够生效了。

5. 异常类型不匹配

如果一个标记了@Transactional注解的方法抛出了一个不是RuntimeException或Error的异常，我们可以通过在@Transactional注解中指定回滚的异常类型来解决这个问题。

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Transactional(rollbackFor = Exception.class)
    public void updateUser(User user) throws Exception {
        // 更新用户信息
        userDao.updateUser(user);

        // 抛出异常
        throw new Exception("updateUser error");
    }
}

上面的代码中，在@Transactional注解中指定了rollbackFor属性为Exception.class，这样即使抛出了Exception异常，事务也能够回滚。

四、总结

@Transactional注解是Spring框架中非常常用的注解，它可以将一个方法标记为事务性方法，使得在方法执行过程中发生异常时，可以自动回滚事务，保证数据的一致性。然而，在某些情况下，@Transactional注解可能会失效，本文介绍了这些情况及其解决方法。

如果在一个标记了@Transactional注解的方法内部调用另一个标记了@Transactional注解的方法，我们可以将内部方法抽取到一个单独的类中，并在这个类上标记@Transactional注解来解决这个问题；如果一个标记了@Transactional注解的方法抛出了异常，并且这个异常被捕获了，我们可以通过在catch块中重新抛出异常来解决这个问题；如果一个标记了@Transactional注解的方法的访问级别不是public，我们可以将它的访问级别改为public来解决这个问题；如果一个标记了@Transactional注解的方法自己调用自己，我们可以将自调用的逻辑抽取到一个单独的方法中，并在这个方法上标记@Transactional注解来解决这个问题；如果一个标记了@Transactional注解的方法抛出了一个不是RuntimeException或Error的异常，我们可以通过在@Transactional注解中指定回滚的异常类型来解决这个问题。

最后，需要注意的是，虽然@Transactional注解非常方便，但是在使用时需要注意它的失效情况，以免出现数据不一致的情况。

公众号请关注"果酱桑", 一起学习,一起进步!