## 前言
往期文章：
- [Spring IoC - Spring IoC 的设计](/archives/Spring%20IoC%20-%20Spring%20IoC%20%E7%9A%84%E8%AE%BE%E8%AE%A1)
- [Spring IoC - IoC 容器初始化 源码解析](/archives/Spring%20IoC%20%20-%20IoC%20%E5%AE%B9%E5%99%A8%E5%88%9D%E5%A7%8B%E5%8C%96%E6%BA%90%E7%A0%81%E8%A7%A3%E8%AF%BB)
- [Spring IoC - 依赖注入 源码解析](/archives/Spring%20IoC%20-%20%E4%BE%9D%E8%B5%96%E6%B3%A8%E5%85%A5%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90)
- [向您生动地讲解Spring AOP 源码（1）](/archives/Spring%20AOP%20-%20%E6%B3%A8%E8%A7%A3%E6%96%B9%E5%BC%8F%E4%BD%BF%E7%94%A8%E4%BB%8B%E7%BB%8D%EF%BC%88%E9%95%BF%E6%96%87%E8%AF%A6%E8%A7%A3%EF%BC%89)
- [向您生动地讲解Spring AOP 源码（2）](/archives/%E5%90%91%E6%82%A8%E5%9B%BE%E6%96%87%E5%B9%B6%E8%8C%82%E7%94%9F%E5%8A%A8%E8%AE%B2%E8%A7%A3Spring%20AOP%20%E6%BA%90%E7%A0%81%EF%BC%882%EF%BC%89)
在上一章[向您生动地讲解Spring AOP 源码（2）](/archives/%E5%90%91%E6%82%A8%E5%9B%BE%E6%96%87%E5%B9%B6%E8%8C%82%E7%94%9F%E5%8A%A8%E8%AE%B2%E8%A7%A3Spring%20AOP%20%E6%BA%90%E7%A0%81%EF%BC%882%EF%BC%89)中，作者介绍了【如何获取对应 Bean 适配的Advisors 链】。
在本章中，作者会向您介绍，**Spring AOP 是如何解析我们配置的Aspect，并将advice织入的？**
在本章的附录部分，还会介绍如何保存 JDK动态代理和 Cglib生成的类文件。
闲话不多说，让我们直接开始。
## 创建代理类
上一章结束之后，Spring AOP的核心逻辑已经走了一半了，获取了目标类所适用的增强器列表，下面开始分析获取代理的过程。
未免读者阅读不连贯，我们再贴一下[向您生动地讲解Spring AOP 源码（1）]()中我们最后讲解的一段源码，由此继续往下讲述。
源码位置：`AbstractAutoProxyCreator#wrapIfNecessary(..)`
**TODO-2** `createProxy`
稍微提一下 `TargetSource` 这个概念，它用于封装真实实现类的信息，在我理解看来就是把获取目标对象这个步骤做了一个代理的操作，提供一个扩展点给外部，使得使用者可以通过这个扩展点去对目标对象做一些处理；
上面用了 `SingletonTargetSource` 这个实现类，其实我们这里也不太需要关心这个，知道有这么回事就可以了，个人感觉这个扩展点用处不是特别的大。
------
来条分割线，正式进入今天的核心内容。
现在，让我们开始解析，Spring AOP创建代理类的流程。
源码位置：`AbstractAutoProxyCreator#createProxy(..)`
流程：
1. 获取当前类中的属性
2. 添加代理接口
3. 封装Advisor并加入到ProxyFactory中
4. 设置要代理的类
5. Spring中为子类提供了定制的函数`customizeProxyFactory`，子类可以在此函数中对ProxyFactory的进一步封装
6. ★★★ 获取代理操作
------
主要分析关键的生成代理类的操作。
源码位置：`ProxyFactory#getProxy(..)`
```java
public Object getProxy(ClassLoader classLoader) {
return createAopProxy().getProxy(classLoader);
}
```
这里要分为两步，
1. 创建`AopProxy`
2. 获取代理类
## 1. 创建 AopProxy
```java
protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
activate();
}
return getAopProxyFactory().createAopProxy(this);
}
```
这一步之后我们根据ProxyConfig 获取到了对应的`AopProxy`的实现类，分别是`JdkDynamicAopProxy`和`ObjenesisCglibAopProxy`。
## 2. 获取代理类
### JDK 动态代理
源码位置：`JdkDynamicAopProxy#getProxy(..)`
我们关注的是最后一行代码`Proxy.newProxyInstance(classLoader, proxiedInterfaces, this)`，
```java
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h) {
...
}
```
> 注：到这里，你需要了解一下JDK动态代理的使用知识，如果能了解原理，那就更好了
第一个参数是类加载器，第二个参数是目标类的接口集合，第三个参数则是`InvocationHandler`的实现类，`JdkDynamicAopProxy`在创建代理的时候，是将自身作为 `InvocationHandler`传入的，由此可知`JdkDynamicAopProxy `本身实现了`InvocationHandler`接口。
熟悉JDK动态代理实现机制的同学应该会知道，调用代理类的对应方法时，代理类实际上是通过`invoke(Object proxy, Method method, Object[] args)`方法来完成 target class 方法的调用，并在里面进行一些代理类想做的其他的操作。
在AOP中，`invoke`方法会完成AOP编织实现的封装。所以让我们看看这个`invoke`方法是怎么实现的。
`invoke`方法的关键就在于，**利用责任链模式，递归调用的方法，来完成advice 的织入**。
`ReflectiveMethodInvocation`构造方法
关键的`ReflectiveMethodInvocation#proceed()`方法
我们来看看`((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this)`，这个方法有多种实现，其中一些我们熟悉的或者说需要关注的实现，对应的就是我们Advice的类型，或者说增强的时机。
| 术语 | 概念 |
| ----------------- | ---------------------------------------------------- |
| `Before` | 在方法被调用之前执行增强 |
| `After` | 在方法被调用之后执行增强 |
| `After-returning` | 在方法成功执行之后执行增强 |
| `After-throwing` | 在方法抛出指定异常后执行增强 |
| `Around` | 在方法调用的前后执行自定义的增强行为（最灵活的方式） |
这里我们用概览的方式过一下这几种的实现，
① `MethodBeforeAdviceInterceptor#invoke(..)`
② `AspectJAfterAdvice#invoke(..)`
③ `AfterReturningAdviceInterceptor#invoke(..)`
④ `AspectJAfterThrowingAdvice#invoke(..)`
⑤ `AspectJAroundAdvice#invoke(..)`
### Cglib 代理
Cglib 代理 和 JDK 代理 在流程上相似，只是在具体实现上不一样。核心就是`Enhancer`和获得`callbacks`的过程。这里就不分析了。
## 小结
本章的核心内容就是，创建代理类时，Spring 根据 AOP 配置选择JDK动态代理或是 Cglib 代理，增强器的织入是按照事先排序好的顺序、advice 的类型来起作用的。
个人认为核心难点还是在对JDK动态代理和Cglib代理 原理的理解。读者如果对这块不熟悉，可以查阅其他的文章进行学习。
可以学习到责任链的设计模式、JDK 动态代理和反射、Cglib代理等Java 核心知识。
最后，作者写到这里，也是长呼一口气，源码分析不像新技术那样，一开始就抓人眼球，很难写得引人入胜，通常篇幅过长，写的人会乏，看的人也会乏。所幸作者坚持了下来，在这期间对AOP的源码也有了更深的理解。
## 附录
理解JDK 动态代理 和 CGLIB 代理 生成的代理类的源码会让你对advice织入的时机有更深的理解。
### JDK 动态代理 类源码
`TestSvc`
```java
public interface TestSvc {
void process();
}
@Service("testSvc")
public class TestSvcImpl implements TestSvc {
@Override
public void process() {
System.out.println("test svc is working");
}
}
```
生成代理类：
> 关键点：实现接口，method.invoke(..) 反射调用
```java
package com.sun.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import ric.study.demo.aop.svc.TestSvc;
public final class $Proxy19
extends Proxy
implements TestSvc
{
private static Method m1;
private static Method m2;
private static Method m0;
private static Method m3;
public $Proxy19(InvocationHandler paramInvocationHandler)
{
super(paramInvocationHandler);
}
public final boolean equals(Object paramObject)
{
try
{
return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final String toString()
{
try
{
return (String)this.h.invoke(this, m2, null);
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final int hashCode()
{
try
{
return ((Integer)this.h.invoke(this, m0, null)).intValue();
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final void process()
{
try
{
this.h.invoke(this, m3, null);
return;
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
static
{
try
{
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
m3 = Class.forName("ric.study.demo.aop.svc.TestSvc").getMethod("process", new Class[0]);
return;
}
catch (NoSuchMethodException localNoSuchMethodException)
{
throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
}
catch (ClassNotFoundException localClassNotFoundException)
{
throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
}
}
}
```
### 如何保存JDK 动态代理的源文件
只需要在系统变量中设置`sun.misc.ProxyGenerator.saveGeneratedFiles`为`true`即可。比如这样，
会在项目目录下生成`com.sun.proxy`目录，并存储对应的文件。想要找到你的代理类到底是哪个，你还需要打印出（或者debug查看）这个代理类的类名，像我上图一样。
### Cglib 代理 类源码
> 关键：继承；MethodInterceptor.intercept()；
>
> BTW：Cglib 的 源码未免太过冗长，放上来的阅读体验非常不好（1000+行）。读者可以按照我后面提到的方法自己生成，然后利用反编译工具查看。
### 如何保存 Cglib 生成代理类 的源文件
和JDK 动态代理类似，`System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "...");`，设置class 文件的输出目录即可。
