分布式场景下接口的限流、幂等、防止重复提交

简单实现

定义注解

import java.lang.annotation.*;
 
/**
 * @author 向振华
 * @date 2022/11/21 18:16
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Limiter {
 
    /**
     * 限制时间（秒）
     *
     * @return
     */
    long limitTime() default 2L;
 
    /**
     * 限制后的错误提示信息
     *
     * @return
     */
    String errorMessage() default "请求频繁，请稍后重试";
}

定义切面

import com.alibaba.fastjson.JSONObject;
import com.xzh.web.ApiResponse;
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.reflect.MethodSignature;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
 
import javax.annotation.Resource;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.StringJoiner;
import java.util.concurrent.TimeUnit;
 
/**
 * @author 向振华
 * @date 2022/11/21 18:16
 */
@Aspect
@Component
@Slf4j
public class LimiterAspect {
 
    @Resource
    private RedisTemplate redisTemplate;
 
    @Around("@annotation(com.xzh.aop.Limiter)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
        Limiter annotation = method.getAnnotation(Limiter.class);
        if (annotation != null) {
            // 获取限制key
            String limitKey = getKey(joinPoint);
 
            if (limitKey != null) {
                log.info("limitKey ---> " + limitKey);
                Boolean hasKey = redisTemplate.hasKey(limitKey);
                if (Boolean.TRUE.equals(hasKey)) {
                    // 返回限制后的返回内容
                    return ApiResponse.fail(annotation.errorMessage());
                } else {
                    // 存入限制的key
                    redisTemplate.opsForValue().set(limitKey, "", annotation.limitTime(), TimeUnit.SECONDS);
                }
            }
        }
 
        return joinPoint.proceed();
    }
 
    public String getKey(ProceedingJoinPoint joinPoint) {
        // 参数
        StringJoiner asj = new StringJoiner(",");
        Object[] args = joinPoint.getArgs();
        Arrays.stream(args).forEach(a -> asj.add(JSONObject.toJSONString(a)));
        if (asj.toString().isEmpty()) {
            return null;
        }
        // 切入点
        String joinPointString = joinPoint.getSignature().toString();
        // 限制key = 切入点 + 参数
        return joinPointString + ":" + asj.toString();
    }
}

使用

import com.xzh.web.ApiResponse;
import com.xzh.aop.Limiter;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
 
/**
 * @author 向振华
 * @date 2021/11/21 18:03
 */
@RestController
public class TestController {
 
    @Limiter(limitTime = 10L)
    @PostMapping("/test1")
    public ApiResponse