关于redis:Redis-做接口限流一个注解的事

31次阅读

共计 6586 个字符，预计需要花费 17 分钟才能阅读完成。

Redis 除了做缓存，还无能很多很多事件：分布式锁、限流、解决申请接口幂等性。。。太多太多了～

明天想和小伙伴们聊聊用 Redis 解决接口限流，这也是最近的 TienChin 我的项目波及到这个知识点了，我就拎进去和大家聊聊这个话题，前面视频也会讲。

1. 筹备工作

首先咱们创立一个 Spring Boot 工程，引入 Web 和 Redis 依赖，同时思考到接口限流个别是通过注解来标记，而注解是通过 AOP 来解析的，所以咱们还须要加上 AOP 的依赖，最终的依赖如下：

<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>

而后提前准备好一个 Redis 实例，这里咱们我的项目配置好之后，间接配置一下 Redis 的根本信息即可，如下：

spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=123

好啦，筹备工作就算是到位了。

2. 限流注解

接下来咱们创立一个限流注解，咱们将限流分为两种状况：

  1. 针对以后接口的全局性限流，例如该接口能够在 1 分钟内拜访 100 次。
  2. 针对某一个 IP 地址的限流，例如某个 IP 地址能够在 1 分钟内拜访 100 次。

针对这两种状况，咱们创立一个枚举类：

public enum LimitType {
    /**
     * 默认策略全局限流
     */
    DEFAULT,
    /**
     * 依据请求者 IP 进行限流
     */
    IP
}

接下来咱们来创立限流注解：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RateLimiter {
    /**
     * 限流 key
     */
    String key() default "rate_limit:";

    /**
     * 限流工夫, 单位秒
     */
    int time() default 60;

    /**
     * 限流次数
     */
    int count() default 100;

    /**
     * 限流类型
     */
    LimitType limitType() default LimitType.DEFAULT;}

第一个参数限流的 key，这个仅仅是一个前缀，未来残缺的 key 是这个前缀再加上接口办法的残缺门路，独特组成限流 key，这个 key 将被存入到 Redis 中。

另外三个参数好了解，我就不多说了。

好了，未来哪个接口须要限流，就在哪个接口上增加 @RateLimiter 注解，而后配置相干参数即可。

3. 定制 RedisTemplate

小伙伴们晓得，在 Spring Boot 中，咱们其实更习惯应用 Spring Data Redis 来操作 Redis，不过默认的 RedisTemplate 有一个小坑，就是序列化用的是 JdkSerializationRedisSerializer，不晓得小伙伴们有没有留神过，间接用这个序列化工具未来存到 Redis 上的 key 和 value 都会莫名其妙多一些前缀，这就导致你用命令读取的时候可能会出错。

例如存储的时候，key 是 name，value 是 javaboy，然而当你在命令行操作的时候，get name 却获取不到你想要的数据，起因就是存到 redis 之后 name 后面多了一些字符，此时只能持续应用 RedisTemplate 将之读取进去。

咱们用 Redis 做限流会用到 Lua 脚本，应用 Lua 脚本的时候，就会呈现下面说的这种状况，所以咱们须要批改 RedisTemplate 的序列化计划。

可能有小伙伴会说为什么不必 StringRedisTemplate 呢？StringRedisTemplate 的确不存在下面所说的问题，然而它可能存储的数据类型不够丰盛，所以这里不思考。

批改 RedisTemplate 序列化计划，代码如下：

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        // 应用 Jackson2JsonRedisSerialize 替换默认序列化 (默认采纳的是 JDK 序列化)
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        redisTemplate.setKeySerializer(jackson2JsonRedisSerializer);
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        return redisTemplate;
    }
}

这个其实也没啥好说的，key 和 value 咱们都应用 Spring Boot 中默认的 jackson 序列化形式来解决。

4. 开发 Lua 脚本

这个其实我在之前 vhr 那一套视频中讲过，Redis 中的一些原子操作咱们能够借助 Lua 脚本来实现，想要调用 Lua 脚本，咱们有两种不同的思路：

  1. 在 Redis 服务端定义好 Lua 脚本，而后计算出来一个散列值，在 Java 代码中，通过这个散列值锁定要执行哪个 Lua 脚本。
  2. 间接在 Java 代码中将 Lua 脚本定义好，而后发送到 Redis 服务端去执行。

Spring Data Redis 中也提供了操作 Lua 脚本的接口，还是比拟不便的，所以咱们这里就采纳第二种计划。

咱们在 resources 目录下新建 lua 文件夹专门用来寄存 lua 脚本，脚本内容如下：

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)

这个脚本其实不难，大略瞅一眼就晓得干啥用的。KEYS 和 ARGV 都是一会调用时候传进来的参数，tonumber 就是把字符串转为数字，redis.call 就是执行具体的 redis 指令，具体流程是这样：

  1. 首先获取到传进来的 key 以及 限流的 count 和工夫 time。
  2. 通过 get 获取到这个 key 对应的值，这个值就是以后工夫窗内这个接口能够拜访多少次。
  3. 如果是第一次拜访，此时拿到的后果为 nil，否则拿到的后果应该是一个数字，所以接下来就判断，如果拿到的后果是一个数字，并且这个数字还大于 count，那就阐明曾经超过流量限度了，那么间接返回查问的后果即可。
  4. 如果拿到的后果为 nil，阐明是第一次拜访，此时就给以后 key 自增 1，而后设置一个过期工夫。
  5. 最初把自增 1 后的值返回就能够了。

其实这段 Lua 脚本很好了解。

接下来咱们在一个 Bean 中来加载这段 Lua 脚本，如下：

@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;
}

能够啦，咱们的 Lua 脚本当初就筹备好了。

5. 注解解析

接下来咱们就须要自定义切面，来解析这个注解了，咱们来看看切面的定义：

@Aspect
@Component
public class RateLimiterAspect {private static final Logger log = LoggerFactory.getLogger(RateLimiterAspect.class);

    @Autowired
    private RedisTemplate<Object, Object> redisTemplate;

    @Autowired
    private RedisScript<Long> limitScript;

    @Before("@annotation(rateLimiter)")
    public void doBefore(JoinPoint point, RateLimiter rateLimiter) throws Throwable {String key = rateLimiter.key();
        int time = rateLimiter.time();
        int count = rateLimiter.count();

        String combineKey = getCombineKey(rateLimiter, point);
        List<Object> keys = Collections.singletonList(combineKey);
        try {Long number = redisTemplate.execute(limitScript, keys, count, time);
            if (number==null || number.intValue() > count) {throw new ServiceException("拜访过于频繁，请稍候再试");
            }
            log.info("限度申请'{}', 以后申请'{}', 缓存 key'{}'", count, number.intValue(), key);
        } catch (ServiceException e) {throw e;} catch (Exception e) {throw new RuntimeException("服务器限流异样，请稍候再试");
        }
    }

    public String getCombineKey(RateLimiter rateLimiter, JoinPoint point) {StringBuffer stringBuffer = new StringBuffer(rateLimiter.key());
        if (rateLimiter.limitType() == LimitType.IP) {stringBuffer.append(IpUtils.getIpAddr(((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest())).append("-");
        }
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();
        Class<?> targetClass = method.getDeclaringClass();
        stringBuffer.append(targetClass.getName()).append("-").append(method.getName());
        return stringBuffer.toString();}
}

这个切面就是拦挡所有加了 @RateLimiter 注解的办法，在前置告诉中对注解进行解决。

  1. 首先获取到注解中的 key、time 以及 count 三个参数。
  2. 获取一个组合的 key，所谓的组合的 key，就是在注解的 key 属性根底上，再加上办法的残缺门路，如果是 IP 模式的话，就再加上 IP 地址。以 IP 模式为例，最终生成的 key 相似这样：rate_limit:127.0.0.1-org.javaboy.ratelimiter.controller.HelloController-hello（如果不是 IP 模式，那么生成的 key 中就不蕴含 IP 地址）。
  3. 将生成的 key 放到汇合中。
  4. 通过 redisTemplate.execute 办法取执行一个 Lua 脚本，第一个参数是脚本所封装的对象，第二个参数是 key，对应了脚本中的 KEYS，前面是可变长度的参数，对应了脚本中的 ARGV。
  5. 将 Lua 脚本执行的后果与 count 进行比拟，如果大于 count，就阐明过载了，抛异样就行了。

好了，功败垂成了。

6. 接口测试

接下来咱们就进行接口的一个简略测试，如下：

@RestController
public class HelloController {@GetMapping("/hello")
    @RateLimiter(time = 5,count = 3,limitType = LimitType.IP)
    public String hello() {return "hello>>>"+new Date();
    }
}

每一个 IP 地址，在 5 秒内只能拜访 3 次。

这个本人手动刷新浏览器都能测试进去。

7. 全局异样解决

因为过载的时候是抛异样进去，所以咱们还须要一个全局异样处理器，如下：

@RestControllerAdvice
public class GlobalException {@ExceptionHandler(ServiceException.class)
    public Map<String,Object> serviceException(ServiceException e) {HashMap<String, Object> map = new HashMap<>();
        map.put("status", 500);
        map.put("message", e.getMessage());
        return map;
    }
}

这是一个小 demo，我就不去定义实体类了，间接用 Map 来返回 JSON 了。

好啦，功败垂成。

最初咱们看看过载时的测试成果：

好啦，这就是咱们应用 Redis 做限流的形式。

松哥最近正在录制 TienChin 我的项目视频，本文的内容也是 TienChin 我的项目视频的一部分～TienChin 我的项目采纳 Spring Boot+Vue3 技术栈，里边会波及到各种好玩的技术，小伙伴们来和松哥一起做一个完成率超 90% 的我的项目。

正文完
redis
发表至： redis
2022-05-17
 0
关于golang:优雅的写单元测试
关于redis:redis进阶4限流策略
关于redis:Redis-高并发场景-获取连接失败-amp-击穿-amp-锁-等问题复盘
关于redis:腾讯云大佬亲码redis深度笔记不讲一句废话全是精华