一 代理模式
定义：在拜访指标对象的时候，提供一种间接拜访的办法，通过代理对象去拜访指标对象，达到客户端的目标。
益处：爱护指标对象；在指标对象的行为根底上，代理对象能够减少本人的解决，使得同一个指标对象能够满足不同的客户端的目标。
代理模式的模型：
波及三个角色：
RealSubject：指标对象，也是真正要做事件的人。
Proxy：代理对象，持有对指标对象的援用，裸露给客户端，通过操作指标对象来实现客户端的目标。并且，代理对象能够在操作指标对象的前后做一些自定义的行为，灵便扩大了指标对象。
Subject：指标对象和代理对象的形象，以便在任何应用指标对象的中央都能够应用代理对象。Subject 能够是一个接口也能够是一个抽象类。
二 动态代理
以最简略的模式实现上述模型
public interface Subject {void doRequst();
}
public class RealSubject implements Subject {
@Override
public void doRequst() {System.out.println("it's the thing i really want to do");
}
}
public class Proxy implements Subject {
private Subject subject;
public Proxy(Subject subject){this.subject = subject;}
@Override
public void doRequst() {System.out.println("before do the real thing");
subject.doRequst();
System.out.println("after do the real thing");
}
}
public class Client {public static void main(String[] args) {Proxy proxy = new Proxy(new RealSubject());
proxy.doRequst();}
}
/**
before do the real thing
it's the thing i really want to do
after do the real thing
**/这种实现形式即常说的动态代理，有几个方面的束缚：
1 代理对象和指标对象须要实现独特的接口，接口有变动，指标对象和代理对象都须要保护。
2 想要代理其余的指标对象，须要新增代理类。
三 动静代理
先看 java 实现动静代理的几个次要角色
1 Proxy：java.lang.reflect.Proxy，jdk api 提供的代理类的主类，该类提供办法动静生成代理类，生成的时候须要指定一组接口（即代理类和指标对象要实现哪些接口）
public static Object newProxyInstance(ClassLoader var0, Class<?>[] var1, final InvocationHandler var2) throws IllegalArgumentException
/**
提供了这个静态方法用于动静生成代理类
var0: 指标对象的类加载器
var1: 代理类要实现哪些接口，即指标对象实现的接口
var2: 处理器，代理类具体要做什么写在处理器中
**/2 InvocationHandler：java.lang.reflect.InvocationHandler
/**
@param proxy the proxy instance that the method was invoked on
代理对象，执行 invoke 的时候其实是在替这个 proxy 执行
@param method the {@code Method} instance corresponding to
the interface method invoked on the proxy instance. The declaring
class of the {@code Method} object will be the interface that
the method was declared in, which may be a superinterface of the
proxy interface that the proxy class inherits the method through.
指标对象要执行的办法
@param args an array of objects containing the values of the
arguments passed in the method invocation on the proxy instance,
or {@code null} if interface method takes no arguments.
Arguments of primitive types are wrapped in instances of the
appropriate primitive wrapper class, such as
{@code java.lang.Integer} or {@code java.lang.Boolean}.
执行办法须要的参数
**/
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable
java 动静代理实例
public interface Subject {void doRequest();
}
public class RealSubject1 implements Subject {
@Override
public void doRequest() {System.out.println("RealSubject1 want to sing");
}
}
public class RealSubject2 implements Subject {
@Override
public void doRequest() {System.out.println("RealSubject2 want to dance");
}
}
public class RealInvocationHandler implements InvocationHandler {
private Object subject;
public RealInvocationHandler(Object subject){this.subject = subject;}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("before process");
Object result = method.invoke(subject,args);
System.out.println("after process");
return result;
}
}
public class Client {public static void main(String[] args) {Subject realSubject1 = new RealSubject1();
InvocationHandler handler1 = new RealInvocationHandler(realSubject1);
Subject subject1 = (Subject) Proxy.newProxyInstance(realSubject1.getClass().getClassLoader(),realSubject1.getClass().getInterfaces(),handler1);
subject1.doRequest();
System.out.println("-----------------------");
Subject realSubject2 = new RealSubject2();
InvocationHandler handler2 = new RealInvocationHandler(realSubject2);
Subject subject2 = (Subject)Proxy.newProxyInstance(realSubject2.getClass().getClassLoader(),realSubject2.getClass().getInterfaces(),handler2);
subject2.doRequest();}
}
/**
before process
RealSubject1 want to sing
after process
-----------------------
before process
RealSubject2 want to dance
after process
**/与动态代理做个比拟：
不须要挨个写代理类，想代理其余的，动静 new 一个代理类
相干源码解析
Proxy.newProxyInstance 生成的代理具备什么以及为什么能够转换成指标对象
protected InvocationHandler h;
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
// 校验 handler
if (h == null) {throw new NullPointerException();
}
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
/*
* Proxy 保护了一个 proxyClassCache，如果想要的代理类曾经有实现了指定接口的 loader 定义好了，间接返回 cache 的备份
* 否则，通过 ProxyClassFactory 生成一个代理类，实现指定的 intfs
*/
Class<?> cl = getProxyClass0(loader, intfs);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
// 获取构造函数，将传进来的 h 赋给 proxy 外部持有的 Invokerhanler 对象
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
// create proxy instance with doPrivilege as the proxy class may
// implement non-public interfaces that requires a special permission
return AccessController.doPrivileged(new PrivilegedAction<Object>() {public Object run() {return newInstance(cons, ih);
}
});
} else {return newInstance(cons, ih);
}
} catch (NoSuchMethodException e) {throw new InternalError(e.toString());
}
}所以，Proxy 生成的代理对象具备一个 invokehandler 对象的援用；并且实现了指标对象实现的接口，因为能够转换为指标对象的形象
InvokeHandler 为什么能够实现指标对象办法的执行
如上述例子中指标对象 RealSubject1 要执行 doRequest 办法，Proxy 生成的代理类也会实现这个办法，大略如下：
public final void doRequest()
{
// 这个会调用 invokehandler 的 invoke 办法，这里的 h 即是父类 Proxy 的 h，通过 newProxyInstance 传进来的
try {this.h.invoke(this, m3, null);
return;
} catch (RuntimeException localRuntimeException) {throw localRuntimeException;} catch (Throwable localThrowable) {throw new UndeclaredThrowableException(localThrowable);
}
}有了 InvocationHandler 能够使 Proxy 从具体的代码逻辑抽离进去，更不便对立的生成代理类。
后续 todo：
Proxy 生成的代理对象的具体分析
method.invoke 具体做了什么