代理是基本的设计模式之一,它是为了提供额外的或不同的操作,而插入的用来代替“实际”对象的对象。这些操作通常涉及与“实际”对象的通信,因此代理通常充当中间人的角色。
1 静态代理
代理这种设计模式其实很好理解,基本就是最简单的一个“组合”。
比如说下面这个例子,我们有 RealObject
这个类,本来可以直接调用 RealObject
类的 doSomething()
和 somethingElse()
方法。
但代理模式就非要把RealObject
类当成 SimpleProxy
类的一个成员字段放在 SimpleProxy
类里面。然后因为RealObject
类和 SimpleProxy
类都实现了Interface
这个接口,所以SimpleProxy
类里也有doSomething()
和somethingElse()
方法。而且 SimpleProxy
类里的 doSomething()
和somethingElse()
方法就是傻瓜式的调用 RealObject
类的doSomething()
和 somethingElse()
方法。
package com.test.class_obj;
interface Interface {
void doSomething();
void somethingElse(String arg);
}
class RealObject implements Interface {
public void doSomething() {
System.out.println("doSomething");
}
public void somethingElse(String arg) {
System.out.println("somethingElse " + arg);
}
}
class SimpleProxy implements Interface {
private Interface proxied;
public SimpleProxy(Interface proxied) {
this.proxied = proxied;
}
public void doSomething() {
System.out.println("SimpleProxy doSomething");
proxied.doSomething();
}
public void somethingElse(String arg) {
System.out.println("SimpleProxy somethingElse " + arg);
proxied.somethingElse(arg);
}
}
public class SimpleProxyDemo {
public static void consumer(Interface iface) {
iface.doSomething();
iface.somethingElse("bonobo");
}
public static void main(String[] args) {
consumer(new RealObject());
System.out.println("-----------------------");
consumer(new SimpleProxy(new RealObject()));
}
}
SimpleProxy 被插入到了“客户端”与 RealObject 之间,因此它会执行操作,然后调用 RealObject 上相同的方法。
在任何时刻,只要想将额外的操作从“实际”对象中分离到不同的地方,特别是希望能够很容易的做出修改,从 没有使用额外操作 转为 使用额外操作,或者反过来,代理就显得很有用(设计模式的关键就是封装修改)。
例如:如果想要跟踪对 RealObject 中的方法的调用,或者想要度量这些调用的开销,这些额外的操作时,因为这些额外操作而添加的代码不能合并到 RealObject 的代码中,使用代理便可以很容易的添加或移除它们。
代理类里能非常好地控制,辅助被代理类,甚至是增加额外的功能。而且一般来说代理类B和被代理A都会实现同样的接口,这样对用户端(就是上面例子里的Consumer类)的代码没有任何影响,耦合很低。
2 动态代理
Java 的动态代理可以动态地创建代理并动态地处理对所代理方法的调用。
package com.test.class_obj;
import java.lang.reflect.*;
class DynamicProxyHandler implements InvocationHandler {
private Object proxied;
public DynamicProxyHandler(Object proxied) {
this.proxied = proxied;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("**** proxy: " + proxy.getClass() +
", method: " + method + ", args: " + args);
if (args != null)
for (Object arg : args)
System.out.println(" " + arg);
return method.invoke(proxied, args);
}
}
class SimpleDynamicProxy {
public static void consumer(Interface iface) {
iface.doSomething();
iface.somethingElse("bonobo");
System.out.println("----------------------");
}
public static void main(String[] args) {
RealObject real = new RealObject();
consumer(real);
// 创建动态代理
Interface proxy = (Interface) Proxy.newProxyInstance(
// 类加载器(可以从已经被加载的对象中获取其类加载器)
Interface.class.getClassLoader(),
// 希望代理实现的接口列表
new Class[]{Interface.class},
// InvocationHandler 接口的一个实现
new DynamicProxyHandler(real));
consumer(proxy);
}
}
doSomething
somethingElse bonobo
----------------------
**** proxy: class com.test.class_obj.$Proxy0, method: public abstract void com.test.class_obj.Interface.doSomething(), args: null
doSomething
**** proxy: class com.test.class_obj.$Proxy0, method: public abstract void com.test.class_obj.Interface.somethingElse(java.lang.String), args: [Ljava.lang.Object;@4b67cf4d
bonobo
somethingElse bonobo
----------------------
Process finished with exit code 0
动态代理可以将所有调用重定向到调用处理器(DynamicProxyHandler
)。因此通常会向调用处理器的构造器传递一个“实际”对象的引用(real
),从而使得调用处理器在执行其中介任务(iface.doSomething();
)时,可以将请求转发(invoke()
)。
invoke()方法中传递进来了代理对象(Object proxy
),以防需要区分请求的来源。
在 invoke()内部,在代理上调用方法时需要格外当心,因为对接口的调用将被重定向为对代理的调用。
Method.invoke() 将请求转发给被代理的对象,并传入必要的参数。
newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
- 第一个ClassLoader是为了生成B类的Class对象。作用是根据一组类的字节码byte[]直接生成这个类的Class对象。
- 第二个参数是由委托类实现的接口的Class对象数组。主要是包含了最重要的代理类需要实现的接口方法的信息。
- 最后一个最重要的就是一个实现了 InvocationHandler接口 的对象。InvocationHandler接口在java.lang.reflect包里。最主要的就是定义了invoke( )方法。它就是假设在已经动态生成了最后的proxy代理对象,以及所有接口定义的方法Method对象以及方法的参数的情况下,定义我们要怎么调用这些方法的地方。
-
3 通过传递参数,过滤方法调用
package com.test.class_obj; import java.lang.reflect.*; class MethodSelector implements InvocationHandler { private Object proxied; public MethodSelector(Object proxied) { this.proxied = proxied; } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // 通过方法名来过滤方法的调用 if (method.getName().equals("interesting")) { System.out.println("----通过传入的参数来过滤方法的调用----"); System.out.println("Proxy detected the interesting method"); System.out.println("----------------------------------"); } return method.invoke(proxied, args); } } interface SomeMethods { void boring1(); void boring2(); void interesting(String arg); void boring3(); } class Implementation implements SomeMethods { public void boring1() { System.out.println("boring1"); } public void boring2() { System.out.println("boring2"); } public void interesting(String arg) { System.out.println("interesting " + arg); } public void boring3() { System.out.println("boring3"); } } class SelectingMethods { public static void main(String[] args) { SomeMethods proxy = (SomeMethods) Proxy.newProxyInstance( SomeMethods.class.getClassLoader(), new Class[]{SomeMethods.class}, new MethodSelector(new Implementation())); proxy.boring1(); proxy.boring2(); proxy.interesting("bonobo"); proxy.boring3(); } }
这里我们只是查看了方法名,其实还可以查看方法签名的其他方面,甚至可以搜索特定的参数值。
4 参考资料
1、《Java编程思想》
2、Java 动态代理作用是什么?
https://www.zhihu.com/question/207941073、Java JDK动态代理Proxy类的原理是什么?
https://www.zhihu.com/question/49337471?rf=49332059