Spring——AOP中五大通知功能的执行顺序（完全注解开发）

Spring——AOP中五大通知功能的执行顺序（完全注解开发）

Spring大家肯定都用过的，IOC和AOP是它的两大核心，那么这篇文章主要和大家分享一下如果对一个方法声明了切面、添加了五种通知，它们的执行顺序是怎样的呢？

由于之前学Spring的时候写过太多了xml配置了，所以这篇文章采用完全注解开发的方式来实现。

首先是pom文件，我们添加所需依赖。

1. <dependency>
2. <groupId>org.springframeworkgroupId>
3. <artifactId>spring-contextartifactId>
4. <version>5.2.5.RELEASEversion>
5. dependency>
7. <dependency>
8. <groupId>org.springframeworkgroupId>
9. <artifactId>spring-aspectsartifactId>
10. <version>5.2.5.RELEASEversion>
11. dependency>
13. <dependency>
14. <groupId>junitgroupId>
15. <artifactId>junitartifactId>
16. <version>4.11version>
17. <scope>testscope>
18. dependency>

接下来我们来一个业务接口以及它的实现类。

1. package com.szh.service;
3. /**
4. *
5. */
6. public interface SomeService {
8. String doSome(String name,Integer age);
10. }

由于我们不写xml配置，所以需要在业务接口实现类上添加 @Service 注解，通过注解将这个类交给Spring IOC容器管理。 

1. package com.szh.service.impl;
3. import com.szh.service.SomeService;
4. import org.springframework.stereotype.Service;
6. @Service
7. public class SomeServiceImpl implements SomeService {
9. @Override
10. public String doSome(String name, Integer age) {
11. //int a = 10 / 0; //用于测试异常通知
12. System.out.println("业务方法doSome()，创建商品的订单");
13. return "姓名：" + name + "，年龄：" + age;
14. }
16. }

然后是我们的切面类，同上面的业务实现类，也需要使用 @Component 注解将这个类交给Spring IOC容器管理。 

1. package com.szh.handle;
3. import org.aspectj.lang.ProceedingJoinPoint;
4. import org.aspectj.lang.annotation.*;
5. import org.springframework.stereotype.Component;
7. @Aspect
8. @Component
9. public class MyAspect {
11. @Before(value = "myPointCut()")
12. public void myBefore() {
13. System.out.println("前置通知，在目标方法之前先执行的....");
14. }
16. @AfterReturning(value = "myPointCut()", returning = "obj")
17. public void myAfterReturning(Object obj) {
18. System.out.println("后置通知，在目标方法之后再执行的（如有异常，则后置通知不会执行）.... 目标方法返回值：" + obj);
19. }
21. @Around(value = "myPointCut()")
22. public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable {
23. System.out.println("环绕通知中前置通知的功能....");
24. Object obj = joinPoint.proceed();
25. System.out.println("环绕通知中后置通知的功能....");
26. return obj;
27. }
29. @AfterThrowing(value = "myPointCut()", throwing = "e")
30. public void myAfterThrowing(Exception e) {
31. System.out.println("异常通知，在目标方法抛出异常时执行的，异常原因是：" + e.getMessage());
32. }
34. @After(value = "myPointCut()")
35. public void myAfter() {
36. System.out.println("最终通知，总是会被执行的....");
37. }
39. @Pointcut(value = "execution(* com.szh.service.impl.*.do*(..))")
40. private void myPointCut() {
41. //无需代码
42. }
43. }

最后再来个配置类，在这个配置类中开启要替代xml配置文件的相关功能。

1. package com.szh.config;
3. import org.springframework.context.annotation.Bean;
4. import org.springframework.context.annotation.ComponentScan;
5. import org.springframework.context.annotation.Configuration;
6. import org.springframework.context.annotation.EnableAspectJAutoProxy;
8. /**
9. *
10. */
11. @Configuration
12. //开启包扫描功能，相当于xml中的
13. @ComponentScan(basePackages = "com.szh")
14. //开启aop自动代理功能，相当于xml中的
15. @EnableAspectJAutoProxy
16. public class MyConfig {
17. }

最后是测试类。

1. package com.szh;
3. import com.szh.config.MyConfig;
4. import com.szh.service.SomeService;
5. import org.junit.Test;
6. import org.springframework.context.ApplicationContext;
7. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
9. /**
10. *
11. */
12. public class MyTest {
14. @Test
15. public void testAnnotationAop() {
16. ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
17. SomeService service = (SomeService) context.getBean("someServiceImpl");
18. String info = service.doSome("张起灵", 20);
19. System.out.println(info);
20. }
21. }

2.1 无异常的执行结果