JAVA-乐观锁更新失败或业务异常后接口重试

最近在阅读《阿里巴巴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）到之后再抛出自定义异常。

二、使用框架

1、增加spring-retry依赖：

<retry.version>1.2.5.RELEASE</retry.version>

<!--retry-->
<dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
    <version>${retry.version}</version>
</dependency>

2、在相应的方法上加上注解：

/**
 * 测试重试
 *
 * @Retryable的参数说明： •value：抛出指定异常才会重试
 * •include：和value一样，默认为空，当exclude也为空时，默认所以异常
 * •exclude：指定不处理的异常
 * •maxAttempts：最大重试次数，默认3次
 * •backoff：重试等待策略，默认使用@Backoff，@Backoff的value默认为1000L，我们设置为2000L；
 * multiplier（指定延迟倍数）默认为0，表示固定暂停1秒后进行重试
 */
@Retryable(value = RetryException.class, maxAttempts = 3, backoff = @Backoff(delay = 2000L, multiplier = 1))
BaseResponse testRetry();

3、在业务异常出抛出指定异常即可，建议抛出框架定义的异常RetryException。

总结

建议大家还是使用框架，有兴趣和能力的小伙伴可以看下源码。但是第一种方式的AOP思想还是要了解的。