代理模式

Posted on In

代理模式也叫做委托模式，许多其他的模式，比如状态模式、策略模式、访问者模式等本质上都是在更加特殊的场景中采用了委托模式。有时候我们可能会把代理模式与装饰器模式搞混，简单来说，装饰器模式更加专注于向对象动态地添加或增强功能，而代理模式则更专注于控制对对象的访问。装饰器模式强调的是增强自身，在被装饰之后你能够在被增强的类上使用增强后的功能，但是增强后的你还是你，只不过能力更强了而已。代理模式则强调要让别人帮你去做一些与你本身没有太大关联的职责，比如记录日志、设置缓存等。

有的时候我们可能不能直接访问一个对象，只能通过代理来间接访问，比如这个对象在另外一台机器，这其实就是 RPC，我们在本地访问的是远程对象的代理。或者对象被持久化了，比如 MyBatis 的 mapperProxy，通过 mapper 文件自动生成代理类。从编译器的角度来看，装饰器模式无法在编译期就确定一个对象的功能，需要在运行时动态地给对象添加职责，因为这些功能都是使用者在使用时动态配置的；而代理模式在编译期就已经确定了和代理对象的关联。

代理模式

代理模式

在代理模式中，Subject 抽象主题角色可以是抽象类也可以是接口，它是一个最普通的业务类型定义。RealSubject 是具体的主题角色，继承或实现了抽象主题角色，是业务逻辑的具体执行者，同时也是被代理的角色。Proxy 代理类负责把抽象主题类中定义的方法委托给具体主题类来实现，并在具体主题类的方法前后做预处理和善后处理工作。

这种代理模式也叫做静态代理，从 UML 图中可以看出，要代理的目标类和代理类都实现或继承了一个接口或抽象类，代理类持有一个目标类的对象，在执行操作时，其实是调用的目标对象的方法。静态代理类的作用类似一个中介，然而为了一个中介我们就要创建一个类，如果在系统中大量使用静态代理，就会造成系统中类的规模增大，导致系统比较臃肿。

动态代理

动态代理的出现就是为了弥补静态代理为了使用代理就要真实创建代理类的缺陷，动态代理只需要有 Subject 和 RealSubject 就可以产生代理类并将它加载到内存当中，不需要我们手动创建。目前常见的动态代理有两种，包括 JDK 动态代理和 cglib 动态代理。

在面向对象的编程当中，如果我们想约定 Proxy 类与 RealSubject 类要实现相同的功能，一般有两种方式：其中一种就是定义一个业务接口，然后让 Proxy 和 RealSubject 都实现这个接口；另一种就是让 Proxy 类直接继承 RealSubject 类，这样 Proxy 类就拥有了 RealSubject 的功能。JDK 动态代理使用的就是第一种方式，即面向接口的代理；而 cglib 使用的是第二种方式，即通过操纵字节码来继承要代理的类，因此这种方式有一个缺陷就是无法代理被 final 修饰的类。

JDK 动态代理

我们不牵扯业务，就单纯以 Subject 主题为例，看看 JDK 的动态代理是如何实现的。

1
2
3
public interface Subject {
    void operation();
}
1
2
3
4
5
6
public class RealSubject implements Subject {
    @Override
    public void operation() {
        System.out.println("operation...");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class MyInvocationHandler implements InvocationHandler {
    // 目标实例
    private Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 调用前置处理
        this.before();
        // 调用目标实例指定的方法
        Object result = method.invoke(this.target, args);
        // 调用后置处理
        this.after();

        return result;
    }

    private void before() {
        System.out.println("before...");
    }

    private void after() {
        System.out.println("after...");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Client {

    public static void main(String[] args) {
        // 创建一个主题
        Subject subject = new RealSubject();
        // 创建 Handler
        InvocationHandler handler = new MyInvocationHandler(subject);
        // 获取类加载器
        ClassLoader classLoader = subject.getClass().getClassLoader();
        // 获取接口数组
        Class<?>[] interfaces = subject.getClass().getInterfaces();
        // 创建主题的代理对象
        Subject proxySubject = (Subject) Proxy.newProxyInstance(classLoader, interfaces, handler);
        // 调用代理对象的方法
        proxySubject.operation();
    }
}

下面来分析源码，可以看到代理对象是通过 Proxy.newProxyInstance() 方法创建的，这是 JDK 动态代理的关键。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
    Objects.requireNonNull(h);

    final Class<?>[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }

    // 获取代理类的 Class 对象
    Class<?> cl = getProxyClass0(loader, intfs);

    try {
        if (sm != null) {
            checkNewProxyPermission(Reflection.getCallerClass(), cl);
        }
        // 获取代理类的构造函数
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        if (!Modifier.isPublic(cl.getModifiers())) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    cons.setAccessible(true);
                    return null;
                }
            });
        }
        // 通过构造函数创建代理类的实例，创建实例时传入 InvocationHandler 对象
        return cons.newInstance(new Object[]{h});
    } catch (IllegalAccessException|InstantiationException e) {
        throw new InternalError(e.toString(), e);
    } catch (InvocationTargetException e) {
        Throwable t = e.getCause();
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new InternalError(t.toString(), t);
        }
    } catch (NoSuchMethodException e) {
        throw new InternalError(e.toString(), e);
    }
}

可以看到，Proxy.newInstance() 方法首先获取了代理类的 Class 对象，然后通过这个 Class 对象获取代理类的构造函数，最后通过构造函数创建了一个代理类的实例，在创建代理类实例时还传入了一个 InvocationHandler 对象。接下来再看看它是如何获取代理类的 Class 对象的。

1
2
3
4
5
6
7
8
9
private static Class<?> getProxyClass0(ClassLoader loader,
                                        Class<?>... interfaces) {
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }

    // 从缓存中取。如果缓存中不存在就使用 ProxyClassFactory 生成
    return proxyClassCache.get(loader, interfaces);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public V get(K key, P parameter) {
    Objects.requireNonNull(parameter);

    expungeStaleEntries();

    Object cacheKey = CacheKey.valueOf(key, refQueue);

    // lazily install the 2nd level valuesMap for the particular cacheKey
    ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
    if (valuesMap == null) {
        ConcurrentMap<Object, Supplier<V>> oldValuesMap
            = map.putIfAbsent(cacheKey,
                              valuesMap = new ConcurrentHashMap<>());
        if (oldValuesMap != null) {
            valuesMap = oldValuesMap;
        }
    }

    // apply 方法是创建代理对象的关键
    Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
    Supplier<V> supplier = valuesMap.get(subKey);
    Factory factory = null;
    // 省略以下部分代码
}
1
2
3
4
5
6
7
8
9
10
11
12
13
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
    // 省略以上部分代码

    // 这是生成 Class 文件的代码
    byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
        proxyName, interfaces, accessFlags);
    try {
        return defineClass0(loader, proxyName,
                            proxyClassFile, 0, proxyClassFile.length);
    } catch (ClassFormatError e) {
        throw new IllegalArgumentException(e.toString());
    }
}

从上面的代码可以看出，Proxy 类中定义了一个名称为 proxyClassCache 的 WeakCache。也就是说，在调用 get 方法获取代理类的 Class 对象的时候，如果缓存中有，则直接取出，如果没有，则使用 ProxyClassFactory 的 apply 方法创建一个。而在 apply 方法中，有一个方法非常重要，它就是 generateProxyClass 方法，该方法会生成代理类的二进制字节码文件，然后使用对应的类加载器加载这个字节码文件，就可以得到对应的 Class 对象。由于我很好奇通过这种方式生成的 Class 文件到底是什么样子的，于是就写了下面一个小工具，将生成的字节码文件持久化。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class ProxyUtils {

    public static void generateProxyClassFile(Class clazz, String proxyName) {
        // 生成字节码
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, clazz.getInterfaces());
        String path = clazz.getResource(".").getPath();
        try (BufferedOutputStream output =
                     new BufferedOutputStream(new FileOutputStream(path + proxyName + ".class"))) {
            output.write(proxyClassFile);
            output.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        generateProxyClassFile(RealSubject.class, "SubjectProxy");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
public final class SubjectProxy extends Proxy implements Subject {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public SubjectProxy(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void operation() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("com.github.nekolr.Subject").getMethod("operation");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

可以看到，该代理类有几个特征：实现了 Subject 接口，继承 Proxy 类。构造函数中有形参 InvocationHandler，这就是为什么在 Proxy.newProxyInstance 方法中，通过构造函数创建代理类的实例时传入了一个 InvocationHandler 对象。代理类中实现的接口方法都是通过最终都通过 InvocationHandler 来处理。

参考

Java 中“装饰模式”和“代理模式”有啥区别？