Comment SpringBoot utilise AOP pour compter le nombre de visites de l'interface globale

Qu'est-ce que l'AOP

AOP (Aspect Oriented Programming), également connu sous le nom de programmation orientée aspect, est une technologie traditionnelle et maintenue qui implémente les fonctions du programme via la précompilation et des proxys dynamiques pendant l'exécution.

Le rôle et les avantages d'AOP

Fonction : Pendant l'exécution du programme, certaines méthodes peuvent être améliorées fonctionnellement sans modifier le code source

Avantages : Réduisez le code en double, améliorez l'efficacité du développement et facilitez la maintenance

Proxy dynamique commun technologie

proxy jdk : technologie de proxy dynamique basée sur l'interface

proxy cglib : technologie de proxy dynamique basée sur la classe parent

Concepts liés à l'AOP

• Élément de liste - Cible (objet cible) : La cible objet du proxy

• Proxy (proxy) : Une fois qu'une classe est tissée et améliorée par AOP, une classe proxy de résultat est générée

• Joinpoint (point de connexion) : Le point de connexion fait référence au point qui est intercepté. Dans Spring, ces points font référence à des méthodes, car Spring ne prend en charge que les points de connexion de type méthode (les méthodes qui peuvent être améliorées sont appelées points de connexion)

• PointCut (pointcut) : Pointcut fait référence au point de jointure que nous voulons effectuer. La définition de l'interception

• Conseil (notification/amélioration) : La notification fait référence à ce qui doit être fait après avoir intercepté le Joinpoint, c'est-à-dire notifier

• Aspect (Aspect) : C'est la combinaison du point d'entrée et de la notification

• Tissage ( tissage) Entrée) : Le processus d'application d'améliorations à l'objet cible pour créer un nouvel objet proxy. Spring utilise le tissage de proxy dynamique, tandis qu'AspectJ utilise le tissage de compilateur et le tissage de chargeur de classe

implémentation

J'utilise ici le développement AOP basé sur des annotations.

Étapes de développement

Ajouter des dépendances

		<!--引入AOP依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <!--AOP-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.9.4</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.2.12</version>
        </dependency>

Créer une interface cible et une classe cible (avec des points de coupure à l'intérieur)

Créer une classe d'aspect (avec des méthodes d'amélioration à l'intérieur)

Laisser les droits de création d'objet de la classe cible et de la classe d'aspect à Spirng

Utilisez des annotations pour configurer la relation de tissage dans la classe d'aspect

Activez l'analyse des composants et le proxy automatique AOP dans le fichier de configuration

Étant donné que mon projet est un projet Web SpringBoot, activez simplement les annotations ici.

Le code suivant est la classe de comptage atomique utilisée.

import java.util.concurrent.atomic.AtomicInteger;
public class AtomicCounter {
    private static final AtomicCounter atomicCounter = new AtomicCounter();
    /**
     * 单例，不允许外界主动实例化
     */
    private AtomicCounter() {
    }
    public static AtomicCounter getInstance() {
        return atomicCounter;
    }
    private static AtomicInteger counter = new AtomicInteger();
    public int getValue() {
        return counter.get();
    }
    public int increase() {
        return counter.incrementAndGet();
    }
    public int decrease() {
        return counter.decrementAndGet();
    }
    // 清零
    public void toZero(){
        counter.set(0);
    }
}

Le code suivant est la surveillance globale de l'interface implémentée.

J'utilise simplement Redis pour la mise en cache dans le projet, et vous pouvez voir toutes les opérations liées à Redis.

Utilisez @Before pour configurer les pré-notifications. Spécifie que la méthode améliorée est exécutée avant la méthode pointcut.

Utilisez @ @AfterReturning pour configurer les notifications de publication. Spécifie que la méthode améliorée est exécutée après la méthode pointcut.

Utilisez @ @AfterThrowing pour configurer les notifications de lancement d'exceptions. Spécifie que la méthode améliorée est exécutée lorsqu'une exception se produit.

@Component
@Aspect
public class GlobalActuator {
    private static final Logger log = LoggerFactory.getLogger(GlobalActuator.class);
    @Resource
    private StringRedisTemplate stringRedisTemplate;
    ThreadLocal<Long> startTime = new ThreadLocal<>();
    ConcurrentHashMap<Object, Object> countMap = new ConcurrentHashMap<Object, Object>();
    /**
     * 匹配控制层层通知 这里监控controller下的所有接口
     */
    @Pointcut("execution(* com.sf.controller.*Controller.*(..))")
    private void controllerPt() {
    }
    /**
     * 在接口原有的方法执行前，将会首先执行此处的代码
     */
    @Before("com.sf.actuator.GlobalActuator.controllerPt()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
        startTime.set(System.currentTimeMillis());
        //获取传入目标方法的参数
        Object[] args = joinPoint.getArgs();
    }
    /**
     * 只有正常返回才会执行此方法
     * 如果程序执行失败，则不执行此方法
     */
    @AfterReturning(returning = "returnVal", pointcut = "com.sf.actuator.GlobalActuator.controllerPt()")
    public void doAfterReturning(JoinPoint joinPoint, Object returnVal) throws Throwable {
        Signature signature = joinPoint.getSignature();
        String declaringName = signature.getDeclaringTypeName();
        String methodName = signature.getName();
        String mapKey = declaringName + methodName;
        // 执行成功则计数加一
        int increase = AtomicCounter.getInstance().increase();
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        synchronized (this) {
        //在项目启动时，需要在Redis中读取原有的接口请求次数
            if (countMap.size() == 0) {
                JSONObject jsonObject = RedisUtils.objFromRedis(StringConst.INTERFACE_ACTUATOR);
                if (jsonObject != null) {
                    Set<String> strings = jsonObject.keySet();
                    for (String string : strings) {
                        Object o = jsonObject.get(string);
                        countMap.putIfAbsent(string, o);
                    }
                }
            }
        }
        // 如果此次访问的接口不在countMap，放入countMap
        countMap.putIfAbsent(mapKey, 0);
        countMap.compute(mapKey, (key, value) -> (Integer) value + 1);
        synchronized (this) {
            // 内存计数达到30 更新redis
            if (increase == 30) {
                RedisUtils.objToRedis(StringConst.INTERFACE_ACTUATOR, countMap, Constants.AVA_REDIS_TIMEOUT);
                //删除过期时间
                stringRedisTemplate.persist(StringConst.INTERFACE_ACTUATOR);
                //计数器置为0
                AtomicCounter.getInstance().toZero();
            }
        }
        //log.info("方法执行次数:" + mapKey + "------>" + countMap.get(mapKey));
        //log.info("URI:[{}], 耗费时间:[{}] ms", request.getRequestURI(), System.currentTimeMillis() - startTime.get());
    }
    /**
     * 当接口报错时执行此方法
     */
    @AfterThrowing(pointcut = "com.sf.actuator.GlobalActuator.controllerPt()")
    public void doAfterThrowing(JoinPoint joinPoint) {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        log.info("接口访问失败，URI:[{}], 耗费时间:[{}] ms", request.getRequestURI(), System.currentTimeMillis() - startTime.get());
    }
}

Le code de la couche contrôleur est donné ici.

    @GetMapping("/interface/{intCount}")
    @ApiOperation(value = "查找接口成功访问次数（默认倒序）")
    public Result<List<InterfaceDto>> findInterfaceCount(
            @ApiParam(name = "intCount", value = "需要的接口数") @PathVariable Integer intCount
    ) {
        HashMap<String, Integer> hashMap = new HashMap<>();
        JSONObject jsonObject = RedisUtils.objFromRedis(StringConst.INTERFACE_ACTUATOR);
        if (jsonObject != null) {
            Set<String> strings = jsonObject.keySet();
            for (String string : strings) {
                Integer o = (Integer) jsonObject.get(string);
                hashMap.putIfAbsent(string, o);
            }
        }
        //根据value倒序
        Map<String, Integer> sortedMap = hashMap.entrySet().stream().sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
        //返回列表
        List<InterfaceDto> resultList = new ArrayList<>();
        //排序后中的map中所有的key
        Object[] objects = sortedMap.keySet().toArray();
        for (int i = 0; i < intCount; i++) {
            InterfaceDto interfaceDto = new InterfaceDto();
            interfaceDto.setName((String) objects[i]);
            interfaceDto.setCount(sortedMap.get((String) objects[i]));
            resultList.add(interfaceDto);
        }
        return Result.success(resultList);
    }

Une fois le projet exécuté pendant un certain temps, vous pouvez voir le nombre de requêtes pour l'interface dans Redis.

Le rendu final du Web est le suivant :

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!