代理设计模式

1、 什么是代理设计模式

即Proxy Pattern，23种常用的面向对象软件的设计模式之一。为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象或者为了某种简洁方便，而代理对象可以在客户端和目标对象之间起到中介的作用。

生活中我们处处会见到代理，比如抢票软件、各种中介（卖房子的、租房的、婚介等）还有代理服务器，这写其实和我们今天说的代理设计模式原理是一样的，中介帮我们中很多事，让我们省心、省事，只要把我们要做的是委托给代理就ok了，中介当然要费用或者好处了。。一些代理或者说中介可能会做一些我们不知道的事，比如偷工减料、增加我们不想要的或者价值很低的东西等等，同理代理设计模式也会有这种问题。

2、 什么时候使用代理设计模式及好处

好处：①职责清晰：被代理对象只用关注自己的业务逻辑，不用关心与其他模块或者调用者的交互，具体交互交由代理对象实现，这样编程比较清晰，而且符合生活场景

② 降低系统耦合以及符合开闭原则：代理对象可以在客户端和目标对象之间起到中介的作用，这样就可以保护目标对象。

③高扩展性

缺点：①可能增加复杂度②可靠性可能降低，毕竟代理对象可以在代理的时候增加一些“暗箱操作”，这就需要代理对象公开透明其操作

使用场景：

远程代理，为一个对象在不同的地址空间提供局部代表，这样就可以隐藏一个对象存在于不同地址空间的事实。 虚拟代理，是根据需要创建开销很大的对象。通过它来存放实例化需要很长时间的真是对象。 安全代理，用来控制真实对象访问时的权限。 智能指引，是指当调用真是的对象时，代理处理另外的一些事情。

3、 代理设计模式的JAVA实现

代理设计模式结构实现一般包含两个对象一个接口①真正要访问的对象（目标对象）②代理对象③代理对象和目标对象之间共同实现的接口；代理对象是作为直接被client调用的对象，而其真正调用则是目标对象，其关系如下图：

image

   静态代理：代理对象是由程序猿创建的，而且一个Proxy一般就只能代理一类目标对象（实现共同Subject接口），相当于代理类和被代理类关系提前要确定。

动态代理：在实现阶段不用关心代理类的具体实现，而是在运行时才生成代理对象（JAVA中是通过反射实现，具体见下文）平台或者三方库有提供。动态代理的扩展性更高，所以一般一些开源框架都会使用。知道概念及大概原理代码实现就是轻轻松松的事了，一下是动态代理和静态代理JAVA实现的简单demo

1、静态代理代码实现：

代理接口

interface Subject {
    void doAction();
}

目标对象

class RealASubject implements Subject{
    @Override
    public void doAction() {
        System.out.println("this is realASubject");
    }
}
class RealBSubject implements Subject{
    @Override
    public void doAction() {
        System.out.println("this is realBSubject");
    }
}

代理对象

class ProxySubject implements Subject {
    public Subject subject;
    public ProxySubject (Subject subject) {//也可以通过set方法设置subject
        this.subject = subject;
    }
    @Override
    public void doAction() {
        //subject的doAction调用之前，可以做很多之前操作
        before();
        subject.doAction();
        after();//被代理对象执行之后处理代码
    }

    public void before(){
        System.out.println("this is execute before subject");
    }
    public void after() {
        System.out.println("this is execute after subject");
    }
}

client代码及结果

public static void main(String[] args) {
        Subject proxySubject = new ProxySubject(new RealASubject());
        proxySubject.doAction();
    }
this is execute before subject
this is realASubject
this is execute after subject

2、动态代理代码实现及原理：

动态代理可以通过JDK和CGLib（一个开源工具，spring 和hibernate已经广泛使用）两种方式实现。JDK动态代理只能对实现了接口的类生成代理，而不能针对类 ；CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法 ，因为是继承，所以该类或方法最好不要声明成final 。CGLib暂时没研究，听过性能比JDK实现要好，等有时间做一个对比研究。

动态代理类及其方法

class DynamicProxy implements InvocationHandler {
    public Object mTarget = null;

    public Object bind(Object obj) {
        this.mTarget = obj;
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),obj.getClass().getInterfaces(),this);
    }
    @Override
    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
        before();
        Object obj = method.invoke(mTarget, objects);
        after();
        return obj;
    }
    public void before(){
        System.out.println("this is execute before subject for DynamicProxy");
    }
    public void after() {
        System.out.println("this is execute after subject for DynamicProxy");
    }
}

客户端代码及结果

public static void main(String[] args) {
        DynamicProxy dynamicProxy = new DynamicProxy();
        Subject sub = (Subject) dynamicProxy.bind(new RealBSubject());
        sub.doAction();
    }
this is execute before subject for DynamicProxy
this is realBSubject
this is execute after subject for DynamicProxy

动态代理实现更具扩展性，并且一个代理类可以代理很多subject，使用时注意==①最后方法的调用一定要转为接口，使用Subject.doAction()②method.invoke(mTarget,objects)的调用一定是在InvocationHandler或者子类的invoke方法中。动态代理实现是通过反射机制实现的，具体原理继续下看---》》》》

动态代理原理：

可能爱思考的你可能会问，为什么动态代理只能对实现了接口的类生成代理？答案：

因为在动态代理过程中，会生成对应的代理类形如$Proxy0,$Proxy1....这样的匿名类，这些类都是继承java.lang.reflect.Proxy类和实现了我们传入的接口，形如:public final class $Proxy0 extends Proxy implements Subject .所以，通过Proxy.newProxyInstance方法返回的就是这个匿名类的实例。通常就通过强制转换成指定接口，最后就可以调用方法了。【java中不能多重继承，当代理匿名类实现了jdk中的Proxy.class类的时候，就只能通过实现目标接口的方式来实现拓展】

Proxy.newProxyInstance()方法是动态代理人口，newProxyInstance方法会传入类装载器，InvocationHandler对象以及接口以便反射的时候使用。根据类加载器和目标接口类获取代理类Class对象：这部分也是代理类的核心，因为这方法里面包含了代理类的动态创建过程。会生成一个形如$Proxy0...之类的动态代理类，然后JVM会加载这些字节类，得到对应的Class对象，进行缓存。由于篇幅的原因newProxyInstance方法的源码以及其调用的getProxyClass0进行代理类字节码对象生成方法的源码就不粘贴了有兴趣的同学可以自己看下源码。这里提供一个文章，对动态代理分析的比较好动态代理原理分析 文章中介绍：代码中设置：System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true")，会在项目根目录生成class字节文件，通过反编译可以看到生成的代理对象的，对象中有对应方法和接口中定义的方法名以及参数相同如下：

public final class $Proxy0 extends Proxy implements Subject {
    private static Method m1;
    private static Method m3;
    private static Method m0;
    private static Method m2;

    //这就是为什么需要将InvocationHandler.class出入构造器来查找构造器实例的原理
    public $Proxy0(InvocationHandler paramInvocationHandler) throws {
        super(paramInvocationHandler);
    }

    public final boolean equals(Object paramObject) throws {
        try {
            return ((Boolean) this.h.invoke(this, m1, new Object[]{paramObject})).booleanValue();
        } catch (Error | RuntimeException localError) {
            throw localError;
        } catch (Throwable localThrowable) {
            throw new UndeclaredThrowableException(localThrowable);
        }
    }

    //这个是我们要调用的目标类中方法
    public final void doAction() throws {
        try {
            //实际上可以看到，是调用了我们自定义的InvocationHandler接口实现类的invoke方法。
            // m3这个Method对象，是通过反射获取
            this.h.invoke(this, m3, null);
            return;
        } catch (Error | RuntimeException localError) {
            throw localError;
        } catch (Throwable localThrowable) {
            throw new UndeclaredThrowableException(localThrowable);
        }
    }

    public final int hashCode() throws {
        try {
            return ((Integer) this.h.invoke(this, m0, null)).intValue();
        } catch (Error | RuntimeException localError) {
            throw localError;
        } catch (Throwable localThrowable) {
            throw new UndeclaredThrowableException(localThrowable);
        }
    }

    public final String toString() throws {
        try {
            return (String) this.h.invoke(this, m2, null);
        } catch (Error | RuntimeException localError) {
            throw localError;
        } catch (Throwable localThrowable) {
            throw new UndeclaredThrowableException(localThrowable);
        }
    }

    //静态代码块，用于通过反射来初始化四个方法属性
    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m3 = Class.forName("proxy.Subject").getMethod("hello", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            return;
        } catch (NoSuchMethodException localNoSuchMethodException) {
            throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
        } catch (ClassNotFoundException localClassNotFoundException) {
            throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
        }
    }
}

看到这个亲们可能就恍然大悟了，，今天就先到这里吧、、!