利用Redisson和Spring AOP确保接口操作的幂等性

---

幂等性的重要性

幂等性在HTTP方法定义中有明确的指导意义。例如，GET、PUT、DELETE被定义为幂等方法，而POST通常不是。在现实场景中，比如网络延迟或用户重复点击提交按钮，都可能导致同一请求被发送多次，幂等性保护机制可以防止这些重复请求导致数据的不一致或重复操作。

实现接口幂等性的策略

实现幂等性的常见策略包括使用唯一事务ID、乐观锁、或者分布式锁等。在本文中，使用Redisson提供的分布式锁来实现幂等性校验。

步骤 1: 定义幂等性注解

首先，定义一个自定义注解@Idempotent来标识需要进行幂等性校验的方法。

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * @Author derek_smart
 * @Date 2024/7/11 8:00
 * @Description 幂等性注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Idempotent {
    String key();
    long timeout() default 60; // 默认超时时间为60秒
}

步骤 2: 创建幂等性校验切面

接着，创建一个切面IdempotentAspect来处理带有@Idempotent注解的方法。该切面将在方法执行前尝试获取一个分布式锁，并在执行后释放该锁。

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.expression.BeanFactoryResolver;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.stereotype.Component;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import java.lang.reflect.Method;
import java.util.concurrent.TimeUnit;
/**
 * @Author derek_smart
 * @Date 2024/7/11 8:00
 * @Description 幂等切面
 *
 * 整个切面的目的是确保标记了`@Idempotent`注解的方法在执行时能够获得分布式锁，以此来保证幂等性。
 * 如果无法获取锁，表示另一个相同的请求已经在执行中或已执行，防止了重复处理
 */
@Aspect
@Component
public class IdempotentAspect {

    private static final Logger logger = LoggerFactory.getLogger(IdempotentAspect.class);

    @Autowired
    private RedissonClient redissonClient;

    @Autowired
    private ApplicationContext applicationContext;

    @Around("@annotation(idempotent)")
    public Object around(ProceedingJoinPoint joinPoint, Idempotent idempotent) throws Throwable {
        Method method = getCurrentMethod(joinPoint);
        String key = resolveKey(joinPoint, method, idempotent.key());
        RLock lock = redissonClient.getLock(key);
        boolean isLocked = false;

        try {
            isLocked = lock.tryLock(1, idempotent.timeout(), TimeUnit.SECONDS);
            if (!isLocked) {
                logger.warn("Unable to acquire idempotent lock for key: {}", key);
                throw new IllegalStateException("Request is not idempotent.");
            }

            return joinPoint.proceed();
        } catch (Throwable throwable) {
            logger.error("Exception occurred in idempotent protected method", throwable);
            throw throwable;
        } finally {
            if (isLocked) {
                lock.unlock();
                logger.info("Idempotent lock released for key: {}", key);
            }
        }
    }

    private Method getCurrentMethod(ProceedingJoinPoint joinPoint) throws NoSuchMethodException {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        return signature.getMethod();
    }

    /**
     * `resolveKey`方法使用SpEL表达式解析功能来动态生成锁的key。它创建了一个SpEL表达式解析器和评估上下文
     * ，将方法参数和方法名添加到上下文中，然后解析注解中定义的key表达式。
     * @param joinPoint
     * @param method
     * @param key
     * @return
     */
    private String resolveKey(ProceedingJoinPoint joinPoint, Method method, String key) {
        ExpressionParser parser = new SpelExpressionParser();
        StandardEvaluationContext context = new StandardEvaluationContext();
        context.setRootObject(joinPoint.getArgs());
        context.setVariable("methodName", method.getName());
        context.setBeanResolver(new BeanFactoryResolver(applicationContext));

        // Add method parameters to the SpEL context
        Object[] args = joinPoint.getArgs();
        String[] paramNames = new LocalVariableTableParameterNameDiscoverer().getParameterNames(method);
        if (paramNames != null) {
            for (int i = 0; i < paramNames.length; i++) {
                context.setVariable(paramNames[i], args[i]);
            }
        }

        return parser.parseExpression(key).getValue(context, String.class);
    }
}

步骤 3: 切面实现细节

在IdempotentAspect中，首先通过解析注解中的SpEL表达式来动态生成锁的key。然后，尝试获取Redisson分布式锁，如果获取成功，则执行目标方法；否则，抛出异常表示操作不幂等。

// 环绕通知的具体实现
public Object around(ProceedingJoinPoint joinPoint, Idempotent idempotent) throws Throwable {
    String key = resolveKey(joinPoint, idempotent.key());
    RLock lock = redissonClient.getLock(key);
    boolean isLocked = lock.tryLock(1, idempotent.timeout(), TimeUnit.SECONDS);
    if (!isLocked) {
        throw new IllegalStateException("Request is not idempotent.");
    }
    try {
        return joinPoint.proceed();
    } finally {
        lock.unlock();
    }
}

步骤 4: 在控制器中使用幂等性注解

最后，在控制器中的方法上使用@Idempotent注解，并指定用于生成锁key的SpEL表达式。

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;
/**
 * @Author derek_smart
 * @Date 2024/7/11 8:00
 * @Description 幂等切面 测试
 */
@RestController
public class MyController {

    @PostMapping("/submit")
    @Idempotent(key = "'submit:' + #requestId", timeout = 120)
    public ResponseEntity<?> submitData(@RequestBody Map data, @RequestParam String requestId) {
        // 处理请求
        return ResponseEntity.ok().build();
    }
}

客户端的责任

客户端在发送请求时，需要在HTTP请求头中携带一个唯一标识符（如UUID）作为幂等性令牌。服务端将使用这个令牌来检查请求是否已经被处理。

总结

通过上述步骤，在Spring Boot应用程序中实现了一个幂等性校验机制。这种机制使用Redisson分布式锁来确保在分布式系统中，即使面临网络问题和用户重复操作，每个操作也只会被执行一次。这对于维护数据一致性和防止重复操作非常重要。

注意事项

• • 确保Redisson配置正确，且Redis服务可用。
• • 生成锁key时，确保使用的唯一标识符在所有请求尝试中保持不变。
• • 考虑合理设置锁的超时时间，以防止服务异常导致的死锁问题。

通过这种方式，可以在微服务或分布式系统中有效地实现接口的幂等性保护，从而提高系统的稳定性和可靠性。