spring事物失效的场景

北南天

已于 2023-06-26 16:06:39 修改

阅读量96

点赞数

分类专栏： spring系列文章标签： spring

于 2023-06-25 14:39:30 首次发布

本文链接：https://blog.csdn.net/qq_43134169/article/details/131371876

版权

spring系列专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1.未被spring管理

在我们平时开发过程中，有个细节很容易被忽略。即使用spring事务的前提是：对象要被spring管理，需要创建bean实例。

通常情况下，我们通过@Controller、@Service、@Component、@Repository等注解，可以自动实现bean实例化和依赖注入的功能。

//@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;


    @Transactional
    public void updateUser() {
        //todo
    }


}

2.访问权限问题

众所周知，java的访问权限主要有四种：public、protected、default、private，它们的权限从左到右，依次变小。

但如果我们把某些事务方法，定义了错误的访问权限级别，就会导致事务功能出问题，例如：

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Transactional
    private void add(BaseTagdata baseTagdata) {
        //todo
    }

}

上面定义add方法的访问权限为private，这样最终会导致事务失效，spring要求被代理方法必须是public的。

想要了解代理方法必须是public的，我们需要看spring事务的源码，在
AbstractFallbackTransactionAttributeSource类的computeTransactionAttribute方法中有个判断，如果目标方法不是public，则TransactionAttribute返回null，即不支持事务。

#AbstractFallbackTransactionAttributeSource
protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
	if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
		return null;
	}

因此如果我们自定义方法，它的访问权限不是public，而是protected、default或者private，spring则不会提供事务功能。

3.错误的传播特性

其实，我们在使用@Transactional注解时，是可以指定propagation参数的,扩展其配置不支持事务

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Transactional
    public void add(InOutBaseTag inOutBaseTag){
        userMapper.insert(inOutBaseTag);
        updateStatus(inOutBaseTag);
    }

    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void updateStatus(InOutBaseTag inOutBaseTag){
        //todo
    }
}

我们可以看到add方法的事务传播特性定义成了Propagation.NOT_SUPPORTED，这种类型的传播特性不支持事务，如果有事务则会抛异常。

目前只有这三种传播特性才会创建新事务：NESTED,REQUIRES_NEW,REQUIRED。

传播行为	含义
PROPAGATION_REQUIRED	表示当前方法必须运行在事务中，如果当前事务存在，方法将会在该事务中运行，否则，会启动一个新的事务
PROPAGATION_REQUIRED_NEW	表示当前方法必须运行在它自己的事务中。一个新的事务将被启动，如果存在当前事务，在该方法执行期间，当期事务会被挂起。如果使用JTATransactionManager的话，则需要访问TransactionManager
PROPAGATION_SUPPORTS	表示该方法不需要事务上下文，但是如果存在当前的事务的话，那么该方法会在这个事务汇总运行
PROPAGATION_NOT_SUPPORTED	表示当前方法不应该运行在事务中，如果存在当前事务，在该方法运行期间，当前事务将被挂起，如果使用JTATransactionManager的话，则需要访问TransactionManager
PROPAGATION_MANDATORY	表示该方法必须在事务中运行，如果当前事务不存在，则会抛出一个异常
PROPAGATION_NEVER	表示当前方法不应该运行在事务上下文中，如果当前正有一个事务在运行，则抛出异常
PROPAGATION_NESTED	表示如果当前已经存在一个事务，那么该方法将会在嵌套事务中运行。嵌套的事务可以独立于当前事务进行单独的提交或回滚。如果当前事务不存在，那么其行为和 PROPAGATION_REQUIRED一样。注意各厂商对这种传播行为的支持是有所差异的，可以参考资源管理器的文档来确认它们是够支持嵌套事务

4.方法用final修饰

如果某个方法不想被子类重写，这时我们可以将该方法定义成final。普通方法这样定义是没问题的，但如果将事务方法定义成final，例如：

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;


    @Transactional
    public final void add(InOutBaseTag inOutBaseTag){
        userMapper.insert(inOutBaseTag);
    }

   
}

我们可以看到add方法被定义成了final的，这样会导致事务失效。

为什么?

我看过spring事务的源码，就会知道spring事务底层使用了aop，也就是通过jdk动态代理或者cglib，帮我们生成了代理类，在代理类中实现的事务功能。

但如果某个方法用final修饰了，那么在它的代理类中，就无法重写该方法，而无法添加事务功能。

注意：如果某个方法是static的，同样无法通过动态代理，变成事务方法。

5.方法内部调用

有时候我们需要在某个Service类的某个方法中，调用另外一个事务方法，比如：

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Transactional
    public void add(InOutBaseTag inOutBaseTag){
        userMapper.insert(inOutBaseTag);
        updateStatus(inOutBaseTag);
    }

    @Transactional
    public void updateStatus(InOutBaseTag inOutBaseTag){
        //todo
    }
}

我们看到在事务方法add中，直接调用事务方法updateStatus。从前面介绍的内容可以知道，updateStatus方法拥有事务的能力是因为spring aop生成代理了对象，但是这种方法直接调用了this对象的方法，所以updateStatus方法不会生成事务。

由此可见，在同一个类中的方法直接内部调用，会导致事务失效。

那么问题来了，如果有些场景，确实想在同一个类的某个方法中，调用它自己的另外一个方法，该怎么办呢?

新加一个service方法

这个方法非常简单，、需要新加一个Service方法，把@Transactional注解加到新Service方法上，把需要事务执行的代码移到新方法中。具体代码如下：

@Service
public class ServiceA {

    @Autowired
    private ServiceB serviceB;

    public void save(BaseTagdata baseTagdata) {
        queryData1();
        queryData2();
        serviceB.doSave(baseTagdata);
    }

}

@Service
public class ServiceB {

    @Autowired
    private ServiceA serviceA;

    @Transactional(rollbackFor = Exception.class)
    public void doSave(BaseTagdata baseTagdata) {
        addData1();
        updateData2();
    }

}

6.多线程调用

在实际项目开发中，多线程的使用场景还是挺多的。如果spring事务用在多线程场景中，会有问题吗?

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private GivenServie givenServie;


    @Transactional
    public void add(InOutBaseTag inOutBaseTag) {
        userMapper.insert(inOutBaseTag);
        new Thread(() -> {
            givenServie.updateStatus(inOutBaseTag);
        }).start();

    }

}

@Service
public class GivenServiceImpl implements GivenServie {

    @Transactional(rollbackFor = Exception.class)
    @Override
    public void updateStatus(InOutBaseTag inOutBaseTag) {
        //todo
    }
}

从上面的例子中，我们可以看到事务方法add中，调用了事务方法updateStatus，但是事务方法updateStatus是在另外一个线程中调用的。

这样会导致两个方法不在同一个线程中，获取到的数据库连接不一样，从而是两个不同的事务。如果想updateStatus方法中抛了异常，add方法也回滚是不可能的。

如果看过spring事务源码的朋友，可能会知道spring的事务是通过数据库连接来实现的。当前线程中保存了一个map，key是数据源，value是数据库连接。

private static final ThreadLocal<Map<Object, Object>> resources =   new NamedThreadLocal<>("Transactional resources");

我们说的同一个事务，其实是指同一个数据库连接，只有拥有同一个数据库连接才能同时提交和回滚。如果在不同的线程，拿到的数据库连接肯定是不一样的，所以是不同的事务。

7.自己吞了异常

这个也是出现比较多的场景：把异常吃了，然后又不抛出来，事务也不会回滚！比如：

    @Transactional
    public void add(InOutBaseTag inOutBaseTag){
        userMapper.insert(inOutBaseTag);
       try {
           updateStatus(inOutBaseTag);
       }catch (Exception e){
           
       }
       
    }

8.手动抛了别的异常

即使开发者没有手动捕获异常，但如果抛的异常不正确，spring事务也不会回滚。

    @Transactional
    public void add(InOutBaseTag inOutBaseTag) throws Exception {
        userMapper.insert(inOutBaseTag);
        try {
            updateStatus(inOutBaseTag);
        }catch (Error e){
           throw new Exception("更新错误");
        }

    }

这样事务也是不生效的，因为默认回滚的是：RuntimeException，如果你想触发其他异常的回滚，需要在注解上配置一下，如：@Transactional(rollbackFor = Exception.class), 这个配置仅限于 Throwable 异常类及其子类。

9.自定义了回滚异常

在使用@Transactional注解声明事务时，有时我们想自定义回滚的异常，spring也是支持的。可以通过设置rollbackFor参数，来完成这个功能。

但如果这个参数的值设置错了，就会引出一些莫名其妙的问题，例如：

    @Transactional(rollbackFor =BusinessException.class)
    public void add(InOutBaseTag inOutBaseTag){
        userMapper.insert(inOutBaseTag);
        new Thread(()->{

        }).start();
        updateStatus(inOutBaseTag);
    }

如果在执行上面这段代码，保存和更新数据时，程序报错了，抛了SqlException、DuplicateKeyException等异常。而BusinessException是我们自定义的异常，报错的异常不属于BusinessException，所以事务也不会回滚。

即使rollbackFor有默认值，但阿里巴巴开发者规范中，还是要求开发者重新指定该参数。

这是为什么呢?

因为如果使用默认值，一旦程序抛出了Exception，事务不会回滚，这会出现很大的bug。所以，建议一般情况下，将该参数设置成：Exception或Throwable。

10.嵌套事物回滚多了

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private GivenServie givenServie;


    @Transactional
    public void add(InOutBaseTag inOutBaseTag) {
        userMapper.insert(inOutBaseTag);
        givenServie.updateStatus(inOutBaseTag);
    }

}


@Service
public class GivenServiceImpl implements GivenServie {

    @Override
    @Transactional(propagation = Propagation.NESTED)
    public void updateStatus(InOutBaseTag inOutBaseTag) {
        //todo
    }
}

这种情况使用了嵌套的内部事务，原本是希望调用roleService.doOtherThing方法时，如果出现了异常，只回滚doOtherThing方法里的内容，不回滚 userMapper.insertUser里的内容，即回滚保存点。但事实是，insertUser也回滚了。

why?

因为doOtherThing方法出现了异常，没有手动捕获，会继续往上抛，到外层add方法的代理方法中捕获了异常。所以，这种情况是直接回滚了整个事务，不只回滚单个保存点。

怎么样才能只回滚保存点呢?

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private GivenServie givenServie;


    @Transactional
    public void add(InOutBaseTag inOutBaseTag) {
        userMapper.insert(inOutBaseTag);
       try {
           givenServie.updateStatus(inOutBaseTag);
       }catch (Exception e){
           
       }
       
    }

}

可以将内部嵌套事务放在try/catch中，并且不继续往上抛异常。这样就能保证，如果内部嵌套事务中出现异常，只回滚内部事务，而不影响外部事务。

北南天

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spring事物失效的场景

从前面介绍的内容可以知道，updateStatus方法拥有事务的能力是因为spring aop生成代理了对象，但是这种方法直接调用了this对象的方法，所以updateStatus方法不会生成事务。我看过spring事务的源码，就会知道spring事务底层使用了aop，也就是通过jdk动态代理或者cglib，帮我们生成了代理类，在代理类中实现的事务功能。在我们平时开发过程中，有个细节很容易被忽略。那么问题来了，如果有些场景，确实想在同一个类的某个方法中，调用它自己的另外一个方法，该怎么办呢?
复制链接

扫一扫