<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=localhostspring.redis.port=6379spring.redis.password=123
限流注解接下来我们创建一个限流注解，我们将限流分为两种情况：
针对当前接口的全局性限流，例如该接口可以在 1 分钟内访问 100 次。
针对某一个 ip 地址的限流，例如某个 ip 地址可以在 1 分钟内访问 100 次。
针对这两种情况，我们创建一个枚举类：
public enum limittype { /** * 默认策略全局限流 */ default, /** * 根据请求者ip进行限流 */ ip}
接下来我们来创建限流注解：
@target(elementtype.method)@retention(retentionpolicy.runtime)@documentedpublic @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 注解，然后配置相关参数即可。
定制 redistemplate在 spring boot 中，我们其实更习惯使用 spring data redis 来操作 redis，不过默认的 redistemplate 有一个小坑，就是序列化用的是 jdkserializationredisserializer，不知道小伙伴们有没有注意过，直接用这个序列化工具将来存到 redis 上的 key 和 value 都会莫名其妙多一些前缀，这就导致你用命令读取的时候可能会出错。
例如存储的时候，key 是 name，value 是 test，但是当你在命令行操作的时候，get name 却获取不到你想要的数据，原因就是存到 redis 之后 name 前面多了一些字符，此时只能继续使用 redistemplate 将之读取出来。
我们用 redis 做限流会用到 lua 脚本，使用 lua 脚本的时候，就会出现上面说的这种情况，所以我们需要修改 redistemplate 的序列化方案。
可能有小伙伴会说为什么不用 stringredistemplate 呢？stringredistemplate 确实不存在上面所说的问题，但是它能够存储的数据类型不够丰富，所以这里不考虑。
修改 redistemplate 序列化方案，代码如下：
@configurationpublic 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 序列化方式来解决。
lua 脚本这个其实我在之前 vhr 那一套视频中讲过，redis 中的一些原子操作我们可以借助 lua 脚本来实现，想要调用 lua 脚本，我们有两种不同的思路：
在 redis 服务端定义好 lua 脚本，然后计算出来一个散列值，在 java 代码中，通过这个散列值锁定要执行哪个 lua 脚本。
直接在 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)endcurrent = redis.call('incr', key)if tonumber(current) == 1 then redis.call('expire', key, time)endreturn tonumber(current)
这个脚本其实不难，大概瞅一眼就知道干啥用的。keys 和 argv 都是一会调用时候传进来的参数，tonumber 就是把字符串转为数字，redis.call 就是执行具体的 redis 指令，具体流程是这样：
首先获取到传进来的 key 以及 限流的 count 和时间 time。
通过 get 获取到这个 key 对应的值，这个值就是当前时间窗内这个接口可以访问多少次。
如果是第一次访问，此时拿到的结果为 nil，否则拿到的结果应该是一个数字，所以接下来就判断，如果拿到的结果是一个数字，并且这个数字还大于 count，那就说明已经超过流量限制了，那么直接返回查询的结果即可。
如果拿到的结果为 nil，说明是第一次访问，此时就给当前 key 自增 1，然后设置一个过期时间。
最后把自增 1 后的值返回就可以了。
其实这段 lua 脚本很好理解。
接下来我们在一个 bean 中来加载这段 lua 脚本，如下：
@beanpublic defaultredisscript<long> limitscript() { defaultredisscript<long> redisscript = new defaultredisscript<>(); redisscript.setscriptsource(new resourcescriptsource(new classpathresource("lua/limit.lua"))); redisscript.setresulttype(long.class); return redisscript;}
可以啦，我们的 lua 脚本现在就准备好了。
注解解析接下来我们就需要自定义切面，来解析这个注解了，我们来看看切面的定义：
@aspect@componentpublic 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 注解的方法，在前置通知中对注解进行处理。
首先获取到注解中的 key、time 以及 count 三个参数。
获取一个组合的 key，所谓的组合的 key，就是在注解的 key 属性基础上，再加上方法的完整路径，如果是 ip 模式的话，就再加上 ip 地址。以 ip 模式为例，最终生成的 key 类似这样：rate_limit:127.0.0.1-org.javaboy.ratelimiter.controller.hellocontroller-hello（如果不是 ip 模式，那么生成的 key 中就不包含 ip 地址）。
将生成的 key 放到集合中。
通过 redistemplate.execute 方法取执行一个 lua 脚本，第一个参数是脚本所封装的对象，第二个参数是 key，对应了脚本中的 keys，后面是可变长度的参数，对应了脚本中的 argv。
判断 lua 脚本执行后的结果是否超过 count，若超过则视为过载，抛出异常处理即可。
接口测试接下来我们就进行接口的一个简单测试，如下：
@restcontrollerpublic class hellocontroller { @getmapping("/hello") @ratelimiter(time = 5,count = 3,limittype = limittype.ip) public string hello() { return "hello>>>"+new date(); }}
每一个 ip 地址，在 5 秒内只能访问 3 次。
这个自己手动刷新浏览器都能测试出来。
全局异常处理由于过载的时候是抛异常出来，所以我们还需要一个全局异常处理器，如下：
@restcontrolleradvicepublic 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。 最后我们看看过载时的测试效果：
以上就是如何使用springboot + redis实现接口限流的详细内容。