Comment utiliser Springboot pour intégrer la limitation de courant RateLimiter

Schéma du compartiment de jetons RateLimiter

• Au fil du temps, le système ajoutera des jetons au compartiment à un intervalle de temps constant de 1/QPS (si QPS=100, l'intervalle est de 10 ms) (imaginez le contraire d'une fuite ), il y a un robinet qui ajoute constamment de l'eau). Si le seau est plein, plus d'eau ne sera ajoutée. Lorsqu'une nouvelle demande arrive, chacun enlèvera un Jeton à prendre, le service le fera. être bloqué ou refusé.

• Commande Un autre avantage du seau à jetons est qu'il peut facilement modifier la vitesse une fois que le taux doit être augmenté, le taux de jetons mis dans le seau est généralement augmenté selon les besoins. nombre de jetons sont ajoutés régulièrement au compartiment (par exemple 100 millisecondes). Certaines variantes d'algorithmes calculent le nombre de jetons qui doivent être ajoutés en temps réel.

Le compartiment de jetons est une technologie de contrôle de flux couramment utilisée. Le compartiment de jetons lui-même n'a aucune politique de suppression ni de priorité.

Principe

1. Les jetons sont mis dans le seau à un certain taux.

2. Chaque jeton permet à la source d'envoyer un certain nombre de bits.

3. Pour envoyer un paquet, le conditionneur de trafic supprime du compartiment un nombre de jetons égal à la taille du paquet.

4. S'il n'y a pas assez de jetons pour envoyer un paquet, le paquet attend jusqu'à ce qu'il y ait suffisamment de jetons (dans le cas d'un shaper) ou le paquet est abandonné, éventuellement marqué d'un DSCP inférieur (dans le cas d'un politique).

5. Les buckets ont une capacité spécifique. Si le bucket est plein, les jetons nouvellement ajoutés seront supprimés. Par conséquent, la quantité maximale de données en rafale qu'une source peut envoyer sur le réseau à tout moment est proportionnelle à la taille du bucket. Le compartiment de jetons autorise les rafales, mais ne peut pas dépasser la limite.

Résumé de la méthode

Modificateurs et types	Méthode et description
double	acquire() Obtenir de RateLimiter Une autorisation, la méthode bloquera jusqu'à obtention de la demande
double	acquire(int permits) Obtenez le nombre spécifié de permis auprès de RateLimiter. Cette méthode sera bloquée jusqu'à ce que la demande soit obtenue
static RateLimiter	create(double permitsPerSecond) Créez en fonction du débit stable spécifié. rate RateLimiter, le débit ici fait référence au nombre de permis par seconde (généralement QPS, combien de requêtes par seconde)
static RateLimiter	create(double permitsPerSecond, long warmupPeriod, TimeUnit unit) en fonction du débit stable spécifié rate et créez un RateLimiter pendant la période de préchauffage. Le débit fait ici référence au nombre de licences par seconde (généralement QPS, combien de requêtes par seconde). Pendant cette période de préchauffage, le nombre de licences allouées par le RateLimiter. par seconde sera stable jusqu'à ce qu'elle atteigne son taux maximum à la fin de la période d'échauffement. (Tant qu'il y a suffisamment de requêtes pour le saturer)
double	getRate() renvoie le débit stable dans la configuration RateLimiter, l'unité de débit est le nombre de permis par seconde
void	setRate( double permitsPerSecond) Mettre à jour le taux stable de RateLimite. Le paramètre permitsPerSecond est fourni par la méthode d'usine qui construit RateLimiter.
String	ToString () Renvoie la représentation du caractère de l'objet
boolean	tryacquire () obtient l'autorisation du ratelimiter si l'autorisation peut être obtenue immédiatement sans délai
Boolean	TryCQuire (permis int) Obtenez le nombre d'autorisations de RateLimiter, si le nombre d'autorisations peut être obtenu immédiatement sans délai
boolean	tryAcquire(permis int, délai d'attente long, unité TimeUnit) de RateLimiter Obtenez le nombre de licences spécifié. Si le nombre de licences peut être obtenu dans un délai qui ne dépasse pas le délai d'attente, ou si le nombre de licences ne peut pas être obtenu avant l'expiration du délai d'attente, renvoyez immédiatement false (pas besoin d'attendre)
boolean	tryAcquire (long timeout, unité TimeUnit) Obtenir l'autorisation de RateLimiter Si l'autorisation peut être obtenue dans un délai qui ne dépasse pas le délai d'attente, ou si l'autorisation ne peut pas être obtenue avant l'expiration du délai d'attente, renvoyez immédiatement false (pas besoin d'attendre)

Commencez à coller le code

pom.xml

<!--guava RateLimiter限流-->
<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>28.2-jre</version>
</dependency>

Interface personnalisée Limit

package com.zjy.knife4j.inte;
import java.lang.annotation.*;
/**
 * 限流注解
 */
@Inherited
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Limit {
    // 默认每秒放入桶中的token
    double limitNum() default 20;
    String name() default "";
}

aspect aop

package com.zjy.knife4j.aspect;
import com.google.common.util.concurrent.RateLimiter;
import com.zjy.knife4j.inte.Limit;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
import java.util.concurrent.ConcurrentHashMap;
@Aspect
@Component
public class RateLimitAspect {
    /**日志对象*/
    private static final Logger logger = LoggerFactory.getLogger(RateLimitAspect.class);
    private ConcurrentHashMap<String, RateLimiter> RATE_LIMITER  = new ConcurrentHashMap<>();
    private RateLimiter rateLimiter;
    @Pointcut("@annotation(com.zjy.knife4j.inte.Limit)")
    public void serviceLimit() {
    }
    @Around("serviceLimit()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        Object obj = null;
        //获取拦截的方法名
        Signature sig = point.getSignature();
        //获取拦截的方法名
        MethodSignature msig = (MethodSignature) sig;
        //返回被织入增加处理目标对象
        Object target = point.getTarget();
        //为了获取注解信息
        Method currentMethod = target.getClass().getMethod(msig.getName(), msig.getParameterTypes());
        //获取注解信息
        Limit annotation = currentMethod.getAnnotation(Limit.class);
        double limitNum = annotation.limitNum(); //获取注解每秒加入桶中的token
        String functionName = msig.getName(); // 注解所在方法名区分不同的限流策略
        if(RATE_LIMITER.containsKey(functionName)){
            rateLimiter=RATE_LIMITER.get(functionName);
        }else {
            RATE_LIMITER.put(functionName, RateLimiter.create(limitNum));
            rateLimiter=RATE_LIMITER.get(functionName);
        }
        if(rateLimiter.tryAcquire()) {
            logger.info("执行成功！！！...做一些业务处理");
            return point.proceed();
        } else {
            logger.info("请求繁忙...做一些业务处理");
            return null;
        }
    }
}

RateLimiterController

package com.zjy.knife4j.controller;
import com.zjy.knife4j.inte.Limit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RequestMapping("/ratelimiter")
@RestController
public class RateLimiterController {
    /**
     * 开启限流
     * @return
     */
    @GetMapping("/open")
    @Limit(limitNum = 1, name = "test1")
    public String openRateLimiter1() {
        System.out.println("【限流执行了....编写业务....】");
        return "限流执行了";
    }
    /**
     * 开启限流
     * @return
     */
    @GetMapping("/open2")
    @Limit(limitNum = 1, name = "test2")
    public String openRateLimiter2() {
        System.out.println("【限流执行了222】");
        return "限流执行了222";
    }
    /**
     * 未开启限流
     * @return
     */
    @GetMapping("/close")
    public String closeRateLimiter() {
        System.out.println("【不限流执行了】");
        return "不限流执行了";
    }
}

Après avoir collé le code, commencez à tester

Démarrez le service et accédez à l'interface qui ajoute le annotation limite actuelle

Accédez à nouveau à l'interface non annotée

La console imprime le résultat :

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!