Comment SpringBoot utilise-t-il RateLimiter pour limiter le courant via AOP ?

Utilisez RateLimiter pour limiter le courant via AOP

1 Présentation des dépendances

<!-- guava 限流 -->
<dependency>
     <groupId>com.google.guava</groupId>
     <artifactId>guava</artifactId>
     <version>25.1-jre</version>
</dependency>

2 Annotations personnalisées

@Target({ElementType.PARAMETER, ElementType.METHOD})    
@Retention(RetentionPolicy.RUNTIME)    
@Documented    
public  @interface ServiceLimit { 
     String description()  default "";
}

3.

@Component
@Scope
@Aspect
public class LimitAspect {
    每秒只发出5个令牌，此处是单进程服务的限流,内部采用令牌捅算法实现
    private static   RateLimiter rateLimiter = RateLimiter.create(5.0);
    
    //Service层切点  限流
    @Pointcut("@annotation(com.itstyle.seckill.common.aop.ServiceLimit)")  
    public void ServiceAspect() {
        
    }
    
    @Around("ServiceAspect()")
    public  Object around(ProceedingJoinPoint joinPoint) { 
        Boolean flag = rateLimiter.tryAcquire();
        Object obj = null;
        try {
            if(flag){
                obj = joinPoint.proceed();
            }
        } catch (Throwable e) {
            e.printStackTrace();
        } 
        return obj;
    } 
}

4, utilisez

@Override
@ServiceLimit
@Transactional
    public Result startSeckil(long seckillId,long userId) {
        //todo 操作
    }

Limite actuelle de SpringBoot

Algorithme de base de la limite actuelle

#🎜 🎜#Token Bucket et Leaky Bucket

• La mise en œuvre de l'algorithme du bucket qui fuit repose souvent sur la file d'attente. Si la demande arrive et que la file d'attente n'est pas pleine, elle le sera. être placé directement dans la file d'attente. Ensuite, il y a un processeur qui extrait les demandes de la tête de file d'attente et les traite à une fréquence fixe. Si le volume de requêtes est important, la file d'attente sera pleine et les nouvelles requêtes seront rejetées.

• L'algorithme du bucket de jetons est un bucket qui stocke des jetons avec une capacité fixe, et les jetons sont ajoutés au bucket à un taux fixe. Il existe une limite maximale pour le nombre de jetons stockés dans le compartiment. Une fois dépassés, ils seront rejetés. Lorsque les demandes de trafic ou de réseau arrivent, chaque demande doit obtenir un jeton. Si elle peut être obtenue, elle sera traitée directement et un jeton sera supprimé du compartiment de jetons. Si elle ne peut pas être obtenue, la demande sera limitée en débit et soit rejetée directement, soit attendue dans le tampon. Seau de jetons Les jetons sont ajoutés au compartiment à un taux fixe. Le traitement de la demande dépend du nombre suffisant de jetons dans le compartiment. Lorsque le nombre de jetons est réduit à zéro, les nouvelles demandes de sortie des compartiments qui fuient sont rejetées. taux fixe constant et flux dans le compartiment. Le taux de demandes est arbitraire. Lorsque le nombre de demandes entrantes s'accumule jusqu'à la capacité du compartiment qui fuit, les nouvelles demandes entrantes seront rejetées ; #Le compartiment de jetons limite le taux d'entrée moyen. Les demandes de rafale sont autorisées et peuvent être traitées tant qu'il y a des jetons. Il prend en charge 3 jetons et 4 jetons à la fois ; le taux de sortie est une valeur constante fixe, telle qu'un taux de 1. sortie, au lieu d'être 1 une fois et 2 la fois suivante, lissant ainsi le taux d'entrée en rafale. L'objectif principal est de lisser le taux de sortie .Exemple de code#🎜 ; 🎜#

  <dependency>
      <groupId>com.google.guava</groupId>
      <artifactId>guava</artifactId>
      <version>28.1-jre</version>
      <optional>true</optional>
  </dependency>

3. Test

@Slf4j
@Configuration
public class RequestInterceptor implements HandlerInterceptor {
    // 根据字符串分不同的令牌桶, 每天自动清理缓存
    private static LoadingCache<String, RateLimiter> cachesRateLimiter = CacheBuilder.newBuilder()
            .maximumSize(1000)  //设置缓存个数
            /**
             * expireAfterWrite是在指定项在一定时间内没有创建/覆盖时，会移除该key，下次取的时候从loading中取
             * expireAfterAccess是指定项在一定时间内没有读写，会移除该key，下次取的时候从loading中取
             * refreshAfterWrite是在指定时间内没有被创建/覆盖，则指定时间过后，再次访问时，会去刷新该缓存，在新值没有到来之前，始终返回旧值
             * 跟expire的区别是，指定时间过后，expire是remove该key，下次访问是同步去获取返回新值；
             * 而refresh则是指定时间后，不会remove该key，下次访问会触发刷新，新值没有回来时返回旧值
             */
            .expireAfterAccess(1, TimeUnit.HOURS)
            .build(new CacheLoader<String, RateLimiter>() {
                @Override
                public RateLimiter load(String key) throws Exception {
                    // 新的字符串初始化 (限流每秒2个令牌响应)
                    return RateLimiter.create(2);
                }
            });
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        log.info("request请求地址path[{}] uri[{}]", request.getServletPath(), request.getRequestURI());
        try {
            String str = "hello";
            // 令牌桶
            RateLimiter rateLimiter = cachesRateLimiter.get(str);
            if (!rateLimiter.tryAcquire()) {
                System.out.println("too many requests.");
                return false;
            }
        } catch (Exception e) {
            // 解决拦截器的异常，全局异常处理器捕获不到的问题
            request.setAttribute("exception", e);
            request.getRequestDispatcher("/error").forward(request, response);
        }
        return true;
    }
}

http://localhost:8080/user/

If il n'y a pas de classe de résultats, vous pouvez simplement renvoyer une chaîne

• 4 Résultats du test

• #🎜 🎜##🎜. 🎜#Other

• Create

RateLimiter propose deux méthodes d'usine :

L'une est une limitation de courant en rafale douce#🎜 🎜#

@RestController
@RequestMapping(value = "user")
public class UserController {
    @GetMapping
    public Result test2(){
        System.out.println("1111");
        return new Result(true,200,"");
    }
}

L'un est la limitation du courant de préchauffage en douceur

RateLimiter r = RateLimiter.create(5); //项目启动，直接允许5个令牌

Inconvénients

RateLimiter ne peut que Il est utilisé pour limiter le courant de une seule machine Si vous souhaitez limiter le courant d'un cluster, vous devez introduire redis ou le middleware sentinelle open source d'Alibaba.

RateLimiter r = RateLimiter.create(2, 3, TimeUnit.SECONDS); //项目启动后3秒后才会到达设置的2个令牌

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!