本文首发于 https://jaychen.cc
作者 jaychen
最近在学 Spring，研究了下 AOP 和代理模式，写点心得和大家分享下。
AOP
先说下AOP，AOP 全称 Aspect Oriented Programming，面向切面编程，和 OOP 一样也是一种编程思想。AOP 出现的原因是为了解决 OOP 在处理 侵入性业务上的不足。
那么，什么是侵入性业务？类似日志统计、性能分析等就属于侵入性业务。本来原本的业务逻辑代码优雅大气，正常运行，突然说需要在这段逻辑里面加上性能分析，于是代码就变成了下面这个样子
long begin = System.currentTimeMillis();
// 原本的业务
doSomething();
long end = System.currentTimeMillis();
long step = end - begin;
System.out.println("执行花费 ：" + step);
从上面的代码看到，性能分析的业务代码和原本的业务代码混在了一起，好端端的代码就这么被糟蹋了。所以，侵入性业务必须有一个更好的解决方案，这个解决方案就是 AOP。
那么，AOP 是如何解决这类问题？
代理模式
通常，我们会使用代理模式来实现 AOP，这就意味着代理模式可以优雅的解决侵入性业务问题。所以下面来重点分析下代理模式。
这个是代理模式的类图。很多人可能看不懂类图，但是说实话有时候一图胜千言，这里稍微解释下类图的含义，尤其是类图中存在的几种连线符。
- 矩形代表一个类，矩形内部的信息有：类名，属性和方法。
- 虚线 + 三角空心箭头为
is=a的关系，表示继承，所以上图中TestSQL和Performance都实现IDatabase接口。 - 实线 + 箭头为关联关系，一般在代码中以成员变量的形式体现，所以上图中
Performance类有一个TestSQL的成员变量。
有了类图，我们可以根据类图直接写出代理模式的代码了。这里代理模式分为静态代理和动态代理两种，我们分别来看下。
静态代理
假设一个场景，我们需要测试一条 sql query 执行所花费的时间。
如果按照普通的方式，代码逻辑应该如下
long begin = System.currentTimeMillis();
query();
long end = System.currentTimeMillis();
long step = end - begin;
System.out.println("执行花费 ：" + step);
上面说过了，这种会导致查询逻辑和性能测试逻辑混淆在一块，那么来看看使用代理模式是如何解决这个问题的。
代理模式，代理，意味着有一方代替另一方完成一件事。这里，我们会编写两个类：TestSQL 为query 执行逻辑，Performance 为性能测试类。这里 Performance 会代替 TestSQL 去执行 query 逻辑。
要想 Performance 能够代替 TestSQL 执行 query 逻辑，那么这两个类应该是有血缘关系的，即这两个必须实现同一个接口。
// 接口
public interface IDatabase {
void query();
}
public class TestSQL implements IDatabase {
@Override
public void query() {
System.out.println("执行 query。。。。");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
// 代理类
public class PerformanceMonitor implements IDatabase {
TestSQL sql;
public PerformanceMonitor(TestSQL sql) {
this.sql = sql;
}
@Override
public void query() {
long begin = System.currentTimeMillis();
// 业务逻辑。
sql.query();
long end = System.currentTimeMillis();
long step = end - begin;
System.out.println("执行花费 : " + step);
}
}
// 测试代码
public class Main {
public static void main(String[] strings) {
TestSQL sql = new TestSQL();
PerformanceMonitor performanceMonitor = new PerformanceMonitor(sql);
// 由 Performance 代替 testSQL 执行
performanceMonitor.query();
}
}
从上面的示例代码可以分析出来代理模式是如何运作的，这里我们可以很明显看出代理模式的优越性，TestSQL 的逻辑很纯粹，没有混入其他无关的业务代码。
动态代理
回顾静态代理的代码，发现代理类 Performance 必须实现 IDatabase 接口。如果有很多业务需要用到代理来实现，那么每个业务都需要定义一个代理类，这会导致类迅速膨胀，为了避免这点，Java 提供了动态代理。
为何称之为动态代理，动态代理底层是使用反射实现的，是在程序运行期间动态的创建接口的实现。在静态代理中，我们需要在编码的时候编写 Performance 类实现 IDatabase 接口。而使用动态代理，我们不必编写 Performance 实现 IDatabase 接口，而是 JDK 在底层通过反射技术动态创建一个 IDatabase 接口的实现。
使用动态代理需要使用到 InvocationHandler 和 Proxy 这两个类。
// 代理类,不再实现 IDatabase 接口，而是实现 InvocationHandler 接口
public class Performance implements InvocationHandler {
private TestSQL sql;
public Performance(TestSQL sql) {
this.sql = sql;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
long begin = System.currentTimeMillis();
// method.invoke 实际上就是调用 sql.query()
Object object = method.invoke(sql, args);
long end = System.currentTimeMillis();
long step = end - begin;
System.out.println("执行花费 ：" + step);
return object;
}
}
public class Main {
public static void main(String[] strings) {
TestSQL sql = new TestSQL();
Performance performance = new Performance(sql);
IDatabase proxy = (IDatabase) Proxy.newProxyInstance(
sql.getClass().getClassLoader(),
sql.getClass().getInterfaces(),
performance
);
proxy.query();
}
}
先来看看 newProxyInstance 函数，这个函数的作用就是用来动态创建一个代理对象的类，这个函数需要三个参数：
- 第一个参数为类加载器，如果不懂是什么玩意，先套着模板写，等我写下一篇文章拯救你。
- 第二个参数为要代理的接口，在这个例子里面就是
IDatabase接口。 - 第三个参数为实现
InvocationHandler接口的对象。
执行 newProxyInstance 之后，Java 会在底层自动生成一个代理类，其代码大概如下：
public final class $Proxy1 extends Proxy implements IDatabase{
private InvocationHandler h;
private $Proxy1(){}
public $Proxy1(InvocationHandler h){
this.h = h;
}
public void query(){
////创建method对象
Method method = Subject.class.getMethod("query");
//调用了invoke方法
h.invoke(this, method, new Object[]{});
}
}
你会发现，这个类很像在静态代理中的 Performance 类，是的，动态代理其本质是 Java 自动为我们生成了一个 $Proxy1 代理类。在 mian 函数中 newProxyInstance 的返回值就是该类的一个实例。并且，$Proxy1 中的 h 属性就是 newProxyInstance 的第三个参数。所以，当我们在 main 函数中执行 proxy.query()，实际上是调用 $proxy1#query 方法，进而再调用 Performance#invoke 方法。而在 Performance#invoke 通过 Object object = method.invoke(sql, args); 调用了 TestSQL#query 方法。
回顾上面的流程，理解动态代理的核心在于理解 Java 自动生成的代理类。这里还有一点要说明，JDK 的动态代理有一个不足：它只能为接口创建代理实例。这句话体现在代码上就是 newProxyInstance 的第二个参数是一个接口数组。为什么会存在这个不足？其实看 $Proxy1 代理类就知道了，这个由 JDK 生成的代理类需要继承 Proxy 类，而 Java 只支持单继承，所以就限制了 JDK 的动态代理只能为接口创建代理。
