SpringAop面向切面编程使用详解

我不是女神ヾ 2024-03-31 10:09 5阅读 0赞

### 一、AOP概述 ###

#### 1.1 AOP的概念 ####

`AOP`(`Aspect Oriented Programing`)面向切面编程。

它是一种编程**范式**，属于软工范畴，指导开发者如何组织程序结构。

它是是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

`AOP`弥补了`OOP`(面向对象编程)的不足，`AOP`基于`OOP`基础之上进行横向开发。

`OOP`规定程序开发以类为主体模型，一切围绕对象进行，完成某个任务需要先构建对象模型。

`AOP`开发关注基于`OOP`开发中的共性功能，围绕共性功能进行，完成某个任务先构建可能遇到的所有共性功能。

#### 1.2 AOP的作用 ####

**1）作用**

*  在程序运行期间，在不修改源码的情况下对方法进行功能增强

**2）目标**

*  将软件开发由手工制作走向半自动化/全自动化阶段，实现“插拔式组件体系结构”搭建
 *  一步一步将所有共性功能逐一开发完毕，最终以功能组合来完成个别业务模块乃至整体业务系统的开发

#### 1.3 AOP优势 ####

*  提高代码的可重用性
 *  业务代码编码更简洁
 *  业务代码维护更高效
 *  业务功能扩展更便捷

#### 1.6 AOP工作流程 ####

*  `Spring`容器启动
 *  读取所有切面配置中的切入点
 *  初始化`bean`，判定`bean`对应的类中的方法是否匹配到任意切入点
    
     *  匹配失败，创建原始对象
     *  匹配成功，创建原始对象（目标对象）的代理对象
 *  获取`bean`执行方法
    
     *  获取的`bean`是原始对象时，调用方法并执行，完成操作
     *  获取的`bean`是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

#### 1.5 AOP底层 ####

AOP的底层是通过Spring提供的的动态代理技术实现的。

在运行期间，`Spring`通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，

再去调用目标对象的方法，从而完成功能的增强。

**常用的动态代理技术：**（spring两者都有使用，任君选择）

*  `JDK`代理：基于接口的动态代理技术，缺点是代理的对象必须要有接
 *  `cglib`代理：基于父类的动态代理技术

### 二、AOP的相关概念 ###

*  `Target`(要代理目标对象)：就是挖掉功能的方法对应的类产生的对象。
    
    这种对象因为还缺少共性功能，是无法直接完成最终功能要求的。
 *  `Proxy`(代理对象)：目标对象无法直接完成工作，需要对其进行功能回填。
    
    由Spring帮我们创建原始对象的代理对象实现。
 *  `Joinpoint`(连接点)：就是方法(可以被增强的方法，就是可以使用`AOP`插入共性功能的方法)。
    
    连接点是指那些被拦截到的点。在`Spring`中，这些点指的是方法，因为`Spring`只支持方法类型的连接点。
 *  `Pointcut`(切入点)：就是挖掉共性功能的方法，所谓切入点是指要对哪些`Joinpoint`进行拦截的定义。
    
    **点**：其实就是方法的意思。
    
    **连接点和切点的区别：**
    
    所有的可以被增强的方法都可以是连接点。
    
    但是最后被增强的方法，就是切入点。切入点可以看成连接点的一部分。
 *  `Advice`(通知)：就是共性功能，最终以一个方法的形式呈现。
    
    通知是指拦截到`Joinpoint`(连接点)之后所要做的事情就是通知，就是共性功能。
 *  `Aspect`(切面/增强)：就是共性功能与挖的位置的对应关系，是切入点和通知的结合,切入点 + 通知）。
 *  `Weaving`(织入)：就是将挖掉的功能回填的动态过程（就是将切点和通知结合的过程，就是织入）。
    
    即把增强应用到目标对象来创建新的代理对象的过程。
    
    `Spring`采用动态代理织入，而`AspectJ`采用编译期织入和类装载期织入。
 *  `Introduction`(引入/引介) ：就是对原始对象无中生有的添加成员变量或成员方法。

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

#### 3.1 语法格式 ####

*  切入点：要进行增强的方法
 *  切入点表达式：要进行增强的方法的描述方式
    
     *  描述方式一：执行`com.dao`包下的`CardDao`接口中的无参`update`方法
    
        execution(void com.dao.CardDao.update())
    
     *  描述方式二：执行`com.dao.impl`包下的`CardDaoImpl`类中的无参`update`方法
    
        execution(void com.dao.impl.CardDaoImpl.update())
 *  切入点表达式标准格式：动作关键字(访问修饰符 返回值 包名.类/接口名.方法名(参数) 异常名）
    
        execution(public User com.service.UserService.findById(int))
    
     *  动作关键字：描述切入点的行为动作，例如`execution`表示执行到指定切入点
     *  访问修饰符：`public`，`private`等，可以省略
     *  返回值：写返回值类型
     *  包名：多级包使用点连接
     *  类/接口名
     *  方法名
     *  参数：直接写参数的类型，多个类型用逗号隔开
     *  异常名：方法定义中抛出指定异常，可以省略

#### 3.2 通配符 ####

目的：可以使用通配符描述切入点，快速描述。

*  `*`：单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现

> 匹配com包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法

execution（public * com.*.UserService.find*(*))

*  `..`：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写

> 匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法

execution（public User com..UserService.findById(..))

*  `+`：专用于匹配子类类型

execution(* *..*Service+.*(..))

#### 3.3 书写技巧 ####

*  描述切入点通常**描述接口**，而不描述实现类
 *  访问控制修饰符针对接口开发均采用`public`描述，**这样可以省略访问控制修饰符描述**）
 *  返回值类型对于**增删改类**使用精准类型加速匹配，对于**查询类**使用`*`通配快速描述
 *  包名书写**尽量不使用…匹配**，效率过低，常用`*`做单个包描述匹配，或精准匹配
 *  **接口名/类名**书写名称与模块相关的**采用\*匹配**，例如`UserService`书写成`*Service`，绑定业务层接口名
 *  **方法名**书写以**动词**进行**精准匹配**，例如`getById`书写成`getBy`，`selectAll`书写成`selectAll`
 *  参数规则较为复杂，根据业务方法灵活调整
 *  通常**不使用异常**作为**匹配**规则

### 四、AOP通知类型 ###

#### 4.1 AOP通知分类 ####

*  `AOP`通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置
 *  `AOP`通知共分为5种类型
    
     *  前置通知：在切入点方法执行之前执行
     *  后置通知：在切入点方法执行之后执行，无论切入点方法内部是否出现异常，后置通知都会执行。
     *  \*\*环绕通知：\*\*手动调用切入点方法并对其进行增强的通知方式。
     *  返回后通知：在切入点方法执行之后执行，如果切入点方法内部出现异常将不会执行。
     *  抛出异常后通知(了解)：在切入点方法执行之后执行，只有当切入点方法内部出现异常之后才执行。

#### 4.2 AOP通知详解 ####

##### 4.2.1 前置通知 #####

*  名称：`@Before`
 *  类型：**方法注解**
 *  位置：通知方法定义上方
 *  作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前运行
 *  范例：

@Before("pt()")
    public void before() {
        
        System.out.println("before advice ...");
    }

##### 4.2.2 后置通知 #####

*  名称：`@After`
 *  类型：**方法注解**
 *  位置：通知方法定义上方
 *  作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法后运行
 *  范例：

@After("pt()")
    public void after() {
        
        System.out.println("after advice ...");
    }

##### 4.2.3 返回后通知 #####

*  名称：`@AfterReturning`
 *  类型：**方法注解**
 *  位置：通知方法定义上方
 *  作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法正常执行完毕后运行
 *  范例：

@AfterReturning("pt()")
    public void afterReturning() {
        
        System.out.println("afterReturning advice ...");
    }
    
    // 或者下面写法
    // 方法变量名要和returning = "jsonResult"的属性值一致，jsonResult就是方法的返回值
    @AfterReturning(pointcut = "pt()", returning = "jsonResult")
    public void doAfterReturning(JoinPoint joinPoint, Object jsonResult) {
        
        handleLog(joinPoint, null, jsonResult);
    }

##### 4.2.4 抛出异常后通知 #####

*  名称：`@AfterThrowing`
 *  类型：**方法注解**
 *  位置：通知方法定义上方
 *  作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法运行抛出异常后执行
 *  范例：

@AfterThrowing("pt()")
    public void afterThrowing() {
        
        System.out.println("afterThrowing advice ...");
    }
    
    // 或者下面写法
    // 抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的异常对象
    // 方法变量名要和throwing = "t"的属性值一致
    @AfterThrowing(value = "pt()", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, Exception e) {
        
        handleLog(joinPoint, e, null);
    }

##### 4.2.5 环绕通知 #####

*  名称：`@Around`（常用）
 *  类型：**方法注解**
 *  位置：通知方法定义上方
 *  作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前后运行
 *  范例：：

@Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        
        System.out.println("around before advice ...");		// 编写方法执行前逻辑
        Object ret = pjp.proceed();							// 执行原生方法
        System.out.println("around after advice ...");		// 编写方法执行后逻辑
        return ret;
    }

**环绕通知注意事项**

*  环绕通知方法形参必须是`ProceedingJoinPoint`，表示正在执行的连接点，使用该对象的`proceed()`方法表示对原始对象方法进行调用，返回值为原始对象方法的返回值。
 *  环绕通知方法的返回值建议写成`Object`类型，用于将原始对象方法的返回值进行返回，哪里使用代理对象就返回到哪里。

### 五、注解方式开发AOP程序 ###

由于`SpringBoot`应用的兴起，现在基本都是使用注解方式开发`AOP`功能，而不是使用原始的`xml`文件的方式。

这里也是基于`SpringBoot`来演示`AOP`的基本使用。

#### 5.1 开发步骤 ####

*  引入`aspectj`依赖
    
     *  它是`Spring`推荐的方式，因为这种方式比`Spring`原生的更好，`Spring`也因此集成了它
 *  创建目标接口和目标类(内部有切点)
 *  创建切面类(内部有增强方法)，给切面类添加`@Aspect`注解
 *  将目标类和切面类的对象创建权交给spring
 *  在切面类中使用注解配置织入关系
    
     *  定义专用的切入点方法，给方法添加`@Pointcut`注解，并配置切入点表达式
     *  为通知方法配置通知类型及对应切入点

#### 5.2 引入依赖 ####

**1）使用SpringBoot**

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

**2）使用Spring**

<dependencies>
        
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
        
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
    </dependencies>

> 只使用Spring而不使用SpringBoot的项目应该比较少，了解就可以了

#### 5.3 定义通知类 ####

//通知类必须配置成Spring管理的bean
    @Component
    public class MyAdvice {
        
        public void method(){
        
            
        }
    }

#### 5.4 配置切入点并使用 ####

切点可以在切面中配置，也可以单独写一个类去配置切入点。具体如何选择应结合实际业务需求决定。

通常不用复用的情况下，选择写在切面中也不错的选择，找起来会方便一些。

@Component			//通知类必须配置成Spring管理的bean
    @Aspect				//设置当前类为切面类类
    public class MyAdvice {
        
        //设置切入点，@Pointcut注解要求配置在方法上方
        @Pointcut("execution(void com.dao.CardDao.update())")
        private void pt(){
        }
    
        //设置在切入点pt()的前面运行当前操作(环绕通知)
        @Around("pt()")
        public Object around(ProceedingJoinPoint pjp) throws Throwable {
        
            Object ret = pjp.proceed();					// 执行被切入的方法
            return ret;
        }
    }

> 在SpringBoot中，完成上述步骤就完成了切面的编写，比仅使用`Spring`方便太多

### 六、在切面类中获取信息 ###

在切面（通知）方法中，经常需要获取到切入点的各种各样的数据，比如返回值、异常、是否加了什么注解等。

#### 6.1 获取方法参数 ####

**在前置通知和环绕通知中都可以获取到连接点方法的参数们。**

*  `JoinPoint`对象描述了连接点方法的运行状态，可以获取到原始方法的调用参数

@Before("pt()")
    public void before(JoinPoint jp) {
        
        Object[] args = jp.getArgs(); //获取连接点方法的参数们
        System.out.println(Arrays.toString(args));
    }

*  `ProccedJointPoint`是`JoinPoint`的子类

@Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        
        Object[] args = pjp.getArgs(); //获取连接点方法的参数们
        System.out.println(Arrays.toString(args));
        Object ret = pjp.proceed();
        return ret;
    }

#### 6.2 获取返回值 ####

**在返回后通知和环绕通知中都可以获取到连接点方法的返回值。**

*  抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的异常对象

@AfterReturning(value = "pt()",returning = "ret")
    public void afterReturning(String ret) {
         	//变量名要和returning="ret"的属性值一致
        System.out.println("afterReturning advice ..."+ret);
    }

*  环绕通知中可以手工书写对原始方法的调用，得到的结果即为原始方法的返回值

@Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        
        // 手动调用连接点方法，返回值就是连接点方法的返回值
        Object ret = pjp.proceed();
        return ret;
    }

#### 6.3 获取异常 ####

**在抛出异常后通知和环绕通知中都可以获取到连接点方法中出现的异常。**

*  抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的异常对象

@AfterThrowing(value = "pt()",throwing = "t")
    public void afterThrowing(Throwable t) {
        //变量名要和throwing = "t"的属性值一致
        System.out.println("afterThrowing advice ..."+ t);
    }

*  如果是在环绕通知中，只能使用下面的方式获取异常信息了

@Around("pt()")
    public Object around(ProceedingJoinPoint pjp)  {
        
        Object ret = null;
        //此处需要try...catch处理，catch中捕获到的异常就是连接点方法中抛出的异常
        try {
        
            ret = pjp.proceed();
        } catch (Throwable t) {
        
            t.printStackTrace();
        }
        return ret;
    }