java常用设计模式八：代理模式
一、概述
代理模式是指客户端并不直接调用实际的对象，而是通过调用代理，来间接的调用实际的对象。 其特征是代理类与委托类有同样的接口，真正的核心业务逻辑还是在实际对象里面。
二、为什么要使用代理模式
- 当客户端不想直接调用实际对象，或是客户端直接调用实际对象有困难。
- 比如：想在实际对象的业务方法执行前或执行后额外处理一些事情。但是又不能修改原来的实际对象的方法，这时候也可以用代理模式。
三、代理模式的分类
1、静态代理（在程序运行前，代理类的.class文件已经存在，所以称为静态代理）
1）原业务接口
public interface SourceObject { void operation(); }
2）原业务接口的实现类
public class SourceObjectImpl implements SourceObject { public void operation() { System.out.println("这是原业务核心方法"); } }
3）静态代理类
public class StaticProxy implements SourceObject { private SourceObjectImpl srcObj; public StaticProxy(SourceObjectImpl srcObj){ this.srcObj = srcObj; } public void operation() { System.out.println("原业务方法执行前：记录处理中日志"); srcObj.operation(); System.out.println("原业务方法执行前：记录完成日志"); } }
public class StaticProxy implements SourceObject { private SourceObject srcObj; public StaticProxy(SourceObject srcObj){ this.srcObj = srcObj; } public void operation() { System.out.println("原业务方法执行前：记录处理中日志"); srcObj.operation(); System.out.println("原业务方法执行前：记录完成日志"); } }
4）测试类
public class Client { public static void main(String[] args){ SourceObject srcObj = new SourceObjectImpl(); StaticProxy staticProxy = new StaticProxy(srcObj); staticProxy.operation(); } }
原业务方法执行前：记录处理中日志
这是原业务核心方法
原业务方法执行前：记录完成日志
由以上的结构可知：每个接口（SourceObject）有一个与之对应的代理类（StaticProxy），如果再有一个接口，那么就要同时新增一个代理类，这种情况在接口很多的时候，就会产生很多代理类。是否能只有一个代理类呢？当然是可以的，就是动态代理
2、动态代理（在程序运行前，代理类的.class文件不存在，是运行时序由Java反射机制动态生成）
动态代理主要是借助 类Proxy、接口InvocationHandler 来实现的。下面以一个具体的例子来说明 动态代理的过程
1）原业务接口
public interface SourceObject { void operation(); }
2）原业务接口的实现类
public class SourceObjectImpl implements SourceObject { public void operation() { System.out.println("这是原业务核心方法"); } }
3）新建动态代理类处理器（注意，该类并不是SourceObject的代理类，它并没有实现于接口SourceObject，因此它不能调用operation()方法，这是与静态代理 最大的不同之处，代理类是程序运行的时候才动态产生的。）
public class DynamicProxyHandler implements InvocationHandler { private Object srcObj;//被代理的实际对象，定义为Object类型表明，可以是任意对象 /** * 该方法负责动态创建代理类，并返回代理类的实例,这个实例的类继承于java.lang.reflect.Proxy，还实现了传入进来的srcObject的原业务接口。 * * @param srcObj * @return */ public Object getProxyInstance(Object srcObj) { this.srcObj = srcObj; return Proxy.newProxyInstance(srcObj.getClass().getClassLoader(), srcObj.getClass().getInterfaces(), this); } /** * 注意：客户端不会真正的显示调用该方法，当通过getProxyInstance取得的实例执行真正的方法时，该方法会执行。 * * @param proxy 参数传递的是动态生成的代理类的实例,本方法并没有使用它 * @param method 是调用的方法，即需要执行的方法 * @param args 是执行方法的参数 * @return * @throws Throwable */ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("原业务方法执行前：记录处理中日志"); System.out.println("invoke 方法的第一个参数proxy 的类是：" + proxy.getClass().toString()); method.invoke(srcObj, args); System.out.println("原业务方法执行前：记录完成日志"); return null; } }
4）测试类
public class Client { public static void main(String[] args){ SourceObject srcObj = new SourceObjectImpl(); DynamicProxyHandler dynamicProxyHandler = new DynamicProxyHandler(); //为什么这里可以用SourceObject来接收getProxyInstance返回的实例呢？从后面的结果可知道动态产生的代理类实质上是继承于Proxy类，并实现于SourceObject SourceObject dynamicProxyInstance = (SourceObject)dynamicProxyHandler.getProxyInstance(srcObj); System.out.println("dynamicProxyInstance 的类是：================="+dynamicProxyInstance.getClass().toString()); System.out.println("dynamicProxyInstance 的父类是：==============="+dynamicProxyInstance.getClass().getSuperclass()); System.out.println("dynamicProxyInstance 实现的接口如下：==========="); Class<?>[] interfaces=dynamicProxyInstance.getClass().getInterfaces(); for(Class<?> i:interfaces){ System.out.println(i.getName()); } System.out.println("dynamicProxyInstance 的方法有：==============="); Method[] method=dynamicProxyInstance.getClass().getDeclaredMethods(); for(Method m:method){ System.out.println(m.getName()); } //执行真正的核心业务方法 System.out.println("dynamicProxyInstance 执行原业务方法：==============="); dynamicProxyInstance.operation(); //以下的代码是将动态生成的代理类保存到target的classes里面，便于查看。 byte[] bts = ProxyGenerator.generateProxyClass("$Proxy0", interfaces); FileOutputStream fos = null; try { fos = new FileOutputStream(new File("target/classes/proxy/demo/$Proxy0.class")); fos.write(bts); fos.flush(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } }
dynamicProxyInstance 的类是：=================class com.sun.proxy.$Proxy0 dynamicProxyInstance 的父类是：===============class java.lang.reflect.Proxy dynamicProxyInstance 实现的接口如下：=========== proxy.demo.SourceObject dynamicProxyInstance 的方法有：=============== equals toString hashCode operation dynamicProxyInstance 执行原业务方法：=============== 原业务方法执行前：记录处理中日志 invoke 方法的第一个参数proxy 的类是：class com.sun.proxy.$Proxy0 这是原业务核心方法 原业务方法执行前：记录完成日志
由以上结果可知：程序运行时动态生成了一个代理类com.sun.proxy.$Proxy0，它的父类是Proxy，并且还实现了接口SourceObject。这个代理类是由Proxy的 newProxyInstance 方法生成的。生成的代理类的源代码如下：
// // Source code recreated from a .class file by IntelliJ IDEA // (powered by Fernflower decompiler) // import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.lang.reflect.UndeclaredThrowableException; import proxy.demo.SourceObject; public final class $Proxy0 extends Proxy implements SourceObject { private static Method m1; private static Method m3; private static Method m2; private static Method m0; public $Proxy0(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("proxy.demo.SourceObject").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()); } } }
当调用 dynamicProxyInstance.operation() 的时候，实质上就是调用了以上生成的代理类中红色标注的方法。
super.h.invoke(this, m3, (Object[])null);
super就是指父类Proxy，h就是指InvocationHandler的实例，这里应该是传入的子类DynamicProxyHandler 的实例，所以h.invoke方法，就是执行DynamicProxyHandler的invoke方法。
