Redis和Nginx实现限制接口请求频率的示例

redis > zadd runoobkey 1 redis
(integer) 1
redis > zadd runoobkey 2 mongodb
(integer) 1
redis > zadd runoobkey 3 mysql
(integer) 1
redis > zadd runoobkey 3 mysql
(integer) 0
redis > zadd runoobkey 4 mysql
(integer) 0
redis > zrange runoobkey 0 10 withscores

1) "redis"
2) "1"
3) "mongodb"
4) "2"
5) "mysql"
6) "4"

redis > zrange runoobkey 0 10 withscores

1) "redis"
2) "1"
3) "mongodb"
4) "2"
5) "mysql"
6) "4"

redis > zrem mongodb
(integer) 1

redis > zrange runoobkey 0 10 withscores
1) "redis"
2) "1"
3) "mysql"
4) "4"

redis > zadd myzset 1 "one"
(integer) 1
redis > zadd myzset 2 "two"
(integer) 1
redis > zcard myzset
(integer) 2

redis > zrange salary 0 -1 withscores
1) "tom"
2) "2000"
3) "peter"
4) "3500"
5) "jack"
6) "5000"

redis > zremrangebyscore salary 1500 3500
(integer) 2

redis> zrange salary 0 -1 withscores
1) "jack"
2) "5000"

package org.example.interceptor;

import cn.hutool.json.jsonobject;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.data.redis.core.stringredistemplate;
import org.springframework.http.httpstatus;
import org.springframework.stereotype.component;
import org.springframework.web.servlet.handlerinterceptor;

import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletresponse;
import java.util.hashmap;
import java.util.concurrent.timeunit;

/**
 * 限流拦截器
 */
@component
public class ratelimiterinterceptor implements handlerinterceptor {
    private static final string rate_limiter_prefix = "rate-limiter:";
    private static final int limit = 10; // 限流阈值
    private static final int time_window = 60; // 时间窗口，单位为秒

    @autowired
    private stringredistemplate stringredistemplate;

    @override
    public boolean prehandle(httpservletrequest request, httpservletresponse response, object handler) throws exception {
        response.setcharacterencoding("utf-8");
        response.setcontenttype("application/json");

        string key = rate_limiter_prefix + request.getrequesturi() + ":" + request.getremoteaddr(); // rate-limiter:/api/sendcode:127.0.0.1

        long currenttime = system.currenttimemillis(); // 1703036748554
        long beforetime = currenttime - time_window * 1000; // 1703036748554 - 60000 = 1703036688554

        // long removenum = stringredistemplate.opsforzset().removerangebyscore(k key, double min, double max); // 删除有序集合中分数在指定范围内的元素，返回删除元素的数量
        stringredistemplate.opsforzset().removerangebyscore(key, 0, beforetime); // 删除有序集合中60秒之前存进去的所有数据，如：

        // long membernum = stringredistemplate.opsforzset().size(k key); // 获取有序集合中元素的数量
        long count = stringredistemplate.opsforzset().size(key); // 3
        if (count >= limit) {
            hashmap<string, object> responseobj = new hashmap<>();
            responseobj.put("code", httpstatus.too_many_requests.value());
            responseobj.put("success", false);
            responseobj.put("msg", httpstatus.too_many_requests.getreasonphrase());
            jsonobject json = new jsonobject(responseobj);
            response.getwriter().println(json);
            return false;
        } else {
            // boolean addflag = stringredistemplate.opsforzset().add(k var1, v var2, double var3); // 向有序集合中添加一个或多个元素，并指定其分数
            stringredistemplate.opsforzset().add(key, string.valueof(currenttime), currenttime);

            // boolean expireflag = stringredistemplate.expire(k key, long timeout, timeunit unit); // 对指定key的数据设置过期时间
            stringredistemplate.expire(key, time_window, timeunit.seconds);

            return true;
        }
    }
}

package org.example.config;

import org.example.interceptor.ratelimiterinterceptor;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.context.annotation.configuration;
import org.springframework.web.servlet.config.annotation.interceptorregistry;
import org.springframework.web.servlet.config.annotation.webmvcconfigurationsupport;

@configuration
public class resourceconfig extends webmvcconfigurationsupport {
    @autowired
    private ratelimiterinterceptor ratelimiterinterceptor;

    @override
    public void addinterceptors(interceptorregistry registry) {
        registry.addinterceptor(ratelimiterinterceptor).addpathpatterns("/abcd/api/sendcode");
    }
}

user  nginx;
worker_processes  1;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

    include /etc/nginx/conf.d/*.conf;

    # 负载均衡
    upstream springboot {
        server xxx.xxx.xxx.xxx:8080;
    }

    # limit_req_zone $binary_remote_addr zone=limit_zone:10m rate=10r/s; # 定义了一个名为limit_zone的限流区域，使用ip地址进行限流，该区域的大小为10mb，限流速率为10个请求每秒。

    limit_req_zone $binary_remote_addr zone=limit_zone:10m rate=10r/m; # 定义了一个名为limit_zone的限流区域，使用ip地址进行限流，该区域的大小为10mb，限流速率为10个请求每分钟。


    # 80端口的服务
    server { 
        listen       80;
        server_name  xxx.xxx.xxx.xxx;

        location / {
            alias  html;
            index  index.html index.htm;
            try_files $uri $uri/ /love/index.html;
            proxy_pass http://localhost;
        }

        location ^~ /love/ {
            root   html/love;
            index  index.html index.htm;
            proxy_pass http://localhost;
        }

        location ^~ /abcd/api/sendcode {
          # 在/xxx/api/sendcode接口的location中使用limit_req指令进行限流，限流区域为limit_zone，同时设置了一个瞬时突发流量为20个请求的阈值。
          # 这样，当同一个ip地址在一秒钟内发送超过10个请求到此接口时，nginx会返回503错误码，表示请求被限流了。
          # limit_req zone=limit_zone burst=20;

          # 在/xxx/api/sendcode接口的location中使用limit_req指令进行限流，限流区域为limit_zone，同时设置了一个瞬时突发流量为5个请求的阈值。
          # 这样，当同一个ip地址在一秒钟内发送超过10个请求到此接口时，如果在一分钟内有超过10个请求，则允许其中的5个请求通过，nodelay表示不延迟响应，即立即返回503错误码。
          limit_req zone=limit_zone burst=5 nodelay;

          proxy_pass http://springboot;
        }
    }
}