<!-- 需要的依賴 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

#具體配置以實際為主這里只是演示
spring:  
	redis:
		host: localhost
		port: 6379
		password: 123  

public enum LimitType {
    /**
     * 默認策略
     */
    DEFAULT,
    /**
     * 根據(jù)IP進行限流
     */
    IP
}

@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimiter {
    /**
     * 限流key
     */
    String key() default "rate_limit:";
    /**
     * 限流時間,單位秒
     */
    int time() default 60;
    /**
     * 限流次數(shù)
     */
    int count() default 50;
    /**
     * 限流類型
     */
    LimitType limitType() default LimitType.DEFAULT;
}

@Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置連接工廠
        template.setConnectionFactory(factory);
        //使用Jackson2JsonRedisSerializer來序列化和反序列化redis的value值（默認使用JDK的序列化方式）
        Jackson2JsonRedisSerializer<Object> jacksonSeial = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修飾符范圍，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化輸入的類型，類必須是非final修飾的，final修飾的類，比如String,Integer等會跑出異常
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jacksonSeial.setObjectMapper(om);
        // 值采用json序列化
        template.setValueSerializer(jacksonSeial);
        //使用StringRedisSerializer來序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        // 設(shè)置hash key 和value序列化模式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(jacksonSeial);
        template.afterPropertiesSet();
        return template;
    }

local key = KEYS[1]
local count = tonumber(ARGV[1])
local time = tonumber(ARGV[2])
local current = redis.call('get', key)
if current and tonumber(current) > count then
    return tonumber(current)
end
current = redis.call('incr', key)
if tonumber(current) == 1 then
    redis.call('expire', key, time)
end
return tonumber(current)

@Bean
	public DefaultRedisScript<Long> limitScript() {
		DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
		redisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("lua/limit.lua")));
		redisScript.setResultType(Long.class);
		return redisScript;
	}

@Slf4j
@Aspect
@Component
public class RateLimiterAspect {
    private final RedisTemplate redisTemplate;
    private final RedisScript<Long> limitScript;
    public RateLimiterAspect(RedisTemplate redisTemplate, RedisScript<Long> limitScript) {
        this.redisTemplate = redisTemplate;
        this.limitScript = limitScript;
    }
    @Around("@annotation(com.example.demo.annotation.RateLimiter)")
    public Object doBefore(ProceedingJoinPoint joinPoint) throws Throwable{
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        RateLimiter rateLimiter = methodSignature.getMethod().getAnnotation(RateLimiter.class);
		//判斷該方法是否存在限流的注解
        if (null != rateLimiter){
        	//獲得注解中的配置信息
            int count = rateLimiter.count();
            int time = rateLimiter.time();
            String key = rateLimiter.key();
			//調(diào)用getCombineKey()獲得存入redis中的key   key -> 注解中配置的key前綴-ip地址-方法路徑-方法名
            String combineKey = getCombineKey(rateLimiter, methodSignature);
            log.info("combineKey->,{}",combineKey);
            //將combineKey放入集合
            List<Object> keys = Collections.singletonList(combineKey);
            log.info("keys->",keys);
            try {
            	//執(zhí)行l(wèi)ua腳本獲得返回值
                Long number = (Long) redisTemplate.execute(limitScript, keys, count, time);
                //如果返回null或者返回次數(shù)大于配置次數(shù)，則限制訪問
                if (number==null || number.intValue() > count) {
                    throw new ServiceException("訪問過于頻繁，請稍候再試");
                }
                log.info("限制請求'{}',當前請求'{}',緩存key'{}'", count, number.intValue(), combineKey);
            } catch (ServiceException e) {
                throw e;
            } catch (Exception e) {
                throw new RuntimeException("服務器限流異常，請稍候再試");
            }
        }
        return joinPoint.proceed();
    }
	/**
     * Gets combine key.
     *
     * @param rateLimiter the rate limiter
     * @param signature   the signature
     * @return the combine key
     */
    public String getCombineKey(RateLimiter rateLimiter, MethodSignature signature) {
        StringBuilder stringBuffer = new StringBuilder(rateLimiter.key());
        if (rateLimiter.limitType() == LimitType.IP) {
            stringBuffer.append(RequestUtil.getIpAddr(((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest())).append("-");
        }
        Method method = signature.getMethod();
        Class<?> targetClass = method.getDeclaringClass();
        stringBuffer.append(targetClass.getName()).append("-").append(method.getName());
        return stringBuffer.toString();
    }
}

/**
 * 自定義ServiceException
 */
public class ServiceException extends Exception{
    public ServiceException(){
        super();
    }
    public ServiceException(String msg){
        super(msg);
    }
}
/**
 * 異常捕獲處理
 */
 @RestControllerAdvice
public class GlobalExceptionAdvice {
	@ExceptionHandler(ServiceException.class)
    public Result<Object> serviceException(ServiceException e) {
    	//Result.failure()是我們在些項目是自定義的統(tǒng)一返回
        return Result.failure(e.getMessage());
    }
}

@GetMapping("/strategy")
    @RateLimiter(time = 3,count = 1,limitType = LimitType.IP)
    public String strategyTest(){
        return "test";
    }