spring事务注解 @Transactional

最新推荐文章于 2024-07-18 13:50:38 发布

存在,及合理

最新推荐文章于 2024-07-18 13:50:38 发布

阅读量118

点赞数

分类专栏： # spring 文章标签： spring java spring boot

本文链接：https://blog.csdn.net/qq_26594041/article/details/131362057

版权

spring 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Advantages of the Spring Framework’s Transaction Support Model :: Spring Framework

Propagation

REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED)

默认值如果当前事务不存在，则创建新的，如果存在则加入

SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS)

支持当前事务，如果不存在则以非事务运行

MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY)

支持当前事务，如果不存在则抛出异常

REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW)

如果当前有事务，则挂起该事务，并且自己创建一个新的事务给自己使用如果当前没有事务，则同REQUIRED

NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),

如果当前有事务，则把事务挂起，自己不适用事务去运行数据库操

NEVER(TransactionDefinition.PROPAGATION_NEVER),

如果当前有事务存在，则抛出异常

NESTED(TransactionDefinition.PROPAGATION_NESTED);

如果当前有事务，则开启子事务（嵌套事务）,嵌套事务是独立提交或者回滚；
如果当前没有事务，则同REQUIRED。但是如果主事务提交，则会携带子事务一起提交。
如果主事务回滚，则子事务会一起回滚。相反，子事务异常，则父事务可以回滚或不回滚

事务不生效

不是public

@Service 
public class UserService { 
     
    @Transactional 
    private void add(UserModel userModel) { 
         saveData(userModel); 
         updateData(userModel); 
    } 
}

spring要求被代理方法必须是public的。

在AbstractFallbackTransactionAttributeSource类的computeTransactionAttribute方法中有个判断，如果目标方法不是public，则TransactionAttribute返回null，即不支持事务。

protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class<?> targetClass) { 
    // Don't allow no-public methods as required. 
  if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) { 
       return null; 
    } 
    Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass); 
 
    // First try is the method in the target class. 
    TransactionAttribute txAttr = findTransactionAttribute(specificMethod); 
    if (txAttr != null) { 
      return txAttr; 
    }

方法用final修饰

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

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

方法是static

同样无法通过动态代理，变成事务方法。

方法内部调用

// 现象
@Service
public class OrderServiceImpl implements OrderService {
 
    public void update(Order order) {
        updateOrder(order);
    }
    @Transactional
    public void updateOrder(Order order) {
        // update order
    }

//解决

方法一：新加一个Service方法
新加一个Service方法，把@Transactional注解加到新Service方法上，把需要事务执行的代码移到新方法中
@Servcie 
public class ServiceA { 
   @Autowired 
   prvate ServiceB serviceB; 
 
   public void save(User user) { 
         queryData1(); 
         queryData2(); 
         serviceB.doSave(user); 
   } 
 } 
 
 @Servcie 
 public class ServiceB { 
 
 @Transactional(rollbackFor=Exception.class) 
    public void doSave(User user) { 
       addData1(); 
       updateData2(); 
    } 
 }


方法二：AopContent
@Servcie 
public class ServiceA { 
 
   public void save(User user) { 
         queryData1(); 
         queryData2(); 
  ((ServiceA)AopContext.currentProxy()).doSave(user); 
   } 
 
   @Transactional(rollbackFor=Exception.class) 
   public void doSave(User user) { 
       addData1(); 
       updateData2(); 
    } 
 }

方法三：在该Service类中注入自己
@Servcie 
public class ServiceA { 
   @Autowired 
prvate ServiceA serviceA; 
 
   public void save(User user) { 
         queryData1(); 
         queryData2(); 
         serviceA.doSave(user); 
   } 
 
   @Transactional(rollbackFor=Exception.class) 
   public void doSave(User user) { 
       addData1(); 
       updateData2(); 
    } 
 }

未被spring容器管理

使用spring事务的前提是：对象要被spring管理，需要创建bean实例。

// @Service
public class OrderServiceImpl implements OrderService {
 
    @Transactional
    public void updateOrder(Order order) {
         // update order
    }
}

多线程调用

@Slf4j 
@Service 
public class UserService { 
 
    @Autowired 
    private UserMapper userMapper; 
    @Autowired 
    private RoleService roleService; 
 
    @Transactional 
    public void add(UserModel userModel) throws Exception { 
        userMapper.insertUser(userModel); 
        new Thread(() -> { 
            roleService.doOtherThing(); 
        }).start(); 
    } 
} 
 
@Service 
public class RoleService { 
 
    @Transactional 
    public void doOtherThing() { 
        System.out.println("保存role表数据"); 
    } 
}

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

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

spring的事务是通过数据库连接来实现的。当前线程中保存了一个map，key是数据源，value是数据库连接。

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

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

手动控制事务(lock)

在事务中,使用了Redis分布式锁.这个方法一旦执行,事务生效，接着就Redis分布式锁生效，代码执行完后,先释放Redis分布式锁,然后再提交事务数据，最后事务结束。在这个过程中,事务没有提交之前,分布式锁已经被释放，导致分布式锁失效

这是因为:

spring的Aop，会在updateDB方法之前开启事务，之后再加锁，当锁住的代码执行完成后，再提交事务，因此锁住的代码块执行是在事务之内执行的，可以推断在代码块执行完时，事务还未提交，锁已经被释放，此时其他线程拿到锁之后进行锁住的代码块，读取的库存数据不是最新的。

还没有开事务之前就加锁，那么就可以保证线程的安全性

@Autowired
PlatformTransactionManager platformTransactionManager;

@Autowired
TransactionDefinition  transactionDefinition;
@Autowired
SysUserMapper sysUserMapper;
@Test
public void sqlSel(){

   ReentrantLock reentrantLock = new ReentrantLock();
   TransactionStatus transaction = null;
   try {
       if (reentrantLock.tryLock(20, TimeUnit.SECONDS)){

           transaction = platformTransactionManager.getTransaction(transactionDefinition);
           SysUser sysUser = sysUserMapper.selectByPrimaryKey(1l);
           sysUser.setUserName("Transaction");
           sysUserMapper.updateByPrimaryKey(sysUser);
       }else{
           System.out.println("Ss");
       }
   }catch (Exception e){
       if (transaction != null) {
           platformTransactionManager.rollback(transaction);
       }

       e.printStackTrace();
   }finally {
       if (transaction != null) {
           platformTransactionManager.commit(transaction);
       }
       reentrantLock.unlock();
   }
}

事务不回滚

错误的传播特性

Propagation.NOT_SUPPORTED，这种类型的传播特性不支持事务，如果有事务则会抛异常。

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

@Service 
public class OrderServiceImpl implements OrderService{ 
 
    @Transactional
    public void update(Order order) {
        updateOrder(order);
    }
 
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void updateOrder(Order order) {
        // update order
    }

自己吞了异常

把异常吃了，然后又不抛出来，事务也不会回滚！

@Transactional
public void CatchExceptionCanNotRollback() {

    try {
        extraAdDao.save(new ExtraAd("qinyi"));
        throw new RuntimeException();
    } catch (Exception ex) {
        ex.printStackTrace();
        // 手动标记回滚
      TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
}

手动抛了别的异常

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

@Service
public class OrderServiceImpl implements OrderService {
 
    @Transactional
    public void updateOrder(Order order) {
        try {
            // update order
        } catch {
            throw new Exception("更新错误");
        }
    }
}

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

自定义了回滚异常

@Slf4j 
@Service 
public class UserService { 
     
    @Transactional(rollbackFor = BusinessException.class) 
    public void add(UserModel userModel) throws Exception { 
       saveData(userModel); 
       updateData(userModel); 
    } 
}

保存和更新数据时，程序报错了，抛了SqlException、DuplicateKeyException等异常。而BusinessException是我们自定义的异常，报错的异常不属于BusinessException，所以事务也不会回滚。

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

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

捕捉异常并转换异常, 导致不能回滚

@Override
@Transactional
public void NotRuntimeExceptionCanNotRollback() throws CustomException {

    try {
        extraAdDao.save(new ExtraAd("qinyi"));
        throw new RuntimeException();
    } catch (Exception ex) {
        throw new CustomException(ex.getMessage());
    }
}
public class CustomException extends Exception {

    public CustomException(String message) {
        super(message);
    }
}

指定异常, 可以回滚

@Override
@Transactional(rollbackFor = {CustomException.class})
public void AssignExceptionCanRollback() throws CustomException {

    try {
        extraAdDao.save(new ExtraAd("qinyi"));
        throw new RuntimeException();
    } catch (Exception ex) {
        throw new CustomException(ex.getMessage());
    }
}

嵌套事务回滚多了

public class UserService {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private RoleService roleService;

    @Transactional
    public void add(UserModel userModel) throws Exception {
        userMapper.insertUser(userModel);
        roleService.doOtherThing();
    }
}

@Service
public class RoleService {

    @Transactional(propagation = Propagation.NESTED)
    public void doOtherThing() {
        System.out.println("保存role表数据");
    }
}

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

@Slf4j 
@Service 
public class UserService { 
 
    @Autowired 
    private UserMapper userMapper; 
 
    @Autowired 
    private RoleService roleService; 
 
    @Transactional 
    public void add(UserModel userModel) throws Exception { 
 
        userMapper.insertUser(userModel); 
        try { 
            roleService.doOtherThing(); 
        } catch (Exception e) { 
            log.error(e.getMessage(), e); 
        } 
    } 
}

存在,及合理

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spring事务注解 @Transactional

REQUIRED默认值如果当前事务不存在，则创建新的，如果存在则加入支持当前事务，如果不存在则以非事务运行支持当前事务，如果不存在则抛出异常如果当前有事务，则挂起该事务，并且自己创建一个新的事务给自己使用如果当前没有事务，则同REQUIRED如果当前有事务，则把事务挂起，自己不适用事务去运行数据库操如果当前有事务存在，则抛出异常spring要求被代理方法必须是public的。
复制链接

扫一扫