本文首发于 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 的动态代理只能为接口创建代理。