Spring AOP解决乐观锁重试 - 简书

最近在阅读《阿里巴巴Java开发手册》时有这么一段内容：

【强制】并发修改同一记录时，避免更新丢失，需要加锁。要么在应用层加锁，要么在缓存加锁，要么在数据库层使用乐观锁，使用version作为更新依据。说明：如果每次访问冲突概率小于20%，推荐使用乐观锁，否则使用悲观锁。乐观锁的重试次数不得小于3次。

那这个重试机制怎么实现呢，大体思路是：

用aop解决问题
1.自定义重试注解及切面
2.在需要重试的接口上加上自定义注解
3.自定义异常
4.更新失败/业务异常 的时候抛出自定义异常
5.切面中定义重试机制

代码：

1.自定义重试注解

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**

• 重试注解（异常重试，乐观锁更新失败重试）
  */
  @Target(ElementType.METHOD) // 作用到方法上
  @Retention(RetentionPolicy.RUNTIME)
  public @interface NeedTryAgain {

  /**

  • 重试次数
  • @return
    */
    int tryTimes() default 3;

}
2.在需要重试的service接口上增加注解

/**

• 修改用户
• @return
  */
  @NeedTryAgain(tryTimes = 3)
  RbacUser update(RbacUserDTO user);
  3.自定义异常

import org.springframework.http.HttpStatus;

import static org.springframework.http.HttpStatus.INTERNAL_SERVER_ERROR;

/**

• 自定义重试异常
  */
  public class TryAgainException extends RuntimeException {

  private Integer status = INTERNAL_SERVER_ERROR.value();

  public TryAgainException( String msg) {
  super(msg);
  }

  public TryAgainException(HttpStatus status, String msg) {
  super(msg);
  this.status = status.value();
  }

}
4.更新失败抛出自定义异常

...

if(1 != rbacUserMapper.update(rbacUser)){
// 回滚
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
// 保存失败，抛出重试异常
throw new TryAgainException("乐观锁导致修改失败");
}

...
5.自定义重试切面及重试机制

import com.gourd.base.annotation.NeedTryAgain;
import com.gourd.base.exception.BadRequestException;
import com.gourd.base.exception.TryAgainException;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.lang.reflect.Method;

/**

• 重试切面

• @author gourd
  */
  @Aspect
  @Component
  @Slf4j
  public class TryAgainAspect{

  private int maxRetries;

  public void setMaxRetries(int maxRetries) {
  this.maxRetries = maxRetries;
  }

  @Pointcut("@annotation(com.gourd.base.annotation.NeedTryAgain)")
  public void retryOnOptFailure() {
  }

  @Around("retryOnOptFailure()")
  @Transactional(rollbackFor = Exception.class)
  public Object doConcurrentOperation(ProceedingJoinPoint pjp) throws Throwable {
  // 获取拦截的方法名
  MethodSignature msig = (MethodSignature) pjp.getSignature();
  // 返回被织入增加处理目标对象
  Object target = pjp.getTarget();
  // 为了获取注解信息
  Method currentMethod = target.getClass().getMethod(msig.getName(), msig.getParameterTypes());
  // 获取注解信息
  NeedTryAgain annotation = currentMethod.getAnnotation(NeedTryAgain.class);
  // 设置重试次数
  this.setMaxRetries(annotation.tryTimes());
  // 重试次数
  int numAttempts = 0;
  do {
  numAttempts++;
  try {
  // 再次执行业务代码
  return pjp.proceed();
  } catch (TryAgainException ex) {
  if (numAttempts > maxRetries) {
  // 如果大于 默认的重试机制 次数，我们这回就真正的抛出去了
  throw new BadRequestException(HttpStatus.BAD_REQUEST,"服务内部错误-重试结束");
  }else{
  // 如果 没达到最大的重试次数，将再次执行
  log.info(" ⁰ === 正在重试====="+numAttempts+"次");
  }
  }
  } while (numAttempts <= this.maxRetries);

          return null;
  

  }
  }
  至此重试机制就完成了，如果是JPA或者hibernate，乐观锁保存失败会报异常，同样的try..catch（ObjectOptimisticLockingFailureException）到之后再抛出自定义异常。