漫谈设计模式(一):代理(Proxy)模式与适配器(Adapter)模式对比

代理模式和适配器模式有什么区别 (Proxy Pattern)和(Adapter Pattern)都是结构型设计模式,它们有不同的应用场景和目标,虽然在某些方面看起来相似,但它们的意图和实现方式有显著的区别。 阅读详情

1.前言

         为什么要将代理模式与适配器模式放在一起来说呢?因为它们有许多的共同点,当然也有一些不同的地方。首先两者都是属于结构型模式。结构型模型是这样定义的:

结构型模式涉及到如何组合类和类以获得更大的结构,结构型类模式采用继承机制来组合接口或实现。

     1)代理模式与适配器模式都分别有继承、接口方式实现的子分类模式。基于接口实现的代理模式称为静态代理模式、JDK(动态)代理模式,基于继承实现的代理模式称为Cglib(动态)代理模式。基于接口(同时含类继承)实现的适配器模式称为类适配器模式,(只)基于继承(使用委托)实现的适配器模式称为类适配器模式。

      2)代理模式是为其他类提供一种代理以控制对这个类的访问。我们不直接去接触目标类,而是直接操作代理类,代理类再去操作目标类。因为不直接接触目标类,因此我们可以在代理类的同名方法中添加或删除功能模块,而不用去修改目标类的原方法。

而适配器模式则主要是协调现实与需求的差异,减少对已有代码的改动,适配不同的接口、类类型。项目实施中可能会出现这样的情况:当前已完成的项目的某一个包内的各个类实现了一些特定的接口,而客户提出了新的需求,要求实现他所指定的那些接口(抛弃原有的方法或接口),但其业务细节却是相同、完全一样的。此时,我们可能并不想复制粘贴原代码到新的方法中去,这就需要将一个类的接口转换成新需求的另一个接口。

2.代理模式

1)静态代理

 静态代理,必须提供一(多)个公用的接口。目标类和代理类都要实现这个接口,外界调用代理类的(接口)方法,代理类的方法再去调用目标类(接口)的方法。

 定义一个公用的接口

    public static interface Human {
        void behave();
    }

实现接口的目标类

    public static class Student implements Human {
        String name;
        public Student() {
        }
        public Student(String name) {
            super();
            this.name = name;
        }
        @Override
        public void behave() {
            System.out.println(name + "上学去了");
        }
    }

实现接口的代理类

    public static  class StudentProxy implements Human{
        private Human target; // 目标类
        protected StudentProxy(Human target) {
            this.target = target;
        }

        @Override
        public void behave() {
            System.out.println("+++++++目标方法执行前打印加号+++++++");
            target.behave();
            System.out.println("*******目标方法执行后打印星号*******");
        }
    }

主方法测试

public static void main(String[] args) {
Human studentProxy=new StudentProxy(new Student("何峰"));
studentProxy.behave();
}

 控制台结果输出

2)JDK动态代理

JDK动态代理,主要是利用JDK提供的API动态生成代理类实例。

我们不需要去写一个具体代理类,只需要一个代理工厂即可,JDK的系统API将在运行时动态生成代理类的字节码,并此字节码将加载到JVM中,在JVM中直接构建代理类(不需要将class文件读取到内存中)。

要用到的JDK的API

(1)java.lang.reflect.Proxy工具类

我们主要会用到的静态方法   static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )  

这个静态方法将能够动态构建一个实现了和目标类相同的接口的代理类(具体实现的接口个数,此方法中的参数interfaces有关),此方法的三个参数分别是目标类的类加载器loader、目标类实现的接口数组interfaces、 InvocationHandler类handler。

(2)java.lang.reflect.InvocationHandler接口

 此接口只有一个抽象方法  public Object invoke(Object proxy, Method method, Object[] args)throws Throwable

这个抽象方法的三个参数分别表示代理类proxy, 目标类方法method,目标类方法的参数args。

这是一个回调方法,当我们调用代理类所实现的接口方法(和目标类相同的接口相同)时,java虚拟机会调用此方法。所以重写此方法非常重要,可以在此方法中添加我们所需要的增强效果。

实现细节

 先定义一个接口Human

    public static interface Human {
        void behave();
    }

 定义一个实现Human接口的目标类Student

 

    public static class Student implements Human {
        String name;
        public Student() {
        }
        public Student(String name) {
            super();
            this.name = name;
        }
        @Override
        public void behave() {
            System.out.println(name + "上学去了");
        }
    }

 

 定义动态代理的抽象工厂类

    // 继承InvocationHandler,但不实现其接口方法,接口方法的具体实现交给抽象工厂类的子类去完成
    public static abstract class ProxyFactory implements InvocationHandler {
        // 访问权限设置为保护级,其子类能继承到此成员变量
        protected Object target; // 目标类

        // 只有这一个单参数构造方法,访问权限同时也设为保护级,则子类必须显式调用此构造方法
        protected ProxyFactory(Object target) {
            super();
            this.target = target;
        }

        // 方法设为final,防止子类重写此方法
        public final Object getProxyInstance() {
            /*
             * Proxy.newProxyInstance方法的三个参数依次是目标类的类加载器loader、目标类实现的接口数组interfaces、
             * InvocationHandler类handler。
             *             InvocationHandler是个接口,而当前抽象类implements此接口,此处的抽象类并没有具体实现此接口,具体实现将交给子类
             */
            return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
        }
    }

定义抽象工厂类的子类(实现类)

    /**
     * 上小学的代理工厂类
     * @author Administrator
     */
    public static class PrimaryProxyFactory extends ProxyFactory {
        public PrimaryProxyFactory(Object target) {
            super(target);
        }

        /**
         * 实现InvocationHandler接口,增强目标类实现接口的方法
         */
        @Override
        public final Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("小学学校离家5km。");   //目标类方法执行前的修饰
            Object returnVal = method.invoke(this.target, args); //调用目标类的相应方法
            System.out.println("早上去上学费时30分钟。");//目标类方法执行后的修饰
            return returnVal;
        }
    }

    /**
     * 上高中的代理工厂类
     * @author Administrator
     *
     */
    public static class SeniorProxyFactory extends ProxyFactory {

        public SeniorProxyFactory(Object target) {
            super(target);
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("高中学校离家50km。");
            Object returnVal = method.invoke(this.target, args);
            System.out.println("去一次学校就要费时两个小时。");
            return returnVal;
        }
    }

 

 主方法内进行效果测试

    public static void main(String[] args) {
        Student stu = new Student("李高峰");
        //创建代理工厂类
        ProxyFactory primaryProxyFactory = new PrimaryProxyFactory(stu);
        //代理类向上转型为Human接口
        Human proxyPrimaryHuman = (Human) primaryProxyFactory.getProxyInstance();
        //代理类执行接口方法
        proxyPrimaryHuman.behave();

        System.out.println("");
        ProxyFactory seniorProxyFactory = new SeniorProxyFactory(stu);
        Human proxySeniorHuman = (Human) seniorProxyFactory.getProxyInstance();
        proxySeniorHuman.behave();
    }

 控制台效果输出

 

3)Cglib代理

       静态代理和JDK动态代理都必须要求目标类实现了一(多)个接口,而对未实现任何接口的目标类无法进代理处理。Cglig动态代理就是为了解决这一问题而产生的代理技术。它是在运行时,利用asm字节码框架,动态生成目标类的子类的字节码,并加载到java虚拟机中,运行期动态地创建目标类的子类类。Cglib代理需要外部框架支持,而spring-core-xxx.jar包中就含有Cglib所需的class文件。

使用Cglib代理有以下两点要求:

(1)目标类不能被定义为final。---------------------------   定义的final的类不能被继承扩展,当然就不可能创建出它的(代理类)子类

(2)目标类的方法不能为final或static修饰-------------    final方法不能被重写,(子类)代理类也就不能对此方法进行扩展。静态方法与类本身相关联,不依赖于实例类存在,无法实现多态。

Cglib代理的关键点:

(1)方法拦截器接口  org.springframework.cglib.proxy.MethodInterceptor

此接口中只有一个方法 public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable

此方法为回调方法,在运行期间此方法是将动态地生成代理类(子类)的代理方法(重写目标类的方法)。

此方法的四个参数分别是代理类类proxy、目标类方法类method、目标类方法的参数args、代理类的方法(spring框架中的数据类型,不同于JDK中的Method)类methodProxy。

(2)代理方法增强工具类  org.springframework.cglib.proxy.Enhancer

其方法一void  setSuperclass(Class  supperClass)设置目标类的Class模板类
其方法二void  setCallback(MethodInterceptor methodInterceptor)设置回调方法,其intercept(......)方法定义了代理类(即目标类的子类)的方法重写规范
其方法三  Object  create()创建并返回代理类类 

实现过程                             

未实现任何接口的目标类

 

  public static class Student {
        String name;
        public Student() {}
        public Student(String name) {
            super();
            this.name = name;
        }
        public void behave() {
            System.out.println(name + "上学去了");
        }
    

实现MethodInterceptor接口的代理工厂类

    public static class ProxyFactory implements MethodInterceptor {
        private  Object target; // 目标类
        public ProxyFactory(Object target) {
            this.target = target;
        }
      //返回代理类
        public Object getProxyInstance() {
            Enhancer en = new Enhancer();
            en.setSuperclass(target.getClass());
            en.setCallback(this);
            return en.create();
        }
     //实现MethodInterceptor 接口方法
        @Override
        public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
            System.out.println("上学前记得带作业");
            Object returnVal = method.invoke(target, args);
           /**
            * 不要使用  Object returnVal2 = methodProxy.invokeSuper(proxy, args)
            * 这方法相当于用代理类(子类)调用目标类(父类)的(即未被重写的)方法  ->  super.method(args );
            *   这与我们的目的不符,我们想要效果是:目标类(父类)调用自己的方法
            */
            System.out.println("小心路上的汽车");
            return returnVal;
        }
    }

主方法内进行测试

    public static void main(String[] args) {
        ProxyFactory proxyFactory = new ProxyFactory(new Student("张一凡"));
        //代理类向上转型为Student
        Student proxyStu = (Student) proxyFactory.getProxyInstance();
        proxyStu.behave();
    }

在控制台 测试结果输出

 

 

3.适配器模式

1)类适配器模式

基本思路   

      类适配器模式主要应用于新需求是一个新的接口。为了适应新的需求,我们必须先实现此接口,但我们又要想复用原有的代码。此时要满足这一点,可通过继承原有的类,来复用父类的方法。综合以上的两个关键点,我们应该定义一个新的类,使其继承原有的类,同时去实现业务所需的新目标接口。

实现过程

原有的学生类Student具有behave行为

    public static class Student  {
    private    String name;
        public Student() {    }
        public Student(String name) {
            super();
            this.name = name;
        }
        public void behave() {
            System.out.println(name + "上学去了");
        }
    }

新的目标需求是实现Animal接口,使其具有Animal的能力,但行为细节不用改变

    public static interface Animal {
        void act();
    }

定义一个新类(适配者),让其适配新的需求,同时复用已有的代码 

    public static class Actor extends Student implements Animal{
        public Actor() {
            super();
        }
        public Actor(String name) {
            super(name);
        }
        @Override
        public void act() {
            /**
             * 调用父类Student的behave()方法,使当前act()方法产生与behave()完全相同的效果输出,
             *    但在外界来看,是实现了新的行为方法,外界只会调用act方法,而不知其内部具体实现
             *    实际上还是在执行behave()方法
             */
            super.behave();
        }
    }

主方法测试

    public static void main(String[] args) {
        Animal actor= new Actor("张天一");
        actor.act();
    }

 控制台输出

 

2)对象适配器模式

设计思路

     对象适配器模式主要应用于新的需求的一个(抽象)基类。在这里我们不能使用类适配器模式的所用到的继承父类、实现接口的方式去满足目标需求,因为java中不允许多根继承,只能单根继承,我们也就无法在继承(目标需求)抽象类的同时再去继承原有的类(复用原代码)。此时定义一个新类(适配者),将一个原有的类类(被适配者)作为成员变量放在这个类中,此类还要继承目标抽象类,并实现其中的抽象方法。

实现过程

 现有学生类Student (被适配者)

    public static class Student  {
    private    String name;
        public Student() {    }
        public Student(String name) {
            super();
            this.name = name;
        }
        public void behave() {
            System.out.println(name + "上学去了");
        }
    }

目标需求的抽象类Animal 

    public static abstract class Animal {
        public    abstract    void act();
    }

定义新类(适配者),继承(需求)抽象类,Student(被适配者)作为它的成员变量

    public static class Actor extends  Animal{
        private Student student;
        //student属性,让构造方法传的Student类参数让其初始化
        public Actor(Student student) {
            super();
            this.student = student;
        }
        @Override
        public void act() {
            student.behave();
        }
    }

主方法测试

    public static void main(String[] args) {
        Animal actor=new Actor(new Student("张一峰"));
        actor.act();
    }

 控制台输出

4.总结

       (1)代理模式,按照是代理类否由java虚拟机动态生成的,可将代理模式分为静态代理和动态代理。

        代理模式,为其他类提供一种代理以控制对这个类的访问  ,主要目的就是实现对目标类的方法增强。    

        静态代理,需要定义接口,代理类和目标类都实现此接口,然后代理类调用接口的同名方法来调用目标类的方法。需要注意的是:此代理类需要我们手动去接口中的每个方法去写实现,并在保存编译后classpath路径中将存在这个代理类的class文件。

        然而大多数情况下, 对目标类方法的增强控制代码是相同或类似的,如果接口中的方法较多或接口较多,一 一为之编写代理类的接口实现方法,会增加工作量,造成代码冗余。而动态代理,则不需要一 一编写代理类对接口的实现方法,不需要编写具体的代理类,那么classpath中就不存在代理类的class文件,但需要定义统一的接口方法实现规范,即编写一个生成代理类的代理工厂类。而在动态代理中又可分为JDK(接口)代理、Cglib代理。

        JDK代理需提供接口,动态生成的代理类实现此接口,实质上是根据代理工厂类的接口实现规范(如上面的PrimaryProxyFactory的"invoke(Object proxy, Method method, Object[] args)"方法)来实现 与目标类相同方法签名的接口方法以完成方法代理;而Cglib代理不需要提供接口,动态生成的代理类会去继承目标类,实质上也是根据代理工厂类的方法重写规范(如上面的ProxyFactory类的"intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy)"方法)来重写父类的方法以实现方法代理。

       (2)适配器模式,按照需求是就接口或(抽象)类,可分为类适配器模式和对象适配器模式。

       适配器模式,将一个类的接口转换成客户希望的另外一个接口,它填补了“现有程序” 和“所需程序”之间的差异,增强代码的兼容复用能力,以适应不同的目标需求。

       类适配器模式需要新定义一个适配器类,它实现了需求对应的接口,并继承现有的业务类,通过在接口方法中显式地调用父类的方法的方式,达到适应新需求同时又复用现有方法代码的目的。

        对象适配器模式同样需要定义一个适配器类,它继承需求对应的(抽象)类,将现有的业务类作为适配器的一个成员变量,并用构造方法传入业务类实例对象的引用,以初始化此成员变量;在实现父类的抽象方法中使用委托机制(某个方法将实际处理工作交给其他对象的方法去完成),让成员变量(现有业务类对象)调用自己的方法。

      (3)代理模式和适配器模式的比较

      代理模式和对象适配器模式都需要持有一个对象的引用(作为成员变量),且此成员变量通过构造方法来初始化,使用委托机制完成想要的全部或部分的业务处理。

      静态代理、JDK动态代理与类适配器模式都基于实现接口方法,而Cglib动态代理、对象适配器模式都基于继承(抽象)类。

      从广义的角度上来看(参考C++中的多继承),实现接口方法、继承父类都属于广义上的“继承”,达成多态的效果。"继承"(包含实现接口)是设计模式中常用的策略,"继承"的目的就是代码重用和多态。无论是代理模式还是适配器模式,都是对满足新需求而应运而生的设计模式。不同之处在于,代理模式中,新的需求是具体业务有了变化,但接口或方法名没有变化;适配器模式中,新需求是接口或方法名变化了,但具体业务没有变化。为了充分利用变化中的不变因素,我们常使用广义上的“继承”机制来实现,所以代理模式和适配器模式都用到了大量的“继承”机制。

适配器模式和代理模式的区别 代理模式 组成: 抽象角色:通过接口或抽象类声明真实角色实现的业务方法。 代理角色:实现抽象角色,是真实角色的代理,通过真实角色的业务逻辑方法来实现抽象方法,并可以附加自己的操作。 真实角色:实现抽象角色,定义真实角色所要实现的业务逻辑,供代理角色调用。 即Proxy Pattern,23种常用的面向对象软件的设计模式之一。(设计模式的说法源自《设计模式》一书,原名《Design Patterns: Elements of Reusable Object-Oriented Software》。1995年出版,出版社:Addison Wesly Longman.Inc。该书提出了23种基本设计模式,第一次将设计模式提升到理论高度,并将之规范化。) 代理模式的定义:为其他对象提供一种代理以控制对这个对象的访问。在某些情况下,一个对象不适合或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。 (1)职责清晰 真实的角色就是实现实际的业务逻辑,不用关心其他非本职责的事务,通过后期的代理完成一件完成事务,附带的结果就是编程简洁清晰。 (2)代理对象可 立即下载

相关推荐

clock-gating整理

文章目录clock gating 理解1、latch双稳态器件常见锁存器结构SR锁存器D锁存器2、clock gating(clock low-active) latch + AND gating 电路(clock high-active)latch + OR gating 电路 clock gating 理解 1、latch 参考:https://www.cnblogs.com/IClearner/p/6443539.html 双稳态器件 稳定状态为0或1两种 举例:交叉耦合反相器 假设初始Q为1,则可

d_b_的博客 1万+

适配器模式与代理模式的区别

适配器模式与代理模式的区别 适配器模式:https://blog.csdn.net/weixin_49639753/article/details/120472980 代理模式:https://blog.csdn.net/weixin_49639753/article/details/119322908 区别: 目的不同 适配器模式:将一个接口转换成客户希望的另一个接口,使原本不兼容的接口类可以一起工作。 代理模式:给一个对象提供一个代理对象,并由代理对象控制对原对象的引用,是在对原有对象功能的增强,使客户

解忧小店 2219

高动态范围结构光三维测量技术:从多曝光融合到深度学习的演进与应用

本文深入探讨了高动态范围结构光三维测量技术的演进与应用,从传统的多曝光融合技术到深度学习驱动的创新方案。通过工业案例展示了该技术在提升测量精度和效率方面的显著优势,特别是在处理高反光、复杂表面时的突破性表现。文章还提供了针对不同工业场景的技术选型指南,帮助工程师优化三维测量解决方案。

weixin_29063979的博客 294

适配器和代理模式的区别

适配器模式是一种结构型设计模式,它允许将一个接口转换为客户希望的另一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的类可以协同工作。代理模式是一种结构型设计模式,它为其他对象提供一种代理以控制对这个对象的访问。换句话说,代理模式为目标对象创建一个代理对象,由代理对象控制对目标对象的引用。适配器模式和代理模式都是Java编程中常用的设计模式,它们在各自的应用领域中发挥着重要的作用。适配器模式主要用于接口转换以实现兼容性,而代理模式主要用于控制对对象的访问以增加功能或优化性能。

Flying_Fish_roe的博客 870

EtherCat 从站开发中遇到的问题分享

EtherCat从站 AX58100

yu_arius的博客 2063

HWSD中国土壤数据库

T_PH_H2O: Real (酸碱度) T_CEC_CLAY: Real (粘性层土壤的阳离子交换能力);T_CEC_SOIL: Real (土壤的阳离子交换能力) T_BS: Real (基本饱和度);T_CACO3: Real (碳酸盐或石灰含量) T_CASO4: Real (硫酸盐含量);ADD_PROP: Real (土壤单元中与农业用途有关的特定土壤类型);T_USDA_TEX: Real (USDA土壤质地分类);T_REF_BULK: Real (土壤容重);

地球资源数据云的官方博客 4659

设计模式之适配器模式、桥接模式、代理模式、装饰者模式

本章介绍设计模式中的 适配器模式、桥接模式、代理模式、装饰者模式

路漫漫其修远兮,吾将上下而求索 2540

【PSINS】EKF、UKF、CKF三个滤波下的组合导航(松组合)对比,订阅专栏后可查看完整代码

基于PSINS的MATLAB工具箱。工具箱给的例程只有单独的EKF等滤波算法,这个程序将三种方法汇总在一起,并进行对比。EKF:扩展卡尔曼滤波UKF:无迹卡尔曼滤波CKF:容积卡尔曼滤波。

985工科博士毕业,专攻定位、导航和滤波等算法研究。从业10年,主要使用MATLAB 1911

代理模式和适配器模式的对比

代理模式和适配器模式的对比

zjj_flower的博客 512

Office系列完全干净卸载工具合集(最全)

使用 Microsoft Fix it 卸载 Microsoft Office 套件 一、Windows 7、Windows Vista或Windows XP下卸载Office 1.MicrosoftEasyFix50416 工具用来卸载office 2003 MicrosoftEasyFix50416_Office2003.msi 2.MicrosoftEasyFix50154 工具用来卸载office 2007 MicrosoftEasyFix50154_Office2007.msi 3.Microso

业精于勤,荒于嬉 3万+

PON架构(全光网络)

目前组网架构世界上有一种最快的速度又是光,以前传统以太网络规划满足不了现在的需求。有线网 无线网 全光网络方案场景 全光网络分类 以太全光网络 PON(Pas-sive-Optical Network 无源光网络) 再典型的中大型高校网络中 推荐万兆入室 千兆到桌面的带宽设计 一般三层 (终端-接入层-汇聚层-核心层-出口(安全设备)-互联网) 单校区核心设备 一般采用两台高性能的核心交换机 双机的方式采用的是 M-LAG 多校区之间核心交换机采用1

qq_56248592的博客 6278

设计模式——结构型模式之代理模式和适配器模式(类比+图解,从无到有,一文看懂几种模式的区别)

设计模式 系列文章: 一、创建型模式——工厂模式 二、创建型模式——单例模式、原型模式 三、创建型模式——建造者模式 四、结构型模式——装饰者模式 五、结构型模式——代理模式、适配器模式 文章目录设计模式前言一、 代理模式的定义二、代理模式类图和一个设计实例三、适配器模式定义四、装饰者、代理、适配器的区别 前言 代理模式属于结构型模式中最为简单的模式之一,易于理解的同时又妙用无穷,能够适用于远程代理,安全保护,智能处理等多种方面。 适配器模式较为复杂,同时与之前的装饰者又神似而有所差异,在Ja

代码之狐的博客 3283

这才是 Python 的正确玩法!用强化学习 (RL) 训练 AI 玩《王者荣耀》,胜率 90%!

大家打排位时,一定遇到过那种“意识神级、操作零失误”的对手,或者“走位呆滞、送人头”的队友。以前的“人机”是程序员写死的脚本(If 血量<20% Then 回城)。而现在的顶级 AI(如腾讯绝悟、OpenAI Five),是靠强化学习 (Reinforcement Learning)自己“左右互搏”练出来的。今天,我们不谈枯燥的数学公式,我将手把手教你用,搭建一个能玩 MOBA 游戏的 AI Agent。即使不能去 KPL 打职业,虐一下钻石局还是绰绰有余的!

BUG猿的博客 1185

代理模式和适配器的区别

1、适配器模式:是新旧接口不一致,导入没法使用新接口的对象。这时候增加一个适配器类(继承旧接口),程序依然调用旧接口,而在适配器类中调用新接口。至于新接口的对象在哪,可以让适配器类本身继承(常用),也可以作为一个成员变量,甚至作为参数传进去(比如spring的DispatcherServlet中的HandlerAdapter ha = getHandlerAdapter(mappedHandle...

iteye_19269的博客 647

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

代理模式和适配器模式的相似以及不同之处

代理模式 UML图表示: 代码举例: 适配器模式 UML图表示 代码举例: target.h #pragma once #include <iostream> class Target { public: virtual ~Target() {} virtual void Request() { std::cout << "普通请求..." <&lt...

斧冰 1371

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

代理模式和适配器模式,装饰模式的区别

代理模式和适配器模式: 相同点: 都为另一个对象提供间接性访问,而且都是从自身以外的接口向这个对象转发请求 不同点:适配器模式主要是解决两个接口之间不匹配的问题,他通常是为所适配的对象提供不同的接口;而代理对象会和目标对 象实现相同的接口 代理模式和装饰模式: 相同点: 装饰模式和保护代理模式实现上是类似的,都是再转调其他对象的前后执...

henry_liu的博客 2239

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

90% 的人都搞混了!代理模式和适配器模式到底有什么区别?一篇文章彻底讲透!(附生活案例)

对比项代理模式(Proxy)适配器模式(Adapter)核心目的增强功能、控制访问转换接口、解决兼容性是否改变接口否,与原对象接口一致是,转换为新的接口是否增强功能是否典型场景AOP、事务、日志、权限接口兼容、第三方库接入、老系统改造生活案例经纪人代理明星USB 转 Type-C 转接头很多设计模式看起来代码结构相似,但设计模式真正的区别不在代码,而在设计意图。代理模式:增强功能,不改接口;适配器模式:转换接口,解决兼容。

程序员夏洛的博客 398

代理模式、桥接模式、装饰器模式、适配器模式4种设计模式的区别

前言 如果不了解这四种模式的可以查看相关文章: 代理模式 桥接模式 装饰器模式 适配器模式 区别 代理、桥接、装饰器、适配器,这 4 种模式是比较常用的结构型设计模式。它们的代码结构非常相似。笼统来说,它们都可以称为 Wrapper 模式,也就是通过 Wrapper 类二次封装原始类。 尽管代码结构相似,但这 4 种设计模式的用意完全不同,也就是说要解决的问题、应用场景不同,这也是它们的主要区别。这里我就简单说一下它们之间的区别。 代理模式:代理模式在不改变原始类接口的条件下,为原始类定义

ezconn的博客 2272

Adapter和Proxy两种设计模式

Normal 0 7.8 磅 0 2 false false false MicrosoftInternetExplorer4 <!-- /* Font

厌米's CUO Zone 2280

二、代理模式与适配器模式的异同

代理模式和适配器模式非常相似,区别在于代理模式可以在真正的业务处理前后进行一些处理,下面简单示例演示下: (一)基本要素 1、真正的处理逻辑 public class RealSubject { public void operation() { System.out.println("真正的方法调用"); } } 2、用户直接调用的接口 public inter...

panchang199266的博客 1066

代理模式VS适配器模式

适配器模式 定义:将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。简单点就是需要的东西就在面前,但却不能使用,而短时间又无法改造=它,于是我们就想办法适配它。 举一个生活中最常见的例子!就如我们的球类吧!如排球,如果只是想拿着排球在自行车老大爷那说点好的来打气是行不通,因为那的打气筒是无法往...

weixin_30321449的博客 390
上一篇: 在mybatis框架中,连表查询与延迟加载比较
下一篇: 漫谈设计模式(二):单例(Singleton)模式
蜀中孤鹰
博客等级 码龄8年 270粉丝 132原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址