Proxy----代理模式

1、代理模式：租房找中介

2、代理模式的作用：为其他对象提供一种代理以控制对这个对象的访问

3、代理模式涉及的角色

（1）抽象角色：声明这是对象和代理对象的共同接口（租房子：中介和房主都可以提供房子）

（2）代理角色：代理对象内部含有对真实对象的引用，从而可以操作真是对象。同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同事，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真是对象进行封装（房主可以为我们解决的事情，代理也可以完成）

（3）真是角色：代理角色所代表的真实对象，是我们最终要引用的对象

4、静态代理模式的模拟：真是角色必须事先已经存在，并将其作为代理对象的内部属性

（1）抽象角色：可以用接口/抽象类都可以：

//相当于房子
public abstract class Subject {
public abstract void request();
}

（2）真是角色：

//相当于房主
public class RealSubject extends Subject{
public void request() {
System.out.println("From realSubject");
}
}

（3）代理角色：

public class ProxySubject extends Subject{
private RealSubject realSubject;//代理角色内部引用的真是角色
public void request() {
this.beforeRequest();
if (null == realSubject) {
realSubject = new RealSubject();
}
realSubject.request();//真实角色所完成的事情
this.afterRequest();
}

//代理角色自己可以完成的其他事情：
private void beforeRequest()//真是角色操作之前所附加的操作
{
System.out.println("before requet");
}
private void afterRequest()//真是角色操作之后所附加的操作
{
System.out.println("after requet");
}
}

（4）测试：

Subject subject = new ProxySubject();

subject.request();

上述方法使用的是静态代理模式，其要求真是角色必须是事先已经存在的，并将其作为代理对的内部属性。但是实际使用时，一个真是角色必须对应一个代理角色。如果大量使用会导致类的急剧膨胀；如果我们事先并不知道真是角色，那么代理将无法完成。接下来我们看动态代理

5、动态代理

（1）动态代理Dynamic Proxy是这样的一个中的任何一个来用class：它是在运行时生成的class。在生成它时必须提供一组interface给他，然后该class就宣称它实现了这些interface。可以把该class的实例当作这些interface中任何一个来用（也就是说这个类的实例就是一个接口：多态 

public class Test implements A, B, C{

public static void main(String[] args) {
A a = new Test();
B b = new Test();
C c = new Test();
}

}//Test可以当做A、B、C中任何一个来用）这个Dynamic Proxy就是一个Proxy，还不会替我们做实质性的工作，在使用他的实例时我们必须提供一个handler，由它接管实际的工作

（2）动态代理模拟：要想使用动态代理必须实现InvocationHandler接口

（a）首先声明一个公共接口

public interface Subject {
public abstract void request();
}

（b）创建一个真是角色类实现公共接口

public class RealSubject implements Subject{
public void request() {
System.out.println("From realSubject");
}
}

（3）简历动态代理类，该类实现InvocationHandler接口

/**
 * 该代理类的内部属性是Object类型，实际使用的时候通过该类的构造方法传递进来一个对象。
 * 此类还实现了invoke方法，该方法中的method.invoke其实就是调用被代理对象的将要执行的方法，
 * invoke方法参数是sub，表示该方法从属于sub，通过动态代理类，我们可以在执行真是对象的方法前后加入自己的一些额外方法
 */

public class DynamicSubject implements InvocationHandler{
private Object sub;
public DynamicSubject(Object obj)
{
this.sub = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
//System.out.println("before calling:" + method);

method.invoke(sub, args);

//System.out.println("after calling:" + method);
return null;
}
}

（4）调用：

（a）首先创建一个真是角色的实例：

RealSubject realSub = new RealSubject();

（b）创建动态代理角色实例，并以InvocationHandler的对象来接收

InvocationHandler handler = new DynamicSubject(realSub);

（c）生成handler的Class对象：

Class<?> classType = handler.getClass();

（d）生成代理

Subject sub = (Subject) Proxy.newProxyInstance(classType.getClassLoader(), realSub.getClass().getInterfaces(), handler);

//参数意义详见JDK

注意：虽然我们是以Subject的对象sub来接收，但是，生成的实例既不是realSubject也不是DynamicSUbject实例（虽然他被强制转化为Subject类型），而是运行期间动态所生成的实例。也就是说sub是$Proxy0的实例：public class $Proxy0 implements Sbuject{}

（e）调用request方法：

sub.request()

总结：动态代理实现步骤：

1、创建一个实现InvocationHandler接口的类，它必须实现invoke方法

2、创建被代理的类以及接口

3、通过Proxy的静态方法newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)创建一个代理

4、通过代理调用方法