Spring笔记（二）——AOP面向切面编程

---

Spring AOP面向切面编程

1.1 场景设定和问题复现

1. 准备AOP项目

   项目名：spring-aop-annotation

   pom.xml

<dependencies>
    <!--spring context依赖-->
    <!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>6.0.6</version>
    </dependency>

    <!--junit5测试-->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.3.1</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>6.0.6</version>
        <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>jakarta.annotation</groupId>
        <artifactId>jakarta.annotation-api</artifactId>
        <version>2.1.1</version>
    </dependency>
</dependencies>
```

2. 声明接口

/**
 *       + - * / 运算的标准接口!
 */
public interface Calculator {

    int add(int i, int j);

    int sub(int i, int j);

    int mul(int i, int j);

    int div(int i, int j);

}

2. 接口实现

package com.atguigu.proxy;

/**
 * 实现计算接口,单纯添加 + - * / 实现! 掺杂其他功能!
 */
public class CalculatorPureImpl implements Calculator {
    
    @Override
    public int add(int i, int j) {
    
        int result = i + j;
    
        return result;
    }
    
    @Override
    public int sub(int i, int j) {
    
        int result = i - j;
    
        return result;
    }
    
    @Override
    public int mul(int i, int j) {
    
        int result = i * j;
    
        return result;
    }
    
    @Override
    public int div(int i, int j) {
    
        int result = i / j;
    
        return result;
    }
}
```

4. 声明带日志接口实现

   新需求： 需要在每个方法中，添加控制台输出，输出参数和输出计算后的返回值！

package com.atguigu.proxy;

/**
 * 在每个方法中,输出传入的参数和计算后的返回结果!
 */
public class CalculatorLogImpl implements Calculator {
    
    @Override
    public int add(int i, int j) {
    
        System.out.println("参数是：" + i + "," + j);
        int result = i + j;
        System.out.println("方法内部 result = " + result);
      
        return result;
    }
    
    @Override
    public int sub(int i, int j) {
    
        System.out.println("参数是：" + i + "," + j);
    
        int result = i - j;
    
        System.out.println("方法内部 result = " + result);
        return result;
    }
    
    @Override
    public int mul(int i, int j) {
    
        System.out.println("参数是：" + i + "," + j);
    
        int result = i * j;
    
        System.out.println("方法内部 result = " + result);
    
        return result;
    }
    
    @Override
    public int div(int i, int j) {
    
        System.out.println("参数是：" + i + "," + j);
    
        int result = i / j;
    
        System.out.println("方法内部 result = " + result);
        
        return result;
    }
}

4. 代码问题分析

   1. 代码缺陷

      • 对核心业务功能有干扰，导致程序员在开发核心业务功能时分散了精力
      • 附加功能代码重复，分散在各个业务功能方法中！冗余，且不方便统一维护！

   2. 解决思路

      核心就是：解耦。我们需要把附加功能从业务功能代码中抽取出来。

      将重复的代码统一提取，并且[[动态插入]]到每个业务方法！

   3. 技术困难

      解决问题的困难：提取重复附加功能代码到一个类中，可以实现

      但是如何将代码插入到各个方法中，我们不会，我们需要引用新技术！！！

1.2 解决技术代理模式

1. 代理模式

   二十三种设计模式中的一种，属于结构型模式。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。让不属于目标方法核心逻辑的代码从目标方法中剥离出来——解耦。调用目标方法时先调用代理对象的方法，减少对目标方法的调用和打扰，同时让附加功能能够集中在一起也有利于统一维护。

   生活中的代理：

   • 广告商找大明星拍广告需要经过经纪人
   • 合作伙伴找大老板谈合作要约见面时间需要经过秘书
   • 房产中介是买卖双方的代理
   • 太监是大臣和皇上之间的代理
     相关术语：
   • 代理：将非核心逻辑剥离出来以后，封装这些非核心逻辑的类、对象、方法。(中介)
     • 动词：指做代理这个动作，或这项工作
     • 名词：扮演代理这个角色的类、对象、方法
   • 目标：被代理“套用”了核心逻辑代码的类、对象、方法。(房东)
     代理在开发中实现的方式具体有两种：静态代理，[动态代理技术]

2. 静态代理

   主动创建代理类：

   public class CalculatorStaticProxy implements Calculator {
       
       // 将被代理的目标对象声明为成员变量
       private Calculator target;
       
       public CalculatorStaticProxy(Calculator target) {
           this.target = target;
       }
       
       @Override
       public int add(int i, int j) {
       
           // 附加功能由代理类中的代理方法来实现
           System.out.println("参数是：" + i + "," + j);
       
           // 通过目标对象来实现核心业务逻辑
           int addResult = target.add(i, j);
       
           System.out.println("方法内部 result = " + result);
       
           return addResult;
       }
       ……
   

   静态代理确实实现了解耦，但是由于代码都写死了，完全不具备任何的灵活性。就拿日志功能来说，将来其他地方也需要附加日志，那还得再声明更多个静态代理类，那就产生了大量重复的代码，日志功能还是分散的，没有统一管理。

   提出进一步的需求：将日志功能集中到一个代理类中，将来有任何日志需求，都通过这一个代理类来实现。这就需要使用动态代理技术了。

3. 动态代理

   动态代理技术分类

   • JDK动态代理：JDK原生的实现方式，需要被代理的目标类必须实现接口！他会根据目标类的接口动态生成一个代理对象！代理对象和目标对象有相同的接口！（拜把子）
   • cglib：通过继承被代理的目标类实现代理，所以不需要目标类实现接口！（认干爹）
     JDK动态代理技术实现（了解）

   代理工程：基于jdk代理技术，生成代理对象

   public class ProxyFactory {
   
       private Object target;
   
       public ProxyFactory(Object target) {
           this.target = target;
       }
   
       public Object getProxy(){
   
           /**
            * newProxyInstance()：创建一个代理实例
            * 其中有三个参数：
            * 1、classLoader：加载动态生成的代理类的类加载器
            * 2、interfaces：目标对象实现的所有接口的class对象所组成的数组
            * 3、invocationHandler：设置代理对象实现目标对象方法的过程，即代理类中如何重写接口中的抽象方法
            */
           ClassLoader classLoader = target.getClass().getClassLoader();
           Class<?>[] interfaces = target.getClass().getInterfaces();
           InvocationHandler invocationHandler = new InvocationHandler() {
               @Override
               public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                   /**
                    * proxy：代理对象
                    * method：代理对象需要实现的方法，即其中需要重写的方法
                    * args：method所对应方法的参数
                    */
                   Object result = null;
                   try {
                       System.out.println("[动态代理][日志] "+method.getName()+"，参数："+ Arrays.toString(args));
                       result = method.invoke(target, args);
                       System.out.println("[动态代理][日志] "+method.getName()+"，结果："+ result);
                   } catch (Exception e) {
                       e.printStackTrace();
                       System.out.println("[动态代理][日志] "+method.getName()+"，异常："+e.getMessage());
                   } finally {
                       System.out.println("[动态代理][日志] "+method.getName()+"，方法执行完毕");
                   }
                   return result;
               }
           };
   
           return Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
       }
   }
   

   测试代码：

   @Test
   public void testDynamicProxy(){
       ProxyFactory factory = new ProxyFactory(new CalculatorLogImpl());
       Calculator proxy = (Calculator) factory.getProxy();
       proxy.div(1,0);
       //proxy.div(1,1);
   }
   

4. 代理总结

   代理方式可以解决附加功能代码干扰核心代码和不方便统一维护的问题！

   他主要是将附加功能代码提取到代理中执行，不干扰目标核心代码！

   但是我们也发现，无论使用静态代理和动态代理(jdk,cglib)，程序员的工作都比较繁琐！

   需要自己编写代理工厂等！

   但是，提前剧透，我们在实际开发中，不需要编写代理代码，我们可以使用[Spring AOP]框架，

   他会简化动态代理的实现！！！

1.3 面向切面编程思维（AOP）

1. 面向切面编程思想AOP

   AOP：Aspect Oriented Programming面向切面编程

   AOP可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对应的对象的核心功能毫无关系对于其他类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切（cross cutting），在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

   AOP技术恰恰相反，它利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。

   使用AOP，可以在不修改原来代码的基础上添加新功能。

   

2. AOP思想主要的应用场景

   AOP（面向切面编程）是一种编程范式，它通过将通用的横切关注点（如日志、事务、权限控制等）与业务逻辑分离，使得代码更加清晰、简洁、易于维护。AOP可以应用于各种场景，以下是一些常见的AOP应用场景：

   1. 日志记录：在系统中记录日志是非常重要的，可以使用AOP来实现日志记录的功能，可以在方法执行前、执行后或异常抛出时记录日志。
   2. 事务处理：在数据库操作中使用事务可以保证数据的一致性，可以使用AOP来实现事务处理的功能，可以在方法开始前开启事务，在方法执行完毕后提交或回滚事务。
   3. 安全控制：在系统中包含某些需要安全控制的操作，如登录、修改密码、授权等，可以使用AOP来实现安全控制的功能。可以在方法执行前进行权限判断，如果用户没有权限，则抛出异常或转向到错误页面，以防止未经授权的访问。
   4. 性能监控：在系统运行过程中，有时需要对某些方法的性能进行监控，以找到系统的瓶颈并进行优化。可以使用AOP来实现性能监控的功能，可以在方法执行前记录时间戳，在方法执行完毕后计算方法执行时间并输出到日志中。
   5. 异常处理：系统中可能出现各种异常情况，如空指针异常、数据库连接异常等，可以使用AOP来实现异常处理的功能，在方法执行过程中，如果出现异常，则进行异常处理（如记录日志、发送邮件等）。
   6. 缓存控制：在系统中有些数据可以缓存起来以提高访问速度，可以使用AOP来实现缓存控制的功能，可以在方法执行前查询缓存中是否有数据，如果有则返回，否则执行方法并将方法返回值存入缓存中。
   7. 动态代理：AOP的实现方式之一是通过动态代理，可以代理某个类的所有方法，用于实现各种功能。
      综上所述，AOP可以应用于各种场景，它的作用是将通用的横切关注点与业务逻辑分离，使得代码更加清晰、简洁、易于维护。

3. AOP术语名词介绍

   1-横切关注点

   从每个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。

   这个概念不是语法层面天然存在的，而是根据附加功能的逻辑上的需要：有十个附加功能，就有十个横切关注点。

   AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事务、异常等。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。

   2-通知(增强)

   每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。

   • 前置通知：在被代理的目标方法前执行
   • 返回通知：在被代理的目标方法成功结束后执行（寿终正寝）
   • 异常通知：在被代理的目标方法异常结束后执行（死于非命）
   • 后置通知：在被代理的目标方法最终结束后执行（盖棺定论）
   • 环绕通知：使用try…catch…finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置
     3-连接点 joinpoint

   这也是一个纯逻辑概念，不是语法定义的。

   指那些被拦截到的点。在 Spring 中，可以被动态代理拦截目标类的方法

   4-切入点 pointcut

   定位连接点的方式，或者可以理解成被选中的连接点！

   是一个表达式，比如execution(* com.spring.service.impl..(…))。符合条件的每个方法都是一个具体的连接点。

   5-切面 aspect

   切入点和通知的结合。是一个类。

   6-目标 target

   被代理的目标对象。

   7-代理 proxy

   向目标对象应用通知之后创建的代理对象。

   8-织入 weave

   指把通知应用到目标上，生成代理对象的过程。可以在编译期织入，也可以在运行期织入，Spring采用后者。

1.4 Spring AOP框架介绍和关系梳理

1. AOP一种区别于OOP的编程思维，用来完善和解决OOP的非核心代码冗余和不方便统一维护问题！
2. 代理技术（动态代理|静态代理）是实现AOP思维编程的具体技术，但是自己使用动态代理实现代码比较繁琐！
3. Spring AOP框架，基于AOP编程思维，封装动态代理技术，简化动态代理技术实现的框架！SpringAOP内部帮助我们实现动态代理，我们只需写少量的配置，指定生效范围即可,即可完成面向切面思维编程的实现！

1.5 Spring AOP基于注解方式实现和细节

1.5.1 Spring AOP底层技术组成

• 动态代理（InvocationHandler）：JDK原生的实现方式，需要被代理的目标类必须实现接口。因为这个技术要求代理对象和目标对象实现同样的接口（兄弟两个拜把子模式）。
• cglib：通过继承被代理的目标类（认干爹模式）实现代理，所以不需要目标类实现接口。
• AspectJ：早期的AOP实现的框架，SpringAOP借用了AspectJ中的AOP注解。

1.5.2 初步实现

1. 加入依赖

   <!-- spring-aspects会帮我们传递过来aspectjweaver -->
   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-aop</artifactId>
       <version>6.0.6</version>
   </dependency>
   
   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-aspects</artifactId>
       <version>6.0.6</version>
   </dependency>
   

2. 准备接口

   public interface Calculator {
       
       int add(int i, int j);
       
       int sub(int i, int j);
       
       int mul(int i, int j);
       
       int div(int i, int j);
       
   }
   

3. 纯净实现类

   package com.atguigu.proxy;
   

   /**

   • 实现计算接口,单纯添加 + - * / 实现! 掺杂其他功能!
     */
     @Component
     public class CalculatorPureImpl implements Calculator {

     @Override
     public int add(int i, int j) {

      int result = i + j;
     
      return result;
     

     }

     @Override
     public int sub(int i, int j) {

      int result = i - j;
     
      return result;
     

     }

     @Override
     public int mul(int i, int j) {

      int result = i * j;
     
      return result;
     

     }

     @Override
     public int div(int i, int j) {

      int result = i / j;
     
      return result;
     

     }
     }

4. 声明切面类

package com.atguigu.advice;

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

// @Aspect表示这个类是一个切面类
@Aspect
// @Component注解保证这个切面类能够放入IOC容器
@Component
public class LogAspect {
        
    // @Before注解：声明当前方法是前置通知方法
    // value属性：指定切入点表达式，由切入点表达式控制当前通知方法要作用在哪一个目标方法上
    @Before(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")
    public void printLogBeforeCore() {
        System.out.println("[AOP前置通知] 方法开始了");
    }
    
    @AfterReturning(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")
    public void printLogAfterSuccess() {
        System.out.println("[AOP返回通知] 方法成功返回了");
    }
    
    @AfterThrowing(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")
    public void printLogAfterException() {
        System.out.println("[AOP异常通知] 方法抛异常了");
    }
    
    @After(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")
    public void printLogFinallyEnd() {
        System.out.println("[AOP后置通知] 方法最终结束了");
    }
    
}

4. 开启aspectj注解支持
   1. xml方式

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 进行包扫描-->
    <context:component-scan base-package="com.atguigu" />
    <!-- 开启aspectj框架注解支持-->
    <aop:aspectj-autoproxy />
</beans>

1. 配置类方式

   @Configuration
   @ComponentScan(basePackages = "com.atguigu")
   //作用等于 <aop:aspectj-autoproxy /> 配置类上开启 Aspectj注解支持!
   @EnableAspectJAutoProxy
   public class MyConfig {
   }
   
   

2. 测试效果

   //@SpringJUnitConfig(locations = "classpath:spring-aop.xml")
   @SpringJUnitConfig(value = {MyConfig.class})
   public class AopTest {
   
       @Autowired
       private Calculator calculator;
   
       @Test
       public void testCalculator(){
           calculator.add(1,1);
       }
   }
   
   

   输出结果：

   "C:\Program Files\Java\jdk-17\bin\java.exe" -ea -Didea.test.cyclic.buffer.size=1048576 "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2022.3.2\lib\idea_rt.jar=65511:D:\Program Files\JetBrains\IntelliJ IDEA 2022.3.2\bin" -Dfile.encoding=UTF-8 -classpath "C:\Users\Jackiechan\.m2\repository\org\junit\platform\junit-platform-launcher\1.3.1\junit-platform-launcher-1.3.1.jar;C:\Users\Jackiechan\.m2\repository\org\apiguardian\apiguardian-api\1.0.0\apiguardian-api-1.0.0.jar;C:\Users\Jackiechan\.m2\repository\org\junit\platform\junit-platform-engine\1.3.1\junit-platform-engine-1.3.1.jar;C:\Users\Jackiechan\.m2\repository\org\junit\platform\junit-platform-commons\1.3.1\junit-platform-commons-1.3.1.jar;C:\Users\Jackiechan\.m2\repository\org\opentest4j\opentest4j\1.1.1\opentest4j-1.1.1.jar;C:\Users\Jackiechan\.m2\repository\org\junit\jupiter\junit-jupiter-engine\5.3.1\junit-jupiter-engine-5.3.1.jar;C:\Users\Jackiechan\.m2\repository\org\junit\jupiter\junit-jupiter-api\5.3.1\junit-jupiter-api-5.3.1.jar;D:\Program Files\JetBrains\IntelliJ IDEA 2022.3.2\lib\idea_rt.jar;D:\Program Files\JetBrains\IntelliJ IDEA 2022.3.2\plugins\junit\lib\junit5-rt.jar;D:\Program Files\JetBrains\IntelliJ IDEA 2022.3.2\plugins\junit\lib\junit-rt.jar;D:\javaprojects\backend-engineering\part01-spring\spring-aop-annotation\target\test-classes;D:\javaprojects\backend-engineering\part01-spring\spring-aop-annotation\target\classes;D:\repository\org\springframework\spring-context\6.0.6\spring-context-6.0.6.jar;D:\repository\org\springframework\spring-beans\6.0.6\spring-beans-6.0.6.jar;D:\repository\org\springframework\spring-core\6.0.6\spring-core-6.0.6.jar;D:\repository\org\springframework\spring-jcl\6.0.6\spring-jcl-6.0.6.jar;D:\repository\org\springframework\spring-expression\6.0.6\spring-expression-6.0.6.jar;D:\repository\org\junit\jupiter\junit-jupiter-api\5.3.1\junit-jupiter-api-5.3.1.jar;D:\repository\org\apiguardian\apiguardian-api\1.0.0\apiguardian-api-1.0.0.jar;D:\repository\org\opentest4j\opentest4j\1.1.1\opentest4j-1.1.1.jar;D:\repository\org\junit\platform\junit-platform-commons\1.3.1\junit-platform-commons-1.3.1.jar;D:\repository\org\springframework\spring-test\6.0.6\spring-test-6.0.6.jar;D:\repository\jakarta\annotation\jakarta.annotation-api\2.1.1\jakarta.annotation-api-2.1.1.jar;D:\repository\mysql\mysql-connector-java\8.0.25\mysql-connector-java-8.0.25.jar;D:\repository\com\google\protobuf\protobuf-java\3.11.4\protobuf-java-3.11.4.jar;D:\repository\com\alibaba\druid\1.2.8\druid-1.2.8.jar;D:\repository\javax\annotation\javax.annotation-api\1.3.2\javax.annotation-api-1.3.2.jar;D:\repository\org\springframework\spring-aop\6.0.6\spring-aop-6.0.6.jar;D:\repository\org\springframework\spring-aspects\6.0.6\spring-aspects-6.0.6.jar;D:\repository\org\aspectj\aspectjweaver\1.9.9.1\aspectjweaver-1.9.9.1.jar" com.intellij.rt.junit.JUnitStarter -ideVersion5 -junit5 com.atguigu.test.AopTest,testCalculator
   [AOP前置通知] 方法开始了
   [AOP返回通知] 方法成功返回了
   [AOP后置通知] 方法最终结束了
   

1.5.3 获取通知细节信息

1. JointPoint接口

   需要获取方法签名、传入的实参等信息时，可以在通知方法声明JoinPoint类型的形参。

   • 要点1：JoinPoint 接口通过 getSignature() 方法获取目标方法的签名（方法声明时的完整信息）
   • 要点2：通过目标方法签名对象获取方法名
   • 要点3：通过 JoinPoint 对象获取外界调用目标方法时传入的实参列表组成的数组

   // @Before注解标记前置通知方法
   // value属性：切入点表达式，告诉Spring当前通知方法要套用到哪个目标方法上
   // 在前置通知方法形参位置声明一个JoinPoint类型的参数，Spring就会将这个对象传入
   // 根据JoinPoint对象就可以获取目标方法名称、实际参数列表
   @Before(value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))")
   public void printLogBeforeCore(JoinPoint joinPoint) {
       
       // 1.通过JoinPoint对象获取目标方法签名对象
       // 方法的签名：一个方法的全部声明信息
       Signature signature = joinPoint.getSignature();
       
       // 2.通过方法的签名对象获取目标方法的详细信息
       String methodName = signature.getName();
       System.out.println("methodName = " + methodName);
       
       int modifiers = signature.getModifiers();
       System.out.println("modifiers = " + modifiers);
       
       String declaringTypeName = signature.getDeclaringTypeName();
       System.out.println("declaringTypeName = " + declaringTypeName);
       
       // 3.通过JoinPoint对象获取外界调用目标方法时传入的实参列表
       Object[] args = joinPoint.getArgs();
       
       // 4.由于数组直接打印看不到具体数据，所以转换为List集合
       List<Object> argList = Arrays.asList(args);
       
       System.out.println("[AOP前置通知] " + methodName + "方法开始了，参数列表：" + argList);
   }
   

2. 方法返回值

   在返回通知中，通过 @AfterReturning注解的returning属性获取目标方法的返回值！

   // @AfterReturning注解标记返回通知方法
   // 在返回通知中获取目标方法返回值分两步：
   // 第一步：在@AfterReturning注解中通过returning属性设置一个名称
   // 第二步：使用returning属性设置的名称在通知方法中声明一个对应的形参
   @AfterReturning(
           value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))",
           returning = "targetMethodReturnValue"
   )
   public void printLogAfterCoreSuccess(JoinPoint joinPoint, Object targetMethodReturnValue) {
       
       String methodName = joinPoint.getSignature().getName();
       
       System.out.println("[AOP返回通知] "+methodName+"方法成功结束了，返回值是：" + targetMethodReturnValue);
   }
   

3. 异常对象捕捉

   在异常通知中，通过@AfterThrowing注解的throwing属性获取目标方法抛出的异常对象

   // @AfterThrowing注解标记异常通知方法
   // 在异常通知中获取目标方法抛出的异常分两步：
   // 第一步：在@AfterThrowing注解中声明一个throwing属性设定形参名称
   // 第二步：使用throwing属性指定的名称在通知方法声明形参，Spring会将目标方法抛出的异常对象从这里传给我们
   @AfterThrowing(
           value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))",
           throwing = "targetMethodException"
   )
   public void printLogAfterCoreException(JoinPoint joinPoint, Throwable targetMethodException) {
       
       String methodName = joinPoint.getSignature().getName();
       
       System.out.println("[AOP异常通知] "+methodName+"方法抛异常了，异常类型是：" + targetMethodException.getClass().getName());
   }
   

1.5.4 切点表达式语法

1. 切点表达式作用

   AOP切点表达式（Pointcut Expression）是一种用于指定切点的语言，它可以通过定义匹配规则，来选择需要被切入的目标对象。

2. 切点表达式语法

   切点表达式总结

   语法细节

   • 第一位：execution( ) 固定开头

   • 第二位：方法访问修饰符

     public private 直接描述对应修饰符即可
     

   • 第三位：方法返回值

     int String void 直接描述返回值类型
     
     

     注意：

     特殊情况 不考虑 访问修饰符和返回值

     execution(* * ) 这是错误语法

     execution( *) == 你只要考虑返回值 或者 不考虑访问修饰符 相当于全部不考虑了

   • 第四位：指定包的地址

      固定的包: com.atguigu.api | service | dao
      单层的任意命名: com.atguigu.*  = com.atguigu.api  com.atguigu.dao  * = 任意一层的任意命名
      任意层任意命名: com.. = com.atguigu.api.erdaye com.a.a.a.a.a.a.a  ..任意层,任意命名 用在包上!
      注意: ..不能用作包开头   public int .. 错误语法  com..
      找到任何包下: *..
     

   • 第五位：指定类名称

     固定名称: UserService
     任意类名: *
     部分任意: com..service.impl.*Impl
     任意包任意类: *..*
     
     

   • 第六位：指定方法名称

     语法和类名一致
     任意访问修饰符,任意类的任意方法: * *..*.*
     

   • 第七位：方法参数

     第七位: 方法的参数描述
            具体值: (String,int) != (int,String) 没有参数 ()
            模糊值: 任意参数 有 或者 没有 (..)  ..任意参数的意识
            部分具体和模糊:
              第一个参数是字符串的方法 (String..)
              最后一个参数是字符串 (..String)
              字符串开头,int结尾 (String..int)
              包含int类型(..int..)
     

1.5.5 重用（提取）切点表达式

1. 重用切点表达式优点

    // @Before注解：声明当前方法是前置通知方法
   // value属性：指定切入点表达式，由切入点表达式控制当前通知方法要作用在哪一个目标方法上
   @Before(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")
   public void printLogBeforeCore() {
       System.out.println("[AOP前置通知] 方法开始了");
   }
   
   @AfterReturning(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")
   public void printLogAfterSuccess() {
       System.out.println("[AOP返回通知] 方法成功返回了");
   }
   
   @AfterThrowing(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")
   public void printLogAfterException() {
       System.out.println("[AOP异常通知] 方法抛异常了");
   }
   
   @After(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")
   public void printLogFinallyEnd() {
       System.out.println("[AOP后置通知] 方法最终结束了");
   }
   

   上面案例，是我们之前编写切点表达式的方式，发现， 所有增强方法的切点表达式相同！

   出现了冗余，如果需要切换也不方便统一维护！

   我们可以将切点提取，在增强上进行引用即可！

2. 同一类内部引用

   提取

   // 切入点表达式重用
   @Pointcut("execution(public int com.atguigu.aop.api.Calculator.add(int,int)))")
   public void declarPointCut() {}
   

   注意：提取切点注解使用@Pointcut(切点表达式) ， 需要添加到一个无参数无返回值方法上即可！

   引用

   @Before(value = "declarPointCut()")
   public void printLogBeforeCoreOperation(JoinPoint joinPoint) {
   

3. 不同类中引用

   不同类在引用切点，只需要添加类的全限定符+方法名即可！

   @Before(value = "com.atguigu.spring.aop.aspect.LogAspect.declarPointCut()")
   public Object roundAdvice(ProceedingJoinPoint joinPoint) {
   

4. 切点统一管理

   建议：将切点表达式统一存储到一个类中进行集中管理和维护！

   @Component
   public class AtguiguPointCut {
       
       @Pointcut(value = "execution(public int *..Calculator.sub(int,int))")
       public void atguiguGlobalPointCut(){}
       
       @Pointcut(value = "execution(public int *..Calculator.add(int,int))")
       public void atguiguSecondPointCut(){}
       
       @Pointcut(value = "execution(* *..*Service.*(..))")
       public void transactionPointCut(){}
   }
   

1.5.6 环绕通知

环绕通知对应整个 try…catch…finally 结构，包括前面四种通知的所有功能。

// 使用@Around注解标明环绕通知方法
@Around(value = "com.atguigu.aop.aspect.AtguiguPointCut.transactionPointCut()")
public Object manageTransaction(
    
        // 通过在通知方法形参位置声明ProceedingJoinPoint类型的形参，
        // Spring会将这个类型的对象传给我们
        ProceedingJoinPoint joinPoint) {
    
    // 通过ProceedingJoinPoint对象获取外界调用目标方法时传入的实参数组
    Object[] args = joinPoint.getArgs();
    
    // 通过ProceedingJoinPoint对象获取目标方法的签名对象
    Signature signature = joinPoint.getSignature();
    
    // 通过签名对象获取目标方法的方法名
    String methodName = signature.getName();
    
    // 声明变量用来存储目标方法的返回值
    Object targetMethodReturnValue = null;
    
    try {
    
        // 在目标方法执行前：开启事务（模拟）
        log.debug("[AOP 环绕通知] 开启事务，方法名：" + methodName + "，参数列表：" + Arrays.asList(args));
    
        // 过ProceedingJoinPoint对象调用目标方法
        // 目标方法的返回值一定要返回给外界调用者
        targetMethodReturnValue = joinPoint.proceed(args);
    
        // 在目标方法成功返回后：提交事务（模拟）
        log.debug("[AOP 环绕通知] 提交事务，方法名：" + methodName + "，方法返回值：" + targetMethodReturnValue);
    
    }catch (Throwable e){
    
        // 在目标方法抛异常后：回滚事务（模拟）
        log.debug("[AOP 环绕通知] 回滚事务，方法名：" + methodName + "，异常：" + e.getClass().getName());
    
    }finally {
    
        // 在目标方法最终结束后：释放数据库连接
        log.debug("[AOP 环绕通知] 释放数据库连接，方法名：" + methodName);
    
    }
    
    return targetMethodReturnValue;
}

1.5.7 切面优先级设置

相同目标方法上同时存在多个切面时，切面的优先级控制切面的内外嵌套顺序。

• 优先级高的切面：外面
• 优先级低的切面：里面

使用 @Order 注解可以控制切面的优先级：

• @Order(较小的数)：优先级高
• @Order(较大的数)：优先级低

实际意义

实际开发时，如果有多个切面嵌套的情况，要慎重考虑。例如：如果事务切面优先级高，那么在缓存中命中数据的情况下，事务切面的操作都浪费了。

此时应该将缓存切面的优先级提高，在事务操作之前先检查缓存中是否存在目标数据。

1.5.8 CGLib动态代理生效

在目标类没有实现任何接口的情况下，Spring会自动使用cglib技术实现代理。为了证明这一点，我们做下面的测试：

@Service
public class EmployeeService {
    
    public void getEmpList() {
       System.out.print("方法内部 com.atguigu.aop.imp.EmployeeService.getEmpList");
    }
}

测试：

  @Autowired
  private EmployeeService employeeService;
  
  @Test
  public void testNoInterfaceProxy() {
      employeeService.getEmpList();
  }

使用总结：

a. 如果目标类有接口,选择使用jdk动态代理

b. 如果目标类没有接口,选择cglib动态代理

c. 如果有接口,接口接值

d. 如果没有接口,类进行接值

1.4 Spring AOP对获取Bean的影响理解

1.4.1 根据类型装配 bean

1. 情景一

   • bean 对应的类没有实现任何接口

   • 根据 bean 本身的类型获取 bean

     • 测试：IOC容器中同类型的 bean 只有一个

       正常获取到 IOC 容器中的那个 bean 对象

     • 测试：IOC 容器中同类型的 bean 有多个

       会抛出 NoUniqueBeanDefinitionException 异常，表示 IOC 容器中这个类型的 bean 有多个

2. 情景二

   • bean 对应的类实现了接口，这个接口也只有这一个实现类
     • 测试：根据接口类型获取 bean
     • 测试：根据类获取 bean
     • 结论：上面两种情况其实都能够正常获取到 bean，而且是同一个对象

3. 情景三

   • 声明一个接口

   • 接口有多个实现类

   • 接口所有实现类都放入 IOC 容器

     • 测试：根据接口类型获取 bean

       会抛出 NoUniqueBeanDefinitionException 异常，表示 IOC 容器中这个类型的 bean 有多个

     • 测试：根据类获取bean

       正常

4. 情景四

   • 声明一个接口

   • 接口有一个实现类

   • 创建一个切面类，对上面接口的实现类应用通知

     • 测试：根据接口类型获取bean

       正常

     • 测试：根据类获取bean

       无法获取
       原因分析：

   • 应用了切面后，真正放在IOC容器中的是代理类的对象

   • 目标类并没有被放到IOC容器中，所以根据目标类的类型从IOC容器中是找不到的

5. 情景五

   • 声明一个类
   • 创建一个切面类，对上面的类应用通知
     • 测试：根据类获取 bean，能获取到

1.4.2 使用总结

对实现了接口的类应用切面

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

对没实现接口的类应用切面new

如果使用AOP技术，目标类有接口，必须使用接口类型接收IoC容器中代理组件！

如有问题，欢迎指正！