设计模式之代理模式

代理模式有静态代理和动态代理

静态代理：提到代理，我们首先想到的就是代理商了，代理商就是替厂家卖产品，这里有三个关键的地方，第一点，卖产品的行为是代理商做的（至少对于消费者来说，消费者接触的就是代理商）；第二产品是厂家的（也就是说代理商卖的商品是厂家的，而代理商是没有产品的，从这点来说实质上还是厂家再卖产品）。

回到我们的静态代理上，静态代理有三个角色，委托类（相当于厂家），代理类（相当于代理商），委托类需要实现的接口（产品，只是产品将厂家和代理商联系了起来，同样也是接口将委托类和代理类联系起来了）。了解了这些，静态代理地UML图为：

 1.RealSubject是委托类，Proxy是代理类

2.Subject是委托类和代理类实现的接口

3.request（）是委托类和代理类的共同方法，相当于卖产品这种行为。

 具体代码如下：

//接口
interface Subject {
    void request();
}

//委托类
class RealSubject implements Subject {
    
    public void request(){
        System.out.println("RealSubject");
    }
}

//代理类
class Proxy implements Subject {
    private Subject subject;
   //代理的行为（方法） 
    public Proxy(Subject subject){
        this.subject = subject;
    }
    public void request(){
        System.out.println("begin");
        subject.request();
        System.out.println("end");
    }
}

//测试类
public class ProxyTest {
    public static void main(String args[]) {
        RealSubject subject = new RealSubject();
        Proxy p = new Proxy(subject);
        p.request();
    }
}    

静态代理实现中，代理类在编译期间就已经确定（程序员直接写了出来）。

动态代理：

代理对象如何产生？

（代理对象的）方法执行过程（如何进行代理的）？进去再出来机制，进去就是利用接口给类传参数来产生需要的代理类，出来就是通过接口，代理类执行自己写的方法。

主要体现在Proxy类中产生代理类的静态方法public static Object getInstance(Class[] interfac,MethodHandler h)

出来时,代理类中，在代理方法中通过MethodHandler变量h ，调用h.invoke(this,Method m)；这时方法便执行实现了（自己写的）MethodHandler类的invoke（Object，Method）方法，在MethodHandler类中，我们实现插入的逻辑。

动态代理中，代理类并不是在Java代码中实现，而是在运行时期生成，相比静态代理，动态代理可以代理任何类所实现的接口的任何方法，进行任意的处理。例如：可以代理所有的类而不用像静态代理那样为每个类生成一个代理类，而是动态生成代理类。修改代理的逻辑时（如将时间代理换成日志代理）而不同修改代理类的逻辑，也就是说更加灵活。动态代理更加灵活，代码重用性好，模块化，低内聚。

接下来，用具体类分析：

1.定义委托类实现的接口（接口中的方法也就是要代理的方法）和委托类

package dynamic_proxy2;

public interface Service {
    public void add();
}

package dynamic_proxy2;

public class UserServiceImpl implements Service{
    public void add(){
        System.out.println("this is an add()");
    }
    
}

2.利用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口生成代理

package dynamic_proxy2;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class MyInvocationHandler implements InvocationHandler{
    private Object target;//委托对象
    
    public MyInvocationHandler(Object target){
        this.target = target;
    }
    
    /**
     * 此方法由生成的代理类调用，并生成调用方法的方法对象，并传入到此方法，此后在此方法中由原生类进行反射调用
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("add() begin");
        Object result = method.invoke(target,args);//反射
        System.out.println("add() end");
        return result;
    }
    
    public Object getProxy(){
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        Class<?>[] interfaces = target.getClass().getInterfaces();
        
        /**
         * classLoader:用ContextClassLoader进行对代理类进行加载
         * interfaces:原生类实现的接口
         * this:实现了InvocationHandler接口的MyInvocationHandler(自己写的),
         * 这个对象对传入到代理类的InvocationHandler变量中
         */
        return Proxy.newProxyInstance(classLoader, interfaces, this);
    }

}

3.使用动态代理：

package dynamic_proxy2;

public class ProxyTest {

    public static void main(String[] args) {
        Service service = new UserServiceImpl();//原生类
        
        MyInvocationHandler handler = new MyInvocationHandler(service);
        Service serviceproxy = (Service) handler.getProxy();//获得代理对象
        
        /**
         * 生成add()对象 m，并调用InvocationHandler变量的invoke(this,m)
         */
        serviceproxy.add();
    }

}

　　以上的这些也就是程序员需要编写的，动态代理的核心Proxy类和InvocationHandler接口已经由JDK实现了。

接下来看看运行结果

add() begin
this is an add()
add() end

然后我们借用这个例子再具体说说，动态代理的特点与好处：

1.若我们想对任何的类进行代理，我们只要创建这个类即可，然后生成该类的对象作为参数传给实现了InvocationHandler接口的MyInvocationHandler类的构造器方法。

2.若我们相对委托类进行任何的处理只需在MyInvocationHandler类中的invoke方法（此方法即是实现的InvocationHandler的方法）中写入处理代码。

了解了这些后，我们就该谈谈代理类是如何产生的？以及代理类如何进行代理的？

首先，我们来谈谈代理类的产生，代理类（对象）的生成过程是由Proxy类的newProxyInstance方法实现，分为三个步骤：

1.ProxyGenerator.generateProxyClass方法负责生成代理类的字节码，在我的模拟JDK动态代理实现中，是生成代理类源码,这个代理类源码由委托类实现的接口，类加载器组装而成。

2.native方法Proxy.defineClass0负责字节码的加载，并返回对应的Class对象。在模拟实验中，是利用Java提供的编译器，加载器，对代理类进行编译和加载。

3.利用反射机制生成代理类的对象。在模拟实验中，通过反射机制，得到带有委托类实现接口参数的构造器对象，并利用这个对象生成代理类的对象。代码如：

//ul为类加载器，方法里的参数为生成的代理类的源码
Class c = ul.loadClass("com.bjsxt.proxy.TankTimeProxy");
//Moveable为委托类，代理类实现的接口        
Constructor ctr = c.getConstructor(Moveable.class);
//得到代理类的对象
Moveable m = (Moveable)ctr.newInstance(new Tank());

通过反编译得到代理类的源码：

public final class $proxy1 extends Proxy implements Service {

    public $proxy1(InvocationHandler invocationhandler) {
        super(invocationhandler);
    }

    public final boolean equals(Object obj) {
        try {
            return ((Boolean)super.h.invoke(this, m1, new Object[] {
                obj
            })).booleanValue();
        }
        catch(Error _ex) { }
        catch(Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public final String toString() {
        try {
            return (String)super.h.invoke(this, m2, null);
        }
        catch(Error _ex) { }
        catch(Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public final void add() {
        try {
            super.h.invoke(this, m3, null);
            return;
        }
        catch(Error _ex) { }
        catch(Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public final int hashCode() {
        try {
            return ((Integer)super.h.invoke(this, m0, null)).intValue();
        }
        catch(Error _ex) { }
        catch(Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {
                Class.forName("java.lang.Object")
            });
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m3 = Class.forName("zzzzzz.Service").getMethod("add", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        }
        catch(NoSuchMethodException nosuchmethodexception) {
            throw new NoSuchMethodError(nosuchmethodexception.getMessage());
        }
        catch(ClassNotFoundException classnotfoundexception) {
            throw new NoClassDefFoundError(classnotfoundexception.getMessage());
        }
    }
}

根据我们前面的分析，生成的代理类中应该有InvocationHandler变量，实现了代理方法会调用子类（也就是我们实现InvocationHandler接口的类）的invoke方法。

而从上面的代码中并没有发现有InvocationHandler变量，但是它（生成的代理类）继承自Proxy类，接下来看一下Proxy类

public class Proxy implements java.io.Serializable {

    private static final long serialVersionUID = -2222568056686623797L;

    /** parameter types of a proxy class constructor */
    private static final Class<?>[] constructorParams =
        { InvocationHandler.class };

    /**
     * a cache of proxy classes
     */
    private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

    /**
     * the invocation handler for this proxy instance.
     * @serial
     */
    protected InvocationHandler h;

在代码的最后，我们发现了InvocationHandler变量h。由此代理方法的整个调用过程就是，

1，代理类调用代理方法，在代理方法内，得到该方法对象，

2，调用InvocationHandler变量h的invoke方法，传入代理类，代理方法对象，代理方法参数，

 此时h引用的是我们实现InvocationHandler接口的子类，这步操作是在zileidegetProxy（）方法里

public Object getProxy(){
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        Class<?>[] interfaces = target.getClass().getInterfaces();
        
        /**
         * classLoader:用ContextClassLoader进行对代理类进行加载
         * interfaces:原生类实现的接口
         * this:实现了InvocationHandler接口的MyInvocationHandler(自己写的),
         * 这个对象对传入到代理类的InvocationHandler变量中
         */
        return Proxy.newProxyInstance(classLoader, interfaces, this);
    }

super.h.invoke(this, m3, null);

JDK动态代理的局限性
通过反射类Proxy和InvocationHandler接口实现的动态代理，要求委托类必须实现一个接口，但事实上并不是所有类都有接口，对于没有实现接口的类

 便无法使用这种方式实现动态代理。而且就算实现了接口也只能代理实现了接口的方法，委托类原有的类仍然不能被代理。

参考：https://www.jianshu.com/p/a1d094fc6c00