Wie SpringBoot AOP verwendet, um die Anzahl globaler Schnittstellenbesuche zu zählen

Was ist AOP? AOP (Aspect Oriented Programming), auch aspektorientierte Programmierung genannt, ist eine traditionelle und gepflegte Technologie, die Programmfunktionen durch Vorkompilierung und dynamische Proxys zur Laufzeit implementiert.

Die Rolle und Vorteile von AOP

Funktion: Während der Ausführung des Programms können einige Methoden funktional erweitert werden, ohne den Quellcode zu ändern

Vorteile: Reduzieren Sie doppelten Code, verbessern Sie die Entwicklungseffizienz und erleichtern Sie die Wartung

Gemeinsamer dynamischer Proxy Technologie

jdk-Proxy: schnittstellenbasierte dynamische Proxy-Technologie

cglib-Proxy: übergeordnete klassenbasierte dynamische Proxy-Technologie

AOP-bezogene Konzepte

Listenelement – ​​Ziel (Zielobjekt): Das Ziel Objekt des Proxys
Proxy (Proxy): Nachdem eine Klasse gewebt und durch AOP erweitert wurde, wird eine Ergebnis-Proxy-Klasse generiert
Joinpoint (Verbindungspunkt): Der Verbindungspunkt bezieht sich auf den Punkt, der abgefangen wird. In Spring beziehen sich diese Punkte auf Methoden, da Spring nur Verbindungspunkte vom Methodentyp unterstützt (Methoden, die erweitert werden können, werden als Verbindungspunkte bezeichnet).

• Hinweis (Benachrichtigung/Verbesserung): Benachrichtigung bedeutet, dass nach dem Abfangen des Joinpoints eine Benachrichtigung erforderlich ist.

• Aspekt (Aspekt): Dies ist die Kombination aus Einstiegspunkt und Benachrichtigung ) Eingabe): Der Prozess der Anwendung von Erweiterungen auf das Zielobjekt, um ein neues Proxy-Objekt zu erstellen. Spring verwendet dynamisches Proxy-Weben, während AspectJ Compiler-Weben und Klassenlader-Weben verwendet.

• Implementierung
• Ich verwende hier die annotationsbasierte AOP-Entwicklung.
  Entwicklungsschritte
• Abhängigkeiten hinzufügen

  		<!--引入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>

  Zielschnittstelle und Zielklasse erstellen (mit Schnittpunkten im Inneren)

Aspektklasse erstellen (mit Erweiterungsmethoden im Inneren)

Überlassen Sie die Objekterstellungsrechte der Zielklasse und der Aspektklasse Spirng

Verwenden Sie Anmerkungen, um die Webbeziehung in der Aspektklasse zu konfigurieren.

Aktivieren Sie das Scannen von Komponenten und den automatischen AOP-Proxy in der Konfigurationsdatei.

Da es sich bei meinem Projekt um ein SpringBoot-Webprojekt handelt, aktivieren Sie hier einfach Anmerkungen.

Der folgende Code ist die verwendete atomare Zählklasse.

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);
    }
}

Der folgende Code ist die implementierte globale Schnittstellenüberwachung.

Ich verwende Redis einfach zum Caching im Projekt und Sie können alle Redis-bezogenen Vorgänge sehen.

Verwenden Sie @Before, um Vorabbenachrichtigungen zu konfigurieren. Gibt an, dass die erweiterte Methode vor der Pointcut-Methode ausgeführt wird.

Verwenden Sie @ @AfterReturning zum Konfigurieren von Beitragsbenachrichtigungen. Gibt an, dass die erweiterte Methode nach der Pointcut-Methode ausgeführt wird.

Verwenden Sie @ @AfterThrowing, um Benachrichtigungen zum Auslösen von Ausnahmen zu konfigurieren. Gibt an, dass die erweiterte Methode ausgeführt wird, wenn eine Ausnahme auftritt.

@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());
    }
}

Der Controller-Layer-Code ist hier angegeben.

    @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);
    }

Nachdem das Projekt eine Zeit lang gelaufen ist, können Sie die Anzahl der Anfragen für die Schnittstelle in Redis sehen.

Das endgültige Rendering von Web ist wie folgt:

Das obige ist der detaillierte Inhalt vonWie SpringBoot AOP verwendet, um die Anzahl globaler Schnittstellenbesuche zu zählen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!