一、概述
代理模式是指客户端并不直接调用实际的对象，而是通过调用代理，来间接的调用实际的对象。 其特征是代理类与委托类有同样的接口，真正的核心业务逻辑还是在实际对象里面。
二、为什么要使用代理模式
- 当客户端不想直接调用实际对象，或是客户端直接调用实际对象有困难。
- 比如：想在实际对象的业务方法执行前或执行后额外处理一些事情。但是又不能修改原来的实际对象的方法，这时候也可以用代理模式。
三、代理模式的分类
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方法。