精华内容
下载资源
问答
  • 外观模式

    千次阅读 2019-09-25 20:40:22
    外观模式(Facade Pattern)隐藏系统的复杂性,并向客户端提供了一个客户端可以访问系统...意图:为系统中的一组接口提供一个一致的界面,外观模式定义了一个高层接口,这个接口使得这一系统更加容易使用。 主要...

    外观模式(Facade Pattern)隐藏系统的复杂性,并向客户端提供了一个客户端可以访问系统的接口。这种类型的设计模式属于结构型模式,它向现有的系统添加一个接口,来隐藏系统的复杂性。

    这种模式涉及到一个单一的类,该类提供了客户端请求的简化方法和对现有系统类方法的委托调用。

    介绍

    意图:为子系统中的一组接口提供一个一致的界面,外观模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。

    主要解决:降低访问复杂系统的内部子系统时的复杂度,简化客户端与之的接口。

    何时使用: 1、客户端不需要知道系统内部的复杂联系,整个系统只需提供一个"接待员"即可。 2、定义系统的入口。

    如何解决:客户端不与系统耦合,外观类与系统耦合。

    关键代码:在客户端和复杂系统之间再加一层,这一层将调用顺序、依赖关系等处理好。

    应用实例 :1、去医院看病,可能要去挂号、门诊、划价、取药,让患者或患者家属觉得很复杂,如果有提供接待人员,只让接待人员来处理,就很方便。 2、JAVA 的三层开发模式。

    优点 :1、减少系统相互依赖。 2、提高灵活性。 3、提高了安全性。

    缺点:不符合开闭原则,如果要改东西很麻烦,继承重写都不合适。

    使用场景 :1、为复杂的模块或子系统提供外界访问的模块。 2、子系统相对独立。 3、预防低水平人员带来的风险。

    注意事项:在层次化结构中,可以使用外观模式定义系统中每一层的入口。

    实现

    我们将创建一个 Shape 接口和实现了 Shape 接口的实体类。下一步是定义一个外观类 ShapeMaker

    ShapeMaker 类使用实体类来代表用户对这些类的调用。FacadePatternDemo,我们的演示类使用 ShapeMaker 类来显示结果。

    外观模式

    步骤 1

    创建一个接口。

    Shape.java

    public interface Shape {
    
        void draw();
    
    }
    

    步骤 2

    创建实现接口的实体类。

    Rectangle.java

    public class Rectangle implements Shape {
    
        @Override
        public void draw() {
            System.out.println("Rectangle::draw()");
        }
    
    }
    

    Square.java

    public class Square implements Shape {
    
        @Override
        public void draw() {
            System.out.println("Square::draw()");
        }
    
    }
    

    Circle.java

    public class Circle implements Shape {
    
        @Override
        public void draw() {
            System.out.println("Circle::draw()");
        }
    
    }
    

    步骤 3

    创建一个外观类。

    ShapeMaker.java

    public class ShapeMaker {
    
        private Shape circle;
        private Shape square;
        private Shape rectangle;
    
        public ShapeMaker() {
            circle = new Circle();
            square = new Square();
            rectangle = new Rectangle();
        }
    
        public void drawCircle() {
            circle.draw();
        }
    
        public void drawSquare() {
            square.draw();
        }
    
        public void drawRectangle() {
            rectangle.draw();
        }
    
    }
    

    步骤 4

    使用该外观类画出各种类型的形状。

    FacadePatternDemo.java

    public class FacadePatternDemo {
    
        public static void main(String[] args) {
            ShapeMaker shapeMaker = new ShapeMaker();
    
            shapeMaker.drawCircle();
            shapeMaker.drawRectangle();
            shapeMaker.drawSquare();
        }
    
    }
    

    步骤 5

    验证输出。

    Circle::draw()
    Rectangle::draw()
    Square::draw()
    
    展开全文
  • JAVA设计模式--外观模式

    万次阅读 2017-02-12 23:37:41
    四、外观模式和中介者模式 五、外观模式的优缺点 六、总结 一、什么是外观式 外观(Facade)模式是一种对象的结构型模式。为系统中的一组接口提供一个一致的界面, Facade模式定义了一个高层接口,这个接口使得...

    目录

    一、什么是外观式

    二、外观模式的结构

    三、外观模式的适用性

    四、外观模式和中介者模式

    五、外观模式的优缺点

    六、总结


    一、什么是外观式

    外观(Facade)模式是一种对象的结构型模式。为子系统中的一组接口提供一个一致的界面, Facade模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。

    外观模式的本质:封装交互,简化调用

    设计意图:隐藏系统的复杂性,并向客户端提供一个可以访问系统的简单接口,以降低用户使用系统的复杂性。

    将一个系统划分成为若干个子系统有利于降低系统的复杂性。一个常见的设计目标是使子系统间的通信和相互依赖关系达到最小,达到该目标的途径之一就是引入一个外观(Facade)对象,它为子系统中较一般的设施提供了一个单一而简单的界面。

    如图所示,引入外观角色之后,用户只需要直接与外观角色交互,用户与子系统之间的复杂关系由外观角色来实现,从而降低了系统的耦合度。 

    二、外观模式的结构

    外观模式没有一个一般化的类图表示,下图仅是一个功能示意。

    外观模式涉及的角色及其职责如下:

    外观(Facade)角色:定义整个系统对外的高层接口,通常需要调用内部多个子系统,从而把客户的请求代理给适当的子系统对象。

    子系统(Subsystem)角色:接受Facade对象的委派,真正实现功能,各个子系统对象之间可能有交互。但是请注意,Facade对象知道各个子系统,但是各个子系统不应该知道Facade对象。

    此处为了示意,我们举一个简单的例子:汽车停车起步。

    汽车停车起步简化之后一般会包括以下几个操作步骤:发动汽车-->踩下离合-->挂档-->松开离合-->踩油门。当然这只是一个极简化了的步骤,真实的操作步骤可能比这还要复杂得多(还要配合刹车等操作)。然而,即便就是这经过简化的步骤,也经常会把许多学车的新手搞得手忙脚乱、连连憋熄火。

    这是一个典型的用户与一个系统(汽车)中的多个子系统(动力系统,离合器,变速器,油门)进行交互的情形,用户需要和所有的子系统交互,才能完成自己想要实现的功能,这其实是极不合理的,也极容易出错,毕竟并非所有的用户都是“老司机”,你说是吧!

    接下来我们使用外观模式来改造,实现以上的功能,类图结构如下:

    下面是其实现的源代码:

    首先来看看各个子系统的定义,包括:动力系统、离合器、加速器、变速器四个子系统。

    /**
     * 动力系统
     */
    public class PowerSystem {
    
    	/**
    	 * 汽车发动
    	 */
    	public void startUp() {
    		System.out.println("汽车发动。。。。");
    	}
    
    	/**
    	 * 汽车熄火
    	 */
    	public void closeDown() {
    		System.out.println("汽车熄火。。。。");
    	}
    }
    /**
     * 离合器
     */
    public class ClutchSystem {
    
    	/**
    	 * 踩下离合
    	 */
    	public void press() {
    		System.out.println("踩下离合。。。。");
    	}
    
    	/**
    	 * 松开离合
    	 */
    	public void release() {
    		System.out.println("松开离合。。。。");
    	}
    }
    /**
     * 变速器
     */
    public class TransmissionSystem {
    
    	/**
    	 * 挂挡操作
    	 * @param gear 所挂档位
    	 */
    	public void shift(int gear) {
    		switch (gear) {
    		case -1:
    			System.out.println("挂倒档。。。。");
    			break;
    		case 0:
    			System.out.println("挂空档。。。。");
    			break;
    		case 1:
    			System.out.println("挂一档。。。。");
    			break;
    		case 2:
    			System.out.println("挂二档。。。。");
    			break;
    		case 3:
    			System.out.println("挂三档。。。。");
    			break;
    		case 4:
    			System.out.println("挂四档。。。。");
    			break;
    		case 5:
    			System.out.println("挂五档。。。。");
    			break;
    		}
    	}
    }
    /**
     * 加速器,即油门
     */
    public class AcceleratorSystem {
    
    	/**
    	 * 踩下油门
    	 */
    	public void press() {
    		System.out.println("踩下油门。。。。");
    	}
    
    	/**
    	 * 松开油门
    	 */
    	public void release() {
    		System.out.println("松开油门。。。。");
    	}
    }

    接下来该看看外观的定义了,示例代码如下。  

    /**
     * 外观类
     */
    public class Facade {
    
    	/**
    	 * 示意方法,停车起步
    	 */
    	public void parkingStart() {
    		// 创建需要转调的子系统对象实例
    		ClutchSystem clutchSystem = new ClutchSystem();
    		TransmissionSystem transmissionSystem = new TransmissionSystem();
    		AcceleratorSystem acceleratorSystem = new AcceleratorSystem();
    		// 转调子系统的功能
    		clutchSystem.press();
    		transmissionSystem.shift(1);
    		clutchSystem.release();
    		acceleratorSystem.press();
    		System.out.println("汽车开始动了。。。。");
    	}
    
    }
    

    创建一个客户端类测试一下,示例代码如下。  

    public class Client {
    
    	public static void main(String[] args) {
    
    		PowerSystem powerSystem = new PowerSystem();
    		// 发动汽车
    		// 此处作为示意,用户可以跳过外观,直接与子系统进行交互
    		powerSystem.startUp();
    		// 创建外观实例
    		Facade facade = new Facade();
    		// 停车起步
    		facade.parkingStart();
    	}
    }

    运行程序打印结果如下:  

    汽车发动。。。。
    踩下离合。。。。
    挂一档。。。。
    松开离合。。。。
    踩下油门。。。。
    汽车开始动了。。。。

    在以上代码示例中,为简明起见,只为Facade对象添加了一个“停车起步”的功能,事实上它还可以有更多其他的功能,Facade对象这个“停车起步”的功能其实就相当于是为已经发动了的汽车增加了一个“一键停车起步”的功能。

    并未把“发动汽车”这个步骤一并加入的Facade对象中,主要是为了作一个示意:根据实际需要,用户是可以越过Facade层,直接与子系统进行交互的。

    三、外观模式的适用性

    在以下条件下可以考虑使用外观模式:

    • 当你要为一个复杂子系统提供一个简单接口时。子系统往往因为不断演化而变得越来越复杂。大多数模式使用时都会产生更多更小的类。这使得子系统更具可重用性,也更容易对子系统进行定制,但这也给那些不需要定制子系统的用户带来一些使用上的困难。facade可以提供一个简单的缺省视图,这一视图对大多数用户来说已经足够,而那些需要更多的可定制性的用户可以越过facade层。

    • 客户程序与抽象类的实现部分之间存在着很大的依赖性。引入facade将这个子系统与客户以及其他的子系统分离,可以提高子系统的独立性和可移植性。

    • 当你需要构建一个层次结构的子系统时,使用 facade模式定义子系统中每层的入口点。如果子系统之间是相互依赖的,你可以让它们仅通过facade进行通讯,从而简化了它们之间的依赖关系。

    四、外观模式和中介者模式

    外观模式和中介者模式非常类似,但是却有本质的区别。

    中介者模式主要用来封装多个对象之间相互的交互,多用在系统内部的多个模块之间;而外观模式封装的是单向的交互,是从客户端访问系统的调用,没有从系统中来访问客户端的调用。

    在中介者模式的实现里面,是需要实现具体的交互功能的;而外观模式的实现里面,一般是组合调用或是转调内部实现的功能,通常外观模式本身并不实现这些功能。

    中介者模式的目的主要是松散多个同事之间的耦合,把这些耦合关系全部放到中介者中去实现;而外观模式的目的是简化客户端的调用,这点和中介者模式也不同。

    五、外观模式的优缺点

    使用外观模式的优点:

    松散耦合

    • 外观模式松散了客户端与子系统的耦合关系,让子系统内部的模块能更容易扩展和维护。

    简单易用

    • 外观模式让子系统更加易用,客户端不再需要了解子系统内部的实现,也不需要跟众多子系统内部的模块进行交互,只需要跟外观交互就可以了,相当于外观类为外部客户端使用子系统提供了一站式服务。

    更好地划分访问的层次

    • 通过合理使用Facade,可以帮助我们更好地划分访问的层次。有些方法是对系统外的,有些方法是在系统内部使用的。把需要暴露给外部的功能集中到外观中,这样既方便客户端使用,也很好地隐藏了内部的细节。

    使用外观模式的缺点

    • 不能很好地限制客户使用子系统类,如果对客户访问子系统类做太多的限制则减少了可变性和灵活性。

    • 在不引入抽象外观类的情况下,增加新的子系统可能需要修改外观类或客户端的源代码,违背了“开闭原则”。

    六、总结

    Facade封装了子系统外部和子系统内部多个模块的交互过程,从而简化了外部的调用。通过外观,子系统为外部提供一些高层的接口,以方便它们的使用。

    外观模式很好地体现了“最少知识原则”。

    如果不使用外观模式,客户端通常需要和子系统内部的多个模块交互,也就是说客户端会和这些模块之间都有依赖关系,任意一个模块的变动都可能会引起客户端的变动。

    使用外观模式后,客户端只需要和外观类交互,即只和这个外观类有依赖关系,不需要再去关心子系统内部模块的变动情况了。

    这样一来,客户端不但简单,而且这个系统会更有弹性。当系统内部多个模块发生变化的时候,这个变化可以被这个外观类吸收和消化,并不需要影响到客户端,换句话说就是:可以在不影响客户端的情况下,实现系统内部的维护和扩展。 

    展开全文
  • 设计模式——外观模式

    千次阅读 2018-04-06 17:33:15
    外观模式,是一种把系统客户端做松耦合操作的一个设计模式。这样客户端调用系统,根本不需要知道系统内部是如何操作的,只需要调用外部“接待员”即可,所以即使系统有变化时,也不需要客户端做改变,达到松...

    外观模式,是一种把子系统和客户端做松耦合操作的一个设计模式。这样客户端调用系统,根本不需要知道系统内部是如何操作的,只需要调用外部“接待员”即可,所以即使子系统有变化时,也不需要客户端做改变,达到松耦合的效果。

    我们通过外观的包装,使应用程序只能看到外观对象,而不会看到具体的细节对象,这样无疑会降低应用程序的复杂度,并且提高了程序的可维护性。

    外观模式包含三个角色:

    外观角色(Facade):是模式的核心,他被客户client角色调用,知道各个子系统的功能。同时根据客户角色已有的需求预订了几种功能组合

    子系统角色(Subsystem classes):实现子系统的功能,并处理由Facade对象指派的任务。对子系统而言,facade和client角色是未知的,没有Facade的任何相关信息;即没有指向Facade的实例。

    客户角色(client):调用facade角色获得完成相应的功能。

    主要解决:降低访问复杂系统的内部子系统时的复杂度,客户端与子系统松耦合。

    何时使用: 1、客户端不需要知道系统内部的复杂联系,整个系统只需提供一个"接待员"即可。 2、定义系统的入口。

    如何解决:客户端不与系统耦合,外观类与系统耦合。

    关键代码:在客户端和复杂系统之间再加一层,这一次将调用顺序、依赖关系等处理好。

    应用实例: 1、去医院看病,可能要去挂号、门诊、划价、取药,让患者或患者家属觉得很复杂,如果有提供接待人员,只让接待人员来处理,就很方便。

    优点: 1、减少系统相互依赖。 2、提高灵活性。 3、提高了安全性。

    缺点:不符合开闭原则,如果要改东西很麻烦,继承重写都不合适。

    使用场景: 1、为复杂的模块或子系统提供外界访问的模块。 2、子系统相对独立。 3、预防低水平人员带来的风险。

    注意事项:在层次化结构中,可以使用外观模式定义系统中每一层的入口。

    下边时一个开车和停车操作的例子,两个操作,在不调用和调用外观模式的时候的代码:

    <?php
    //子系统角色
    
    //车门
    class CarDoor{
        public function Open()
        {
            echo "Open the door. ";
        }
        public function Close()
        {
            echo "Close the door. ";
        }
    }
    
    //发动机
    class Engine{
        public function Start()
        {
            echo "Start Engine. ";
        }
        public function Stop()
        {
            echo "Stop Engine. ";
        }
    }
    
    //踩油门
    class Accelerator{
        public function Run()
        {
            echo "Press the accelerator. ";
        }
    }
    
    //踩刹车
    class Breaking {
    
        public function Run()
        {
            echo "Break. ";
        }
    }
    
    //如果不采用外观模式,那么开车和停车的调用如下
    $CarDoor = new CarDoor();
    $Engine = new Engine();
    $Accelerator = new Accelerator();
    $Breaking = new Breaking();
    
    //开车
    $CarDoor->Open();
    $Engine->Start();
    $Accelerator->Run();
    
    //停车
    $Breaking->Run();
    $Engine->Stop();
    $CarDoor->Close();
    
    
    
    //采用外观模式.定义外观角色
    class Facade{
        private $CarDoor;
        private $Engine;
        private $Accelerator;
        private $Breaking;
        
        function __construct()
        {
            $this->CarDoor = new CarDoor();
            $this->Engine = new Engine();
            $this->Accelerator = new Accelerator();
            $this->Breaking = new Breaking();
        }
        
        public function Start()
        {
            $this->CarDoor->Open();
            $this->Engine->Start();
            $this->Accelerator->Run();
        }
        
        public function Stop()
        {
            $this->Breaking->Run();
            $this->Engine->Stop();
            $this->CarDoor->Close();
        }
        
    }
    
    //调用外观模式
    $Facade = new Facade();
    //开车
    $Facade->Start();
    //停车
    $Facade->Stop();
    
    ?>

    展开全文
  • C++ 外观模式

    千次阅读 2017-04-27 12:59:21
    Façade 为系统中的一组接口提供了一个统一的高层接口,该接口使得系统更加容易使用。 简述 模式结构 优缺点 适用场景 案例分析 代码实现 版权所有:一去丶二三里,转载请注明出处:...

    简述

    外观模式(Facade Pattern)又称为门面模式,属于结构型模式。Façade 为子系统中的一组接口提供了一个统一的高层接口,该接口使得子系统更加容易使用。

    | 版权声明:一去、二三里,未经博主允许不得转载。

    模式结构

    UML 结构图:

    Facade Pattern

    • Facade(外观):模式的核心,被 Client 调用,知晓相关子系统的功能和责任。在正常情况下,它将所有从 Client 发来的请求委派到相应的子系统去,让子系统处理。
    • SubSystem(子系统):可以同时有一个或者多个子系统,子系统可以是一个单独的类或类的集合。每个子系统都可以被 Client 直接调用,或者被 Facade 调用,它处理由 Facade 传过来的请求。子系统并不知道 Facade 的存在,对于子系统而言,Facade 仅仅是另外一个 Client 而已。

    优缺点

    优点:

    • 对 Client 屏蔽子系统组件,减少了 Client 处理的对象数目,并使得子系统使用起来更加容易。通过引入外观模式,Client 的代码将变得很简单,与之关联的对象也很少。
    • 实现了子系统与 Client 之间的松耦合关系,这使得子系统的组件变化不会影响到调用它的 Client,只需要调整 Facade 即可。
    • 降低了大型软件系统中的编译依赖性,并简化了系统在不同平台之间的移植过程,因为编译一个子系统一般不需要编译所有其他的子系统。一个子系统的修改对其他子系统没有任何影响,而且子系统内部变化也不会影响到外观对象。
    • 只是提供了一个访问子系统的统一入口,并不影响用户直接使用子系统类。

    缺点:

    • 不能很好地限制 Client 使用子系统类,如果对 Client 访问子系统类做太多的限制,则会减少可变性和灵活性。
    • 在不引入抽象外观类的情况下,增加新的子系统可能需要修改 Facade 或 Client 的源代码,违背了“开闭原则”。

    适用场景

    • 当要为一个复杂子系统提供一个简单接口时。该接口可以满足大多数用户的需求,而且用户也可以越过外观类直接访问子系统。
    • Client 与多个子系统之间存在很大的依赖性。引入外观类将子系统与 Client 以及其他子系统解耦,可以提高子系统的独立性和可移植性。
    • 在层次化结构中,可以使用外观模式定义系统中每一层的入口。层与层之间不直接产生联系,而通过外观类建立联系,降低层之间的耦合度。

    案例分析

    京东 - 多快好省 只为品质生活

    JD

    以前,人们购物需要去超市、百货商店、农贸集市等。网络流行之后,越来越多的人喜欢网购,足不出户便可以淘到很多好东西。

    比起传统模式,网购有很多好处:

    • 方便、快捷,节省时间和费用。
    • 网络信息透明,容易了解卖家信誉度。
    • 网上物品应有尽有,可以非常方便地货比三家。

    除此之外,很多网上商城还不断搞各种活动,双 11、双 12、国庆、元旦、春节,各种花样应有尽有。。。

    像京东、淘宝、亚马逊这些电商平台,客户挑选好喜欢的宝贝,然后进行结算。在随后的过程中,我们并不清楚这些网站背后的情况,所关注的只不过是,下完订单后,将会在一段时间后收货。其实,在幕后,任务被分发给不同的子系统(订单团队、供应商、快递员)去完成,为了方便,可以进行订单跟踪:

    下订单 –> 订单验证 –> 打包 –> 出货 –> 派送 –> 交付

    PS: 说到速度,就不得不夸奖京东了,物流很给力,早上下单,下午送达。。。

    代码实现

    创建子系统

    子系统包含 3 个,订单团队(确认付款、联系供应商)、供应商(确认库存、包装、联系快递)、快递员(分配人员、派送包裹)。

    // sub_system.h
    #ifndef SUB_SYSTEM_H
    #define SUB_SYSTEM_H
    
    #include <iostream>
    #include <string>
    #include <windows.h>
    
    const std::string c_stateToStrCourier[] = { "收到", "验证可达性", "分配人员", "派送包裹", "获取交货确认", "完成" };
    const std::string c_stateToStrVendor[] = { "收到", "确认库存", "从仓库得到物品", "包装", "联系快递员", "完成" };
    const std::string c_stateToStrOrderTeam[] = { "收到", "确认付款", "联系供应商", "完成" };
    const int c_nMsec = 300;  // 休眠时间(毫秒) - Sleep(c_nMsec) 处可以替换为一些有用的代码
    
    // 订单团队
    class OrderTeam
    {
    public:
        void submitRequest() {
            m_nState = 0;
        }
    
        // 检测状态
        bool checkStatus() {
            std::cout << "订单团队 - 当前状态:" << c_stateToStrOrderTeam[m_nState] << std::endl;
    
            Sleep(c_nMsec);
            m_nState++;
    
            return (m_nState == Complete);
        }
    
    private:
        enum States {
            Received,  // 收到
            VerifyPayment,  // 确认付款
            ContactVendor,  // 联系供应商
            Complete  // 完成
        };
        int m_nState;
    };
    
    // 供应商
    class Vendor
    {
    public:
        void submitRequest() {
            m_nState = 0;
        }
    
        // 检测状态
        bool checkStatus() {
            std::cout << "供应商 - 当前状态:" << c_stateToStrVendor[m_nState] << std::endl;
    
            Sleep(c_nMsec);
            m_nState++;
    
            return (m_nState == Complete);
        }
    
    private:
        enum States {
            Received,  // 收到
            VerifyInventory,  // 确认库存
            GetItemFromWareHouse,  // 从仓库得到物品
            PackItem,  // 包装
            ContactCourier,  // 联系快递员
            Complete  // 完成
        };
        int m_nState;
    };
    
    // 快递员
    class Courier
    {
    public:
        // 将请求转发给快递员
        void submitRequest() {
            m_nState = 0;
        }
    
        // 检测状态
        bool checkStatus() {
            std::cout << "快递员 - 当前状态:" << c_stateToStrCourier[m_nState] << std::endl;
    
            Sleep(c_nMsec);
            m_nState++;
    
            return (m_nState == Complete);
        }
    
    private:
        enum States {
            Received,  // 收到
            VerifyReachbility,  // 验证可达性
            AssignPerson,  // 分配人员
            DispatchPackage,  // 派送包裹
            GetDeliveryConfirmation,  // 获取交货确认
            Complete  // 完成
        };
        int m_nState;
    };
    
    #endif // SUB_SYSTEM_H

    创建外观

    用于网上购物的外观,提供了暴露给客户的接口,虽然可以跟踪订单,但仍然隐藏背后的复杂过程。

    // facade.h
    #ifndef FACADE_H
    #define FACADE_H
    
    #include "sub_system.h"
    
    // 网购外观
    class OnlineShoppingFacade
    {
    public:
        OnlineShoppingFacade() {
            m_nCount = 0;
        }
    
        // 返回跟踪次数
        int followupNum() {
            return m_nCount;
        }
    
        // 提交订单
        void submitRequest() {
            m_nState = 0;
        }
    
        // 跟踪订单
        bool checkStatus(){
            // 收到订单请求
            switch (m_nState) {
            case Received:
                m_nState++;
                // 将请求转发给订单团队
                m_order.submitRequest();
                std::cout << "********** 提交给订单团队,跟踪次数:" << m_nCount << " **********" << std::endl;
                break;
            case SubmittedToOrderTeam:
                // 如果订单团队完成验证,则向供应商发出请求
                if (m_order.checkStatus()) {
                    m_nState++;
                    m_vendor.submitRequest();
                    std::cout << "********** 提交给供应商,跟踪次数:" << m_nCount << " **********" << std::endl;
                }
                break;
            case SubmittedToVendor:
                // 如果供应商已将包裹打包,将其转发给快递员
                if (m_vendor.checkStatus()) {
                    m_nState++;
                    m_courier.submitRequest();
                    std::cout << "********** 提交给快递员,跟踪次数:" << m_nCount << " **********" << std::endl;
                }
                break;
            case SubmittedToCourier:
                // 如果包裹交付,订单完成
                if (m_courier.checkStatus())
                    return true;
            default:
                break;
            }
    
            m_nCount++;
    
            // 订单未完成
            return false;
        }
    
    private:
        enum States {
            Received,  // 收到
            SubmittedToOrderTeam,  // 提交给订单团队
            SubmittedToVendor,  // 提交给供应商
            SubmittedToCourier  // 提交给快递员
        };
    
        int m_nState;  // 订单状态
        int m_nCount;  // 跟踪次数
    
        OrderTeam m_order;
        Vendor m_vendor;
        Courier m_courier;
    };
    
    #endif // FACADE_H

    创建客户端

    最终,客户端实现如下:

    // main.cpp
    #include "facade.h"
    
    int main()
    {
        OnlineShoppingFacade facade;
    
        // 提交订单
        facade.submitRequest();
    
        // 跟踪订单,直到订单完成
        while (!facade.checkStatus());
    
        std::cout << "********** 订单完成,跟踪次数:" << facade.followupNum() << " **********" << std::endl;
    
        getchar();
    
        return 0;
    }

    输出如下:

    ********** 提交给订单团队,跟踪次数:0 **********
    订单团队 - 当前状态:收到
    订单团队 - 当前状态:确认付款
    订单团队 - 当前状态:联系供应商
    ********** 提交给供应商,跟踪次数:3 **********
    供应商 - 当前状态:收到
    供应商 - 当前状态:确认库存
    供应商 - 当前状态:从仓库得到物品
    供应商 - 当前状态:包装
    供应商 - 当前状态:联系快递员
    ********** 提交给快递员,跟踪次数:8 **********
    快递员 - 当前状态:收到
    快递员 - 当前状态:验证可达性
    快递员 - 当前状态:分配人员
    快递员 - 当前状态:派送包裹
    快递员 - 当前状态:获取交货确认
    ********** 订单完成,跟踪次数:13 **********

    展开全文
  • 设计模式 外观模式 一键电影模式

    万次阅读 多人点赞 2014-05-14 22:51:52
    老样子,先看 外观模式(Facade Pattern)定义:提供一个统一的接口,用来访问系统中的一群接口,外观定义了一个高层的接口,让系统更容易使用。其实就是为了方便客户的使用,把一群操作,封装成一个方法。 举...
  • Java设计模式之迭代子模式

    万次阅读 多人点赞 2015-04-17 07:26:39
    本文继续介绍23种设计模式系列之观察者模式。定义在软件构建过程中,集合对象内部结构常常变化各异,但对于这些集合对象,我们希望在不暴露其内部结构的同时,可以让外部客户代码透明地...迭代(Iterator)模式又叫游标
  • JAVA设计模式之单例模式

    万次阅读 多人点赞 2014-04-16 06:51:34
    本文继续介绍23种设计模式系列之单例模式。 概念:  java中单例模式是一种常见的设计模式,单例模式的写法有好几种,这里主要介绍三种:懒汉式单例、饿汉式单例、登记式单例。  单例模式有以下特点:  1、单例类...
  • 设计模式之外观模式

    千次阅读 2016-09-08 14:31:14
    外观模式外观模式系统中的各类(或结构与方法)提供一个简明一致的界面,隐藏系统的复杂性,使系统更加容易使用。
  • 浅谈数据库三大模式:模式、概念模式和内模式

    万次阅读 多人点赞 2019-09-17 09:45:56
    对应数据库的升级、模式包括(子模式 用户模式) 用来描述用户看到或者使用那部分的数据的逻辑结构,用户根据模式用户数据操作语句或者程序去操作数据库中的数据,模式的主要特点用来描述组成用户视图各个记录...
  • Java设计模式-外观模式

    千次阅读 2019-03-26 14:53:17
    外观模式
  • Java 设计模式——外观模式

    千次阅读 2016-06-06 00:11:17
    今天要说的外观模式是一个相对简单的设计模式,而且在日常的开发中,可能你也会时常使用它,只是你可能并未想过这是一个设计模式。本文会从一些实例着手,来对本文要说明的外观模式进行尽可能全面的讲解。希望于你...
  • 设计模式专题 - 外观模式

    千次阅读 2019-06-13 18:11:17
    系统中的一组接口提供了一个统一的访问接口,这个接口使得系统更容易被访问或者使用。堪称最简单的设计模式之一! 2. 外观模式应用场景 简单来说,该模式就是把一些复杂的流程封装成一个接口供给外部用户...
  • 设计模式笔记:外观模式

    千次阅读 2016-04-28 15:18:55
    外观模式系统整合出一个统计的对外接口,提供可使用。 【不增加新的行为】 与中介模式 有一定类似,不过外观模式 只能单方向的调用使用; 与适配器模式 相比,外观模式只是提供统一接口,不进行接口转换。 ...
  • 设计模式之外观模式(结构型)

    千次阅读 2019-03-01 00:08:17
    外观模式:外观模式就是提供一个统一的接口,用来访问系统的一群接口。外观模式定义了一个高层接口,让系统更容易使用。,外观模式也称门户模式,是一种对象结构型设计模式。 二、模式角色 从模式定义可以知道...
  • 三级模式结构:模式、模式和内模式 一、模式(Schema) 定义:也称逻辑模式,是数据库中全体数据的逻辑结构和特征的描述,是所有用户的公共数据视图。 理解: ① 一个数据库只有一个模式; ② 是...
  • 设计模式(八)外观模式

    万次阅读 2016-07-25 10:26:25
    当我们开发Android的时候,无论是做SDK还是封装API,我们大多都会用到外观模式,它通过一个外观类使得整个系统的结构只有一个统一的高层接口,这样能降低用户的使用成本。
  • 外观模式(Facade Pattern)隐藏系统的复杂性,并向客户端提供了一个客户端可以访问系统的...意图:为系统中的一组接口提供一个一致的界面,外观模式定义了一个高层接口,这个接口使得这一系统更加容易使用。...
  • Java设计模式_(结构型)_外观模式

    千次阅读 2017-09-25 14:54:33
    引用百科外观模式(Facade),为系统中的一组接口提供一个一致的界面,定义一个高层接口,这个接口使得这一系统更加容易使用。Facade这个外观类为系统提供一个共同的对外接口Clients客户对象通过一个外观接口...
  • 设计模式-外观模式(家庭影院你值得拥有)

    千次阅读 多人点赞 2021-03-18 12:17:15
    外观模式系统的一组接口提供了一个一致的界面,此模式定义了一个高层接口,这个接口使得这一系统更加容易使用。外观模式可以理解为转换一群接口,客户只要调用这一个接口而不用调用多个接口才能达到目的,也不...
  • 本文我们主要介绍数据库的三级模式:模式、模式和内模式的一些知识,希望能够对您有所帮助。 AD:2014WOT全球软件技术峰会北京站 课程视频发布 对于数据库的三级模式和两级映射,可能我们并不陌生。三级模式指...
  • 简说外观模式

    千次阅读 2018-01-18 22:10:29
    外观模式(Facade),为系统中的一组接口提供一个一致的界面,定义一个高层接口,这个接口使得这一系统更加容易使用。 —— [ 百度百科 ] 解释说明 在外观模式下,当客户端需要系统为其服务时,不再关心...
  • 工厂方法模式Factory Method/虚拟构造子模式Virtual Constructor/多态性工厂Polymorphic Factory为什么要有设计模式?为什么要有工厂方法模式?工厂方法模式的类图工厂方法模式的例子产品生产者消费者执行结果JDK中...
  • 中介者模式和外观模式的区别

    千次阅读 2018-12-24 11:33:29
    对于中介者模式和外观模式或许有一定的了解,但是他们因为太过相似而难以分别,今天就总结一下,给自己深刻的理解; 外观模式定义:为系统中的一组接口提供一个一致的界面,此模式定义了一个高层接口,这个接口...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,131,156
精华内容 452,462
关键字:

外模式和子模式