精华内容
下载资源
问答
  • 2015-08-11 19:48:53

    介绍

    • 所谓外观模式Facade, 就是将子系统的接口进行抽象, 使得客户端可以更方便去使用这些子系统, 而无需了解子系统之间的耦合关系;
    • 可以实现子系统与客户之间的松耦合关系, 子系统内部的功能组件往往是紧耦合的;
    • Facade将客户的请求代理给适当的子系统对象;
    • 子系统: 实现相应的功能, 处理有facade指派的任务, 子系统是没有任何facade的信息, 即没有facade的指针, 子系统甚至是不知道有这个中间层;

    • 将一个系统划分为若干子系统有利于降低系统的复杂性, 而子系统之间的通信与相互依赖关系达到最小;使用facade模式定义子系统中每层的入口点, 如果子系统之间是相互依赖的, 可以让他们仅通过facade进行通讯, 从而简化他们之间的依赖关系;

    更多相关内容
  • 外观模式一、外观模式二、举例 一、外观模式 提供一个统一的接口,用来访问子系统中的一群接口。外观定义了一个高层接口,让子系统更容易使用。 二、举例 请设计一个类,要求如下 电影类 投影仪类 将看电影的整个...

    一、外观模式

    提供一个统一的接口,用来访问子系统中的一群接口。外观定义了一个高层接口,让子系统更容易使用。

    二、举例

    请设计一个类,要求如下

    • 电影类
    • 投影仪类
    • 将看电影的整个复杂过程包起来

    电影类

    package com.jackeys.AppearanceMode;
    
    
    /**
     * @Description: 电影类
     * @ClassName: Movie
     * @Package com.jackeys.AppearanceMode
     * @Author: Jackeys 1623427047@qq.com
     * @Copyright 版权归Jackeys企业(或个人)所有
     * @CreateTime: 2021/10/19 16:59
     * @Version: 1.0
     */
    public class Movie {
    
        /**
         * 电影名
         */
        private String name;
    
        public Movie(String name) {
            this.name = name;
        }
    
        public String getName() {
            return this.name;
        }
    
    }
    
    

    投影仪类

    package com.jackeys.AppearanceMode;
    
    /**
     * @Description: 投影仪
     * @ClassName: Projector
     * @Package com.jackeys.AppearanceMode
     * @Author: Jackeys 1623427047@qq.com
     * @Copyright 版权归Jackeys企业(或个人)所有
     * @CreateTime: 2021/10/19 17:00
     * @Version: 1.0
     */
    public class Projector {
    
        public void setMovie(Movie movie) {
            System.out.println("放入电影:" + movie.getName());
        }
    
        public void outMovie(Movie movie) {
            System.out.println("拿出电影:" + movie.getName());
        }
    
        public void onProjector() {
            System.out.println("打开投影仪");
        }
    
        public void offProjector() {
            System.out.println("关闭投影仪");
        }
    
        public void onMovie() {
            System.out.println("播放电影");
        }
    
        public void offMovie() {
            System.out.println("关闭电影");
        }
    }
    
    

    外观类

    package com.jackeys.AppearanceMode;
    
    /**
     * @Description: 外观模式
     * @ClassName: Facade
     * @Package com.jackeys.AppearanceMode
     * @Author: Jackeys 1623427047@qq.com
     * @Copyright 版权归Jackeys企业(或个人)所有
     * @CreateTime: 2021/10/19 17:04
     * @Version: 1.0
     */
    public class Facade {
    
        /**
         * 电影
         */
        private Movie movie;
        /**
         * 投影仪
         */
        private Projector projector;
    
        public Facade(Movie movie, Projector projector) {
            this.movie = movie;
            this.projector = projector;
        }
    
        /**
         * @MethodName: watchMovie
         * @Description: 播放电影
         * @Return void
         * @Auther: Jackeys 1623427947@qq.com
         * @Date: 2021/10/19 17:06
         * @Version: 1.0
         */
        public void watchMovie() {
            this.projector.setMovie(this.movie);
            this.projector.onProjector();
            this.projector.onMovie();
        }
    
        /**
         * @MethodName: endMovie
         * @Description: 结束电影
         * @Return void
         * @Auther: Jackeys 1623427947@qq.com
         * @Date: 2021/10/19 17:07
         * @Version: 1.0
         */
        public void endMovie() {
            this.projector.offMovie();
            this.projector.outMovie(this.movie);
            this.projector.offProjector();
        }
    }
    
    

    测试类

    package com.jackeys.AppearanceMode;
    
    /**
     * @Description: 测试外观模式
     * @ClassName: Test
     * @Package com.jackeys.AppearanceMode
     * @Author: Jackeys 1623427047@qq.com
     * @Copyright 版权归Jackeys企业(或个人)所有
     * @CreateTime: 2021/10/19 17:07
     * @Version: 1.0
     */
    public class Test {
        public static void main(String[] args) {
            Facade facade = new Facade(new Movie("长津湖"), new Projector());
            facade.watchMovie();
            facade.endMovie();
        }
    }
    
    

    运行截图
    在这里插入图片描述

    展开全文
  • 实验7 适配器模式、外观模式与模板方法模式---Java设计模式
  • I . 外观模式概念 II . 外观模式 适用场景 III . 外观模式 优缺点 IV . 外观模式与其它设计模式的联系与区别 V . 外观模式 代码示例



    I . 外观模式概念



    1 . 外观模式概念 :


    ① 设计模式类型 : 结构型 ;

    ② 标准定义 : 提供一个统一接口 , 用于访问子系统中的一群接口 ;

    ③ 隐藏复杂性目的 : 定义高层级接口 , 让子系统更容易使用 , 目的是隐藏系统的复杂性 ;

    ④ 交互流程 : 多个子系统联合完成一个操作 , 提供一个统一的接口 , 供客户端调用 , 客户端不与每个子系统进行复杂的交互 , 客户端只与提供接口的外观类进行交互 ;


    2 . 外观模式的相关角色 :


    ① 外观角色 : 外观类有自己的方法 , 用户可以通过调用外观类的方法 , 调用子系统提供的功能 ;

    ② 子系统角色 : 可以是若干个处理模块 , 数量 1 个或多个 ;

    ③ 用户角色 : 用户通过外观类调用子系统的功能 ;



    II . 外观模式 适用场景



    外观模式适用场景 :

    ① 子系统复杂 : 子系统复杂 , 通过使用外观模式可以简化调用接口 ;

    ② 层次复杂 : 系统结构层次复杂 , 每个层级都一个使用外观对象作为该层入口 , 可以简化层次间的调用接口 ;



    III . 外观模式 优缺点



    1 . 外观模式优点 :


    ① 简化调用 : 简化复杂系统的调用过程 , 无需对子系统进行深入了解 , 即可完成调用 ;

    ② 降低耦合 : 使用外观模式 , 只与外观对象进行交互 , 不与复杂的子系统直接进行交互 , 降低了系统间的依赖 , 使耦合关系更低 ; 子系统内部的模块更容易扩展和维护 ;

    ③ 层次控制 : 层次结构复杂的系统 , 有些方法需要提供给系统外部调用 , 有些方法需要在内部使用 , 将提供给外部的功能定义在外观类中 , 这样既方便调用 , 也能将系统内部的细节隐藏起来 ;

    ④ 符合迪米特法则 : 最少知道原则 , 用户不需要了解子系统内部的情况 , 也不需要与子系统进行交互 , 只与外观类进行交互 ; 降低了应用层与子系统之间的耦合度 ;


    2 . 外观模式缺点 :


    ① 子系统扩展风险 : 系统内部扩展子系统时 , 容易产生风险 ;

    ② 不符合开闭原则 : 外观模式 , 扩展子系统时 , 不符合开闭原则 ;



    IV . 外观模式与其它设计模式的联系与区别



    1 . 外观模式与中介者模式 :


    ① 外观模式 : 外观模式关注外部用户与子系统之间的交互 ;

    ② 中介者模式 : 中介者模式关注子系统内部之间的交互 ;


    2 . 外观模式与单例模式 : 外观类一般会被定义成单例类 ;


    3 . 外观模式 与 抽象工厂模式 : 外观类中 , 使用抽象工厂模式 , 获取子系统的实例对象 , 子系统内部可以屏蔽外观类 ;



    V . 外观模式 代码示例



    1 . 需求描述 : 实现一个购买商品的功能 , 用户提出购买某件商品 , 首先要查看库存 , 然后付款 , 最后物流发货 ;


    ① 用户与子系统直接交互 : 首先要与仓储子系统交互检查是否有库存 , 然后与支付子系统交互支付货款 , 最后进入物流子系统获取物流编号 ; 使用这种交互方式 , 导致用户与子系统耦合度太高 ;

    ② 引入外观类 : 将与仓储子系统 , 支付子系统 , 物流子系统之间的交互统一交给外观类进行处理 , 用户只需要与外观类对象进行交互 , 这样大大减少了用户与多个子系统之间的耦合度 ;


    2 . 多个子系统代码示例 : 三个子系统分别处理各自业务 ;


    ① 仓储子系统代码 :

    package kim.hsl.design.facade;
    
    /**
     * 仓库子系统
     * 查询是否有库存
     */
    public class StoreService {
        public boolean isStokeAvailable(Goods goods){
            System.out.println("校验是否有库存 : " + goods.toString() + " 有库存");
            return true;
        }
    }
    

    ② 支付子系统代码 :

    package kim.hsl.design.facade;
    
    /**
     * 支付子系统
     * 支付成功返回 true
     */
    public class PaymentService {
        public boolean pay(Goods goods){
            System.out.println("使用银联支付");
            return true;
        }
    }
    

    ③ 物流子系统代码 :

    package kim.hsl.design.facade;
    
    /**
     * 物流子系统
     * 进入发货流程 , 返回物流编号
     */
    public class LogisticsService {
        public String logistics(Goods goods){
            String logisticsNo = "31415926";
            System.out.println(goods + " 进入物流系统 , 运单号为 " + logisticsNo);
            return logisticsNo;
        }
    }
    

    3 . 外观类代码 : 外观类中维护三个子系统模块 , 用户通过 buyGoods 方法 , 作为与三个子系统之间的交互接口 ;

    package kim.hsl.design.facade;
    
    /**
     * 用户购买的统一接口
     * 用户只需要与该类进行交互
     * 该类统一处理 仓储 支付 物流 等购买流程
     */
    public class BuyFacade {
        private LogisticsService logisticsService;
        private PaymentService paymentService;
        private StoreService storeService;
    
        public BuyFacade() {
            storeService = new StoreService();
            paymentService = new PaymentService();
            logisticsService = new LogisticsService();
        }
    
        /**
         * 外观类提供的访问内部三个子系统的接口
         * 客户端只需要调用该方法 , 即可完整商品购买流程
         * @param goods
         */
        public void buyGoods(Goods goods){
            if(storeService.isStokeAvailable(goods)){
                if(paymentService.pay(goods)){
                    logisticsService.logistics(goods);
                }
            }
        }
    }
    

    4 . 商品类代码 :

    package kim.hsl.design.facade;
    
    /**
     * 商品
     */
    public class Goods {
        private String name;
        public Goods(String name) {
            this.name = name;
        }
        @Override
        public String toString() {
            return "Goods{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }
    

    5 . 测试函数入口代码 :

    package kim.hsl.design.facade;
    
    public class Main {
        public static void main(String[] args) {
            Goods goods = new Goods("肥皂");
            BuyFacade buyFacade = new BuyFacade();
            buyFacade.buyGoods(goods);
        }
    }
    

    6 . 最终执行结果 :

    校验是否有库存 : Goods{name='肥皂'} 有库存
    使用银联支付
    Goods{name='肥皂'} 进入物流系统 , 运单号为 31415926
    
    展开全文
  • 外观模式:为子系统中的一组接口提供一个一致的界面,该模式定义了一个高层接口,这个接口使这个子系统更加容易使用。我们先看一个使用外观模式的例子,首先定义了三个子系统类public classSubSystemA {public ...

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

    我们先看一个使用外观模式的例子,首先定义了三个子系统类

    public classSubSystemA {public voidfunctionA(){

    System.out.println("子系统A方法");

    }

    }public classSubSystemB {public voidfunctionB(){

    System.out.println("子系统B方法");

    }

    }public classSubSystemC {public voidfunctionC(){

    System.out.println("子系统C方法");

    }

    }

    使用外观模式定义了一个高层接口,这个接口定义了调用子系统的方法

    public interfaceFacade {voidmethodA();voidmethodB();voidmethodC();

    }

    接口调用子系统的具体实现

    public class FacadeImpl implementsFacade {privateSubSystemA subSystemA;privateSubSystemB subSystemB;privateSubSystemC subSystemC;publicFacadeImpl(){

    subSystemA= newSubSystemA();

    subSystemB= newSubSystemB();

    subSystemC= newSubSystemC();

    }

    @Overridepublic voidmethodA() {

    System.out.println("methodA");

    subSystemA.functionA();

    }

    @Overridepublic voidmethodB() {

    System.out.println("methodB");

    subSystemB.functionB();

    subSystemC.functionC();

    }

    @Overridepublic voidmethodC() {

    System.out.println("methodC");

    subSystemA.functionA();

    subSystemC.functionC();

    }

    }

    使用外观模式的调用方法

    public classTest1 {public static voidmain(String[] args) {

    Facade facade= newFacadeImpl();

    facade.methodA();

    facade.methodB();

    facade.methodC();

    }

    }

    执行结果:

    methodA

    子系统A方法

    methodB

    子系统B方法

    子系统C方法

    methodC

    子系统A方法

    子系统C方法

    下面是没有使用外观模式时客户端的调用方法

    public classTest2 {public static voidmain(String[] args) {

    SubSystemA subSystemA= newSubSystemA();

    SubSystemB subSystemB= newSubSystemB();

    SubSystemC subSystemC= newSubSystemC();

    subSystemA.functionA();

    System.out.println("----------------");

    subSystemB.functionB();

    subSystemC.functionC();

    System.out.println("----------------");

    subSystemA.functionA();

    subSystemC.functionC();

    }

    }

    执行结果:

    子系统A方法

    ----------------

    子系统B方法

    子系统C方法

    ----------------

    子系统A方法

    子系统C方法

    通过对比我们可以发现外观模式定义了一个外观类Facade,这个类了解所有子系统的方法和属性,在其内部进行组合后客户端进行调用,如果不使用外观模式,客户端需要去了解所有子系统中的类和属性,有了外观模式,客户端只需要知道外观类Facade就可以了。

    我们经常使用的三层架构就可以理解为一个外观模式的实例,如果没有service层,我们的controller层就可能需要直接去关联多个dao才能实现功能,这样就会出现多个controller和dao交叉关联,使系统越来越复杂,这时我们就可以抽象出一层service和dao接口使得耦合程

    度降低,除此之外,在维护一个遗留的大型系统时,我们也可以抽象出一个接口,用这个接口去和这个旧系统交互,新系统只需要与外观类交互,这样可以使得代码维护的复杂程度大大降低。

    展开全文
  • 1.适配器模式引入 1.1 现实世界的适配器 真实世界的适配器。比如,如果需要在欧洲国家使用美国制造的笔记本电脑,那就可能需要一个交流电的适配器。 上图中适配器的作用:位于美式插头和欧式插座的中间,他的...
  •  第一眼看到适配器模式,我第一反应就是怎么跟外观模式有点像,仔细看完之后,发现做法上是不一样的。 针对适配器模式,笔记本电脑跟显示器需要一根转接线才能连接,而笔记本电脑或者显示器(Client)都依赖于转接...
  • 外观模式是一种使用频率非常高的结构型设计模式,它通过引入一个外观角色来简化客户端与子系统之间的交互,为复杂的子系统调用提供一个统一的入口,降低子系统与客户端的耦合度,且客户端调用非常方便。1. 外观模式...
  • 设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。
  • 外观GitHub代码 适配器模式 场景描述:想象一下我们维护了一套老系统,并于一个厂商通过接口进行交互。但是最近厂商更新它们的代码,并变更了接口格式,我们如何在不修改老系统代码的基础上,优雅的过渡呢? 提出...
  • 外观模式

    2018-03-12 14:18:30
    外观模式:  外观模式(Facade),他隐藏了系统的复杂性,并向客户端提供了一个可以访问系统的接口。这种类型的设计模式属于结构性模式。为子系统中的一组接口提供了一个【高层的】统一的访问接口,这个接口使得...
  • 举例说明JPA的会话外观模式的概念,以及在JavaEE中的会话Bean中如何应用会话外观模式,并就此总结JPA在EJB组件和普通Java应用中使用时的区别
  • 设计模式和性能优化有没有关系?最近,我看到有人再讲性能优化的时候,讲到了“有些设计模式可以做到一定程度的性能优化”。我读书少,别骗我。我看过无数篇设计模式了,第一次听到有人说,设计模式有性能优化的...
  • 本篇文章介绍一种设计模式——外观模式。本篇文章内容参考《JAVA与模式》之门面模式,外观模式,深入浅出外观模式(二)。 一、外观模式概述1.定义外观模式(Facade Pattern):外部与一个子系统的通信必须通过一个...
  • 外观模式是一种使用频率非常高的结构型设计模式,它通过引入一个外观角色来简化客户端与子系统之间的交互,为复杂的子系统调用提供一个统一的入口,降低子系统与客户端的耦合度,且客户端调用非常方便。   1. ...
  • python-外观模式

    2020-12-06 14:16:27
    说明外观模式又叫做门面模式。在面向对象程序设计中,解耦是一种推崇的理念。但事实上由于某些系统中过于复杂,从而增加了客户端与子系统之间的耦合度。例如:在家观看多媒体影院时,更希望按下一个按钮就能实现...
  • 外观模式,为子系统中的一组接口提供一个一致的界面,定义一个高层接口,这个接口使得这一子系统更加容易使用。 由于子系统可能有多个,而且联系错综复杂,作为系统的使用者,我们不想也不需要去了解这些子系统之间...
  • 介绍外观模式之前,首先让我们来看下面的例子: 假设我们现有一个对外接口FacadeService,里面有一个对外的方法a(); public interface FacadeService { public void a();//这个方法是给外部调用的 } 他有一个...
  • 1、适配器模式(别名为包装器) 考虑这样一种情况,我们要给电脑充电,教室里正好有一个可以充电的插头,但是插头是两孔的,虽然这个插头可以通电,但是我们却没有办法直接用,我们需要一个插板,这个插板是两孔的...
  • 本文实例讲述了Java基于外观模式实现美食天下食谱功能。分享给大家供大家参考,具体如下:一、模式定义外观模式,是软件工程师常用的一种...二、模式举例1. 模式分析我们借用美食天下菜谱中制作糖醋排骨这一道菜来说...
  • 一、外观模式基本介绍: 》定义:又叫门面模式,提供了一个统一的接口,用来访问子系统中的一群接口 》外观模式定义了一个高层接口,让系统更容易使用 》类型:结构型 》外观适用场景: 1)子系统越来越复杂,...
  • 接口粒度设计得太大,太小都不好。太大会导致接口不可复用,太小会...其实外观模式我们日常都会不经意间使用,就是分层里更上层的业务层,封装聚合了下层单一行为接口,为调用者提供一个独立且与下层接口解耦的功能。
  • 外观模式是为了解决类与类之间的依赖关系的,像 spring 一样,可以将类和类之间的关系配置到配置文件中,而外观模式就是将他们的关系放在一个 Facade 类中,降低了类类之间的耦合度,该模式中没有涉及到接口 ...
  • 外观模式 定义:为对外提供一组接口的子系统提供一个统一的界面...下面举例说明外观模式的应用: 小巩公司的内部网是由其他人负责设计的,而小巩需要设计人力资源系统。内部网需要人力资源系统提供人员的相关信息。人力
  • 我们首先来看适配器模式: 定义: 将一个类的接口转换成客户希望的另外一个接口,使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 如果一个接口需要B接口,但是待传入的对象却是A接口,无法正常调用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,511
精华内容 3,404
关键字:

外观模式的举例说明