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(" 0 === 正在重试====="+numAttempts+"次");
}
}
} while (numAttempts <= this.maxRetries);return null;
}
}
至此重试机制就完成了,如果是JPA或者hibernate,乐观锁保存失败会报异常,同样的try..catch(ObjectOptimisticLockingFailureException)到之后再抛出自定义异常。