高并发限流纯手写RateLimiter注解版本

RateLimiter实现令牌桶限流

什么是RateLimiter？

RateLimiter是guava提供的基于令牌桶算法的实现类，可以非常简单的完成限流特技，并且根据系统的实际情况来调整生成token的速率。

通常可应用于抢购限流防止冲垮系统；限制某接口、服务单位时间内的访问量，譬如一些第三方服务会对用户访问量进行限制；限制网速，单位时间内只允许上传下载多少字节等。

参考：https://www.jianshu.com/p/226c7907905c

我们先来说说令牌桶算法原理：

这样的好处就是：一个接口突然面对高并发，通过令牌桶算法可以很好的解决这个问题。

下面直接上代码：

一，需要先引入guava的maven依赖

      <parent>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-parent</artifactId>

            <version>2.0.0.RELEASE</version>

      </parent>

      <dependencies>

            <dependency>

                  <groupId>org.springframework.boot</groupId>

                  <artifactId>spring-boot-starter-web</artifactId>

            </dependency>

            <dependency>

                  <groupId>com.google.guava</groupId>

                  <artifactId>guava</artifactId>

                  <version>25.1-jre</version>

            </dependency>

      </dependencies>

 

二，自定义一个注解

import java.lang.annotation.Documented;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;


@Target({ ElementType.METHOD })

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface ExtRateLimiter {

    // 以每秒为单位固定的速率值往令牌桶中添加令牌

    double permitsPerSeconds();

    // 在规定的毫秒数中,如果没有获取到令牌的话，则直接走服务降级处理

    long timeouts();

}

 

三，定义请求方法注解：

// 以每秒添加1个令牌到令牌桶中

@ExtRateLimiter(permitsPerSeconds = 1.0, timeouts = 500)

@RequestMapping("/findIndex")

public String findIndex() {

    System.out.println("findIndex" + System.currentTimeMillis());

    return "findIndex" + System.currentTimeMillis();

}

 

 

四。通过Aop切面，环绕通知拦截方法是否有这个注解，如果有就直接调用令牌桶方法

package com.itmayiedu.aop;


import java.io.IOException;

import java.io.PrintWriter;

import java.lang.reflect.Method;

import java.util.Map;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.TimeUnit;


import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;


import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Pointcut;

import org.aspectj.lang.reflect.MethodSignature;

import org.springframework.stereotype.Component;

import org.springframework.web.context.request.RequestContextHolder;

import org.springframework.web.context.request.ServletRequestAttributes;


import com.google.common.util.concurrent.RateLimiter;

import com.itmayiedu.annotation.ExtRateLimiter;


/**
 * 功能说明:使用AOP环绕通知判断拦截所有springmvc 请求，判断请求方法上是否存在ExtRateLimiter <br>
 * <p>
 * 1.判断请求方法上是否有@ExtRateLimiter<br>
 * <p>
 * 2.如果方法上存在@ExtRateLimiter注解话<br>
 * <p>
 * 3.使用反射技术获取@ExtRateLimiter注解方法上的参数<br>
 * <p>
 * 4.调用原生RateLimiter代码创建令牌桶<br>
 * <p>
 * 5.如果获取令牌超时的，直接调用服务降级方法（需要自己定义）<br>
 * <p>
 * 6.如果能够获取令牌的话，直接进入实际请求方法。<br>
 * <p>
 * AOP创建方式有两种 注解版本和XML方式<br>
 * <p>
 * <br>
 * <p>
 * <br>
 */

@Aspect

@Component

public class RateLimiterAop {

    private Map<String, RateLimiter> rateHashMap = new ConcurrentHashMap<>();


    // 定义切入点 拦截com.itmayeidu.api

    @Pointcut("execution(public * com.itmayeidu.api.*.*(..))")


    public void rlAop() {

    }


    // 使用AOP环绕通知判断拦截所有springmvc 请求，判断请求方法上是否存在ExtRateLimiter注解

    @Around("rlAop()")

    public Object doBefore(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {

        // 1.如果请求方法上存在@ExtRateLimiter注解的话

        Method sinatureMethod = getSinatureMethod(proceedingJoinPoint);

        if (sinatureMethod == null) {

            // 直接报错

            return null;

        }

        // 2.使用java的反射机制获取拦截方法上自定义注解的参数

        ExtRateLimiter extRateLimiter = sinatureMethod.getDeclaredAnnotation(ExtRateLimiter.class);

        if (extRateLimiter == null) {

            // 直接进入实际请求方法中

            return proceedingJoinPoint.proceed();

        }

        double permitsPerSecond = extRateLimiter.permitsPerSeconds();

        long timeout = extRateLimiter.timeouts();

        // 3.调用原生的RateLimiter创建令牌 保证每个请求对应都是单例的RateLimiter
        
        // /index---RateLimiter /order --RateLimiter 使用hashMap key为 请求的url地址##
        
        // 相同的请求在同一个桶

        String requestURI = getRequestURI();

        RateLimiter rateLimiter = null;

        if (rateHashMap.containsKey(requestURI)) {

            // 如果在hashMap URL 能检测到RateLimiter

            rateLimiter = rateHashMap.get(requestURI);

        } else {

            // 如果在hashMap URL 没有检测到RateLimiter 添加新的RateLimiter

            rateLimiter = RateLimiter.create(permitsPerSecond);

            rateHashMap.put(requestURI, rateLimiter);

        }

        // 4.获取令牌桶中的令牌，如果没有有效期获取到令牌的话，则直接调用本地服务降级方法，不会进入到实际请求方法中。

        boolean tryAcquire = rateLimiter.tryAcquire(timeout, TimeUnit.MILLISECONDS);

        if (!tryAcquire) {

            // 服务降级
            
            fallback();

            return null;

        }

        // 5.获取令牌桶中的令牌，如果能在有效期获取令牌到令的话，则直接进入到实际请求方法中。
        // 直接进入实际请求方法中
        
        return proceedingJoinPoint.proceed();

    }


    private void fallback() throws IOException {

        System.out.println("服务降级别抢了， 在抢也是一直等待的， 还是放弃吧！！！");

        // 在AOP编程中获取响应
        
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();

        HttpServletResponse response = attributes.getResponse();

        response.setHeader("Content-type", "text/html;charset=UTF-8");

        PrintWriter writer = response.getWriter();

        try {

            writer.println("别抢了， 在抢也是一直等待的， 还是放弃吧！！！");

        } catch (Exception e) {


        } finally {

            writer.close();


        }


    }


    private String getRequestURI() {

        return getRequest().getRequestURI();

    }


    private HttpServletRequest getRequest() {

        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();

        return attributes.getRequest();

    }


    // 获取到AOP拦截的方法
    
    private Method getSinatureMethod(ProceedingJoinPoint proceedingJoinPoint) {

        MethodSignature signature = (MethodSignature) proceedingJoinPoint.getSignature();

        // 获取到AOP拦截的方法
        
        Method method = signature.getMethod();

        return method;

    }


}

五，代码核心已经全部实现是不是很简单。

其他请参考：https://blog.csdn.net/tianyaleixiaowu/article/details/74942021

创作不易希望大家多多支持