spring5（五）：AOP操作

拼搏现实的明天。 2023-09-29 14:09 12阅读 0赞

### spring5（五）：AOP操作 ###

*  前言
 *  一、代理模式
 *   *  1、场景模拟
     *  2、代理模式
     *   *  2.1 概念
         *  2.2 静态代理
         *  2.3 动态代理
 *  二、AOP概述
 *   *  1、什么是 AOP?
     *  2、相关术语
     *  3、作用
 *  三、AOP底层原理
 *   *  1、AOP 底层使用动态代理
     *  2、AOP（JDK 动态代理）
     *   *  2.1 编写 JDK 动态代理代码
 *  四、AOP 操作的准备工作
 *   *  1、AspectJ概述
     *  2、依赖的引入
 *  五、AOP操作（注解版）
 *   *  1、添加依赖
     *  2、准备被代理的目标资源
     *  3、在Spring的配置文件中配置
     *  4、创建切面类并配置
     *  5、测试
 *  六、重点
 *   *  1、 切入点表达式
     *  2、重用切入点表达式
     *  3、获取通知的相关信息
     *  4、环绕通知
     *  5、切面的优先级
     *  6、完全使用注解开发
 *  七、AOP 操作（AspectJ 配置文件）
 *   *  1、创建两个类，增强类和被增强类，创建方法
     *  2、在 spring 配置文件中创建两个类对象
     *  3、在 spring 配置文件中配置切入点

--------------------

# 前言 #

本博主将用CSDN记录软件开发求学之路上亲身所得与所学的心得与知识，有兴趣的小伙伴可以关注博主！也许一个人独行，可以走的很快，但是一群人结伴而行，才能走的更远！让我们在成长的道路上互相学习，欢迎关注！

# 一、代理模式 #

## 1、场景模拟 ##

**（1）声明计算器接口Calculator，包含加减乘除的抽象方法**

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）创建实现类**  
![在这里插入图片描述][fe07af8f1c6f453581c363c3919146e2.png]

public class CalculatorPureImpl implements Calculator {
         
    	@Override
    	public int add(int i, int j) {
         
    		int result = i + j;
    		System.out.println("方法内部 result = " + result);
    		return result;
    	}
    	@Override
    	public int sub(int i, int j) {
         
    		int result = i - j;
    		System.out.println("方法内部 result = " + result);
    		return result;
    	}
    	@Override
    	public int mul(int i, int j) {
         
    		int result = i * j;
    		System.out.println("方法内部 result = " + result);
    		return result;
    	}
    	@Override
    	public int div(int i, int j) {
         
    		int result = i / j;
    		System.out.println("方法内部 result = " + result);
    		return result;
    	}
    }

**（3）创建带日志功能的实现类**  
![在这里插入图片描述][e768c65720e340889a7e99e0e5ce086b.png]

public class CalculatorLogImpl implements Calculator {
         
    	@Override
    	public int add(int i, int j) {
         
    		System.out.println("[日志] add 方法开始了，参数是：" + i + "," + j);
    		int result = i + j;
    		System.out.println("方法内部 result = " + result);
    		System.out.println("[日志] add 方法结束了，结果是：" + result);
    		return result;
    	}
    	@Override
    	public int sub(int i, int j) {
         
    		System.out.println("[日志] sub 方法开始了，参数是：" + i + "," + j);
    		int result = i - j;
    		System.out.println("方法内部 result = " + result);
    		System.out.println("[日志] sub 方法结束了，结果是：" + result);
    		return result;
    	}
    	@Override
    	public int mul(int i, int j) {
         
    		System.out.println("[日志] mul 方法开始了，参数是：" + i + "," + j);
    		int result = i * j;
    		System.out.println("方法内部 result = " + result);
    		System.out.println("[日志] mul 方法结束了，结果是：" + result);
    		return result;
    	}
    	@Override
    	public int div(int i, int j) {
         
    		System.out.println("[日志] div 方法开始了，参数是：" + i + "," + j);
    		int result = i / j;
    		System.out.println("方法内部 result = " + result);
    		System.out.println("[日志] div 方法结束了，结果是：" + result);
    		return result;
    	}
    }

**（4）提出问题**

> ⭕ **现有代码缺陷：**  
> 针对带日志功能的实现类，我们发现有如下缺陷： 对核心业务功能有干扰，导致程序员在开发核心业务功能时分散了精力  
> 附加功能分散在各个业务功能方法中，不利于统一维护  
> ⭕ **解决思路：**  
> 解决这两个问题，核心就是：解耦。我们需要把附加功能从业务功能代码中抽取出来。  
> ⭕ **困难：**  
> 解决问题的困难：要抽取的代码在方法内部，靠以前把子类中的重复代码抽取到父类的方式没法解决。 所以需要引入新的技术。

## 2、代理模式 ##

### 2.1 概念 ###

**①介绍**

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

⭕ 使用代理前：  
![在这里插入图片描述][f51c8d3b2660454a8305cd12408979af.png]

⭕ 使用代理后：  
![在这里插入图片描述][1c8687ca74c2412dbfc0f2f98be5897c.png]

**②生活中的代理**

> ● 广告商找大明星拍广告需要经过经纪人  
> ● 合作伙伴找大老板谈合作要约见面时间需要经过秘书  
> ● 房产中介是买卖双方的代理

**③相关术语**

> ● 代理：将非核心逻辑剥离出来以后，封装这些非核心逻辑的类、对象、方法。  
> ● 目标：被代理“套用”了非核心逻辑代码的类、对象、方法。

### 2.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("[日志] add 方法开始了，参数是：" + i + "," + j);
    		// 通过目标对象来实现核心业务逻辑
    		int addResult = target.add(i, j);
    		System.out.println("[日志] add 方法结束了，结果是：" + addResult);
    		return addResult;
    	}
    }

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

### 2.3 动态代理 ###

![在这里插入图片描述][6216fdfc8f894d0a89a6ac3d33500504.png]  
生产代理对象的工厂类：

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

# 二、AOP概述 #

## 1、什么是 AOP? ##

> ⭕`AOP（Aspect Oriented Programming）`是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程的一种补充和完善，它以通过预编译方式和运行期动态代理方式实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。

> ⭕ 通俗描述：不通过修改源代码方式，在主干功能里面添加新功能

## 2、相关术语 ##

**⭕ 横切关注点**

> 从每个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。  
> 这个概念不是语法层面天然存在的，而是根据附加功能的逻辑上的需要：有十个附加功能，就有十个横切关注点，比如上例中`CalculatorImpl`类中的日志代码是非核心代码，我们把这些非核心代码抽取出来，作为一些附加功能，即横切关注点。  
> 附加功能相对于目标类来说是横切关注点，相对于目标类来说是通知。

![在这里插入图片描述][c3eeca66ac8548fdbc1862f6f7f0cfa3.png]  
**⭕ 通知**

> 每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。
> 
> 1.  前置通知：在被代理的目标方法前执行
> 2.  返回通知：在被代理的目标方法成功结束后执行（寿终正寝）
> 3.  异常通知：在被代理的目标方法异常结束后执行（死于非命）
> 4.  后置通知：在被代理的目标方法最终结束后执行（盖棺定论）
> 5.  环绕通知：使用try…catch…finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置

![在这里插入图片描述][7e0a4fa1f6744e58ac9c3c69ca6aeb17.png]

**⭕ 切面**

> 封装通知方法的类。

![在这里插入图片描述][6dbe183e9e25481182c88fad5bcbbe56.png]  
**⭕目标**

> 被代理的目标对象。

**⭕代理**

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

**⭕连接点**

> 这也是一个纯逻辑概念，不是语法定义的。  
> 把方法排成一排，每一个横切位置看成x轴方向，把方法从上到下执行的顺序看成y轴，x轴和y轴的交叉点就是连接点。

![在这里插入图片描述][525532ad12ec41319ffee8915c085b94.png]  
**⭕切入点**

> 定位连接点的方式。  
> 每个类的方法中都包含多个连接点，所以连接点是类中客观存在的事物（从逻辑上来说）。  
> 如果把连接点看作数据库中的记录，那么切入点就是查询记录的 `SQL` 语句。  
> `Spring` 的 `AOP` 技术可以通过切入点定位到特定的连接点。  
> 切点通过 `org.springframework.aop.Pointcut` 接口进行描述，它使用类和方法作为连接点的查询条件。

## 3、作用 ##

> 1.  **简化代码**：把方法中固定位置的重复的代码**抽取**出来，让被抽取的方法更专注于自己的核心功能，提高内聚性。
> 2.  **代码增强**：把特定的功能封装到切面类中，看哪里有需要，就往上套，被**套用**了切面逻辑的方法就被切面给增强了。

# 三、AOP底层原理 #

## 1、AOP 底层使用动态代理 ##

> 有两种情况动态代理：

> ⭕ 第一种 有接口情况，使用 `JDK` 动态代理
> 
> 创建接口实现类代理对象，增强类的方法

![在这里插入图片描述][47d1133c574c4d49930ff7db0468eb52.png]

> ⭕ 第二种 没有接口情况，使用 `cglib` 动态代理  
> 创建子类的代理对象，增强类的方法

![在这里插入图片描述][361415995f314775a7eb3003141378a3.png]

## 2、AOP（JDK 动态代理） ##

> ① 使用 `JDK` 动态代理，使用 `Proxy` 类里面的方法创建代理对象

![在这里插入图片描述][18f7df238d1d4eb795d00163dc0b1a7a.png]

> ② 调用 `newProxyInstance()` 方法  
> 方法有三个参数：
> 
> 1.  第一参数，类加载器
> 2.  第二参数，增强方法所在的类，这个类实现的接口，支持多个接口
> 3.  第三参数，实现这个接口InvocationHandler，创建代理对象，写增强的部分

![在这里插入图片描述][7789a2ad6b1245f9a01e91848755c1c6.png]

### 2.1 编写 JDK 动态代理代码 ###

> ① 创建接口，定义方法

public interface UserDao {
         
        public int add(int a,int b);
        public String update(String id);
    }

> ② 创建接口实现类，实现方法

public class UserDaoImpl implements UserDao {
         
        @Override
        public int add(int a, int b) {
         
            System.out.println("add方法执行了.....");
            return a+b;
        }
    
        @Override
        public String update(String id) {
         
            System.out.println("update方法执行了.....");
            return id;
        }
    }

> ③ 使用 Proxy 类创建接口代理对象

public class JDKProxy {
         
    
        public static void main(String[] args) {
         
            //创建接口实现类代理对象
            Class[] interfaces = {
         UserDao.class};
    //        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
         
    //            @Override
    //            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         
    //                return null;
    //            }
    //        });
            UserDaoImpl userDao = new UserDaoImpl();
            UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
            int result = dao.add(1, 2);
            System.out.println("result:"+result);
        }
    }
    
    //创建代理对象代码
    class UserDaoProxy implements InvocationHandler {
         
    
        //1 把创建的是谁的代理对象，把谁传递过来
        //有参数构造传递
        private Object obj;
        public UserDaoProxy(Object obj) {
         
            this.obj = obj;
        }
    
        //增强的逻辑
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         
            //方法之前
            System.out.println("方法之前执行...."+method.getName()+" :传递的参数..."+ Arrays.toString(args));
    
            //被增强的方法执行
            Object res = method.invoke(obj, args);
    
            //方法之后
            System.out.println("方法之后执行...."+obj);
            return res;
        }
    }

# 四、AOP 操作的准备工作 #

## 1、AspectJ概述 ##

> ⭕ `Spring` 框架一般都是基于 `AspectJ` 实现 `AOP` 操作  
> `AspectJ` 不是 `Spring` 组成部分，独立 `AOP` 框架，一般把 `AspectJ` 和 `Spirng` 框架一起使用，进行 `AOP`操作

> ⭕ 基于 `AspectJ` 实现 `AOP` 操作
> 
> 1.  基于 `xml` 配置文件实现
> 2.  基于注解方式实现

> ⭕ 在项目工程里面引入 AOP 相关依赖

## 2、依赖的引入 ##

# 五、AOP操作（注解版） #

## 1、添加依赖 ##

> 在`IOC`所需依赖基础上再加入下面依赖即可：

<dependency>
    	<groupId>org.springframework</groupId>
    	<artifactId>spring-aspects</artifactId>
    	<version>5.3.1</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);
    }

**实现类：**

@Component
    public class CalculatorPureImpl implements Calculator {
         
    	@Override
    	public int add(int i, int j) {
         
    		int result = i + j;
    		System.out.println("方法内部 result = " + result);
    		return result;
    	}
    	@Override
    	public int sub(int i, int j) {
         
    		int result = i - j;
    		System.out.println("方法内部 result = " + result);
    		return result;
    	}
    	@Override
    		public int mul(int i, int j) {
         
    		int result = i * j;
    		System.out.println("方法内部 result = " + result);
    		return result;
    	}
    	@Override
    	public int div(int i, int j) {
         
    		int result = i / j;
    		System.out.println("方法内部 result = " + result);
    		return result;
    	}
    }

## 3、在Spring的配置文件中配置 ##

<context:component-scan base-package="com.atguigu.aop.annotation">
    </context:component-scan>
    <aop:aspectj-autoproxy />

## 4、创建切面类并配置 ##

package com.reds.AOPTest;
    
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.Signature;
    import org.aspectj.lang.annotation.*;
    import org.springframework.stereotype.Component;
    
    import java.util.Arrays;
    
    /**
     * Date:2022/7/4
     * Author:ybc
     * Description:
     * 1、在切面中，需要通过指定的注解将方法标识为通知方法
     * @Before：前置通知，在目标对象方法执行之前执行
     * @After：后置通知，在目标对象方法的finally字句中执行
     * @AfterReturning：返回通知，在目标对象方法返回值之后执行
     * @AfterThrowing：异常通知，在目标对象方法的catch字句中执行
     *
     *
     * 2、切入点表达式：设置在标识通知的注解的value属性中
     * execution(public int com.atguigu.spring.aop.annotation.CalculatorImpl.add(int, int)
     * execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..)
     * 第一个*表示任意的访问修饰符和返回值类型
     * 第二个*表示类中任意的方法
     * ..表示任意的参数列表
     * 类的地方也可以使用*，表示包下所有的类
     * 3、重用切入点表达式
     * //@Pointcut声明一个公共的切入点表达式
     * @Pointcut("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
     * public void pointCut(){}
     * 使用方式：@Before("pointCut()")
     *
     * 4、获取连接点的信息
     * 在通知方法的参数位置，设置JoinPoint类型的参数，就可以获取连接点所对应方法的信息
     * //获取连接点所对应方法的签名信息
     * Signature signature = joinPoint.getSignature();
     * //获取连接点所对应方法的参数
     * Object[] args = joinPoint.getArgs();
     *
     * 5、切面的优先级
     * 可以通过@Order注解的value属性设置优先级，默认值Integer的最大值
     * @Order注解的value属性值越小，优先级越高
     *
     */
    @Component
    @Aspect //将当前组件标识为切面
    public class LoggerAspect {
         
    
        @Pointcut("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
        public void pointCut(){
         }
    
        //@Before("execution(public int com.atguigu.spring.aop.annotation.CalculatorImpl.add(int, int))")
        //@Before("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
        @Before("pointCut()")
        public void beforeAdviceMethod(JoinPoint joinPoint) {
         
            //获取连接点所对应方法的签名信息
            Signature signature = joinPoint.getSignature();
            //获取连接点所对应方法的参数
            Object[] args = joinPoint.getArgs();
            System.out.println("LoggerAspect，方法："+signature.getName()+"，参数："+ Arrays.toString(args));
        }
    
        @After("pointCut()")
        public void afterAdviceMethod(JoinPoint joinPoint){
         
            //获取连接点所对应方法的签名信息
            Signature signature = joinPoint.getSignature();
            System.out.println("LoggerAspect，方法："+signature.getName()+"，执行完毕");
        }
    
        /**
         * 在返回通知中若要获取目标对象方法的返回值
         * 只需要通过@AfterReturning注解的returning属性
         * 就可以将通知方法的某个参数指定为接收目标对象方法的返回值的参数
         */
        @AfterReturning(value = "pointCut()", returning = "result")
        public void afterReturningAdviceMethod(JoinPoint joinPoint, Object result){
         
            //获取连接点所对应方法的签名信息
            Signature signature = joinPoint.getSignature();
            System.out.println("LoggerAspect，方法："+signature.getName()+"，结果："+result);
        }
    
        /**
         * 在异常通知中若要获取目标对象方法的异常
         * 只需要通过AfterThrowing注解的throwing属性
         * 就可以将通知方法的某个参数指定为接收目标对象方法出现的异常的参数
         */
        @AfterThrowing(value = "pointCut()", throwing = "ex")
        public void afterThrowingAdviceMethod(JoinPoint joinPoint, Throwable ex){
         
            //获取连接点所对应方法的签名信息
            Signature signature = joinPoint.getSignature();
            System.out.println("LoggerAspect，方法："+signature.getName()+"，异常："+ex);
        }
    
        @Around("pointCut()")
        //环绕通知的方法的返回值一定要和目标对象方法的返回值一致
        public Object aroundAdviceMethod(ProceedingJoinPoint joinPoint){
         
            Object result = null;
            try {
         
                System.out.println("环绕通知-->前置通知");
                //表示目标对象方法的执行
                result = joinPoint.proceed();
                System.out.println("环绕通知-->返回通知");
            } catch (Throwable throwable) {
         
                throwable.printStackTrace();
                System.out.println("环绕通知-->异常通知");
            } finally {
         
                System.out.println("环绕通知-->后置通知");
            }
            return result;
        }
    
    }

## 5、测试 ##

public class AOPByAnnotationTest {
         
    
    @Test
    public void testAOPByAnnotation(){
         
        ApplicationContext ioc = new ClassPathXmlApplicationContext("aop-annotation.xml");
        //Calculator ：代理对象和目标对象共同实现的接口
        Calculator calculator = ioc.getBean(Calculator.class);
        calculator.div(10, 1);
    }

> 如果直接获取目标类，此时会报无法找到实例的错误。  
> 原因是：  
> **我们为目标对象创建了代理对象，因此我们每次想访问目标对象中的方法时都不能直接通过目标对象去访问，必须通过代理对象来间接访问目标对象，进而去访问目标对象中的方法，所以我们下一步应该是去获取代理对象，可是我们并不知道代理对象是什么，但是我们知道代理对象跟我们的目标对象实现的是相同的接口，我们之前通过IOC获取某个bean的时候，我们不需要通过某个具体的类型来获取，我们可以用它所继承的父类或者所实现的接口，都可以获取到bean。**

# 六、重点 #

## 1、 切入点表达式 ##

**作用**

> 知道对哪个类里面的哪个方法进行增强

![在这里插入图片描述][22a50b049e2c46c6ba988014eae94565.png]

**语法结构**

> `execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )`
> 
> 为了方便，权限修饰符一般使用`*` 代替 ，返回类型一般省略不写

> ⭕ 用`*`号代替“权限修饰符”和“返回值”部分表示“权限修饰符”和“返回值”不限在包名的部分，一个“\*”号只能代表包的层次结构中的一层，表示这一层是任意的。  
> 例如：`*.Hello`匹配`com.Hello`，不匹配`com.atguigu.Hello`

> ⭕ 在包名的部分，使用“`*..`”表示包名任意、包的层次深度任意

> ⭕ 在类名的部分，类名部分整体用`*`号代替，表示类名任意

> ⭕ 在类名的部分，可以使用`*`号代替类名的一部分  
> 例如：`*Service`匹配所有名称以`Service`结尾的类或接口

> ⭕ 在方法名部分，可以使用`*`号表示方法名任意

> ⭕ 在方法名部分，可以使用`*`号代替方法名的一部分  
> 例如：`*Operation`匹配所有方法名以`Operation`结尾的方法

> ⭕ 在方法参数列表部分，使用`(..)`表示参数列表任意

> ⭕ 在方法参数列表部分，使用`(int,..)`表示参数列表以一个`int`类型的参数开头

> ⭕ 在方法参数列表部分，基本数据类型和对应的包装类型是不一样的 切入点表达式中使用 `int` 和实际方法中 `Integer` 是不匹配的

> ⭕ 在方法返回值部分，如果想要明确指定一个返回值类型，那么必须同时写明权限修饰符  
> 例如：`execution(public int ..Service.*(.., int))` 正确  
> 例如：`execution(* int ..Service.*(.., int))` 错误

> ⭕  
> 举例 1：对 com.atguigu.dao.BookDao 类里面的 add 进行增强  
> `execution(*com.atguigu.dao.BookDao.add(..))`  
> 举例 2：对 com.atguigu.dao.BookDao类里面的所有的方法进行增强 `execution(* com.atguigu.dao.BookDao.* (..))`  
> 举例 3：对com.atguigu.dao 包里面所有类，类里面所有方法进行增强 `execution(* com.atguigu.dao.*.* (..))`

![在这里插入图片描述][2bafe5564f8e4844b48b34acd9a31a69.png]

## 2、重用切入点表达式 ##

**①声明**

@Pointcut("execution(* com.atguigu.aop.annotation.*.*(..))")
    public void pointCut(){
         }

**②在同一个切面中使用**

@Before("pointCut()")
    public void beforeMethod(JoinPoint joinPoint){
         
    	String methodName = joinPoint.getSignature().getName();
    	String args = Arrays.toString(joinPoint.getArgs());
    	System.out.println("Logger-->前置通知，方法名："+methodName+"，参数："+args);
    }

**③在不同切面中使用**

@Before("com.atguigu.aop.CommonPointCut.pointCut()")
    public void beforeMethod(JoinPoint joinPoint){
         
    	String methodName = joinPoint.getSignature().getName();
    	String args = Arrays.toString(joinPoint.getArgs());
    	System.out.println("Logger-->前置通知，方法名："+methodName+"，参数："+args);
    }

## 3、获取通知的相关信息 ##

**①获取连接点信息**

> 获取连接点信息可以在通知方法的参数位置设置`JoinPoint`类型的形参

@Before("execution(public int com.atguigu.aop.annotation.CalculatorImpl.*(..))")
    public void beforeMethod(JoinPoint joinPoint){
         
    	//获取连接点的签名信息
    	String methodName = joinPoint.getSignature().getName();
    	//获取目标方法到的实参信息
    	String args = Arrays.toString(joinPoint.getArgs());
    	System.out.println("Logger-->前置通知，方法名："+methodName+"，参数："+args);
    }

**②获取目标方法的返回值**

> `@AfterReturning`中的属性`returning`，用来将通知方法的某个形参，接收目标方法的返回值

@AfterReturning(value = "execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))", returning = "result")
    public void afterReturningMethod(JoinPoint joinPoint, Object result){
         
    	String methodName = joinPoint.getSignature().getName();
    	System.out.println("Logger-->返回通知，方法名："+methodName+"，结果："+result);
    }

**③获取目标方法的异常**

> `@AfterThrowing`中的属性`throwing`，用来将通知方法的某个形参，接收目标方法的异常

@AfterThrowing(value = "execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))", throwing = "ex")
    public void afterThrowingMethod(JoinPoint joinPoint, Throwable ex){
         
    	String methodName = joinPoint.getSignature().getName();
    	System.out.println("Logger-->异常通知，方法名："+methodName+"，异常："+ex);
    }

## 4、环绕通知 ##

@Around("execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))")
    public Object aroundMethod(ProceedingJoinPoint joinPoint){
         
    	String methodName = joinPoint.getSignature().getName();
    	String args = Arrays.toString(joinPoint.getArgs());
    	Object result = null;
    	try {
         
    		System.out.println("环绕通知-->目标对象方法执行之前");
    		//目标方法的执行，目标方法的返回值一定要返回给外界调用者
    		result = joinPoint.proceed();
    		System.out.println("环绕通知-->目标对象方法返回值之后");
    	} catch (Throwable throwable) {
         
    		throwable.printStackTrace();
    		System.out.println("环绕通知-->目标对象方法出现异常时");
    	} finally {
         
    		System.out.println("环绕通知-->目标对象方法执行完毕");
    	}
    	return result;
    }

## 5、切面的优先级 ##

> ⭕ 相同目标方法上同时存在多个切面时，切面的优先级控制切面的内外嵌套顺序。
> 
> 1.  优先级高的切面：外面
> 2.  优先级低的切面：里面

> ⭕ 使用`@Order`注解可以控制切面的优先级：
> 
> 1.  `@Order`(较小的数)：优先级高
> 2.  `@Order`(较大的数)：优先级低

![在这里插入图片描述][a6d05094334349738e469c092b2e5e22.png]

## 6、完全使用注解开发 ##

> 创建配置类，不需要创建 `xml` 配置文件

@Configuration
    @ComponentScan(basePackages = {
         "aopanno"})
    @EnableAspectJAutoProxy(proxyTargetClass = true)
    public class ConfigAop {
         
    
    }

# 七、AOP 操作（AspectJ 配置文件） #

## 1、创建两个类，增强类和被增强类，创建方法 ##

Book类

public class Book {
         
        public void buy() {
         
            System.out.println("buy.............");
        }
    }

BookProxy类

public class BookProxy {
         
        public void before() {
         
            System.out.println("before.........");
        }
    }

## 2、在 spring 配置文件中创建两个类对象 ##

<bean id="book" class="com.atguigu.spring5.aopxml.Book"></bean>
        <bean id="bookProxy" class="com.atguigu.spring5.aopxml.BookProxy"></bean>

## 3、在 spring 配置文件中配置切入点 ##

<aop:config>
            
            <aop:pointcut id="p" expression="execution(* com.atguigu.spring5.aopxml.Book.buy(..))"/>
            
            <aop:aspect ref="bookProxy">
                
                <aop:before method="before" pointcut-ref="p"/>
            </aop:aspect>
        </aop:config>

[fe07af8f1c6f453581c363c3919146e2.png]: https://img-blog.csdnimg.cn/fe07af8f1c6f453581c363c3919146e2.png
[e768c65720e340889a7e99e0e5ce086b.png]: https://img-blog.csdnimg.cn/e768c65720e340889a7e99e0e5ce086b.png
[f51c8d3b2660454a8305cd12408979af.png]: https://img-blog.csdnimg.cn/f51c8d3b2660454a8305cd12408979af.png
[1c8687ca74c2412dbfc0f2f98be5897c.png]: https://img-blog.csdnimg.cn/1c8687ca74c2412dbfc0f2f98be5897c.png
[6216fdfc8f894d0a89a6ac3d33500504.png]: https://img-blog.csdnimg.cn/6216fdfc8f894d0a89a6ac3d33500504.png
[c3eeca66ac8548fdbc1862f6f7f0cfa3.png]: https://img-blog.csdnimg.cn/c3eeca66ac8548fdbc1862f6f7f0cfa3.png
[7e0a4fa1f6744e58ac9c3c69ca6aeb17.png]: https://img-blog.csdnimg.cn/7e0a4fa1f6744e58ac9c3c69ca6aeb17.png
[6dbe183e9e25481182c88fad5bcbbe56.png]: https://img-blog.csdnimg.cn/6dbe183e9e25481182c88fad5bcbbe56.png
[525532ad12ec41319ffee8915c085b94.png]: https://img-blog.csdnimg.cn/525532ad12ec41319ffee8915c085b94.png
[47d1133c574c4d49930ff7db0468eb52.png]: https://img-blog.csdnimg.cn/47d1133c574c4d49930ff7db0468eb52.png
[361415995f314775a7eb3003141378a3.png]: https://img-blog.csdnimg.cn/361415995f314775a7eb3003141378a3.png
[18f7df238d1d4eb795d00163dc0b1a7a.png]: https://img-blog.csdnimg.cn/18f7df238d1d4eb795d00163dc0b1a7a.png
[7789a2ad6b1245f9a01e91848755c1c6.png]: https://img-blog.csdnimg.cn/7789a2ad6b1245f9a01e91848755c1c6.png
[22a50b049e2c46c6ba988014eae94565.png]: https://img-blog.csdnimg.cn/22a50b049e2c46c6ba988014eae94565.png
[2bafe5564f8e4844b48b34acd9a31a69.png]: https://img-blog.csdnimg.cn/2bafe5564f8e4844b48b34acd9a31a69.png
[a6d05094334349738e469c092b2e5e22.png]: https://img-blog.csdnimg.cn/a6d05094334349738e469c092b2e5e22.png