Java 代理设计模式 (Proxy) 的四种具体实现：静态代理和动态代理

作者：Jerry Wang

2021 年 12 月 11 日
本文字数：3345 字
阅读完需：约 11 分钟

面试问题：Java 里的代理设计模式（Proxy Design Pattern）一共有几种实现方式？这个题目很像孔乙己问“茴香豆的茴字有哪几种写法？”

所谓代理模式，是指客户端(Client)并不直接调用实际的对象(下图右下角的 RealSubject)，而是通过调用代理(Proxy)，来间接的调用实际的对象。

代理模式的使用场合，一般是由于客户端不想直接访问实际对象，或者访问实际的对象存在技术上的障碍，因而通过代理对象作为桥梁，来完成间接访问。

实现方式一：静态代理

开发一个接口 IDeveloper，该接口包含一个方法 writeCode，写代码。

public interface IDeveloper {
     public void writeCode();
}

复制代码

创建一个 Developer 类，实现该接口。

public class Developer implements IDeveloper{  private String name;  public Developer(String name){    this.name = name;  }  @Override  public void writeCode() {    System.out.println("Developer " + name + " writes code");  }}

复制代码

测试代码：创建一个 Developer 实例，名叫 Jerry，去写代码！

public class DeveloperTest {  public static void main(String[] args) {    IDeveloper jerry = new Developer("Jerry");    jerry.writeCode();  }}

复制代码

现在问题来了。Jerry 的项目经理对 Jerry 光写代码，而不维护任何的文档很不满。假设哪天 Jerry 休假去了，其他的程序员来接替 Jerry 的工作，对着陌生的代码一脸问号。经全组讨论决定，每个开发人员写代码时，必须同步更新文档。

为了强迫每个程序员在开发时记着写文档，而又不影响大家写代码这个动作本身, 我们不修改原来的 Developer 类，而是创建了一个新的类，同样实现 IDeveloper 接口。这个新类 DeveloperProxy 内部维护了一个成员变量，指向原始的 IDeveloper 实例：

public class DeveloperProxy implements IDeveloper{  private IDeveloper developer;  public DeveloperProxy(IDeveloper developer){    this.developer = developer;  }  @Override  public void writeCode() {    System.out.println("Write documentation...");    this.developer.writeCode();  }}

复制代码

这个代理类实现的 writeCode 方法里，在调用实际程序员 writeCode 方法之前，加上一个写文档的调用，这样就确保了程序员写代码时都伴随着文档更新。

测试代码：

静态代理方式的优点

1. 易于理解和实现

2. 代理类和真实类的关系是编译期静态决定的，和下文马上要介绍的动态代理比较起来，执行时没有任何额外开销。

静态代理方式的缺点

每一个真实类都需要一个创建新的代理类。还是以上述文档更新为例，假设老板对测试工程师也提出了新的要求，让测试工程师每次测出 bug 时，也要及时更新对应的测试文档。那么采用静态代理的方式，测试工程师的实现类 ITester 也得创建一个对应的 ITesterProxy 类。

public interface ITester {  public void doTesting();}Original tester implementation class:public class Tester implements ITester {  private String name;  public Tester(String name){    this.name = name;  }  @Override  public void doTesting() {    System.out.println("Tester " + name + " is testing code");  }}public class TesterProxy implements ITester{  private ITester tester;  public TesterProxy(ITester tester){    this.tester = tester;  }  @Override  public void doTesting() {    System.out.println("Tester is preparing test documentation...");    tester.doTesting();  }}

复制代码

正是因为有了静态代码方式的这个缺点，才诞生了 Java 的动态代理实现方式。

Java 动态代理实现方式一：InvocationHandler

InvocationHandler 的原理我曾经专门写文章介绍过：Java动态代理之InvocationHandler最简单的入门教程

通过 InvocationHandler, 我可以用一个 EnginnerProxy 代理类来同时代理 Developer 和 Tester 的行为。

public class EnginnerProxy implements InvocationHandler {  Object obj;  public Object bind(Object obj)  {    this.obj = obj;    return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj    .getClass().getInterfaces(), this);  }  @Override  public Object invoke(Object proxy, Method method, Object[] args)  throws Throwable  {    System.out.println("Enginner writes document");    Object res = method.invoke(obj, args);    return res;  }}

复制代码

真实类的 writeCode 和 doTesting 方法在动态代理类里通过反射的方式进行执行。

测试输出：

通过 InvocationHandler 实现动态代理的局限性

假设有个产品经理类(ProductOwner) 没有实现任何接口。

public class ProductOwner {  private String name;  public ProductOwner(String name){    this.name = name;  }  public void defineBackLog(){    System.out.println("PO: " + name + " defines Backlog.");  }}

复制代码

我们仍然采取 EnginnerProxy 代理类去代理它，编译时不会出错。运行时会发生什么事？

ProductOwner po = new ProductOwner("Ross");
ProductOwner poProxy = (ProductOwner) new EnginnerProxy().bind(po);
poProxy.defineBackLog();

复制代码

运行时报错。所以局限性就是：如果被代理的类未实现任何接口，那么不能采用通过 InvocationHandler 动态代理的方式去代理它的行为。

Java 动态代理实现方式二：CGLIB

CGLIB 是一个 Java 字节码生成库，提供了易用的 API 对 Java 字节码进行创建和修改。关于这个开源库的更多细节，请移步至 CGLIB 在 github 上的仓库：https://github.com/cglib/cglib

我们现在尝试用 CGLIB 来代理之前采用 InvocationHandler 没有成功代理的 ProductOwner 类(该类未实现任何接口)。

现在我改为使用 CGLIB API 来创建代理类：

public class EnginnerCGLibProxy {  Object obj;  public Object bind(final Object target)  {    this.obj = target;    Enhancer enhancer = new Enhancer();    enhancer.setSuperclass(obj.getClass());    enhancer.setCallback(new MethodInterceptor() {      @Override      public Object intercept(Object obj, Method method, Object[] args,      MethodProxy proxy) throws Throwable      {        System.out.println("Enginner 2 writes document");        Object res = method.invoke(target, args);        return res;      }    }    );    return enhancer.create();  }}

复制代码

测试代码：

ProductOwner ross = new ProductOwner("Ross");
ProductOwner rossProxy = (ProductOwner) new EnginnerCGLibProxy().bind(ross);
rossProxy.defineBackLog();

复制代码

尽管 ProductOwner 未实现任何代码，但它也成功被代理了：

用 CGLIB 实现 Java 动态代理的局限性

如果我们了解了 CGLIB 创建代理类的原理，那么其局限性也就一目了然。我们现在做个实验，将 ProductOwner 类加上 final 修饰符，使其不可被继承：

再次执行测试代码，这次就报错了： Cannot subclass final class XXXX。

所以通过 CGLIB 成功创建的动态代理，实际是被代理类的一个子类。那么如果被代理类被标记成 final，也就无法通过 CGLIB 去创建动态代理。

Java 动态代理实现方式三：通过编译期提供的 API 动态创建代理类

假设我们确实需要给一个既是 final，又未实现任何接口的 ProductOwner 类创建动态代码。除了 InvocationHandler 和 CGLIB 外，我们还有最后一招：

我直接把一个代理类的源代码用字符串拼出来，然后基于这个字符串调用 JDK 的 Compiler（编译期）API，动态的创建一个新的.java 文件，然后动态编译这个.java 文件，这样也能得到一个新的代理类。

测试成功：

我拼好了代码类的源代码，动态创建了代理类的.java 文件，能够在 Eclipse 里打开这个用代码创建的.java 文件，

下图是如何动态创建 ProductPwnerSCProxy.java 文件:

下图是如何用 JavaCompiler API 动态编译前一步动态创建出的.java 文件，生成.class 文件：

下图是如何用类加载器加载编译好的.class 文件到内存：

如果您想试试这篇文章介绍的这四种代理模式(Proxy Design Pattern), 请参考我的 github 仓库，全部代码都在上面。感谢阅读。

https://github.com/i042416/JavaTwoPlusTwoEquals5/tree/master/src/proxy

要获取更多 Jerry 的原创技术文章，请关注公众号"汪子熙"。

发布于: 4 小时前阅读数: 5

原文链接:【http://xie.infoq.cn/article/9a9d89fd03634d93c3f5d9513】。文章转载请联系作者。

Jerry Wang

关注

个人微信公众号：汪子熙 2017.12.03 加入

SAP成都研究院开发专家，SAP社区导师，SAP中国技术大使。

发布

暂无评论

创作场景

Java 代理设计模式 (Proxy) 的四种具体实现：静态代理和动态代理

实现方式一：静态代理

静态代理方式的优点

静态代理方式的缺点

Java 动态代理实现方式一：InvocationHandler

Java 动态代理实现方式二：CGLIB

用 CGLIB 实现 Java 动态代理的局限性

Jerry Wang

评论