【Spring】AOP

AOP（Aspect Oriented Programming，面向切面编程）是一种编程范式，用来帮助开发者更好地组织程序结构。它的主要作用是为现有功能添加增强，而不需要修改原始代码。这与 Spring 框架提倡的“无侵入式编程”相符，让开发者能够在不干扰原有设计的情况下，轻松地扩展和维护程序。

AOP 需求引入

假设在 Spring 框架中，我们定义了一个 UserDao 接口，这个接口包含了一组的方法。这些方法将由 UserDaoImpl 类来实现：

@Repository
public class UserDaoImpl implements UserDao {@Overridepublic void save() {System.out.println("user dao save ...");}@Overridepublic void update() {System.out.println("user dao update ...");}
}

现在，如果我们希望统计某个操作在一万次调用中所花费的时间，以评估方法的执行效率，怎么才能在不修改原有代码的情况下实现这一需求呢？这时，我们就可以考虑使用面向切面编程（AOP）的思路。

AOP 核心概念

首先，结合具体代码（如下图）来说明 AOP 中的一些核心概念。在后续的入门案例里，会进一步说明这些概念在 AOP 中的具体应用。

• 连接点（JoinPoint）

在 AOP 中，连接点指程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等，比如图中 save、update、delete 和 select 这些方法都可以被视为连接点。

• 切入点（Pointcut）

在 AOP 中，切入点指程序执行过程中需要统一追加功能的位置，比如现在需要为图中的 update 和 delete 方法追加评估功能，则 update 和 delete 方法被视为切入点。一个切入点可以只描述一个具体方法，也可以匹配多个方法。

• 通知（Advice）

在 AOP 中，通知指共性操作，即在预计在切入点处执行的操作，比如前文提及的评估功能操作和图中对应的 method 方法。通常，会将多个通知封装成一个类，这个类被称为通知类。

• 切面（Aspect）

在 AOP 中，切面用于描述通知与切入点的对应关系。

AOP 入门案例

现假设需要实现这样一个需求：在接口执行前输出当前系统时间。使用 AOP 的实现思路：

1. 导入 AOP 依赖坐标（pom.xml）
2. 定义连接点（原始操作，比如 Dao 接口和实现类）
3. 定义通知类和通知（共性功能）
4. 定义切入点
5. 定义切面（绑定切入点与通知关系）

（1）创建 Maven 项目，导入依赖坐标

使用 IDEA 创建 Maven 项目：

在项目的 pom.xml 文件中，引入 Spring 依赖和 aspectj 依赖：

<dependencies><!-- Spring 上下文依赖 --><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.10.RELEASE</version></dependency><!-- aspectj 依赖 --><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.4</version></dependency>
</dependencies>

这里选择基于注解的开发模式。首先，在 com.it.config 包下创建一个 Spring 核心配置类,这里需要添加 @EnableAspectJAutoProxy 注解，用于告知 Spring 框架当前项目存在注解开发的 AOP：

@Configuration
@ComponentScan("com.it")
@EnableAspectJAutoProxy
public class SpringConfig {
}

（2）定义连接点

接着，定义连接点。在 com.it.dao 和 com.it.dao.impl 分别定义 dao 层接口和实现类，定义两个连接点方法 save 和 update：

public interface UserDao {void save();void update();
}

@Repository
public class UserDaoImpl implements UserDao {@Overridepublic void save() {System.out.println("user dao save ...");}@Overridepublic void update() {System.out.println("user dao update ...");}
}

之后，在 com.it.service 和 com.it.service.impl 分别定义 service 层接口和实现类：

public interface UserService {void save();void update();
}

@Service
public class UserServiceImpl implements UserService {@Autowiredprivate UserDao userDao;@Overridepublic void save() {userDao.save();}@Overridepublic void update() {userDao.update();}
}

（3）定义通知类和通知

在 com.it.aop 包下定义通知类，并实现通知方法：

@Component
@Aspect
public class MyAdvice {public void method() {System.out.println(System.currentTimeMillis());}
}

这里添加 @Component 注解用于将通知类托付给 Spring 管理，添加 @Aspect 用于说明该类是 AOP 通知类。

（4）定义切入点

在 MyAdvice 实现类的基础上，定义切入点，这里指定 save 方法为切入点：

@Component
@Aspect
public class MyAdvice {@Pointcut("execution(void com.it.dao.UserDao.save())")private void pt() {}public void method() {System.out.println(System.currentTimeMillis());}
}

（5）定义切面

绑定切入点与通知关系，这里使用 @Before 注解表示这个通知在切入点的前面执行：

@Component
@Aspect
public class MyAdvice {@Pointcut("execution(void com.it.dao.UserDao.save())")private void pt() {}@Before("pt()")public void method() {System.out.println(System.currentTimeMillis());}
}

（6）测试

在 com.it 包下面创建一个 App 类用于测试。运行 main 方法，执行过程为在接口执行前输出当前系统时间：

public class App {public static void main(String[] args) {ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);UserDao userDao = ctx.getBean(UserDao.class);userDao.save();}
}

从这个案例可以看出，项目原有的接口和实现类的代码并没有受到新增功能的影响。在整个过程中，只需引入 AOP 依赖、创建一个新的通知类，并在 Spring 配置中添加 @EnableAspectJAutoProxy 注解，其余代码保持不变。

AOP 切入点表达式

现在，深入介绍在 AOP 入门案例中涉及的切面表达式的定义和使用。

（1）语法格式

切入点表达式标准格式为 动作关键字(访问修饰符 返回值 包名.类/接口名.方法名(参数)异常名)，比如：

execution(public User com.it.service.UserService.findById(int))

• 动作关键字:描述切入点的行为动作，例如 execution 表示执行到指定切入点

• 访问修饰符：public，private等，可以省略

• 异常名：方法定义中抛出指定异常，可以省略

（2）通配符

在 AOP 中，可以使用通配符高效描述切入点：

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

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

这个切入表达式含义为匹配 com.it 包下的任意包中的 UserSenvice 类或接口中所有 find 开头的带有一个参数的方法。

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

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

这个切入表达式含义为匹配 com 包下的任意包中的 UserService 类或接口中所有名称为 findByld 的方法。

• +：专用于匹配子类类型，比如：

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

这个切入表达式含义为匹配任意包下以 Service 结尾的类或接口的子类的任意方法。

（3）书写技巧

• 描述切入点通常描述接口，而不描述实现类

• 访问控制修饰符针对接口开发均采用 public 描述（可省略访问控制修饰符描述）

• 返回值类型对于增删改类使用精准类型加速匹配，对于查询类使用 * 通配快速描述

• 包名书写尽量不使用 .. 匹配，效率过低，常用 * 做单个包描述匹配，或精准匹配

• 接口名/类名书写名称与模块相关的采用*匹配，例如 UserService 书写成 *Service,绑定业务层接口名

• 方法名书写以动词进行精准匹配，名词采用 * 匹配，例如 getById 书写成 getBy*,selectAll 就直接书写成 selectAll

• 参数规则较为复杂，根据业务方法灵活调整

• 通常不使用异常作为匹配规则

AOP 通知类型

在 AOP 中，通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置。AOP 通知共分为以下 5 种类型：

（1）前置通知

设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前运行：

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

（2）后置通知

设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法后运行：

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

（3）环绕通知

设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前后运行：

@Around("pt()")
public void around(ProceedingJoinPoint pjp) throws Throwable {System.out.println("around before advice ...");// 表示对原始操作的调用pjp.proceed();System.out.println("around after advice ...");// 若原来有返回值，则需要给返回值（将方法的返回值设置为 Object）// Object ret = pjp.proceed();// return ret // 记得强转类型
}

注意事项

• 环绕通知必须依赖形参 ProceedingJoinPoint 才能实现对原始方法的调用，进而实现原始方法调用前后同时添加通知

• 通知中如果未使用 ProceedingJoinPoint 对原始方法进行调用将跳过原始方法的执行

• 对原始方法的调用可以不接收返回值，通知方法设置成 void 即可，如果接收返回值，必须设定为 Object 类型

• 原始方法的返回值如果是 void 类型，通知方法的返回值类型可以设置成 void，也可以设置成 Obiect

• 由于无法预知原始方法运行后是否会抛出异常，因此环绕通知方法必须抛出 Throwable 对象

（4）返回后通知

设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法正常执行完毕后运行：

@AfterReturning("pt()")
public void afterReturning() {System.out.println("afterReturning advice ...");
}

（5）抛出异常后通知

设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法运行抛出异常后执行

@AfterThrowing("pt()")
public void afterThrowing() {System.out.println("afterThrowing advice ...");
}

AOP 工作流程

在了解了 AOP 的使用后，现在说明一下 AOP 背后的工作流程，主要分为以下步骤：

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

其中，目标对象和代理的含义为：

• 目标对象（Target）：被代理的原始对象成为目标对象

• 代理（Proxy）：目标对象无法直接完成工作，通过原始对象的代理对象实现，Spring AOP 的核心本质是采用代理模式实现的