高并发限流纯手写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>
 * 1.判断请求方法上是否有@ExtRateLimiter<br>
 * 2.如果方法上存在@ExtRateLimiter注解话<br>
 * 3.使用反射技术获取@ExtRateLimiter注解方法上的参数<br>
 * 4.调用原生RateLimiter代码创建令牌桶<br>
 * 5.如果获取令牌超时的，直接调用服务降级方法（需要自己定义）<br>
 * 6.如果能够获取令牌的话，直接进入实际请求方法。<br>
 * AOP创建方式有两种 注解版本和XML方式<br>
 * <br>
 * <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

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