Spring基础系列--AOP实践

原创作品，可以转载，但是请标注出处地址：https://www.cnblogs.com/V1haoge/p/9615720.html

　　本文目的是简单讲解下Spring AOP的使用。

　　推荐使用IDEA + Spring Boot。

　　新建Spring Boot 项目，选择Aspect功能。

　　创建完成后，POM文件如下：

 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>

     <groupId>com.example</groupId>
     <artifactId>spring-aspect-demo</artifactId>
     <version>0.0.1-SNAPSHOT</version>
     <packaging>jar</packaging>

     <name>spring-aspect-demo</name>
     <description>Demo project for Spring Boot</description>

     <parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
         <version>2.0.4.RELEASE</version>
         <relativePath/> <!-- lookup parent from repository -->
     </parent>

     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
         <java.version>1.8</java.version>
     </properties>

     <dependencies>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-aop</artifactId>
         </dependency>

         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-test</artifactId>
             <scope>test</scope>
         </dependency>
     </dependencies>

     <build>
         <plugins>
             <plugin>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-maven-plugin</artifactId>
             </plugin>
         </plugins>
     </build>

 </project>

　　然后我们创建目标类和方法：

 package com.example.springaspectdemo;

 import org.springframework.stereotype.Component;

 @Component
 public class AspectDemo {
     public Integer test(String s){
         System.out.println("目标方法执行-"+s);
         return 123321;
     }
 }

　　上面的代码中主要的就是@Component注解，在于将目标类扫描到Spring容器中。

　　下面我们创建切面类：

 package com.example.springaspectdemo;

 import org.aspectj.lang.JoinPoint;
 import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.*;
 import org.springframework.stereotype.Component;

 @Aspect
 @Component
 public class AspectTest {

     @Pointcut(value = "execution(* *.test(..)) && args(s)")
     public void pc(String s){
         System.out.println("切点执行");
     }

     @Before("pc(s)")
     public void beforeTest(JoinPoint jp,String s){
         System.out.println("前置通知-arg="+s);
     }

     @After("pc(s)")
     public void afterTest(String s){
         System.out.println("后置终点通知-arg="+s);
     }

     @AfterReturning(pointcut = "pc(s)", returning = "i")
     public void afterReturningTest(Object i,String s){
         System.out.println("后置返回通知-return="+i+"-arg="+s);
     }

     @AfterThrowing(pointcut = "pc(s)",throwing = "e")
     public void afterThrowingTest(Exception e,String s){
         System.out.println("后置异常通知-"+e.getMessage()+"-arg="+s);
     }

     @Around("pc(s)")
     public void aroundTest(ProceedingJoinPoint jp,String s){
         System.out.println("环绕前置通知-arg="+s);
         Object[] os = jp.getArgs();
         s = "caocao";
         os[0] = s;
         try {
             jp.proceed(os);
         } catch (Throwable throwable) {
             throwable.printStackTrace();
         }
         System.out.println("环绕后置通知-arg="+s);
     }
 }

　　创建测试用例：

 package com.example.springaspectdemo;

 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.context.annotation.EnableAspectJAutoProxy;
 import org.springframework.test.context.junit4.SpringRunner;

 @RunWith(SpringRunner.class)
 @SpringBootTest
 @EnableAspectJAutoProxy
 public class SpringAspectDemoApplicationTests {
     @Autowired
     private AspectDemo aspectDemo;

     @Test
     public void aspecctTest(){
         aspectDemo.test("huahua");
     }
 }

　　执行结果：

环绕前置通知-arg=huahua
前置通知-arg=caocao
目标方法执行-caocao
环绕后置通知-arg=caocao
后置终点通知-arg=caocao
后置返回通知-return=null-arg=caocao

　　重点解析：

　　1、后置返回通知是在目标代码执行完毕，返回结果之后执行，可以对返回的结果进行处理，但是要注意，其不能和环绕通知一起作用于同一个目标方法，否则会导致无法获取到返回值，正如上面例子中执行结果最后一行的null，表示的就是返回值，如果将环绕通知的部分注释掉，则可以返回正确的结果。

　　2、后置返回通知的返回值类型必须是引用类型或者包装类型，不能是原始类型，否则会报错，类型不匹配。

　　3、我们可以对目标方法的参数进行修改，但只能在环绕通知中进行，在环绕通知中的第一个参数必然是ProceedJoinPoint，它是JoinPoint的子类，通过其getArgs方法可以获取到调用目标方法的参数列表，可以对其进行修改，然后再执行带参数的proceed方法，将新的参数列表传递到目标方法。而且我们可以从上面的执行结果看到，环绕通知的前置部分是先于其他所有通知而执行的，那么它修改参数之后将会作用于后面所有的通知。正如例子中，我们在环绕通知前置部分将参数"huahua"改成了"caocao"，在之后的所有通知和目标方法中获取到的参数全部变成了"caocao"。

　　4、异常通知不只是捕捉目标方法中的异常，还有作用于同一方法上的其他通知中发生的异常。所以并不是一旦出现异常就不会执行afterReturning通知方法。如果是目标方法执行正常，却在afterReturning中发生异常的话，那么就会同时执行afterReturning通知方法和afterThrowing通知方法。

　　5、我们还可以从上面的执行结果看到各个通知的执行顺序：

　　　　环绕通知前置部分--->前置通知--->目标方法--->环绕通知后置部分--->后置终点通知--->后置返回通知--->后置异常通知

　　6、对于上面执行的一点补充：

　　　　那就是发生异常的情况，如果在环绕通知前置部分发生异常，那么之后除了后置终点通知是必然执行的外，只有最后的异常通知会被触发，其余一概不会执行。

　　　　如果第5点中执行顺序哪一步发生了异常，那么其前面的通知会正常执行，后面的除了后置终点通知一定会执行外，异常通知也回被触发。

　　　　但有一个例外，那就是前置通知，在前置通知和环绕通知同时作用于一个目标方法时，前置通知的异常将不会被后置异常通知捕捉到。

　　7、终上所述，推荐不要将环绕通知和其他通知一起使用。因为环绕通知会导致一些异常的情况，使其他通知的部分功能失效。

　　可以使用上面的代码进行修改测试！