设计模式-动态代理

一、说明

代理模式（百度百科）：

为其他对象提供一种代理以控制对这个对象的访问。
在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

二、组成

抽象角色（subject）:通过接口、抽象类声明真是角色需要的业务方法。
代理角色（Proxy）代理真实角色操作。
真实角色（RealSubject）：实现抽象角色，定义真实角色需要的业务逻辑。

三、类图

代理模式.png

四、优缺点

优点：

和静态代理相比，不需要创建多个实现类来维护，更灵活。

五、使用场景

Retrofit类似框架，直接代理接口，而不需要实现类。

六、代码举例

（1）subject 抽象接口

/**
 * 接口类
 */
public interface ISaleCarInterface {
    //卖车
    void saleCar();
}

(2) RealSubject 宝马汽车厂


/**
 * 被代理人：宝马汽车厂
 */
public class BMW implements ISaleCarInterface{

    /**
     * 汽车厂商自己卖车需要的手续
     */
    @Override
    public void saleCar() {
        System.out.println("----宝马厂：收钱----");
        System.out.println("----宝马厂：签合同----");
        System.out.println("----宝马厂：交车----");

    }
}

(3) proxy 代理商：4s店，此时动态代理是没有具体实现的，因为他是在运行时由程序动态创建的。

创建过程：

1、Proxy.newProxyInstance()工具类动态创建代理类的proxy0.class文件。放在com.sun.proxy包下。
2、执行方法时，相当于调用这个动态生成的proxy0.class的方法。


/**
 * 统一调用处理类：
 */
public class DynamicProxyHandler implements InvocationHandler {
    //真实被代理人对象
    private Object subject;

    public DynamicProxyHandler(Object subject) {
        this.subject = subject;
    }


    /**
     * 这个调度方法，是在proxy0.class字节码文件的方法里会调用。
     * 这个就是通过反射来接收到proxy0.class的调用。
     *
     * @param proxy：Proxy 代理人对象
     * @param method：被代理人的方法名。宝马厂的方法。
     * @param args：被代理人的参数，宝马厂方法的参数。
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("subject= " + subject.getClass() + "; proxy=   " + proxy.getClass() + ";  method=   " + method + ";  args=   " + args);

        //1、代理人自己的处理
        GregorianCalendar calendar = new GregorianCalendar();
        int hour = calendar.get(Calendar.HOUR_OF_DAY);

        if (hour < 9 || hour > 18) {
            System.out.println("====4s店：下班了，明天再来吧！====" + hour);
            return null;
        }
        System.out.println("====动态代理处理：4s店收费，并收取佣金。。。====");


        //2、反射方式调用被代理人方法
        Object invoke = method.invoke(subject, args);


        //3、代理人最后还可添加自己的处理
        System.out.println("====动态代理处理：4s店推销保险，并交车！。。。====");
        return invoke;
    }
}

(4) 客户端测试类

public class Test {

    public static void main(String[] args) {
        //这一句是生成代理类的class文件，前提是你需要在工程根目录下创建com/sun/proxy目录，不然会报找不到路径的io异常
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");

        //动态代理模式
        //1、创建需要被代理的类
        BMW bmw = new BMW();
        //2、获得加载被代理类的 类加载器
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        //3、指明被代理类实现的接口
        Class<?>[] interfaces = bmw.getClass().getInterfaces();
        //4、将被代理人对象传入，创建被代理类的委托类,之后想要调用被代理类的方法时，都会委托给这个类的invoke(Object proxy, Method method, Object[] args)方法
        DynamicProxyHandler h = new DynamicProxyHandler(bmw);
        //5、生成代理类
        ISaleCarInterface dynamicProxy = (ISaleCarInterface) Proxy.newProxyInstance(loader,interfaces,h);
        //6、调用代理类方法。
        dynamicProxy.saleCar();
    }
}

（5）动态生成的proxy0.class字节码文件


/**
 * 这就是动态生成的代理类
 */
public final class $Proxy0 extends Proxy implements ISaleCarInterface {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    /**
     * 这个就是实现的我们卖车接口方法了。
     */
    public final void saleCar() throws  {
        try {
            //super.h 就是我们的DynamicProxyHandler自定义处理器。
            //就是调用我们自定义的那个invoke方法。从而实现m3方法的调用。这里的m3Method代表就是saleCar()方法。
            //如果还有其他接口方法。比如 buyCar()，那么就会有一个m4对应buyCar()。这个就是一对一的。
            super.h.invoke(this, m3, (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"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.crm.web.controller.ISaleCarInterface").getMethod("saleCar");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }

    /**
     * 系统Object默认需要实现的方法
     */
    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);
        }
    }

    /**
     * 系统Object默认需要实现的方法
     */
    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);
        }
    }
    /**
     * 系统Object默认需要实现的方法
     */
    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);
        }
    }
}

说明：

其实动态代理模式顾名思义，它确实是动态生成一个代理类的字节码文件，并在其中实现好我们声明的接口。
而在调用时使用反射机制，Method.invoke()来实现不同方法的调用。

Retrofit

非常巧妙的利用了动态代理的这个特性。

每个代理后的接口调用都会走invoke()方法，所以retrofit在invoke方法中，获取接口方法上的注解以及参数，来组成Request请求体，然后交给okhttpClient发起网络请求。