坦言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在生成动态代理的时候，并不通过对这个类进行多层动态代理，而是只代理一次，把这些额外功能做成多个切面