关于设计模式:设计模式之代理模式

本文由老王出租房子引出——代理设计模式，将从最简略的动态代理实现开始，后延长应用jdk实现动静代理，最初扩大到Cglib实现动静代理。为了更深刻了解代理模式，咱们会对理论利用中的典型案例进行介绍，包含在Spring和Mybatis中的利用。

读者能够拉取残缺代码到本地进行学习，实现代码均测试通过后上传到码云。

一、引出问题

上篇文章老王和小王组装电脑尽管完满完结了，然而老王和小王的争吵却并没有完结。老王决定将小王扫地出门，并把小王住的房子出租，租金用来补救游戏本的花销。

老王破费很大的功夫，搞清楚了各种租房平台的规定并公布了房源信息，接着街坊揭示他：房子租出去并不代表躺着收租金了，有一天租客提出一些额定的要求，在合同容许的范畴内，你也要尽量满足他们（为了便于了解，事实当然不存在啦），房子租出去后物业有问题你还要和物业协调。

老王开始思考，如果我直租给租客，会面临两个问题：

①我须要理解租房的全过程，我本人的事和租房的事重大的耦合了。

②租客提出的一些要求我不得不染指到其中，我不得不扭转我本人的行程安顿。

我应该想到一种方法，

第一点，将业务和性能解耦，业务层专一业务，比方网络接口申请，业务层只须要晓得该调哪个接口申请办法，而不须要晓得这个接口申请是如何发动网络申请的。

第二点，创立一个切面，在这个切面中减少一些通用的附加操作，比方注解解析，日志上报等，防止这些通用操作在每个接口办法都要写一遍。

老王灵感一闪：我能够给我的房子找一个一个代理，以管制对这个房子的治理。即通过代理治理房子.这样做的益处是:能够在指标实现的根底上,加强额定的性能操作,即扩大指标的性能。

这实际上就是动态代理。

二、动态代理

代理模式：为一个对象提供一个替身，以管制对这个对象的拜访。即通过代理对象拜访指标对象.这样做的益处是:能够在指标对象实现的根底上,加强额定的性能操作,即扩大指标对象的性能。

也即在动态代理中应该有三个角色：

①代理对象，生产端通过它来拜访理论的对象（中介）

②理论被代理的对象（老王房子）

③一组能够被代理的行为的汇合，通常是一个接口（老王和中介之间的约定事件）

老王与中介的约定接口：

/** * 代理行为的汇合（接口） * @author tcy * @Date 02-08-2022 */public interface HostAgreement {    // 房子出租    void rent();}

理论对象类（老王）：

/** * 指标对象 * @author tcy * @Date 02-08-2022 */public class Host implements HostAgreement {    /**     * 指标对象的原始办法     */    @Override    public void rent() {        System.out.println(" 这个房子要出租...");    }}

代理类（中介）：

/** * 理论对象的代理 * @author tcy * @Date 02-08-2022 */public class HostProxy implements HostAgreement {    // 指标对象，通过接口来聚合    private HostAgreement target;    //结构器    public HostProxy(HostAgreement target) {        this.target = target;    }    @Override    public void rent() {        System.out.println("房子出租前，装修一下....");        target.rent();        System.out.println("房子出租后，与物业协调....");//办法    }}

客户类：

/** * @author tcy * @Date 02-08-2022 */public class Client {    public static void main(String[] args) {        //创立指标对象(被代理对象)        Host hostTarget = new Host();        //创立代理对象, 同时将被代理对象传递给代理对象        HostProxy hostProxy = new HostProxy(hostTarget);        //通过代理对象，调用到被代理对象的办法        hostProxy.rent();    }}

这样就很好的解决了老王想到的问题，老王称心如意的看着本人的成绩。

但中介看着老王的计划开始小声的嘀咕了，我一个人管那么多的房子，每一个房东都让我实现一个代理类，那我就会有很多的代理类，这是个问题呀！还有就是，有一天协定变动了，咱们俩都要做许多工作。

最好是不要让我实现咱们之间的协定（接口）了。

老王开始革新他的计划了。

三、动静代理Jdk

老王忽然想到，应用jdk的动静代理能够很好的解决这个问题。

Jdk代理对象的生成，是利用JDK的API，动静的在内存中构建代理对象动静代理，也叫做：JDK代理、接口代理。

咱们对代码进行革新。

指标对象和指标对象的协定放弃不变，咱们须要批改也就是中介（代理类）的代码。

代理类：

/** * 代理类 * @author tcy * @Date 02-08-2022 */public class HostProxy {    //保护一个指标对象 , Object    private Object target;    //结构器 ， 对target 进行初始化    public HostProxy(Object target) {        this.target = target;    }    //给指标对象 生成一个代理对象    public Object getProxyInstance() {        //阐明      /*       *  //1. ClassLoader loader ： 指定以后指标对象应用的类加载器, 获取加载器的办法固定            //2. Class<?>[] interfaces: 指标对象实现的接口类型，应用泛型办法确认类型            //3. InvocationHandler h : 事件解决，执行指标对象的办法时，会触发事件处理器办法, 会把以后执行的指标对象办法作为参数传入       */        return Proxy.newProxyInstance(target.getClass().getClassLoader(),                target.getClass().getInterfaces(),                new InvocationHandler() {                    /**                     * 该办法会调用指标对象的办法                     * @param proxy                     * @param method                     * @param args                     * @return                     * @throws Throwable                     */                    @Override                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                        System.out.println("房子出租前，装修一下....");                        //反射机制调用指标对象的办法                        Object returnVal = method.invoke(target, args);                        System.out.println("房子出租后，与物业协调....");                        return returnVal;                    }                });    }}

客户端：

/** * @author tcy * @Date 02-08-2022 */public class Client {    public static void main(String[] args) {        //创立指标对象        HostAgreement hostAgreement = new Host();        //给指标对象，创立代理对象, 能够转成 ITeacherDao        HostAgreement hostProxy = (HostAgreement)new HostProxy(hostAgreement).getProxyInstance();        // proxyInstance=class com.sun.proxy.$Proxy0 内存中动静生成了代理对象        //通过代理对象，调用指标对象的办法        hostProxy.rent();    }}

这样就很好的解决了中介实现协定（接口）的问题，无论房子怎么变动，中介都能很完满的实现代理。

中介想让老王给他讲讲，Proxy.newProxyInstance（）怎么就能完满的解决这个问题了。

老王撸起袖子开始给他讲实现原理。

在咱们用Proxy.newProxyInstance实现动静代理的时候，有三个参数，第一个便是classloader。

public static Object newProxyInstance(ClassLoader loader,                                      Class<?>[] interfaces,                                      InvocationHandler h)

在咱们的代码中classloader就是指标对象的类加载器。

第二个参数是指标对象实现的接口类型，应用泛型办法确认类型，咱们应用java的反射target.getClass().getInterfaces()获取到了接口类型。

第三个参数是实现InvocationHandler接口，并实现它惟一的办法invoke()，invoke其实就会执行咱们的指标办法，咱们就能够在invoke前后去做一些事。比方，房子出租前，装修一下或者房子出租后，与物业协调。

中介听完称心如意的来到了，老王总感觉哪里不对，中介都从协定中抽出来了，那我为什么还要被协定束缚着呢？我何不也从协定（接口）中抽离进去。

咱们查阅书籍感觉Cglib或者能帮到他。

四、动静代理Cglib

1、概念及实现

CGLIB是一个弱小的、高性能的代码生成库。采纳十分底层的字节码技术，对指定指标类生成一个子类，并对子类进行加强，其被广泛应用于AOP框架（Spring、dynaop）中，用以提供办法拦挡操作。

CGLIB代理次要通过对字节码的操作，为对象引入间接级别，以管制对象的拜访。咱们晓得Java中有一个动静代理也是做这个事件的，那咱们为什么不间接应用Java动静代理，而要应用CGLIB呢？答案是CGLIB相比于JDK动静代理更加弱小，JDK动静代理尽管简略易用，然而其有一个致命缺点是，只能对接口进行代理。如果要代理的类为一个一般类、没有接口，那么Java动静代理就没法应用了。

老王感觉这些概念都不说人话，不如老王间接着手革新我的项目。

CGLIB是一个第三方的类库，首先须要引入依赖。

<dependency>        <groupId>cglib</groupId>        <artifactId>cglib</artifactId>        <version>2.2.2</version></dependency>

当初只须要两个角色即可，代理类和指标类。

指标类：

/** * @author tcy * @Date 02-08-2022 */public class Host {    /**     * 租房办法     */    public void rent() {        System.out.println("这个房子要出租...");    }}

代理类：

/** * 代理类 * @author tcy * @Date 02-08-2022 */public class HostProxy implements MethodInterceptor {    //保护一个指标对象    private Object target;    //结构器，传入一个被代理的对象    public HostProxy(Object target) {        this.target = target;    }    //返回一个代理对象:  是 target 对象的代理对象    public Object getProxyInstance() {        //1. 创立一个工具类        Enhancer enhancer = new Enhancer();        //2. 设置父类        enhancer.setSuperclass(target.getClass());        //3. 设置回调函数        enhancer.setCallback(this);        //4. 创立子类对象，即代理对象        return enhancer.create();    }    @Override    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {        System.out.println("房子出租前，装修一下....");        Object returnVal = method.invoke(target, args);        System.out.println("房子出租后，与物业协调....");        return returnVal;    }}

客户类：

/** * @author tcy * @Date 02-08-2022 */public class Client {    public static void main(String[] args) {        //创立指标对象        Host HostTarget = new Host();        //获取到代理对象，并且将指标对象传递给代理对象        Host Hostproxy = (Host)new HostProxy(HostTarget).getProxyInstance();        //执行代理对象的办法，触发intecept 办法，从而实现 对指标对象的调用        Hostproxy.rent();    }}

当初不仅老王和中介都不须要实现接口了，而且完满的实现了他们之间的性能。

jdk和CGLIB实现动静代理的区别咱们比照一下：

2、JDK动静代理与CGLIB比照

JDK动静代理：基于Java反射机制实现，必须要实现了接口的业务类才生成代理对象。

CGLIB动静代理：基于ASM机制实现，通过生成业务类的子类作为代理类。

JDK Proxy的劣势：

最小化依赖关系、代码实现简略、简化开发和保护、JDK原生反对，比CGLIB更加牢靠，随JDK版本平滑降级。而字节码类库通常须要进行更新以保障在新版Java上可能应用。

基于CGLIB的劣势：

无需实现接口，达到代理类无侵入，只操作关怀的类，而不用为其余相干类减少工作量。高性能。

动态代理和JDK代理模式都要求指标对象是实现一个接口,然而有时候指标对象只是一个独自的对象,并没有实现任何的接口,这个时候可应用指标对象子类来实现代理-这就是Cglib。

为了让代理模式了解的更加粗浅，咱们来看代理模式在两个经典框架SpringAop和Mybtis中的利用。

五、典型利用

1、在SpringAop的使用

动静代理一个显著的作用就是，在不扭转指标对象的前提下，能加强指标对象的性能，这其实就是AOP的外围。

AOP（Aspect Oriented Programming）是基于切面编程的，可无侵入的在本来性能的切面层增加自定义代码，个别用于日志收集、权限认证等场景。

SpringAop同时实现了Jdk的动静代理和Cglib的动静代理。

使用动静代理间接作用到须要加强的办法下面，而不扭转咱们本来的业务代码。

2、在MyBatis的使用

在Mybitis实现的是Jdk的动静代理。

源码中有一个MapperProxyFactory类，其中有一个办法。

//构建handler的过程。protected T newInstance(MapperProxy<T> mapperProxy) {  //规范的类加载器，接口，以及invocationHandler接口实现。  return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);}

Proxy.newProxyInstance()正是咱们在Jdk动静代理中的应用。

联合典型利用，认真领会动静代理设计模式，参考软件设计七大准则在理论利用中更加灵便的应用，不生吞活剥。

为了丝毫退出老王的故事，举荐你看后面的三篇创立型设计模式，以做到丝滑入戏。

一、设计模式之工厂办法和形象工厂

二、设计模式之单例和原型

三、设计模式之建造者模式