坦言spring中事务、重试、异步执行注解

一、@Transaction

我们再编码过程中,大量使用到这个注解。一般情况下,@Transaction使用默认注解可以完成90%的功能,下面会针对一些特殊场景下,@Tansaction的使用注意

1.1 事务回滚

@Transactional()
public void rollback() throws SQLException {
    ... //do something
    throw new SQLException("exeception");
}

上述代码会回滚吗,答案是不会的。原因是:默认配置中,只会对RuntimeException(及其子类)才会进行回滚。因此,在一些抛出非运行时异常的场景下也希望回滚的,则需要进行配置

 
@Transactional(rollbackFor = Exception.class)

除了可以指定哪些异常回滚,也可以指定哪些异常不执行回滚,对应的是noRollbackFor

1.2 事务传播性

@Transaction中可以指定事务的传播性,可以在下面类中查询Spring 支持的事务传播类型,或者网上一搜也有很多

org.springframework.transaction.annotation.Propagation

这里举一个场景分析,在一个事务开启后,在下面场景中,select出来的依旧是事务开启时的数据快照,并无法获取其他事务对其的修改(不可重复读或幻读)

但我们的需求是想及时获取最新数据,那么可以利用事务的传播性,在当前事务中新开另外一个事务去读取

@Transactional(rollbackFor = Exception.class)
public void selectTransaction() {
    // do someThing but update dayEarn
    DayEarn dayEarn = self.selectNotSupported(17L);
    //....
     
}
 
@Transactional(propagation = Propagation.NOT_SUPPORTED, rollbackFor = Exception.class)
public DayEarn selectNotSupported(long autoId) {
    return dayEarnMapper.selectByPrimaryKey(autoId);
}
NOT_SUPPORTED传播性就是 如果当前存在事务,则挂起当前事务,新开一个事务去执行,完成会恢复挂起的事务

1.3 额外说明

我们知道,@Transaction注解的方法不能通过内部方法调用(当然不仅仅是这个注解),因此,可以通过Spring,把当前Bean实例注入到当前Bean一个属性中,即

@Service
public class MyService  {
 
    private MyService self;
 
 
    ...
}

有2种方式:

第一种方法,直接@Autowire

Spring对这种循环依赖是有解决办法的,前提是满足以下条件:

  1. Bean是单例,
  2. 通过属性注入的情况

因此,我们直接像注入其他类一样,注入自己的一个实例,如下

@Service
public class MyService  {
 
    @Autowired
    private MyService self;
}

第二种方法,通过BeanFactoryAware

虽然在第一种方法在大部分情况下是可行的,但是有些情况下还是会报循环依赖的问题(可以尝试在该类中即有@Transaction,又有@Async)

因此,建议使用BeanFactoryAware来注入,这样是在Bean初始完成后再set进来,而不是依赖Spring来解决循环依赖

 
@Service
public class MyService implements BeanFactoryAware {
 
    private MyService self;
     
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        self = beanFactory.getBean(MyService.class);
    }
}

二、@Retry

Spring对重试机制的注解,需要加入@EnableRetry

典型使用方式

@Retryable(value = {RemoteAccessException.class}, maxAttempts = 2, backoff = @Backoff(delay = 500L))
public void retry() {
    System.out.println("rpc 调用失败");
    try {
        TimeUnit.MILLISECONDS.sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    throw new RemoteAccessException("rpc 调用失败");
}
  • 注解中的value是一个Class数组,表示抛出哪些异常的时候回尝试重试
  • maxAttempts,最大执行次数,上面表示该方法2次执行失败,则不再进行重试
  • backoff,设定重试间隔,2次执行之间间隔500ms,(还可以设定多次间隔时间按照一定倍数递增)
如果需要在重试失败以后,再做一些其他的业务处理,可以使用@Recover注解来进行回调
@Recover
public void recover2(Exception e) {
    System.out.println("recover2" + e.getMessage());
}

注:如果存在多个@Recover类,那么只会匹配一个最接近,根据上面的例子,下面只有RemoteAccessException的才会执行

@Recover
public void recover1(RemoteAccessException e) {
    System.out.println("recover1" + e.getMessage());
}
 
@Recover
public void recover2(Exception e) {
    System.out.println("recover2" + e.getMessage());
}

三、@Async

前提:需要加入@EnableAsync

可以对一个方法进行异步调用,例如

@Async
public Future<Boolean> async() {
    //... do something
    return new AsyncResult<>(Boolean.TRUE); //or false
}

这样,在调用的时候,把当前方法放到一个线程池中,异步去执行。使用方法和Callable接口提交线程中完全一样。

如果需要指定一个特定的线程池,可以通过在@Async中指定线程池的beanName来确定。

@Async(value = "executor")
public Future<Boolean> async() {
    //... do something
    return new AsyncResult<>(Boolean.TRUE); //or false
}

四、组合使用

上述的功能实现基本都是基于AopProxy,因此,完全可以进行组合,例如 @Async和@Retry即可以完成异步重试,还是用上面的例子来进行组合

@Async(value = "executor")
public void asyncRetry() {
    self.retry();
}
 
 
@Retryable(value = {RemoteAccessException.class}, maxAttempts = 2, backoff = @Backoff(delay = 500L))
public void retry() {
    System.out.println("rpc 调用失败");
 
    throw new RemoteAccessException("rpc 调用失败");
}
 
@Recover
public void recover1(RemoteAccessException e) {
    System.out.println("recover1" + e.getMessage());
}

额外说明:如果一个类即包含了@Transaction注解,又包含了其他@Retry,@Async注解,那么Spring在生成动态代理的时候,并不通过对这个类进行多层动态代理,而是只代理一次,把这些额外功能做成多个切面

posted @ 2017-11-14 21:18 atheva 阅读(...) 评论(...) 编辑 收藏