Explication détaillée des annotations Spring AOP

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

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 {
}

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

}

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

Résultat de la console :

autour du conseil : aop
avant conseil : aop
faire quelque chose...
après conseil : aop

Tutoriel recommandé : "Tutoriel Java》

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!