1. AOP概念
1.1 定义
AOP全称为Aspet-Oriented Programming，中文名字为面向切面编程。使用AOP，我们可以对类似日志和安全等系统需求进行模块化的组织，简化系统需求与实现之间的对比关系，进而使得整个系统的实现更具模块化。
1.2 AOP国家的公民
1.2.1 Joinpoint
在系统运行之前，AOP的功能模块都需要织入到OOP的功能模块中。所以，要进行这种织入过程，我们需要知道在系统的哪些执行点上进行织入操作，这些将要在其之上进行织入操作的系统执行点就称之为Joinpoint。
以下是一些较为常见的Joinpoint类型
- 方法调用
- 方法执行
- 构造方法调用
- 构造方法执行
- 字段设置
- 字段获取
- 异常处理执行
- 类初始化
1.2.2 Pointcut
Pointcut概念代表的是Joinpoint的表述方式。将横切逻辑织入当前系统的过程中，需要参照Pointcut规定的Joinpoint信息，才可以知道应该往系统的哪些Joinpoint上织入横切逻辑。
1.2.3 Advice
是单一横切关注点逻辑的载体，它代表将会织入到Joinpoint的横切逻辑。
Advice可以分成多种具体形式。
- Before Advice
- After Advice
- Around Advice
1.2.4 Aspect
Aspect是对系统中的横切关注点逻辑进行模块化封装的AOP概念实体。通常情况下，Aspect可以包含多个Pointcut以及相关Advice定义。
1.2.5 Weaving
用来将Aspect模块化的横切关注点集成到OOP的现存系统中。
1.2.6 目标对象
符合Pointcut所指定的条件，将在织入过程中被织入横切逻辑的对象。
最后附上一张AOP各个概念所处的场景图。
[图片上传失败...(image-26c2fc-1616160107453)]
1.3 Java平台上的AOP实现机制
1.3.1 动态代理
JDK1.3之后，引入了动态代理（Dynamic Proxy）机制，可以在运行期间，为相应的接口（Interface）动态生成对应的代理对象。所以，我们可以将横切关注点逻辑封装到动态代理的InvocationHandler中，然后在系统运行期间，根据横切关注点需要织入的模块位置，将横切逻辑织入到相应的代理类中。以动态代理类为载体的横切逻辑，现在当然就可以与系统其他实现模块一起工作了。
这种方式实现的唯一缺点是，所有需要织入横切关注点逻辑的模块类都得实现相应的接口。
SpringAOP默认情况采用这种机制来实现AOP机能。
1.3.2 动态字节码增强
通常的class文件都是从Java源代码文件使用Javac编译器编译而成的，但只要符合Javaclass规范，我们也可以使用ASM或者CGLIB等Java工具库，在程序运行期间，动态构建字节码的class文件。
Spring AOP在无法采用动态代理机制进行AOP功能扩展的时候，会使用CGLIB库的动态字节码增强支持来实现AOP的功能扩展。
1.3.3 Java代码生成
事务属于跨越整个系统的一种横切关注点，所以，EJB容器提供的声明性事务支持，属于一种AOP功能模块实现。但早期EJB容器在实现这一功能的时候，大多会采用Java代码生成技术，这就是我们不需要提供CMP的接口实现类的原因，也是EJB容器提供商大多提供部署接口或者专有部署工具的原因。
1.3.4 自定义类加载器
我们可以通过自定义类加载器的方式完成横切逻辑到系统的织入，自定义类加载器通过读取外部文件规定的织入规则和必要信息，在加载class文件期间就可以将横切逻辑添加到系统模块类的现有逻辑中，然后将改动后的class交给Java虚拟机运行。
1.3.5 AOL扩展
AOL扩展是最强大、也最难掌握的一种方式，我们之前提到的AspectJ就属于这种方式。在这种方式中，AOP的各种概念在AOL中大都有一一对应的实体。我们可以使用扩展过的AOL，实现任何AOP概念实体甚至OOP概念实体，比如Aspect以及Class。所有的AOP概念在AOL中得到了最完美的表达。
2. SpringAOP的实现机制
SpingAOP属于第二代AOP，采用动态代理机制和字节码生成技术实现。
先从动态代理机制的根源--代理模式开始介绍。
2.1 代理模式
在代理模式中通常涉及四种角色，如图所示。
- ISubject:该接口是对被访问者或者被访问资源的抽象
- SubjectImpl:被访问者或者被访问资源的具体实现类
- SubjectProxy:被访问者或者被访问资源的代理实现类，该类持有一个ISubject接口的具体实例。在这个场景中，我们要SubjectImpl进行代理，那么SubjectProxy现在持有的就是SubjectImpl的实例
- Client。代表访问者的抽象角色。
SubjectImpl和SubjectProxy都实现了相同的接口ISubject，而SubjectProxy内部持有SubjectImpl的引用。当Client通过request()请求服务的时候，SubjectProxy将转发该请求给SubjectImpl。从这个角度来说，SubjectProxy反而有多此一举之嫌了。不过，SubjectProxy的作用不只局限于请求的转发，更多时候是对请求添加更多访问限制。
在将请求转发给被代理对象SubjectImp1之前或者之后，都可以根据情况插入其他处理逻辑，比如在转发之前记录方法执行开始时间，在转发之后记录结束时间，这样就能够对SubjectImpl的 request()执行的时间进行检测。或者，可以只在转发之后对SubjectImpl的request()方法返回结果进行覆盖，返回不同的值。甚至，可以不做请求转发，这样，就不会有SubjectImpl的访问发生。如果你不希望某人访问你的SubjectImpl，这种场景正好适合。
代理对象subjectProxy就像是subjectImpl的影子，只不过这个影子通常拥有更多的功能。如果 SubjectImpl是系统中的Joinpoint所在的对象，即目标对象，那么就可以为这个目标对象创建一个代理对象，然后将横切逻辑添加到这个代理对象中。
SpringAOP本质上就是采用这种代理机制实现的，但是，具体实现细节上有所不同。
2.1.1 示例代码
先上代码，把上边的流程图变为具体代码。
package com.spring.aop;
public interface ISubject {
void request();
}
package com.spring.aop;
public class SubjectImpl implements ISubject {
@Override
public void request() {
System.out.println("执行代理类的方法");
}
}
package com.spring.aop;
public class SubjectProxy implements ISubject {
private ISubject iSubject;
public SubjectProxy(ISubject iSubject) {
this.iSubject = iSubject;
}
@Override
public void request() {
//添加前置逻辑
iSubject.request();
//添加后置逻辑
}
}
package com.spring.aop;
public class Client {
public static void main(String[] args) {
SubjectProxy subjectProxy = new SubjectProxy(new SubjectImpl());
subjectProxy.request();
}
}
假设我们要对系统中所有的request()方法进行拦截，那么我们应该为SubjectImpl提供一个ServiceControlSubjectProxy，以添加这种横切逻辑。
package com.spring.aop;
public class ServiceControlSubjectProxy implements ISubject {
private ISubject subject;
public ServiceControlSubjectProxy(ISubject subject) {
this.subject = subject;
}
@Override
public void request() {
//添加新的前置逻辑
subject.request();
//添加新的后置逻辑
}
}
之后我们使用ServiceControlSubjectProxy代替SubjectImpl使用，如下所示
ServiceControlSubjectProxy serviceControlSubjectProxy =
new ServiceControlSubjectProxy(new SubjectImpl());
serviceControlSubjectProxy.request();
但是系统中不一定就ISubject的实现类有request()方法，如果要对所有request()方法都添加这个逻辑，那么还需要新写一个代理类，而实际上，这些代理对象所要添加的横切逻辑是一样的。当系统中存在成百上千目标对象时，我们就要为这成百上千的目标对象创建成百上千的代理对象。
2.2 动态代理
JDK1.3之后引入了一种称之为动态代理（Dynamic Proxy）的机制。使用该机制，我们可以为指定的接口在系统运行期间动态地生成代理对象，从而帮助我们走出最初使用静态代理实现AOP的窘境。
动态代理机制的实现主要由一个类和一个接口组成，即java.lang.reflect.Proxy类和java.lang.reflect.InvocationHåndler接口。下面，让我们看一下，如何使用动态代理来实现之前的功能。虽然要为ISubject和TRequestable两种类型提供代理对象，但因为代理对象中要添加的横切逻辑是一样的，所以，我们只需要实现一个TnvocationHandler就可以了。
2.2.1 具体代码
package com.spring.aop;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class ProxyInvocationHandler implements InvocationHandler {
private Object target;
public ProxyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("添加前置逻辑");
Object object = method.invoke(target, args);
System.out.println("添加后置逻辑");
return object;
}
}
package com.spring.aop;
import java.lang.reflect.Proxy;
public class Client {
public static void main(String[] args) {
ISubject subject = new SubjectImpl();
subject = (ISubject) Proxy.newProxyInstance(
subject.getClass().getClassLoader(),
subject.getClass().getInterfaces(),
new ProxyInvocationHandler(subject)
);
subject.request();
IRequestable requestable = new RequestableImpl();
requestable = (IRequestable) Proxy.newProxyInstance(
requestable.getClass().getClassLoader(),
requestable.getClass().getInterfaces(),
new ProxyInvocationHandler(requestable)
);
requestable.request();
}
}
动态代理虽好，但不能满足所有的需求。因为动态代理机制只能对实现了相应Interface的类使用，如果某个类没有实现任何的Interface，就无法使用动态代理机制为其生成相应的动态代理对象。虽然面向接口编程应该是提倡的做法，但不排除其他的编程实践。对于没有实现任何Interface的目标对象，我们需要寻找其他方式为其动态的生成代理对象。
默认情况下，如果Spring AOP发现目标对象实现了相应Interface，则采用动态代理机制为其生成代理对象实例。而如果目标对象没有实现任何Interface，Spring AOP会尝试使用一个称为CGLIB（Code GenerationLibrary）的开源的动态字节码生成类库，为目标对象生成动态的代理对象实例。
2.3 动态字节码生成
使用动态字节码生成技术扩展对象行为的原理是，我们可以对目标对象进行继承扩展，为其生成相应的子类，而子类可以通过覆写来扩展父类的行为，只要将横切逻辑的实现放到子类中，然后让系统使用扩展后的目标对象的子类，就可以达到与代理模式相同的效果了。
但是，使用继承的方式来扩展对象定义，也不能像静态代理模式那样，为每个不同类型的目标对象都单独创建相应的扩展子类。所以，我们要借助于CGLIB这样的动态字节码生成库，在系统运行期间动态地为目标对象生成相应的扩展子类。
2.3.1 代码
package com.spring.aop;
public class Subject {
public void request(){
System.out.println("没有接口的目标类");
}
}
package com.spring.aop;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class CGLIBProxy implements MethodInterceptor {
@Override
public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("这是CGLIB前置逻辑");
Object result = methodProxy.invokeSuper(object, args);
System.out.println("这是CGLIB后置逻辑");
return result;
}
}
package com.spring.aop;
import org.springframework.cglib.proxy.Enhancer;
public class Client {
public static void main(String[] args) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(Subject.class);
enhancer.setCallback(new CGLIBProxy());
Subject proxy = (Subject) enhancer.create();
proxy.request();
}
}
3. SpringAOP中的术语
- 切面(Aspect):指关注点模块化，这个关注点可能会横切多个对象。事务管理是企业级Java应用中有关横切关注点的例子。在Spring AOP中，切面可以使用通用类基于模式的方法或者在普通类中以@Aspect注解来实现
- 连接点(Join point):在Spring AOP中，一个连接点总是代表一个方法的执行，其实就代表增强的方法
- 通知(Advice):在切面的某个特定的连接点上执行的动作。通知有多种类型，包括"around"、"before"和"after"等待。通知的类型将在后面的章节进行讨论。许多AOP框架，包括Spring在内，都是以拦截器做通知模型的，并维护着一个以连接点为中心的拦截器链
- 目标对象(Target):目标对象指将要被增强的对象。即包含主业务逻辑的类的对象
- 切点(Pointcut):匹配连接点的断言。通知和切点表达式相关联，并在满足这个切点的连接点上运行(例如，当执行某个特定名称的方法时)。切点表达式如何和连接点匹配是AOP的核心:Spring默认使用AspectJ切点语义
- 顾问(Advisor):顾问是Advice的一种包装体现，Advisor是Pointcut以及Advice的一个结合，用来管理Advice和Pointcut。应用无需关心
- 织入(Weaving):将通知切入连接点的过程叫织入
- 引入(Introductions):可以将其他接口和实现动态引入到targetClass中
