<!--springboot redis依賴-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

spring:
  redis:
    database: 3 # Redis數(shù)據(jù)庫索引（默認(rèn)為0）
    host: 127.0.0.1 # Redis服務(wù)器地址
    port: 6379 # Redis服務(wù)器連接端口
    password: 123456 # Redis服務(wù)器連接密碼（默認(rèn)為空）
    timeout: 2000  # 連接超時時間（毫秒）
    jedis:
      pool:
        max-active: 200         # 連接池最大連接數(shù)（使用負(fù)值表示沒有限制）
        max-idle: 20         # 連接池中的最大空閑連接
        min-idle: 0         # 連接池中的最小空閑連接
        max-wait: -1       # 連接池最大阻塞等待時間（使用負(fù)值表示沒有限制）

/**
 * @Description: redis配置類
 * @Author oyc
 * @Date 2020/4/22 11:50 下午
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    /**
     * RedisTemplate相關(guān)配置
     * 使redis支持插入對象
     *
     * @param factory
     * @return 方法緩存 Methods the cache
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置連接工廠
        template.setConnectionFactory(factory);
        // 設(shè)置key的序列化器
        template.setKeySerializer(new StringRedisSerializer());
        // 設(shè)置value的序列化器
        //使用Jackson 2，將對象序列化為JSON
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        //json轉(zhuǎn)對象類，不設(shè)置默認(rèn)的會將json轉(zhuǎn)成hashmap
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        return template;
    }
}

@Autowired
private RedisTemplate<String, Object> redisTemplate;

/**
 * @Description:
 * @Author oyc
 * @Date 2020/10/22 11:16 下午
 */
@Inherited
@Documented
@Target({ElementType.FIELD, ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface AccessLimit {

    /**
     * 指定second 時間內(nèi) API請求次數(shù)
     */
    int maxCount() default 5;

    /**
     * 請求次數(shù)的指定時間范圍  秒數(shù)(redis數(shù)據(jù)過期時間)
     */
    int second() default 60;
}

/**
 * @Description: 訪問攔截器
 * @Author oyc
 * @Date 2020/10/22 11:20 下午
 */
@Component
public class AccessLimitInterceptor implements HandlerInterceptor {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        try {// Handler 是否為 HandlerMethod 實(shí)例
            if (handler instanceof HandlerMethod) {
                // 強(qiáng)轉(zhuǎn)
                HandlerMethod handlerMethod = (HandlerMethod) handler;
                // 獲取方法
                Method method = handlerMethod.getMethod();
                // 是否有AccessLimit注解
                if (!method.isAnnotationPresent(AccessLimit.class)) {
                    return true;
                }
                // 獲取注解內(nèi)容信息
                AccessLimit accessLimit = method.getAnnotation(AccessLimit.class);
                if (accessLimit == null) {
                    return true;
                }
                int seconds = accessLimit.second();
                int maxCount = accessLimit.maxCount();

                // 存儲key
                String key = request.getRemoteAddr() + ":" + request.getContextPath() + ":" + request.getServletPath();

                // 已經(jīng)訪問的次數(shù)
                Integer count = (Integer) redisTemplate.opsForValue().get(key);
                System.out.println("已經(jīng)訪問的次數(shù):" + count);
                if (null == count || -1 == count) {
                    redisTemplate.opsForValue().set(key, 1, seconds, TimeUnit.SECONDS);
                    return true;
                }

                if (count < maxCount) {
                    redisTemplate.opsForValue().increment(key);
                    return true;
                }

                if (count >= maxCount) {
                    logger.warn("請求過于頻繁請稍后再試");
                    return false;
                }
            }
            return true;
        } catch (Exception e) {
            logger.warn("請求過于頻繁請稍后再試");
            e.printStackTrace();
        }
        return true;
    }
}

/**
 * @Description: 訪問攔截器配置
 * @Author oyc
 * @Date 2020/10/22 11:34 下午
 */
@Configuration
public class IntercepterConfig  implements WebMvcConfigurer {

    @Autowired
    private AccessLimitInterceptor accessLimitInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(accessLimitInterceptor)
                .addPathPatterns("/**").excludePathPatterns("/static/**","/login.html","/user/login");
    }
}

/**
 * @Description:
 * @Author oyc
 * @Date 2020/10/22 11:36 下午
 */
@RestController
@RequestMapping("access")
public class AccessLimitController {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    /**
     * 限流測試
     */
    @GetMapping
    @AccessLimit(maxCount = 3,second = 60)
    public String limit(HttpServletRequest request) {
        logger.error("Access Limit Test");
        return "限流測試";
    }

}