动态代理为实现许多常见设计模式（包括 facade、bridge、interceptor、decorator、proxy（包括远程和虚拟代理）和 adapter 模式）提供了替代的动态机制。虽然这些模式不使用动态代理，只用普通的类就能够实现，但是在许多情况下，动态代理方式更方便、更紧凑，可以清除许多手写或生成的类。
　　
　　proxy 模式
　　
　　proxy 模式中要创建“stub”或“surrogate”对象，它们的目的是接受请求并把请求转发到实际执行工作的其他对象。远程方法调用（rmi）利用 proxy 模式，使得在其他 jvm 中执行的对象就像本地对象一样；企业 javabeans （ejb）利用 proxy 模式添加远程调用、安全性和事务分界；而 jax-rpc web 服务则用 proxy 模式让远程服务表现得像本地对象一样。在每一种情况中，潜在的远程对象的行为是由接口定义的，而接口本质上接受多种实现。调用者（在大多数情况下）不能区分出它们只是持有一个对 stub 而不是实际对象的引用，因为二者实现了相同的接口；stub 的工作是查找实际的对象、封送参数、把参数发送给实际对象、解除封送返回值、把返回值返回给调用者。代理可以用来提供远程控制（就像在 rmi、ejb 和 jax-rpc 中那样），用安全性策略包装对象（ejb）、为昂贵的对象（ejb 实体 bean）提供惰性装入，或者添加检测工具（例如日志记录）。
　　
　　在 5.0 以前的 jdk 中，rmi stub（以及它对等的 skeleton）是在编译时由 rmi 编译器（rmic）生成的类，rmi 编译器是 jdk 工具集的一部分。对于每个远程接口，都会生成一个 stub（代理）类，它代表远程对象，还生成一个 skeleton 对象，它在远程 jvm 中做与 stub 相反的工作 ?d?d 解除封送参数并调用实际的对象。类似地，用于 web 服务的 jax-rpc 工具也为远程 web 服务生成代理类，从而使远程 web 服务看起来就像本地对象一样。
　　
　　不管 stub 类是以源代码还是以字节码生成的，代码生成仍然会向编译过程添加一些额外步骤，而且因为命名相似的类的泛滥，会带来意义模糊的可能性。另一方面，动态代理机制支持在编译时没有生成 stub 类的情况下，在运行时创建代理对象。在 jdk 5.0 及以后版本中，rmi 工具使用动态代理代替了生成的 stub，结果 rmi 变得更容易使用。许多 j2ee 容器也使用动态代理来实现 ejb。ejb 技术严重地依靠使用拦截（interception）来实现安全性和事务分界；动态代理为接口上调用的所有方法提供了集中的控制流程路径。
　　
　　动态代理机制
　　
　　动态代理机制的核心是 invocationhandler 接口，如清单 1 所示。调用句柄的工作是代表动态代理实际执行所请求的方法调用。传递给调用句柄一个 method 对象（从 java.lang.reflect 包），参数列表则传递给方法；在最简单的情况下，可能仅仅是调用反射性的方法 method.invoke() 并返回结果。
　　
　　清单 1. invocationhandler 接口
　　
　　public interface invocationhandler {
　　object invoke(object proxy, method method, object[] args)
　　throws throwable;
　　}
　　
　　每个代理都有一个与之关联的调用句柄，只要代理的方法被调用时就会调用该句柄。根据通用的设计原则：接口定义类型、类定义实现，代理对象可以实现一个或多个接口，但是不能实现类。因为代理类没有可以访问的名称，它们不能有构造函数，所以它们必须由工厂创建。清单 2 显示了动态代理的最简单的可能实现，它实现 set 接口并把所有 set 方法（以及所有 object 方法）分派给封装的 set 实例。
　　
　　清单 2. 包装 set 的简单的动态代理
　　
　　public class setproxyfactory {
　　
　　public static set getsetproxy(final set s) {
　　return (set) proxy.newproxyinstance
　　(s.getclass().getclassloader(),
　　new class[] { set.class },
　　new invocationhandler() {
　　public object invoke(object proxy, method method,
　　object[] args) throws throwable {
　　return method.invoke(s, args);
　　}
　　});
　　}
　　}
　　
　　setproxyfactory 类包含一个静态工厂方法 getsetproxy()，它返回一个实现了 set 的动态代理。代理对象实际实现 set ?d?d 调用者无法区分（除非通过反射）返回的对象是动态代理。setproxyfactory 返回的代理只做一件事，把方法分派给传递给工厂方法的 set 实例。虽然反射代码通常比较难读，但是这里的内容很少，跟上控制流程并不难 ?d?d 只要某个方法在 set 代理上被调用，它就被分派给调用句柄，调用句柄只是反射地调用底层包装的对象上的目标方法。当然，绝对什么都不做的代理可能有点傻，是不是呢？
　　
　　什么都不做的适配器
　　
　　对于像 setproxyfactory 这样什么都不做的包装器来说，实际有个很好的应用 ?d?d 可以用它安全地把对象引用的范围缩小到特定接口（或接口集）上，方式是，调用者不能提升引用的类型，使得可以更安全地把对象引用传递给不受信任的代码（例如插件或回调）。清单 3 包含一组类定义，实现了典型的回调场景。从中会看到动态代理可以更方便地替代通常用手工（或用 ide 提供的代码生成向导）实现的 adapter 模式。
　　
　　清单 3. 典型的回调场景
　　
　　public interface servicecallback {
　　public void docallback();
　　}
　　
　　public interface service {
　　public void servicemethod(servicecallback callback);
　　}
　　
　　public class serviceconsumer implements servicecallback {
　　private service service;
　　
　　...
　　public void somemethod() {
　　...
　　service.servicemethod(this);
　　}
　　}
　　
　　serviceconsumer 类实现了 servicecallback（这通常是支持回调的一个方便途径）并把 this 引用传递给 servicemethod() 作为回调引用。这种方法的问题是没有机制可以阻止 service 实现把 servicecallback 提升为 serviceconsumer，并调用 serviceconsumer 不希望 service 调用的方法。有时对这个风险并不关心 ?d?d 但有时却关心。如果关心，那么可以把回调对象作为内部类，或者编写一个什么都不做的适配器类（请参阅清单 4 中的 servicecallbackadapter）并用 servicecallbackadapter 包装 serviceconsumer。servicecallbackadapter 防止 service 把 servicecallback 提升为 serviceconsumer。
　　
　　清单 4. 用于安全地把对象限制在一个接口上以便不被恶意代码不能的适配器类
　　
　　public class servicecallbackadapter implements servicecallback {
　　private final servicecallback cb;
　　
　　public servicecallbackadapter(servicecallback cb) {
　　this.cb = cb;
　　}
　　
　　public void docallback() {
　　cb.docallback();
　　}
　　}
　　
　　编写 servicecallbackadapter 这样的适配器类简单却乏味。必须为包装的接口中的每个方法编写重定向类。在 servicecallback 的示例中，只有一个需要实现的方法，但是某些接口，例如 collections 或 jdbc 接口，则包含许多方法。现代的 ide 提供了“delegate methods”向导，降低了编写适配器类的工作量，但是仍然必须为每个想要包装的接口编写一个适配器类，而且对于只包含生成的代码的类，也有一些让人不满意的地方。看起来应当有一种方式可以更紧凑地表示“什么也不做的限制适配器模式”。
　　
　　通用适配器类
　　
　　清单 2 中的 setproxyfactory 类当然比用于 set 的等价的适配器类更紧凑，但是它仍然只适用于一个接口：set。但是通过使用泛型，可以容易地创建通用的代理工厂，由它为任何接口做同样的工作，如清单 5 所示。它几乎与 setproxyfactory 相同，但是可以适用于任何接口。现在再也不用编写限制适配器类了！如果想创建代理对象安全地把对象限制在接口 t，只要调用 getproxy(t.class,object) 就可以了，不需要一堆适配器类的额外累赘。
　　
　　清单 5. 通用的限制适配器工厂类
　　
　　public class genericproxyfactory {
　　
　　public static<t> t getproxy(class<t> intf,
　　final t obj) {
　　return (t)
　　proxy.newproxyinstance(obj.getclass().getclassloader(),
　　new class[] { intf },
　　new invocationhandler() {
　　public object invoke(object proxy, method method,
　　object[] args) throws throwable {
　　return method.invoke(obj, args);
　　}
　　});
　　}
　　}
　　
　　动态代理作为 decorator
　　
　　当然，动态代理工具能做的，远不仅仅是把对象类型限制在特定接口上。从 清单 2 和 清单 5 中简单的限制适配器到 decorator 模式，是一个小的飞跃，在 decorator 模式中，代理用额外的功能（例如安全检测或日志记录）包装调用。清单 6 显示了一个日志 invocationhandler，它在调用目标对象上的方法之外，还写入一条日志信息，显示被调用的方法、传递的参数，以及返回值。除了反射性的 invoke() 调用之外，这里的全部代码只是生成调试信息的一部分 ?d?d 还不是太多。代理工厂方法的代码几乎与 genericproxyfactory 相同，区别在于它使用的是 logginginvocationhandler 而不是匿名的调用句柄。
　　
　　清单 6. 基于代理的 decorator，为每个方法调用生成调试日志
　　
　　private static class logginginvocationhandler<t>
　　implements invocationhandler {
　　final t underlying;
　　
　　public logginghandler(t underlying) {
　　this