15 面向切面编程AOP

- **连接点 Joinpoint**  
    - 在程序的整个执行流程中，可以织入切面的位置。方法的执行前后，异常抛出之后等位置。  
- **切点 Pointcut**  
    - 在程序执行流程中，真正织入切面的方法。（一个切点对应多个连接点）  
- **通知 Advice**  
    - 通知又叫增强，就是具体你要织入的代码。  
    - 通知包括：  
        - 前置通知  
        - 后置通知  
        - 环绕通知  
        - 异常通知  
        - 最终通知  
- **切面 Aspect**  
    - 切点 + 通知就是切面。  
- **织入 Weaving**  
    - 把通知应用到目标对象上的过程。  
- **代理对象 Proxy**  
    - 一个目标对象被织入通知后产生的新对象。  
- **目标对象 Target**  
    - 被织入通知的对象。  

通过下图，大家可以很好的理解 AOP 的相关术语：  
![[15.02-1.png]]


---
## 15.3 切点表达式  

切点表达式用来定义通知（Advice）往哪些方法上切入。  
切入点表达式语法格式：

**![[15.03-1.png]]**

`execution(\[访问控制权限修饰符\] 返回值类型 \[全限定类名\]方法名(形式参数列表) \[异常\])  `

- **访问控制权限修饰符：**  
    - 可选项。  
    - 没写，就是 4 个权限都包括。  
    - 写 public 就表示只包括公开的方法。  
- **返回值类型：**  
    - 必填项。  
    - \* 表示返回值类型任意。  
- **全限定类名：**  
    - 可选项。  
    - 两个点“..”代表当前包以及子包下的所有类。  
    - 省略时表示所有的类。  
- **方法名：**  
    - 必填项。  
    - \*表示所有方法。  
    - set\*表示所有的 set 方法。  
- **形式参数列表：**  
    - 必填项  
    - () 表示没有参数的方法  
    - (..) 参数类型和个数随意的方法  
    - (\*) 只有一个参数的方法  
    - (\*, String) 第一个参数类型随意，第二个参数是 String 的。  
- **异常：**  
    - 可选项。  
    - 省略时表示任意异常类型。  

理解以下的切点表达式：  

`execution(public * com.powernode.mall.service.*.delete*(..))  `

`execution(* com.powernode.mall..*(..))  `

`execution(* *(..))  `


---
## 15.4 使用 Spring 的 AOP  

Spring 对 AOP 的实现包括以下 3 种方式：  
- 第一种方式：Spring 框架结合 AspectJ 框架实现的 AOP，基于注解方式。  
- 第二种方式：Spring 框架结合 AspectJ 框架实现的 AOP，基于 XML 方式。  
- 第三种方式：Spring 框架自己实现的 AOP，基于 XML 配置方式。  

实际开发中，都是 Spring+AspectJ 来实现 AOP。所以我们重点学习第一种和第二种方式。  

> 什么是 AspectJ？（Eclipse 组织的一个支持 AOP 的框架。AspectJ 框架是独立于 Spring 框架之外的一个框架，Spring 框架用了 AspectJ）  

AspectJ 项目起源于帕洛阿尔托（Palo Alto）研究中心（缩写为 PARC）。该中心由 Xerox 集团资助，Gregor Kiczales 领导，从 1997 年开始致力于 AspectJ 的开发，1998 年第一次发布给外部用户，2001 年发布 1.0 release。为了推动 AspectJ 技术和社团的发展，PARC 在 2003 年 3 月正式将 AspectJ 项目移交给了 Eclipse 组织，因为 AspectJ 的发展和受关注程度大大超出了 PARC 的预期，他们已经无力继续维持它的发展。  

### 15.4.1 准备工作  

使用 Spring+AspectJ 的 AOP 需要引入的依赖如下：  
```XML title:pom.xml
<!--spring context依赖-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>6.0.0-M2</version>
</dependency>
<!--spring aop依赖-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aop</artifactId>
  <version>6.0.0-M2</version>
</dependency>
<!--spring aspects依赖-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aspects</artifactId>
  <version>6.0.0-M2</version>
</dependency>

### 15.4.2 基于 AspectJ 的 AOP 注解式开发  

#### 实现步骤  

第一步：定义目标类以及目标方法  
```Java title:OrderService.java

package com.powernode.spring6.service;  

// 目标类  
public class OrderService {  
    // 目标方法  
    public void generate(){  
        System.out.println("订单已生成！");  
    }  
}  

第三步：目标类和切面类都纳入 spring bean 管理  
- 在目标类 OrderService 上添加@Component 注解。  
- 在切面类 MyAspect 类上添加@Component 注解。  


第四步：在 spring 配置文件中添加组建扫描  
```XML title:spring-aspectj-aop-annotation.xml.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 http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--开启组件扫描-->
    <context:component-scan base-package="com.powernode.spring6.service"/>
</beans>   

注解@Before 表示前置通知。  

第七步：在 spring 配置文件中启用自动代理  
```XML title:spring-aspectj-aop-annotation.xml.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 http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--开启组件扫描-->
    <context:component-scan base-package="com.powernode.spring6.service"/>
    <!--开启自动代理-->
    <aop:aspectj-autoproxy proxy-target-class="true"/>
</beans>

运行结果：  
![[15.04-1.png]]


#### 通知类型  

通知类型包括：  
- **前置通知**：@Before 目标方法执行之前的通知  
- **后置通知**：@AfterReturning 目标方法执行之后的通知  
- **环绕通知**：@Around 目标方法之前添加通知，同时目标方法执行之后添加通知。  
- **异常通知**：@AfterThrowing 发生异常之后执行的通知  
- **最终通知**：@After 放在 finally 语句块中的通知  

接下来，编写程序来测试这几个通知的执行顺序：  
```Java title:MyAspect.java
package com.powernode.spring6.service;  

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

// 切面类  
@Component  
@Aspect  
public class MyAspect {  

    @Around("execution(\* com.powernode.spring6.service.OrderService.\*(..))")  
    public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {  
        System.out.println("环绕通知开始");  
        // 执行目标方法。  
        proceedingJoinPoint.proceed();  
        System.out.println("环绕通知结束");  
    }  

    @Before("execution(\* com.powernode.spring6.service.OrderService.\*(..))")  
    public void beforeAdvice(){  
        System.out.println("前置通知");  
    }  

    @AfterReturning("execution(\* com.powernode.spring6.service.OrderService.\*(..))")  
    public void afterReturningAdvice(){  
        System.out.println("后置通知");  
    }  

    @AfterThrowing("execution(\* com.powernode.spring6.service.OrderService.\*(..))")  
    public void afterThrowingAdvice(){  
        System.out.println("异常通知");  
    }  

    @After("execution(\* com.powernode.spring6.service.OrderService.\*(..))")  
    public void afterAdvice(){  
        System.out.println("最终通知");  
    }  

}  

```Java title:AOPTest.java
package com.powernode.spring6.test;  

import com.powernode.spring6.service.OrderService;  
import org.junit.Test;  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.support.ClassPathXmlApplicationContext;  

public class AOPTest {  
    @Test  
    public void testAOP(){  
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-aspectj-aop-annotation.xml");  
        OrderService orderService = applicationContext.getBean("orderService", OrderService.class);  
        orderService.generate();  
    }  
}  

再次执行测试程序，结果如下：  
![[15.04-3.png]]
通过测试得知，当发生异常之后，最终通知也会执行，因为最终通知@After 会出现在 finally 语句块中。  

出现异常之后，后置通知和环绕通知的结束部分不会执行。  

#### 切面的先后顺序  

我们知道，业务流程当中不一定只有一个切面，可能有的切面控制事务，有的记录日志，有的进行安全控制，如果多个切面的话，顺序如何控制：可以使用@Order 注解来标识切面类，
**为@Order 注解的 value 指定一个整数型的数字，数字越小，优先级越高。**  

再定义一个切面类，如下：  
```Java title:YourAspect.java
package com.powernode.spring6.service;  

import org.aspectj.lang.ProceedingJoinPoint;  
import org.aspectj.lang.annotation.\*;  
import org.springframework.core.annotation.Order;  
import org.springframework.stereotype.Component;  

@Aspect  
@Component  
@Order(1) //设置优先级  
public class YourAspect {  

    @Around("execution(\* com.powernode.spring6.service.OrderService.\*(..))")  
    public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {  
        System.out.println("YourAspect环绕通知开始");  
        // 执行目标方法。  
        proceedingJoinPoint.proceed();  
        System.out.println("YourAspect环绕通知结束");  
    }  

    @Before("execution(\* com.powernode.spring6.service.OrderService.\*(..))")  
    public void beforeAdvice(){  
        System.out.println("YourAspect前置通知");  
    }  

    @AfterReturning("execution(\* com.powernode.spring6.service.OrderService.\*(..))")  
    public void afterReturningAdvice(){  
        System.out.println("YourAspect后置通知");  
    }  

    @AfterThrowing("execution(\* com.powernode.spring6.service.OrderService.\*(..))")  
    public void afterThrowingAdvice(){  
        System.out.println("YourAspect异常通知");  
    }  

    @After("execution(\* com.powernode.spring6.service.OrderService.\*(..))")  
    public void afterAdvice(){  
        System.out.println("YourAspect最终通知");  
    }  
}  

执行测试程序：  
![[15.04-4.png]]

通过修改@Order 注解的整数值来切换顺序，执行测试程序：  
![[15.04-5.png]]

#### 优化使用切点表达式  

观看以下代码中的切点表达式：  
```Java title:MyAspect.java
package com.powernode.spring6.service;  

import org.aspectj.lang.ProceedingJoinPoint;  
import org.aspectj.lang.annotation.\*;  
import org.springframework.core.annotation.Order;  
import org.springframework.stereotype.Component;  

// 切面类  
@Component  
@Aspect  
@Order(2)  
public class MyAspect {  

    @Around("execution(\* com.powernode.spring6.service.OrderService.\*(..))")  
    public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {  
        System.out.println("环绕通知开始");  
        // 执行目标方法。  
        proceedingJoinPoint.proceed();  
        System.out.println("环绕通知结束");  
    }  

    @Before("execution(\* com.powernode.spring6.service.OrderService.\*(..))")  
    public void beforeAdvice(){  
        System.out.println("前置通知");  
    }  

    @AfterReturning("execution(\* com.powernode.spring6.service.OrderService.\*(..))")  
    public void afterReturningAdvice(){  
        System.out.println("后置通知");  
    }  

    @AfterThrowing("execution(\* com.powernode.spring6.service.OrderService.\*(..))")  
    public void afterThrowingAdvice(){  
        System.out.println("异常通知");  
    }  

    @After("execution(\* com.powernode.spring6.service.OrderService.\*(..))")  
    public void afterAdvice(){  
        System.out.println("最终通知");  
    }  

}  

使用 `@Pointcut` 注解来定义独立的切点表达式。  
注意这个 `@Pointcut` 注解标注的方法随意，只是起到一个能够让 `@Pointcut` 注解编写的位置。  

执行测试程序：  
![[15.04-6.png]]

#### 全注解式开发 AOP  

就是编写一个类，在这个类上面使用大量注解来代替 spring 的配置文件，spring 配置文件消失了，如下：  
```Java title:Spring6Configuration.java
package com.powernode.spring6.service;  

import org.springframework.context.annotation.ComponentScan;  
import org.springframework.context.annotation.Configuration;  
import org.springframework.context.annotation.EnableAspectJAutoProxy;  

@Configuration  
@ComponentScan("com.powernode.spring6.service")  
@EnableAspectJAutoProxy(proxyTargetClass = true)  
public class Spring6Configuration {  
}  

执行结果如下：  
![[15.04-7.png]]

### 15.4.3 基于 XML 配置方式的 AOP（了解）  

第一步：编写目标类  
```Java title:VipService.java
package com.powernode.spring6.service;  

// 目标类  
public class VipService {  
    public void add(){  
        System.out.println("保存vip信息。");  
    }  
}  

第三步：编写 spring 配置文件  
```XML title:spring-aop-xml.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 http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--纳入spring bean管理-->
    <bean id="vipService" class="com.powernode.spring6.service.VipService"/>
    <bean id="timerAspect" class="com.powernode.spring6.service.TimerAspect"/>

    <!--aop配置-->
    <aop:config>
        <!--切点表达式-->
        <aop:pointcut id="p" expression="execution(* com.powernode.spring6.service.VipService.*(..))"/>
        <!--切面-->
        <aop:aspect ref="timerAspect">
            <!--切面=通知 + 切点-->
            <aop:around method="time" pointcut-ref="p"/>
        </aop:aspect>
    </aop:config>
</beans>

执行结果：  
![[15.04-8.png]]


---
## 15.5 AOP 的实际案例：事务处理  

项目中的事务控制是在所难免的。在一个业务流程当中，可能需要多条 DML 语句共同完成，**为了保证数据的安全，这多条 DML 语句要么同时成功，要么同时失败。**
这就需要添加事务控制的代码。

例如以下伪代码：  
```Java title:伪代码

class 业务类1{  
            step3();  
            ....  

            // 提交事务  
            commitTransaction();  
        }catch(Exception e){  
            // 回滚事务  
            rollbackTransaction();  
        }  
    }  
}  

class 业务类2{  
    public void 业务方法1(){  
        try{  
            // 开启事务  
            startTransaction();  

            // 执行核心业务逻辑  
            step1();  
            step2();  
            step3();  
            ....  

            // 提交事务  
            commitTransaction();  
        }catch(Exception e){  
            // 回滚事务  
            rollbackTransaction();  
        }  
    }  
    public void 业务方法2(){  
        try{  
            // 开启事务  
            startTransaction();  

            // 执行核心业务逻辑  
            step1();  
            step2();  
            step3();  
            ....  

            // 提交事务  
            commitTransaction();  
        }catch(Exception e){  
            // 回滚事务  
            rollbackTransaction();  
        }  
    }  
    public void 业务方法3(){  
        try{  
            // 开启事务  
            startTransaction();  

            // 执行核心业务逻辑  
            step1();  
            step2();  
            step3();  
            ....  

            // 提交事务  
            commitTransaction();  
        }catch(Exception e){  
            // 回滚事务  
            rollbackTransaction();  
        }  
    }  
}  
//......  

```Java title:订单业务类
package com.powernode.spring6.biz;  

import org.springframework.stereotype.Component;  

@Component  
// 业务类  
public class OrderService {  
    // 生成订单  
    public void generate(){  
        System.out.println("正在生成订单");  
    }  
    // 取消订单  
    public void cancel(){  
        System.out.println("正在取消订单");  
    }  
}  

你看，这个事务控制代码是不是只需要写一次就行了，并且修改起来也没有成本。

编写测试程序：  
```Java title:AOPTest2.java
package com.powernode.spring6.test;  

import com.powernode.spring6.biz.AccountService;  
import com.powernode.spring6.biz.OrderService;  
import com.powernode.spring6.service.Spring6Configuration;  
import org.junit.Test;  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.annotation.AnnotationConfigApplicationContext;  

public class AOPTest2 {  
    @Test  
    public void testTransaction(){  
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(Spring6Configuration.class);  
        OrderService orderService = applicationContext.getBean("orderService", OrderService.class);  
        AccountService accountService = applicationContext.getBean("accountService", AccountService.class);  
        // 生成订单  
        orderService.generate();  
        // 取消订单  
        orderService.cancel();  
        // 转账  
        accountService.transfer();  
        // 取款  
        accountService.withdraw();  
    }  
}  

```Java title:ProductService.java
package com.powernode.spring6.biz;  

import org.springframework.stereotype.Component;  

// 商品业务类  
@Component  
public class ProductService {  
    public void getProduct(){  
        System.out.println("获取商品信息");  
    }  
    public void saveProduct(){  
        System.out.println("保存商品");  
    }  
    public void deleteProduct(){  
        System.out.println("删除商品");  
    }  
    public void modifyProduct(){  
        System.out.println("修改商品");  
    }  
}  

```Java title:testSecurity.java
@Test  
public void testSecurity(){  
    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(Spring6Configuration.class);  
    UserService userService = applicationContext.getBean("userService", UserService.class);  
    ProductService productService = applicationContext.getBean("productService", ProductService.class);  
    userService.getUser();  
    userService.saveUser();  
    userService.deleteUser();  
    userService.modifyUser();  
    productService.getProduct();  
    productService.saveProduct();  
    productService.deleteProduct();  
    productService.modifyProduct();  
}