Redis + Lua 实现分布式应用限流

客官°小女子只卖身不卖艺 2022-02-23 02:24 268阅读 0赞

## 前言 ##

今天讲的 redis+lua 解决分布式限流 任何框架都能用，只要能集成 redis就可以，不管是微服务 dubbo、springcloud，还是直接用 springboot或者 springMVC都通用的方法。

前面我们已经讲了三篇关于 网关做限流的解决方案了，可查看链接

*  [https://blog.csdn.net/weixin\_38003389/article/details/88992478][https_blog.csdn.net_weixin_38003389_article_details_88992478]
 *  [https://blog.csdn.net/weixin\_38003389/article/details/88999062][https_blog.csdn.net_weixin_38003389_article_details_88999062]
 *  [https://blog.csdn.net/weixin\_38003389/article/details/89000754][https_blog.csdn.net_weixin_38003389_article_details_89000754]

以上基于网关做限流操作，除了在 class 里面配置点东西，还需要在 yml 文件写配置，所以我这次使用 redis+lua 做限流，只需要在配置文件写你的 redis 配置就好了， 剩下的都交给 java 来处理。

东西好不好，大家往下看就清楚了，并且直接拿到你们项目里用就ok。

## 正文 ##

介绍一下本次使用所有框架和中间件的版本

### 环境 ###

<table> 
 <thead> 
  <tr> 
   <th> <p>框架</p> </th> 
   <th> <p>版本</p> </th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td> <p>Spring Boot</p> </td> 
   <td>2.0.3.RELEASE</td> 
  </tr> 
  <tr> 
   <td> <p>Spring Cloud</p> </td> 
   <td> <p>Finchley.RELEASE</p> </td> 
  </tr> 
  <tr> 
   <td> <p>redis</p> </td> 
   <td>redis-4.0.11</td> 
  </tr> 
  <tr> 
   <td> <p>JDK</p> </td> 
   <td> <p>1.8.x</p> </td> 
  </tr> 
 </tbody> 
</table>

### 前置准备工作 ###

1.  本机安装一个 redis ，端口按默认的，然后启动。
2.  创建一个 eureka-service ，端口是 8888，然后启动。
3.  父工程pom文件，滑动滚轮即可看到pom 的内容。

**父pom**

<modules>
            <module>ch3-4-eureka-client</module>
            <module>ch3-4-eureka-server</module>
            <module>redis-tool</module>
        </modules>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.0.3.RELEASE</version>
            <relativePath/> 
        </parent>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
            <java.version>1.8</java.version>
            <spring-cloud.version>Finchley.RELEASE</spring-cloud.version>
        </properties>
    
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>${spring-cloud.version}</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</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-test</artifactId>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-aop</artifactId>
            </dependency>
        </dependencies>

### 核心代码示例 ###

首先我们创建一个本次核心的工程，这个工程完全可以是你们项目里公共工程的其中一个文件夹，但在我的 Demo 中我这个重要的工程起名叫 redis-tool。

我们看这个工程所用到的依赖均在 父pom 中，需要有 aop 和redis 的依赖。

接下来看一下 我使用的 Lua 脚本，以下内容复制到 该项目的 resources 目录下，起名 limit.lua 即可。

local key = "rate.limit:" .. KEYS[1] --限流KEY
    local limit = tonumber(ARGV[1])        --限流大小
    local current = tonumber(redis.call('get', key) or "0")
    if current + 1 > limit then --如果超出限流大小
      return 0
    else  --请求数+1，并设置2秒过期
      redis.call("INCRBY", key,"1")
       redis.call("expire", key,"2")
       return current + 1
    end

**解释 Lua 脚本含义：**

*  我们通过KEYS\[1\] 获取传入的key参数 
 *  通过ARGV\[1\]获取传入的limit参数 
 *  redis.call方法，从缓存中get和key相关的值，如果为null那么就返回0 
 *  接着判断缓存中记录的数值是否会大于限制大小，如果超出表示该被限流，返回0 
 *  如果未超过，那么该key的缓存值+1，并设置过期时间为1秒钟以后，并返回缓存值+1

**限流注解**

** **我们自定义一个注解，用来其他服务做限流使用的。

import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * 自定义限流注解
     *
     * @author yanlin
     * @version v1.3
     * @date 2019-04-05 7:58 PM
     * @since v8.0
     **/
    @Target({ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface RateLimit {
        String key() default "limit";
    
        int time() default 5;
    
        int count() default 5;
    }

**配置类**

@Component
    public class Commons {
    
        @Bean
        public DefaultRedisScript<Number> redisluaScript() {
            DefaultRedisScript<Number> redisScript = new DefaultRedisScript<>();
    //读取 lua 脚本
            redisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("limit.lua")));
            redisScript.setResultType(Number.class);
            return redisScript;
        }
        @Bean
        public RedisTemplate<String, Serializable> limitRedisTemplate(LettuceConnectionFactory redisConnectionFactory) {
            RedisTemplate<String, Serializable> template = new RedisTemplate<String, Serializable>();
            template.setKeySerializer(new StringRedisSerializer());
            template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
            template.setConnectionFactory(redisConnectionFactory);
            return template;
        }
    
    }

**拦截器**

/**
     * 拦截器
     * @author yanlin
     * @version v1.3
     * @date 2019-04-05 8:06 PM
     * @since v8.0
     **/
    @Aspect
    @Configuration
    public class LimitAspect {
        private static final Logger logger = LoggerFactory.getLogger(LimitAspect.class);
    
        @Autowired
        private RedisTemplate<String, Serializable> limitRedisTemplate;
    
        @Autowired
        private DefaultRedisScript<Number> redisluaScript;
    
        @Around("execution(* cn.springcloud.book.controller ..*(..) )")
        public Object interceptor(ProceedingJoinPoint joinPoint) throws Throwable {
    
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            Class<?> targetClass = method.getDeclaringClass();
            RateLimit rateLimit = method.getAnnotation(RateLimit.class);
    
            if (rateLimit != null) {
                HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
                String ipAddress = getIpAddr(request);
    
                StringBuffer stringBuffer = new StringBuffer();
                stringBuffer.append(ipAddress).append("-")
                        .append(targetClass.getName()).append("- ")
                        .append(method.getName()).append("-")
                        .append(rateLimit.key());
    
                List<String> keys = Collections.singletonList(stringBuffer.toString());
    
                Number number = limitRedisTemplate.execute(redisluaScript, keys, rateLimit.count(), rateLimit.time());
    
                if (number != null && number.intValue() != 0 && number.intValue() <= rateLimit.count()) {
                    logger.info("限流时间段内访问第：{} 次", number.toString());
                    return joinPoint.proceed();
                }
    
            } else {
                return joinPoint.proceed();
            }
    //由于本文没有配置公共异常类，如果配置可替换
            throw new RuntimeException("已经到设置限流次数");
        }
    
        private static String getIpAddr(HttpServletRequest request) {
            String ipAddress = null;
            try {
                ipAddress = request.getHeader("x-forwarded-for");
                if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                    ipAddress = request.getHeader("Proxy-Client-IP");
                }
                if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                    ipAddress = request.getHeader("WL-Proxy-Client-IP");
                }
                if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                    ipAddress = request.getRemoteAddr();
                }
                // 对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割
                if (ipAddress != null && ipAddress.length() > 15) { // "***.***.***.***".length()
                    // = 15
                    if (ipAddress.indexOf(",") > 0) {
                        ipAddress = ipAddress.substring(0, ipAddress.indexOf(","));
                    }
                }
            } catch (Exception e) {
                ipAddress = "";
            }
            return ipAddress;
        }
    
    }

**代码解释：**

拦截器 拦截 `@RateLimit `注解的方法，使用`Redsi execute` 方法执行我们的限流脚本，判断是否超过限流次数，

我们这里 execution 参数 在你们实际项目中需要变更，一半都会定位到你们 controller层。

### 创建 eureka-client 工程 ###

该工程在项目中就是你们需要做限流的服务，我们创建 一个maven 项目 ，端口设定8081，然后下面是 我 redis 的配置

**redis 配置**

spring:
      # Redis数据库索引
      redis:
        database: 0
      # Redis服务器地址
        host: 127.0.0.1
      # Redis服务器连接端口
        port: 6379
      # Redis服务器连接密码（默认为空）
        password:
      # 连接池最大连接数（使用负值表示没有限制）
        jedis:
          pool:
            max-active: 8
      # 连接池最大阻塞等待时间（使用负值表示没有限制）
            max-wait: -1
      # 连接池中的最大空闲连接
            max-idle: 8
      # 连接池中的最小空闲连接
            min-idle: 0
      # 连接超时时间（毫秒）
        timeout: 10000

**pom 文件**

<parent>
            <groupId>cn.springcloud.book</groupId>
            <artifactId>ch3-4</artifactId>
            <version>0.0.1-SNAPSHOT</version>
            <relativePath>../pom.xml</relativePath> 
        </parent>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            </dependency>
            <dependency>
                <groupId>redis-tool</groupId>
                <artifactId>redis-tool</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            </dependency>
    
        </dependencies>

**控制层**

我们在 controller 层的方法上加上我们的自定义限流注解，可以按照我们的默认值，也可以自定义参数。

@RestController
    public class LimitController {
    
    
        @RateLimit(key = "test", time = 10, count = 10)
        @GetMapping("/test/limit")
        public String testLimit() {
            return "Hello,ok";
        }
    
        @RateLimit()
        @GetMapping("/test/limit/a")
        public String testLimitA() {
            return "Hello,ok";
        }
    }

** 启动类**

** **有一个关键的地方，我们需要引用 redis-tool 中的包，但是利用@ComponentScan 注解也会排除本工程的包，所以，这里我们要写上本工程包 和redis-tool中的包，一会在下面看我工程结构就明白了。

@SpringBootApplication
    @EnableDiscoveryClient
    @ComponentScan(value = {"com.annotaion", "cn.springcloud", "com.config"})
    
    public class Ch34EurekaClientApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(Ch34EurekaClientApplication.class, args);
        }
    }

**测试**

我们最好把 redis-tool 项目 install 一下，然后启动 eureka-client 工程，访问 [http://localhost:8081/test/limit/a][http_localhost_8081_test_limit_a]  5秒中超过5次访问 页面和后端就会报错。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwMzM4OQ_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwMzM4OQ_size_16_color_FFFFFF_t_70 1][]

当然我们不能说流量被限制了给用户一个500吧，所以我们还需要对后端对报错进行一个统一拦截，springboot 统一异常处理我已经出过文章了， 请点击 [https://blog.csdn.net/weixin\_38003389/article/details/83149252][https_blog.csdn.net_weixin_38003389_article_details_83149252] 进行配置，这样就可以友好对输出到前端。

本文参考文献：[https://blog.csdn.net/yanpenglei/article/details/81772530][https_blog.csdn.net_yanpenglei_article_details_81772530]

作者叫磊哥，加我微信可以联系到本人哦

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwMzM4OQ_size_16_color_FFFFFF_t_70 2][]

[https_blog.csdn.net_weixin_38003389_article_details_88992478]: https://blog.csdn.net/weixin_38003389/article/details/88992478
[https_blog.csdn.net_weixin_38003389_article_details_88999062]: https://blog.csdn.net/weixin_38003389/article/details/88999062
[https_blog.csdn.net_weixin_38003389_article_details_89000754]: https://blog.csdn.net/weixin_38003389/article/details/89000754
[http_localhost_8081_test_limit_a]: http://localhost:8081//test/limit/a
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwMzM4OQ_size_16_color_FFFFFF_t_70]: /images/20220223/23e75fcbba51408386af2150adc3743f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwMzM4OQ_size_16_color_FFFFFF_t_70 1]: /images/20220223/d065d6ff6d474887bcaafb787d45c8cf.png
[https_blog.csdn.net_weixin_38003389_article_details_83149252]: https://blog.csdn.net/weixin_38003389/article/details/83149252
[https_blog.csdn.net_yanpenglei_article_details_81772530]: https://blog.csdn.net/yanpenglei/article/details/81772530
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwMzM4OQ_size_16_color_FFFFFF_t_70 2]: /images/20220223/711a3f36f0f349d5b25455945204ebb4.png