Intervieweur : annotations communes et séquence d'exécution de Spring Aop

Récemment, alors que je révisais des CV et faisais des simulations d'entretien pour de nombreuses personnes, certains amis m'ont fait part de leurs commentaires sur les questions d'entretien Spring AOP, et je vais les leur poser aujourd'hui.

La chose la plus puissante à propos de Spring au début, ce sont les deux fonctions principales d'IOC/AOP. Aujourd'hui, nous allons apprendre les annotations communes et la séquence d'exécution de Spring AOP.

Points fondamentaux de l'interview de Spring :

IOC, AOP, injection de bean, cycle de vie du bean, dépendance circulaire du bean

Tout d'abord, passons en revue quelques annotations couramment utilisées dans Spring Aop :

@Before Pré-notification : exécutée avant la méthode cible @Before 前置通知：目标方法之前执行 @After 后置通知：目标方法之后执行（始终执行） @AfterReturning 返回之后通知：执行方法结束之前执行（异常不执行） @AfterThrowing 异常通知：出香异常后执行 @Around @Après notification de publication : Exécuté après la méthode cible (toujours exécutée) @ AfterReturning Notification après retour : exécuté avant la fin de la méthode d'exécution (non exécuté si une exception se produit) @AfterThrowing Notification d'exception : exécutée après l'exception de l'encens

@Around Autour de la notification : exécution de la méthode cible Surround

🎜🎜🎜🎜🎜🎜FAQ🎜🎜🎜 🎜🎜🎜1. Vous devez connaissez Spring, parlons de l'ordre de toutes les notifications dans Aop. Comment Spring Boot ou Spring Boot 2 affecte-t-il l'ordre d'exécution d'aop ? 🎜🎜2. Parlez-moi des pièges que vous avez rencontrés en AOP ? 🎜 Exemple de code Créons rapidement un programme de démonstration Spring Aop pour discuter de certains détails de Spring Aop.

Fichier de configuration Afin de faciliter mon utilisation directe de spring-boot pour une construction rapide de projet, vous pouvez utiliser la fonction de création rapide de projet spring-boot d'idée, ou accéder à start.spring.io ci-dessus pour créer rapidement un spring- application de démarrage. start.spring.io 上面去快速创建spring-boot 应用。

因为本人经常手动去网上贴一些依赖导致，依赖冲突服务启动失败等一些问题。

plugins { id 'org.springframework.boot' version '2.6.3' id 'io.spring.dependency-management' version '1.0.11.RELEASE' id 'java' }

group 'io.zhengsh' version '1.0-SNAPSHOT'

repositories { mavenCentral() maven { url 'https://repo.spring.io/milestone' } maven { url 'https://repo.spring.io/snapshot' } }

dependencies { # 其实这里也可以不增加 web 配置，为了试验简单，大家请忽略 implementation 'org.springframework.boot:spring-boot-starter-web' implementation 'org.springframework.boot:spring-boot-starter-actuator' implementation 'org.springframework.boot:spring-boot-starter-aop' testImplementation 'org.springframework.boot:spring-boot-starter-test' }

tasks.named('test') { useJUnitPlatform() } 接口类 首先我们需要定义一个接口。我们这里可以再来回顾一下 JDK 的默认代理实现的选择：

如果目标对象实现了接口，则默认采用JDK动态代理 如果目标对象没有实现接口，则采用进行动态代理 如果目标对象实现了接口，且强制Cglib，则使用cglib代理 这块的逻辑在 DefaultAopProxyFactory

Comme je publie souvent manuellement certaines dépendances en ligne, des conflits de dépendances se produisent. certains problèmes tels que l'échec du démarrage du service.

public interface CalcService {

public int div(int x, int y); } Classe d'interface Nous devons d'abord définir une interface. Ici, nous pouvons revoir le choix de l'implémentation du proxy par défaut du JDK :

Si l'objet cible Si le est implémentée, le proxy dynamique JDK est utilisé par défaut Si l'objet cible n'implémente pas l'interface, utilisez un proxy dynamique Si l'objet cible implémente l'interface et force Cglib, utilisez le proxy cglib La logique de cette pièce est en DefaultAopProxyFactory Si vous êtes intéressé , vous pouvez y jeter un oeil. @Service public class CalcServiceImpl implements CalcService {

@Override public int div(int x, int y) { int result = x / y; System.out.println("====> CalcServiceImpl 被调用了，我们的计算结果是：" + result); return result; } } Classe d'implémentation

🎜Ici, nous allons simplement faire une opération de division, qui peut simuler un fonctionnement normal et également facilement simuler des erreurs. 🎜 @Aspect @Component public class MyAspect {

@Pointcut("execution(* io.zhengsh.spring.service.impl..*.*(..))") public void divPointCut() {

}

@Before("divPointCut()") public void beforeNotify() { System.out.println("----===>> @Before 我是前置通知"); }

@After("divPointCut") public void afterNotify() { System.out.println("----===>> @After 我是后置通知"); }

@AfterReturning("divPointCut") public void afterReturningNotify() { System.out.println("----===>> @AfterReturning 我是前置通知"); }

@AfterThrowing("divPointCut") public void afterThrowingNotify() { System.out.println("----===>> @AfterThrowing 我是异常通知"); }

@Around("divPointCut") public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable { Object retVal; System.out.println("----===>> @Around 环绕通知之前 AAA"); retVal = proceedingJoinPoint.proceed(); System.out.println("----===>> @Around 环绕通知之后 BBB"); return retVal; } } 🎜🎜🎜aop Interceptor🎜🎜🎜🎜Déclarez un intercepteur et nous devons ajouter @Aspect et @Component à l'objet actuel. L'auteur n'a marché que sur une telle fosse auparavant et n'en a ajouté qu'un. 🎜 其实这块我刚开始也不是很理解，但是我看了 Aspect 注解的定义我就清楚了

这里面根本就没有 Bean 的定义。所以我们还是乖乖的加上两个注解。

还有就是如果当测试的时候需要开启Aop 的支持为配置类上增加 @EnableAspectJAutoProxy 注解。

其实 Aop 使用就三个步骤：

定义 Aspect 定义切面 定义 Pointcut 就是定义我们切入点 定义具体的通知，比如: @After, @Before 等。 @Aspect @Component public class MyAspect {

@Pointcut("execution(* io.zhengsh.spring.service.impl..*.*(..))") public void divPointCut() {

}

@Before("divPointCut()") public void beforeNotify() { System.out.println("----===>> @Before 我是前置通知"); }

@After("divPointCut") public void afterNotify() { System.out.println("----===>> @After 我是后置通知"); }

@AfterReturning("divPointCut") public void afterReturningNotify() { System.out.println("----===>> @AfterReturning 我是前置通知"); }

@AfterThrowing("divPointCut") public void afterThrowingNotify() { System.out.println("----===>> @AfterThrowing 我是异常通知"); }

@Around("divPointCut") public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable { Object retVal; System.out.println("----===>> @Around 环绕通知之前 AAA"); retVal = proceedingJoinPoint.proceed(); System.out.println("----===>> @Around 环绕通知之后 BBB"); return retVal; } } 测试类 其实我这个测试类，虽然用了 @Test 注解，但是我这个类更加像一个 main 方法把：如下所示：

执行结论 结果记录：spring 4.x, spring-boot 1.5.9

无法现在依赖，所以无法试验

我直接说一下结论：Spring 4 中环绕通知是在最里面执行的

结果记录：spring 版本5.3.15 springboot 版本2.6.3

img 多切面的情况 多个切面的情况下，可以通过@Order指定先后顺序，数字越小，优先级越高。如下图所示：

代理失效场景 下面一种场景会导致 aop 代理失效，因为我们在执行 a 方法的时候其实本质是执行 AServer#a 的方法拦截器（ MethodInterceptor ）链, 当我们在 a 方法内直接执行b(), 其实本质就相当于 this.b() , 这个时候由执行 a方法是调用到 a 的原始对象相当于是 this 调用，那么会导致 b() 方法的代理失效。这个问题也是我们开发者在开发过程中最常遇到的一个问题。

@Service public class AService { public void a() { System.out.println("...... a"); b(); } public void b() { System.out.println("...... b"); }

}