精华内容
下载资源
问答
  • 今天面试聊到了模式。 面试官问:装饰者模式了解吗,讲一下? 我:blabla... 面试官:那代理模式呢?...代理模式是一项基本的设计技巧,许多其他的模式,如状态模式、策略模式、访问者模式本质上也...

    今天面试聊到了模式。

    面试官问:装饰者模式了解吗,讲一下?

    我:blabla...

    面试官:那代理模式呢?

    我:blabla.....(说完感觉怎么都一样呢)

    果然,面试官又问了:那两者有什么区别呢?

    我: ....懵.........懵.........懵.........懵.........

    首先呢来看一下定义。

    一、代理模式

    代理模式:为其他对象提供一种代理以控制对这个对象的访问。代理模式是一项基本的设计技巧,许多其他的模式,如状态模式、策略模式、访问者模式本质上也采用了代理模式。

    在代理模式中主要包含三个角色:

    1. 抽象主题角色Subject:是真实主题和代理主题的共同接口,以便在任何可以使用真实主题的地方都可以使用代理主题。
    2. 代理主题角色Proxy Subject:也叫做委托类、代理类,该角色负责控制对真实主题的引用,负责在需要的时候创建或删除真实主题对象,并且在真实主题角色处理完毕前后做预处理和善后处理工作。
    3. 真实主题角色Real Subject:也叫做被委托角色、被代理角色,是业务逻辑的具体执行者。

    二、装饰者模式

    装饰者模式:动态地给一个对象添加一些额外的职责。就增加功能来说,装饰模式比生成子类更为灵活。

    装饰模式有以下4个角色。

    1. 抽象构件(Component)角色:该角色用于规范需要装饰的对象(原始对象)。
    2. 具体构件(Concrete Component)角色:该角色实现抽象构件接口,定义一个需要装饰的原始类。
    3. 装饰(Decorator)角色:该角色持有一个构件对象的实例,并定义一个与抽象构件接口一致的接口。
    4. 具体装饰(Concrete Decorator)角色:该角色负责对构件对象进行装饰。

    三、区别

    从定义上看似乎能够回答面试官的问题,一个是用于实现访问控制,一个是增加功能。可是。。访问控制是什么,增加功能又是怎么样的?到底啥是佩琪,还是要搞清楚些,看一些具体的例子来了解下。

    3.1 访问控制 -- 代理模式

    // 抽象主题
    interface AbstractSubject{
        void doAction();
    }
    
    // 真实主题
    class RealSubject implements AbstractSubject{
        @Override
        public void doAction() {
            System.out.println(" Real Action ");
        }
    }
    
    // 代理主题
    class ProxySubject implements AbstractSubject{
        private AbstractSubject subject;
    
        public ProxySubject(){
            this.subject = new RealSubject();
        }
    
        @Override
        public void doAction() {
            System.out.println(" Before Proxy do Action");
            subject.doAction();
            System.out.println(" Before Proxy do Action");
        }
    }
    
    // 客户端
    public class Client{
    
        public static void main(String[] args) {
            AbstractSubject subject = new ProxySubject();
            subject.doAction();
        }
    }

    3.2 功能扩展 -- 装饰者模式

    // 抽象构件
    interface Human{
        void eat();
    }
    
    // 具体构件
    class Baby implements Human{
    
        @Override
        public void eat() {
            System.out.println("Baby eating");
        }
    }
    
    // 装饰角色
    class Guardian implements Human{
        private Human human;
    
        public Guardian(Human h){
            human = h;
        }
    
        @Override
        public void eat() {
            human.eat();
        }
    }
    
    // 具体装饰角色
    class Parent extends Guardian{
    
        public Parent(Human h) {
            super(h);
        }
    
        @Override
        public void eat() {
            System.out.println("Wash hands for baby");
            super.eat();
        }
    }
    
    
    
    // 客户端
    Baby baby = new Baby();
    Human human = new Parent(baby);
    human.eat();

    四、总结

    等待,看完例子怎么感觉又似懂非懂了呢。不是说一个控制访问,一个增强功能吗,为什么都是中间类和目标类实现了相同的接口,在调用目标类时增加了自己的方法呢?好像确实又懵了。

    zayouhuilail

    其实,代理模式的访问控制主要在于对目标类的透明访问,也就是说我们不需要知道目标类的具体情况,只需要知道代理类可以帮助我们完成想要的功能就对了;而对于装饰者模式,我们是有一个目标类的对象的,比如例子中的baby,这个对象可以完成特定的功能(eat),但是不能满足我们的要求,所以需要对其进行增强(饭前洗手)。

    也就是说,在代理模式中,目标类对于客户端是透明的,由代理类隐藏其具体信息并响应客户端请求;而装饰者中客户端对特定的目标类对象进行增强。所以,代理类与真实对象的关系常在编译时就确定,而装饰者在运行时递归构造。

    ----------

    终于搞明白了这两个相似的设计模式的关系,好像智商又占领了高地,就是脚有点麻   ------

    展开全文
  • 设计模式中有很多种,这里介绍下面试中可能会被问到的一个问题:代理模式和装饰者模式的区别。先看一下代理模式的设计图:再看一下代理模式的代码:第一步:定义一个接口:package ...

    设计模式中有很多种,这里介绍下面试中可能会被问到的一个问题:代理模式和装饰者模式的区别。

    先看一下代理模式的设计图:

    再看一下代理模式的代码:

    第一步:定义一个接口:

    package com.interview.designModel.agentModel;
    /**
     * 第一步:定义一个接口
     * @author EdwardShen
     *
     * 2018年4月13日
     */
    public interface Girl {
        void behavior();
    }
    
    
    

    第二步:定义接口的实现,即为被代理的类

    package com.interview.designModel.agentModel;
    /**
     * 第二步:定义真实的被代理的类
     * @author EdwardShen
     *
     * 2018年4月13日
     */
    public class NiceGirl implements Girl{
    	private String name;
    	public NiceGirl(String name)
    	{
    		this.name = name;
    	}
    
    	@Override
    	public void behavior() {
    		System.out.println(name+"说话很nice");
    		System.out.println(name+"长的很nice");
    	}
    	
    }
    

    第三步:定义代理类

    package com.interview.designModel.agentModel;
    
    import java.util.Random;
    
    /**
     * 第三步:定义代理类
     * 代理类,代理的对象是Girl
     * @author EdwardShen
     *
     * 2018年4月13日
     */
    public class GirlAgent implements Girl{
    	private Girl girl;
    	
    	public GirlAgent(Girl girl)
    	{
    		this.girl = girl;
    	}
    	
    	public void behavior()
    	{
    		Random random = new Random();
    		if(random.nextBoolean())
    		{
    			System.out.println("我安排你们上自习");
    			girl.behavior();
    		}
    		else
    		{
    			System.out.println("上完自习再说");
    		}
    	}
    }
    

    第四步:定义测试类

    package com.interview.designModel.agentModel;
    
    import org.junit.Test;
    
    /**
     * 第四步:定义测试类
     * 装饰者模式:可以对被代理的对象有控制权,决定被代理的对象执行还是不执行
     * @author EdwardShen
     *
     * 2018年4月13日
     */
    public class Client {
    	@Test
    	public void showInfo()
    	{
    		Girl girl = new NiceGirl("小美");
    		Girl friend = new GirlAgent(girl);
    		friend.behavior();
    	}
    }
    

    最后,正确的代码展示结果:

    我安排你们上自习
    小美说话很nice
    小美长的很nice
    
    或者
    上完自习再说
    

    装饰者模式的设计原理:

    对,你没有看错,是一毛一样的。

    接下来,看一下代码的实现。不同的地方,只有装饰类,其余不在展示

    package com.interview.designModel.decoratorModel;
    
    import com.interview.designModel.agentModel.Girl;
    /**
     * 装饰者需要与装饰的对象相关联
     * @author EdwardShen
     *
     * 2018年4月13日
     */
    public class GirlDecorator implements Girl{
    	private Girl girl;
    	public GirlDecorator(Girl girl)
    	{
    		this.girl = girl;
    	}
    
    	@Override
    	public void behavior() {
    		System.out.println("我的闺蜜不但知书达理,还会洗衣做饭");
    		girl.behavior();
    	}
    
    }
    

    正确的代码展示的结果

    我的闺蜜不但知书达理,还会洗衣做饭
    小美说话很nice
    小美长的很nice
    

    所以最终两者的区别是:

    代理模式:对于被代理的对象有控制权,可以执行或者不执行。

    装饰着模式:没有控制权,肯定会执行,但是增加了一层装饰的功能。

    展开全文
  • 在实际的编码过程中,代理模式的应用场景是什么?装饰器模式的应用场景是什么? spring的ioc+aop就是动态代理,可以帮助我开启hibernate的session,commit事务 装饰器模式,在实际的环境中,在哪有所体现? ...
  • 装饰模式:动态的给对象添加额外职责,就增加功能来说,装饰模式比生成子类更灵活 桥接模式:将抽象部分实现部分分离,使得他们可以都可以独立的变化 区别 从实现目的来看: 代理模式主要是为了控制对象的访问...

    定义:

    • 代理模式:为其他对象提供一种代理,以控制该对象的访问
    • 装饰模式:动态的给对象添加额外职责,就增加功能来说,装饰模式比生成子类更灵活
    • 桥接模式:将抽象部分和实现部分分离,使得他们可以都可以独立的变化

    区别

    从实现目的来看:

    • 代理模式主要是为了控制对象的访问(比如权限校验)或者为了更方便的访问对象(比如Binder中的代理使得跨进程调用方法就像调用本地方法一样)
    • 装饰模式是为了增加新的功能,而不改变原有对象,它可以用来代替继承,使得增加功能更灵活
    • 而桥接模式是为了解决多个维度发生变化时带来的类爆炸问题

    UML图

    • 代理模式:
      在这里插入图片描述
    • 装饰模式:

    在这里插入图片描述

    • 桥接模式:
      在这里插入图片描述

    从类结构上来看:

    • 代理模式和装饰模式中的代理角色和装饰者角色,都需要实现或者重写被代理者/被装饰者的方法,使得对用户来说是透明的,而桥接模式则不需要
    • 相对于代理模式来说,装饰者模式多了个装饰者的抽象类,也就是它可以往装饰者和被装饰者这两个维度来扩展,而代理模式中的代理者则是具体的实现类
    • 而桥接模式,则是将抽象类作为桥梁,将各个实现连接起来,它不像装饰模式那样只能往2个维度扩展,而是可以扩展到多个维度,比如手机的抽象类,它可以桥接屏幕、相机、cpu等各个硬件的实现类

    所以装饰模式可以看做是桥接模式的特例,而代理模式则可以看做是装饰模式的特列,在实际开发中往往很少有标准化的设计模式,往往都是根据实际情况多种设计模式结合在一起使用,所以一些设计模式看起来会比较相似,但其实他们核心的目的还是不一样的

    展开全文
  • 装饰模式代理模式区别

    千次阅读 2019-08-21 18:56:25
    学习AOP时,教材上面都说使用的是动态代理,可是在印象中代理模式一直都是控制访问什么的,怎么又动态增加行为了,... 首先,让我们先看一下下面的这两个UML类图,他们分别描述了装饰器模式和代理模式的基本实现。 ...

    学习AOP时,教材上面都说使用的是动态代理,可是在印象中代理模式一直都是控制访问什么的,怎么又动态增加行为了,动态增加行为不是装饰器模式吗?于是 找了很多资料,想弄清楚这两者之间到底有什么区别。结果发现这一篇英文文章讲的很清晰,就翻译一下,供参考。       

            首先,让我们先看一下下面的这两个UML类图,他们分别描述了装饰器模式和代理模式的基本实现。

                        

                         

            这两个图可能使我们产生困惑。这两个设计模式看起来很像。对装饰器模式来说,装饰者(decorator)和被装饰者(decoratee)都实现同一个 接口。对代理模式来说,代理类(proxy class)和真实处理的类(real class)都实现同一个接口。此外,不论我们使用哪一个模式,都可以很容易地在真实对象的方法前面或者后面加上自定义的方法。

            然而,实际上,在装饰器模式和代理模式之间还是有很多差别的。装饰器模式关注于在一个对象上动态的添加方法,然而代理模式关注于控制对对象的访问。换句话 说,用代理模式,代理类(proxy class)可以对它的客户隐藏一个对象的具体信息。因此,当使用代理模式的时候,我们常常在一个代理类中创建一个对象的实例。并且,当我们使用装饰器模 式的时候,我们通常的做法是将原始对象作为一个参数传给装饰者的构造器。

            我们可以用另外一句话来总结这些差别:使用代理模式,代理和真实对象之间的的关系通常在编译时就已经确定了,而装饰者能够在运行时递归地被构造。    

    代理模式:

    //代理模式
    public class Proxy implements Subject{
    
           private Subject subject;
           public Proxy(){
                 //关系在编译时确定
                subject = new RealSubject();
           }
           public void doAction(){
                 ….
                 subject.doAction();
                 ….
           }
    }
    //代理的客户
    public class Client{
            public static void main(String[] args){
                 //客户不知道代理委托了另一个对象
                 Subject subject = new Proxy();
                 …
            }
    }

    装饰模式:

    //装饰器模式
    public class Decorator implements Component{
            private Component component;
            public Decorator(Component component){
                this.component = component
            }
           public void operation(){
                ….
                component.operation();
                ….
           }
    }
    //装饰器的客户
    public class Client{
            public static void main(String[] args){
                //客户指定了装饰者需要装饰的是哪一个类
                Component component = new Decorator(new ConcreteComponent());
                …
            }
    }

    对已有的业务逻辑进一步的封装,使其增加额外的功能,如java中的IO流就使用了装饰者模式,用户在使用的时候,可以任意组装,达到自己想要的效果。 
    举个栗子,我想吃三明治,首先我需要一根大大的香肠,我喜欢吃奶油,在香肠上面加一点奶油,再放一点蔬菜,最后再用两片面包加一下,很丰盛的一顿午饭,营养又健康,那我们应该怎么来写代码呢? 
    首先,我们需要写一个Food类,让其他所有食物都来继承这个类,看代码:

    public class Food {
     
        private String food_name;
     
        public Food() {
        }
     
        public Food(String food_name) {
            this.food_name = food_name;
        }
     
        public String make() {
            return food_name;
        };
    }
    代码很简单,我就不解释了,然后我们写几个子类继承它:
    
    //面包类
    public class Bread extends Food {
     
        private Food basic_food;
     
        public Bread(Food basic_food) {
            this.basic_food = basic_food;
        }
     
        public String make() {
            return basic_food.make()+"+面包";
        }
    }
     
    //奶油类
    public class Cream extends Food {
     
        private Food basic_food;
     
        public Cream(Food basic_food) {
            this.basic_food = basic_food;
        }
     
        public String make() {
            return basic_food.make()+"+奶油";
        }
    }
     
    //蔬菜类
    public class Vegetable extends Food {
     
        private Food basic_food;
     
        public Vegetable(Food basic_food) {
            this.basic_food = basic_food;
        }
     
        public String make() {
            return basic_food.make()+"+蔬菜";
        }
     
    }
    1. 这几个类都是差不多的,构造方法传入一个Food类型的参数,然后在make方法中加入一些自己的逻辑,如果你还是看不懂为什么这么写,不急,你看看我的Test类是怎么写的,一看你就明白了
    public class Test {
        public static void main(String[] args) {
            Food food = new Bread(new Vegetable(new Cream(new Food("香肠"))));
            System.out.println(food.make());
        }
    }

    看到没有,一层一层封装,我没从里往外看:最里面我new了一个香肠,在香肠的外面我包裹了一层奶油,在奶油的外面我又加了一层蔬菜,最外面我放的是面包,是不是很形象,哈哈 ~ 这个设计模式简直跟现实生活中一摸一样,看懂了吗? 
    我们看看运行结果吧 

    展开全文
  • 这篇文章是我找到关于介绍代理模式和装饰器模式比较好的文章了。 节前把3个设计模式的学习心得分享了一下,分别是适配器模式,装饰模式代理模式。 但是似乎越写越有些迷糊,这三种模式都有着一些大同小异的...
  • 装饰模式:以对客户端透明的方式扩展对象的功能,是继承关系的一个替代方案; 代理模式:给一个对象提供一个代理对象,并有代理对象来控制对原有对象的引用; 装饰模式应该为所装饰的对象增强功能;代理模式对代理...
  • 适配器 代理和装饰都是通过... 代理模式着重将复杂部分抽到中间层,通过这个中间层(代理层〉来控制对目标对象的访 问,它要求代理层目标对象的接口相同。而适配器模式解决的恰恰是接口发生了变化导致现 有对象...
  • 这次来总结下代理模式(静态代理以及动态代理)的使用,以及与装饰器模式的区别: 1. 代理(静态代理)模式:  1.1 简介  通俗地讲,代理模式就是提供一个代理,代替实际对象完成某些操作,从而控制对实际对象...
  • 装饰模式与动态代理区别

    千次阅读 2019-06-01 00:36:10
    装饰模式与动态代理区别区别装饰模式动态代理 区别 装饰模式: 就是为了给装饰者的方法增强,单纯的是为了在装饰者方法上增加其他功能。是继承的一种替代方案,可以理解为 在不改变接口的前提下,动态扩展...
  • 文章来源: ...  首先,让我们先看一下下面的这两个UML类图,他们分别描述了装饰器模式和代理模式的基本实现。      这两个图可能使我们产生困
  • 前言 如果不了解这四种模式的可以查看相关文章: 代理模式 桥接模式 装饰器模式 适配器模式 ...区别 ...代理、桥接、装饰器、适配器,这 4 种模式是比较...代理模式代理模式在不改变原始类接口的条件下,为原始类定义
  • 对比代理、桥接、装饰器、适配器 4 种设计模式,从 模式结构与角色、模式定义与意图、模式区别这几个角度
  • 文章目录1 引子2 业务场景介绍3 静态代理模式4 装饰器模式5 动态代理模式 1 引子 看过上篇文章《【Mybatis源码探索】 — Mybatis查询过程核心源码解读 ...同时考虑到由于静态代理模式和装饰器模式过于相似 的原...
  • * 继承 被增强的对象固定的 增强的内容也是固定的 * 装饰模式 被增强的对象是可以切换的 ...还有一种更加灵活的方式,面向切面编程(AOP) ,比装饰模式更加灵活, 被增强的对象增强的内容都是可以更换的.
  • 静态代理和装饰模式区别

    千次阅读 2018-05-22 22:40:44
    截取一篇文章里的总结:代理模式主要是控制对某个特定对象访问,而装饰模式主要是为了给对象添加行为代理模式定义一个测试接口,里面定义一个测试用例执行方法interface ITest{ void execute();}定义一个测试用例...
  • 大家好,上一篇博客讲到了装饰器模式,而这一篇,我们要讲到代理模式。这篇代理模式酝酿了好久。为什么呢?因为我在写这些模式系列的博客中,都会先阅读网上的介绍这些模式的博客,看看别人是怎么写的,有什么问题...
  • Java学习-设计模式-装饰器模式和代理模式区别 区别: **装饰器模式: ** 关注于在一个对象上动态的添加方法。当我们使用装饰器模 式的时候,我们通常的做法是将原始对象作为一个参数传给装饰者的构造器。 **代理...
  • 设计模式-装饰模式:指在不改变现有对象结构的情况下,动态地给该对象增加一些职责(即增加其额外功能)的模式,它属于对象结构型模式
  • 前言 相信很多初学者都对JavaAPI中的IO包感到头大,其中的类非常多,看着看着就晕了,笔者也是一样。不过,IO包的设计其实就是使用了装饰者模式,了解了这个模式再去看IO包就会发现很清晰...与代理模式区别 总结 ...
  • 代理模式定义,代理是一个对象(proxy)用它来控制目标对象的访问。为此他要是先与目标对象相同的接口,但是他不同于装饰者模式,它对目标对象不进行任何修改,它的目的在于延缓”复杂”对象的初始化时间。这样可以在...
  • 一、单列模式:一个类只允许产生一个实例化对象; Singleton是一个创建型...实现方式有懒汉式饿汉式共四种: 1、饿汉式,线程安全 但效率比较低 : public class SingletonTest { private SingletonTest() { ...
  • [设计模式](六):装饰器模式(Decorator)和代理模式(Proxy)|委托模式(Delegater )
  • Java设计模式

    千次阅读 多人点赞 2019-09-03 23:20:31
    Java设计模式 1.工厂模式 工厂模式一般分为简单工厂、工厂、抽象工厂3钟情况,属于创建型设计...5.代理模式 6.状态模式 7.访问者模式 8.命令模式 9.装饰器模式 10.组合模式 ...
  • 和装饰区别 概念 为其他对象提供一种代理以控制这个对象的访问,在某些情况下一个对象不能直接访问那个对象时,代理就起到了客户端代理对象(委托类)中介作用。 代理委托类都有同样接口。 好处:...
  • 装饰模式装饰模式(Decorator Pattern)是指在不改变原有对象的基础之上,将功能附加到对 象上,提供了比继承更有弹性的替代方案(扩展原有对象的功能),属于结构型模式。 1、用于扩展一个类的功能或给一个...
  • 设计模式主要分三个类型:创建型、结构型行为型。 1.创建型模式 社会化的分工越来越细,自然在软件设计方面也是如此,因此对象的创建对象的使用分开也就成为了必然趋势。因为对象的创建会消耗掉系统的很多资源...
  • 代理模式和装饰器模式都持有RealObject(被代理的对象/被装饰的对象)   代理模式用于控制访问,即原本功能的执行与否取决于场景条件,对用户而言重要的是原本的功能 装饰器模式用于动态地添加职责,原本的功能...
  • 抽象工厂模式适配器模式对象建模模式责任链模式命令模式复合模式装饰器模式门面模式迭代器模式中介模式备忘录模式模型-视图-控制器模式观察者模式代理模式接待员模式singleton模式模板方法模式1、创造性模式是专门...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,582
精华内容 14,632
关键字:

代理模式和装饰模式的定义和区别