Appearance
AOP概述
什么是AOP？
面向切面编程（Aspect-Oriented Programming，简称AOP）是一种编程范式，旨在通过分离横切关注点来增加程序的模块化。横切关注点是指那些影响多个类的功能，如日志记录、事务管理、安全性等。在传统的面向对象编程中，这些横切关注点通常会导致代码重复和耦合。
Spring AOP允许开发人员将横切关注点从业务逻辑中分离出来，以切面的形式独立编写，然后通过声明方式将这些切面应用到应用程序的适当位置。
AOP的核心优势
- 关注点分离：将业务逻辑与横切关注点（如日志、事务）分离
- 减少代码重复：集中管理横切关注点，避免代码重复
- 提高可维护性：当需求变化时，只需修改切面代码而非业务逻辑
- 促进代码重用：切面可以应用于多个业务模块
- 减少开发者负担：让开发者专注于核心业务功能
Spring AOP的实现方式
Spring AOP有两种实现方式：
- 基于JDK的动态代理：针对实现了接口的类，Spring AOP使用JDK动态代理
- 基于CGLIB的代理：针对没有实现接口的类，Spring AOP使用CGLIB库生成子类来实现代理
Spring会根据目标类是否实现接口自动选择代理方式。
AOP的核心概念
1. 切面（Aspect）
切面是横切关注点的模块化。在Spring中，切面通常使用常规类（使用@Aspect注解）或在XML配置中定义。
java
@Aspect
@Component
public class LoggingAspect {
// 切面内容
}2. 连接点（Join Point）
连接点是程序执行过程中的一个点，例如方法执行、异常处理等。在Spring AOP中，连接点总是表示方法的执行。
3. 切点（Pointcut）
切点是匹配连接点的表达式。切点决定了哪些连接点会触发通知的执行。Spring AOP使用AspectJ切点表达式语言。
java
@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceMethods() {}4. 通知（Advice）
通知是切面在特定连接点执行的行为。Spring AOP提供了五种类型的通知：
- 前置通知（Before）：在连接点之前执行
- 后置通知（After）：在连接点之后执行（无论方法是正常结束还是抛出异常）
- 返回通知（After returning）：在连接点正常完成后执行
- 异常通知（After throwing）：在连接点抛出异常时执行
- 环绕通知（Around）：包围连接点的通知，可以在连接点前后执行自定义行为，也可以选择是否继续执行连接点
java
@Before("serviceMethods()")
public void logBefore(JoinPoint joinPoint) {
// 前置通知实现
}5. 引入（Introduction）
引入允许向现有类添加新方法或属性。这是一种类型的通知，允许切面声明被通知的对象实现额外的接口。
6. 目标对象（Target Object）
目标对象是被一个或多个切面通知的对象，也是被代理的对象。
7. AOP代理（AOP Proxy）
AOP代理是由AOP框架创建的对象，用于实现切面契约。在Spring中，AOP代理是JDK动态代理或CGLIB代理。
AspectJ表达式语言
Spring AOP使用AspectJ的切点表达式语言来定义切点。常用的表达式包括：
1. execution表达式
匹配方法执行的连接点：
execution(modifiers-pattern? return-type-pattern declaring-type-pattern?method-name-pattern(param-pattern) throws-pattern?)例如：
java
// 匹配所有public方法
execution(public * *(..))
// 匹配所有service包中的方法
execution(* com.example.service.*.*(..))
// 匹配所有以find开头的方法
execution(* find*(..))2. within表达式
匹配特定类型内的连接点：
java
// 匹配service包中的所有连接点
within(com.example.service.*)
// 匹配service包及其子包中的所有连接点
within(com.example.service..*)3. this和target表达式
this表示代理对象是给定类型的实例target表示目标对象是给定类型的实例
java
// 匹配代理实现UserService接口的连接点
this(com.example.service.UserService)
// 匹配目标对象实现UserService接口的连接点
target(com.example.service.UserService)4. args表达式
匹配参数类型符合要求的连接点：
java
// 匹配只有一个参数且类型为Long的方法
args(Long)
// 匹配第一个参数类型为String的方法
args(String,..)5. @annotation表达式
匹配有特定注解的连接点：
java
// 匹配所有带有@Transactional注解的方法
@annotation(org.springframework.transaction.annotation.Transactional)通过实例理解AOP
以下是一个简单的日志切面实例，展示了如何在服务方法执行前后添加日志：
java
package com.example.aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class LoggingAspect {
// 定义切点表达式
@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceMethods() {}
// 前置通知
@Before("serviceMethods()")
public void logBefore(JoinPoint joinPoint) {
System.out.println("Before executing: " + joinPoint.getSignature().getName());
}
// 后置通知
@After("serviceMethods()")
public void logAfter(JoinPoint joinPoint) {
System.out.println("After executing: " + joinPoint.getSignature().getName());
}
// 返回通知
@AfterReturning(pointcut = "serviceMethods()", returning = "result")
public void logAfterReturning(JoinPoint joinPoint, Object result) {
System.out.println("Method " + joinPoint.getSignature().getName()
+ " returned: " + result);
}
// 异常通知
@AfterThrowing(pointcut = "serviceMethods()", throwing = "error")
public void logAfterThrowing(JoinPoint joinPoint, Throwable error) {
System.out.println("Method " + joinPoint.getSignature().getName()
+ " threw: " + error);
}
// 环绕通知
@Around("serviceMethods()")
public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
long start = System.currentTimeMillis();
try {
Object result = joinPoint.proceed();
long end = System.currentTimeMillis();
System.out.println("Method " + joinPoint.getSignature().getName()
+ " executed in " + (end - start) + "ms");
return result;
} catch (Exception e) {
System.out.println("Method " + joinPoint.getSignature().getName()
+ " failed with: " + e.getMessage());
throw e;
}
}
}Spring AOP的限制
Spring AOP有一些限制，了解这些限制有助于选择合适的解决方案：
- 只支持方法连接点：Spring AOP只支持方法执行连接点，而AspectJ支持更多类型的连接点
- 只支持Spring管理的Bean：只有Spring容器创建的Bean才能被Spring AOP代理
- 同类内部方法调用不会触发AOP：由于AOP是通过代理实现的，类内部调用不会通过代理
- 只支持公共方法：私有方法和protected方法不支持AOP
Spring AOP vs AspectJ
| 特性 | Spring AOP | AspectJ |
|---|---|---|
| 连接点 | 仅支持方法执行 | 支持方法调用、字段访问、构造器等 |
| 粒度 | 较粗 | 更细 |
| 织入方式 | 运行时 | 编译时、编译后和加载时 |
| 复杂性 | 简单易用 | 功能强大但学习曲线陡 |
| 性能 | 较低（代理带来开销） | 较高（编译时织入没有运行时开销） |
| 适用场景 | 简单的横切关注点 | 复杂的企业级AOP需求 |
总结
Spring AOP是Spring框架的核心功能之一，它允许开发人员将横切关注点（如日志记录、事务管理、安全性）从业务逻辑中分离出来。通过使用AOP，可以提高代码的模块化程度，减少代码重复，提高系统的可维护性。
Spring AOP采用了代理模式实现，支持基于注解和基于XML的配置方式，并使用AspectJ的切点表达式语言来定义切点。虽然Spring AOP相比AspectJ功能较为有限，但对于大多数应用场景来说已经足够，并且更容易使用和集成到Spring应用程序中。