Explication détaillée des annotations Spring AOP-JavaBase-php.cn

Explication détaillée des annotations Spring AOP

Guanhui

Libérer： 2020-06-28 18:00:16

avant

3341 Les gens l'ont consulté

Aspect : Aspect

Aspect = pointcut + notification. Dans les anciennes versions Spring, la configuration XML est généralement utilisée, mais désormais, une classe est généralement annotée avec @Aspect. Les aspects sont responsables de l’intégration d’une logique transversale (conseils) dans des points de jonction désignés.

Objet cible : Cible

L'objet à améliorer.

Join Point : JoinPoint

Le point d'exécution du programme qui peut être intercepté est la méthode de la classe au printemps.

Point d'entrée : PointCut

La méthode qui doit effectuer une interception, c'est-à-dire la méthode qui implémente spécifiquement la logique transversale. Les règles de pointcut sont décrites au printemps via le langage d'expression pointcut AspectJ.

La différence entre les points d'entrée et les points de connexion : les points de connexion sont tous les points qui peuvent être « coupés » ; les points d'entrée sont les points qui veulent vraiment être coupés.

Conseil : Conseil

Logique transversale des points d'entrée, incluant différents types de conseils tels que "autour", "avant" et "après" .

Le point d'action de notification est comme nommé :

avant : exécuté avant le point d'entrée
après : after Exécuter après le point d'entrée
autour : Méthode d'interception au point d'entrée, avant et après personnalisation, plus flexible

Il existe aussi quelques Notifications de gestion des exceptions, Voici aucun exemple de

Tissage : Tissage

Le processus de connexion des aspects et des objets cibles pour créer des objets proxy. Le proxy dynamique est utilisé au printemps. Si l'objet cible a une interface, utilisez le proxy dynamique jdk ; sinon, utilisez le proxy dynamique cglib.

Après avoir parlé de tant de concepts, examiner l'implémentation du code peut aider les lecteurs à le comprendre plus en profondeur. Voici une simple démo AOP qui améliore la méthode grâce aux annotations.
Le premier est la classe d'aspect :

package com.example.demo.aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @author Fcb
 * @date 2020/6/20
 * @description 切面类=切入点+通知
 */
@Aspect
@Component
public class LogAspect {

  //这个方法定义了切入点
  @Pointcut("@annotation(com.example.demo.aop.anno.MyLog)")
  public void pointCut() {}

  //这个方法定义了具体的通知
  @After("pointCut()")
  public void recordRequestParam(JoinPoint joinPoint) {
    for (Object s : joinPoint.getArgs()) {
      //打印所有参数，实际中就是记录日志了
      System.out.println("after advice : " + s);
    }
  }

  //这个方法定义了具体的通知
  @Before("pointCut()")
  public void startRecord(JoinPoint joinPoint) {
    for (Object s : joinPoint.getArgs()) {
      //打印所有参数
      System.out.println("before advice : " + s);
    }
  }

  //这个方法定义了具体的通知
  @Around("pointCut()")
  public Object aroundRecord(ProceedingJoinPoint pjp) throws Throwable {
    for (Object s : pjp.getArgs()) {
      //打印所有参数
      System.out.println("around advice : " + s);
    }
    return pjp.proceed();
  }
}

Copier après la connexion

Annotation :

package com.example.demo.aop.anno;
import java.lang.annotation.*;
/**
 * @author Fcb
 * @date 2020/6/20
 * @description
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface MyLog {
}

Copier après la connexion

Classe cible :

package com.example.demo.aop.target;

import com.example.demo.aop.anno.MyLog;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author Fcb
 * @date 2020/6/20
 * @description
 */
@RestController
public class MockController {

  @RequestMapping("/hello")
  @MyLog
  public String helloAop(@RequestParam String key) {
    System.out.println("do something...");
    return "hello world";
  }

}

Copier après la connexion

Enfin, la classe de test :

package com.example.demo.aop.target;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
/**
 * @author Fcb
 * @date 2020/6/20
 * @description
 */
@SpringBootTest
class MockControllerTest {
  @Autowired
  MockController mockController;

  @Test
  void helloAop() {
    mockController.helloAop("aop");
  }
}

Copier après la connexion

Résultat de la console :