乐趣区

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

本文由老王出租房子引出——代理设计模式,将从最简略的动态代理实现开始,后延长应用 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 动静代理中的应用。

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

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

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

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

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

退出移动版