【设计模式】外观模式

最新推荐文章于 2023-07-20 15:15:45 发布

梓莘

最新推荐文章于 2023-07-20 15:15:45 发布

阅读量143

点赞数

分类专栏：设计模式文章标签：设计模式外观模式

本文链接：https://blog.csdn.net/daemon_slp/article/details/108366736

版权

设计模式专栏收录该内容

17 篇文章 0 订阅

订阅专栏

外观模式

组建一个家庭影院：

DVD播放器、投影仪、自动屏幕、环绕立体声、爆米花机、要求完成所有的功能，其过程包括

直接用遥控器，统筹各设备开关
开爆米花机
放下屏幕
开投影仪
开音响
开DVD
去拿爆米花
调暗灯光
播放
观影结束，关闭各种设备

首先我们想到的就是为每个设备使用一个遥控器
在这里插入图片描述

一、传统方式问题分析

在ClientTest的main方法中，创建各个子系统的对象，并直接去调用子系统（对象）的相关方法，会造成调用过程混乱。没有清晰的过程
不利于ClientTest中，去维护对子系统的操作
解决思路：定义一个高级接口，给子系统的一组接口提供一个一致的界面，用来访问子系统的一群接口
也就是说，通过定义一个一致的接口（界面类），用以屏蔽内部子系统的细节，使得调用端只需要跟这个接口发生调用，而无需关心这个子系统的内部细节，这就是我们本节要学习的外观模式

二、外观模式基本介绍

外观模式页脚过程模式：外观模式为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用
外观模式通过定义一个一致的接口，用以屏蔽内部子系统的细节，使得调用端只需要跟这个接口发生调用，而不需要关心这个子系统的内部细节
角色分析
- 外观类（Facade）:为调用端提供统一的调用接口，外观类知道哪些子系统负责处理请求，从而将调用端的请求代理给适当子系统对象
- 调用者（Client）:外观接口的调用者
- 子系统的集合：指模块或者子系统，处理Facade对象指派的任务，它是功能的实际提供者

三、使用外观模式解决上述问题

在这里插入图片描述

创建子系统的合集

package com.slp.pattern.facade;

/**
 * @ClassName DVDPlayer
 * @Description TODO
 * @Author sanglp
 * @Date 2020/8/21 8:18
 * @Version 1.0
 **/
public class DVDPlayer {
    //使用单例模式
    private static DVDPlayer instance = new DVDPlayer();
    public static DVDPlayer getInstance(){
        return instance;
    }

    public void on(){
        System.out.println("DVD打开了");
    }

    public void off(){
        System.out.println("DVD关闭");
    }

    public void play(){
        System.out.println("dvd播放中");
    }

    public  void pause(){
        System.out.println("dvdpause");
    }
}

package com.slp.pattern.facade;

/**
 * @ClassName Popcorn
 * @Description TODO
 * @Author sanglp
 * @Date 2020/8/21 8:21
 * @Version 1.0
 **/
public class Popcorn {
    private static Popcorn popcorn= new Popcorn();

    public static Popcorn getInstance(){
        return popcorn;
    }

    public void on(){
        System.out.println("爆米花打开");
    }
    public void off(){
        System.out.println("爆米花关闭");
    }
    public void pop(){
        System.out.println("取爆米花");
    }
}

package com.slp.pattern.facade;

/**
 * @ClassName Projector
 * @Description TODO
 * @Author sanglp
 * @Date 2020/8/21 8:23
 * @Version 1.0
 **/
public class Projector {
    private static  Projector projector = new Projector();
    public static Projector getInstance(){
        return projector;
    }

    public void on(){
        System.out.println("投影仪打开");
    }
    public void off(){
        System.out.println("投影仪关闭");
    }

    public void focus(){
        System.out.println("投影仪聚焦");
    }
}

package com.slp.pattern.facade;

/**
 * @ClassName Screen
 * @Description TODO
 * @Author sanglp
 * @Date 2020/8/21 8:24
 * @Version 1.0
 **/
public class Screen {

    private static Screen screen = new Screen();
    public static Screen  getInstance(){
        return screen;
    }

    public void up(){
        System.out.println("屏幕上升");
    }

    public void down(){
        System.out.println("屏幕下降");
    }
}

package com.slp.pattern.facade;

/**
 * @ClassName Stereo
 * @Description TODO
 * @Author sanglp
 * @Date 2020/8/21 8:26
 * @Version 1.0
 **/
public class Stereo {
    private static Stereo stereo = new Stereo();

    public static Stereo  getInstance(){
        return stereo;
    }

    public void on(){
    System.out.println("立体声打开");
    }
    public void off(){
        System.out.println("立体声关闭");
    }
    public void up(){
        System.out.println("立体声加大");
    }
}

package com.slp.pattern.facade;

/**
 * @ClassName TheaterLight
 * @Description TODO
 * @Author sanglp
 * @Date 2020/8/21 8:27
 * @Version 1.0
 **/
public class TheaterLight {

    private static TheaterLight theaterLight = new TheaterLight();

    public static TheaterLight getInstance(){
        return theaterLight;
    }

    public void on(){
        System.out.println("灯光打开");
    }

    public void off(){
        System.out.println("灯光关闭");
    }

    public void dim(){
        System.out.println("灯光调暗");
    }

    public void bright(){
        System.out.println("灯光调亮");
    }
}

创建门面

package com.slp.pattern.facade;

/**
 * @ClassName HomeTheaterFacade
 * @Description 门面类
 * @Author sanglp
 * @Date 2020/8/21 8:29
 * @Version 1.0
 **/
public class HomeTheaterFacade {
    //定义各个子系统的对象
    private TheaterLight theaterLight;
    private DVDPlayer dvdPlayer;
    private Popcorn popcorn;
    private Projector projector;
    private Stereo stereo;
    private Screen screen;

    //构造器
    public HomeTheaterFacade(TheaterLight theaterLight, DVDPlayer dvdPlayer, Popcorn popcorn, Projector projector, Stereo stereo, Screen screen) {
        this.theaterLight = theaterLight;
        this.dvdPlayer = dvdPlayer;
        this.popcorn = popcorn;
        this.projector = projector;
        this.stereo = stereo;
        this.screen = screen;
    }

    public HomeTheaterFacade() {
        this.theaterLight = TheaterLight.getInstance();
        this.dvdPlayer = DVDPlayer.getInstance();
        this.popcorn = Popcorn.getInstance();
        this.projector = Projector.getInstance();
        this.stereo = Stereo.getInstance();
        this.screen = Screen.getInstance();
    }
    //操作分为四步
    public void ready(){
        popcorn.on();
        popcorn.off();
        screen.down();
        projector.on();
        stereo.on();
        dvdPlayer.on();
        theaterLight.dim();
    }

    public void play(){
        dvdPlayer.play();
    }

    public void pause(){
        dvdPlayer.pause();
    }

    public void end(){
        screen.up();
        projector.off();
        theaterLight.bright();
        stereo.off();
        dvdPlayer.off();

    }
    public static void main(String[] args) {

    }
}

创建调用客户端

package com.slp.pattern.facade;

/**
 * @ClassName Client
 * @Description TODO
 * @Author sanglp
 * @Date 2020/8/21 8:29
 * @Version 1.0
 **/
public class Client {
    public static void main(String[] args) {
        HomeTheaterFacade homeTheaterFacade = new HomeTheaterFacade();
        homeTheaterFacade.ready();
        homeTheaterFacade.play();
        homeTheaterFacade.pause();
        homeTheaterFacade.end();
    }
}

四、外观模式在Mybatis源码中的应用

protected ReflectorFactory reflectorFactory = new DefaultReflectorFactory();
  protected ObjectFactory objectFactory = new DefaultObjectFactory();
  protected ObjectWrapperFactory objectWrapperFactory = new DefaultObjectWrapperFactory();

public MetaObject newMetaObject(Object object) {
    return MetaObject.forObject(object, objectFactory, objectWrapperFactory, reflectorFactory);
  }

 public static MetaObject forObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory, ReflectorFactory reflectorFactory) {
    if (object == null) {
      return SystemMetaObject.NULL_META_OBJECT;
    } else {
      return new MetaObject(object, objectFactory, objectWrapperFactory, reflectorFactory);
    }
  }

 private MetaObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory, ReflectorFactory reflectorFactory) {
    this.originalObject = object;
    this.objectFactory = objectFactory;
    this.objectWrapperFactory = objectWrapperFactory;
    this.reflectorFactory = reflectorFactory;

    if (object instanceof ObjectWrapper) {
      this.objectWrapper = (ObjectWrapper) object;
    } else if (objectWrapperFactory.hasWrapperFor(object)) {
      this.objectWrapper = objectWrapperFactory.getWrapperFor(this, object);
    } else if (object instanceof Map) {
      this.objectWrapper = new MapWrapper(this, (Map) object);
    } else if (object instanceof Collection) {
      this.objectWrapper = new CollectionWrapper(this, (Collection) object);
    } else {
      this.objectWrapper = new BeanWrapper(this, object);
    }
  }

在这里插入图片描述

五、外观模式注意事项和细节

外观模式对外屏蔽了子系统的细节，因此外观模式降低了客户端对子系统使用的复杂性
外观模式对客户端与子系统的耦合关系-解耦，让子系统内部的模块更易维护和扩展
通过合理的使用外观模式，可以帮助我们更好的划分访问的层次
在维护一个遗留的大型系统时，可能这个系统以及变得非常难以维护和扩展，此时可以考虑为新系统开发一个Facade类，来提高遗留系统的比较清晰简单的接口，让新系统与Facade类交互，提高复用性
不同过多的或者不合理的使用外观模式，使用外观模式好，还是直接调用模块好，要以让系统有层次，利于维护为目的

梓莘

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【设计模式】外观模式

外观模式组建一个家庭影院：DVD播放器、投影仪、自动屏幕、环绕立体声、爆米花机、要求完成所有的功能，其过程包括直接用遥控器，统筹各设备开关开爆米花机放下屏幕开投影仪开音响开DVD去拿爆米花调暗灯光播放观影结束，关闭各种设备首先我们想到的就是为每个设备使用一个遥控器一、传统方式问题分析在ClientTest的main方法中，创建各个子系统的对象，并直接去调用子系统（对象）的相关方法，会造成调用过程混乱。没有清晰的过程不利于ClientTest中，去维护对子系统的操作解
复制链接

扫一扫