手写RateLimiter详解编程语言

package com.toov5.annotation; 
 
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 permitsPerSecond(); 
    
   //在规定的时间内，如果没有获取到令牌的话，直接走降级处理 
   long timeout(); 
}

package com.toov5.aop; 
 
import java.io.IOException; 
import java.io.PrintWriter; 
import java.lang.reflect.Method; 
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.toov5.annotation.ExtRateLimiter; 
 
//aop环绕通知 判断拦截所有springmvc请求，判断请求方法上是否存在ExtRateLimiter 
 
@Aspect  //aop两种方式 注解 和 xml方式 
@Component 
public class RateLimiterAop { 
    // 存放接口是否已经存在 
        private static ConcurrentHashMap<String, RateLimiter> rateLimiterMap = new ConcurrentHashMap<String, RateLimiter>(); 
 
     //定义切入点 拦截 
        @Pointcut("execution(public * com.toov5.controller.*.*(..))")  //所有类 所有方法 任意参数 
        public void rlAop() { 
        } 
         
        //使用aop环绕通知判断拦截所有springmvc请求，判断方法上是否存在ExRanteLimiter 
        @Around("rlAop()") 
        public Object doBefore(ProceedingJoinPoint proceedingJoinPoint) throws Throwable { 
            //[email protected] 
            //[email protected] 比如加上了RequestMapping表示请求方法 
         Method sinatureMethod = getSinatureMethod(proceedingJoinPoint); 
         if (sinatureMethod == null) { 
            //直接报错   
             return null; 
        }     
         
            //3、使用Java的反射机制获取拦截方法上自定义注解的参数 
        ExtRateLimiter extRateLimiter = sinatureMethod.getDeclaredAnnotation(ExtRateLimiter.class); 
        if (extRateLimiter==null) {  //方法上没有注解 
            //直接放行代码 进入实际请求方法中 
            proceedingJoinPoint.proceed(); 
        } 
            //4、调用原生RateLimiter创建令牌 
            double permitsPerSecond = extRateLimiter.permitsPerSecond();  //获取参数 
            long timeout = extRateLimiter.timeout(); 
            //调用原生的RateLimiter创建令牌 保证每个请求对应的是单例的RateLimiter 一个请求一个RateLimiter 使用hashMap 
            RateLimiter.create(permitsPerSecond); 
            String requestURI = getRequestUrl(); 
            RateLimiter rateLimiter = null; 
            if (rateLimiterMap.containsKey(requestURI)) { 
                //如果检测到  
              rateLimiter = rateLimiterMap.get(requestURI); 
            }else { 
                //如果没有 则添加 
                rateLimiter = RateLimiter.create(permitsPerSecond); 
                rateLimiterMap.put(requestURI, rateLimiter); 
            } 
          
            //5、获取桶中的令牌，如果没有有效期获取到令牌，直接调用降级方法。 
            boolean tryAcquire = rateLimiter.tryAcquire(timeout,TimeUnit.MILLISECONDS); 
            if (!tryAcquire) { 
                //服务降级 
                fallback(); 
                return null; 
            } 
            //6、否则 直接进入到实际请求方法中 
             
            return proceedingJoinPoint.proceed(); 
        }  
        private void fallback() throws IOException { 
            //在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) { 
                writer.close(); 
            } 
             
        } 
     private String getRequestUrl() { 
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes(); 
            HttpServletRequest request = attributes.getRequest(); 
            return request.getRequestURI(); 
     }     
     private Method getSinatureMethod(ProceedingJoinPoint proceedingJoinPoint) { 
         //获取到目标代理对象 
            MethodSignature signature = (MethodSignature) proceedingJoinPoint.getSignature(); 
            //获取当前aop拦截的方法         
         Method method = signature.getMethod(); 
         return method; 
     } 
}

package com.toov5.controller; 
 
import java.util.concurrent.TimeUnit; 
 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.web.bind.annotation.RequestMapping; 
import org.springframework.web.bind.annotation.RestController; 
 
import com.google.common.util.concurrent.RateLimiter; 
import com.toov5.annotation.ExtRateLimiter; 
import com.toov5.service.OrderService; 
 
@RestController 
public class IndexController { 
  @Autowired 
  private OrderService orderService; 
 //create方法中传入一个参数 以秒为单位固定的速率值 1r/s 往桶中存入一个令牌 
  RateLimiter rateLimiter = RateLimiter.create(1);  //独立线程！它自己是个线程 
    
  //相当于接口每秒只能接受一个客户端请求 
  @RequestMapping("/addOrder") 
    public String addOrder() { 
        //限流放在网关 获取到当前 客户端从桶中获取对应的令牌 结果表示从桶中拿到令牌等待时间 
        //如果获取不到令牌 就一直等待 
        double acquire = rateLimiter.acquire(); 
        System.out.println("从桶中获取令牌等待时间"+acquire); 
      boolean   tryAcquire=rateLimiter.tryAcquire(500,TimeUnit.MILLISECONDS);  //如果在500sms没有获取到令牌 直接走降级 
      if (!tryAcquire) { 
        System.out.println("别抢了，等等吧！"); 
        return "别抢了，等等吧！"; 
    } 
        //业务逻辑处理 
        boolean addOrderResult = orderService.addOrder(); 
        if (addOrderResult) { 
            System.out.println("恭喜抢购成功！等待时间"); 
            return "恭喜抢购成功！"; 
        } 
         
        return "抢购失败！"; 
    } 
  //以每秒1个的速度往桶中添加令牌  
  @RequestMapping("/findIndex") 
  @ExtRateLimiter(permitsPerSecond=1.0,timeout=500) 
  public void findIndex() { 
      System.out.println("findIndex"+System.currentTimeMillis()); 
  } 
   
}

package com.toov5.service; 
 
import org.springframework.stereotype.Service; 
 
@Service 
public class OrderService { 
     
    public boolean addOrder() { 
      System.out.println("db...正在操作订单表数据库");     
      return true; 
    } 
}

package com.toov5; 
 
import org.springframework.boot.SpringApplication; 
import org.springframework.boot.autoconfigure.SpringBootApplication; 
 
@SpringBootApplication 
public class App { 
  public static void main(String[] args) { 
    SpringApplication.run(App.class, args); 
       
} 
}