SpringBoot接口访问频率限制的实现方式（二）

SpringBoot 接口访问频率限制的实现方式

书接前文，上篇文章说明了限制访问的概念，这篇文章讲解下实现原理

一、常见的实现方式

1.基于过滤器的实现

过滤器是Java Web应用中常用的一种组件，它可以在请求到达Servlet之前对请求进行预处理。通过在过滤器中实现限流逻辑，可以对所有的HTTP请求进行统一的限流控制。

2.基于拦截器的实现

拦截器是Spring框架提供的一种处理器，可以在请求处理之前和之后进行相关操作。相比于过滤器，拦截器可以更加细粒度地控制请求，适用于需要针对某些特定接口进行限流的场景。

3.基于第三方库Bucket4j的实现

Bucket4j是一个Java实现的高性能限流库，它支持多种限流算法，如令牌桶算法。通过使用Bucket4j，可以轻松地在Spring Boot应用中实现复杂的限流逻辑，并且它还提供了丰富的配置选项和统计功能。

二、实际代码示例

1.基于过滤器实现Rate Limiting

首先，我们需要创建一个自定义的过滤器类，并在其中实现限流逻辑。以下是一个示例代码：

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;

public class RateLimitingFilter implements Filter {
    private final ConcurrentMap<String, Long> requestCounts = new ConcurrentHashMap<>();
    private static final long ALLOWED_REQUESTS_PER_MINUTE = 60;

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化过滤器
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;

        String clientIp = httpRequest.getRemoteAddr();
        long currentTimeMillis = System.currentTimeMillis();
        requestCounts.putIfAbsent(clientIp, currentTimeMillis);

        long lastRequestTime = requestCounts.get(clientIp);
        if (TimeUnit.MILLISECONDS.toMinutes(currentTimeMillis - lastRequestTime) < 1) {
            long requestCount = requestCounts.values().stream().filter(time -> TimeUnit.MILLISECONDS.toMinutes(currentTimeMillis - time) < 1).count();
            if (requestCount > ALLOWED_REQUESTS_PER_MINUTE) {
                httpResponse.setStatus(HttpServletResponse.SC_TOO_MANY_REQUESTS);
                httpResponse.getWriter().write("Too many requests");
                return;
            }
        }
        
        requestCounts.put(clientIp, currentTimeMillis);
        chain.doFilter(request, response);
    }

    @Override
    public void destroy() {
        // 销毁过滤器
    }
}


// 然后，在Spring Boot应用的配置类中注册这个过滤器：
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean<RateLimitingFilter> loggingFilter(){
        FilterRegistrationBean<RateLimitingFilter> registrationBean = new FilterRegistrationBean<>();
        
        registrationBean.setFilter(new RateLimitingFilter());
        registrationBean.addUrlPatterns("/api/*");
        
        return registrationBean;
    }
}