设计模式系列—外观模式

开发 前端
本篇和大家一起来学习外观(门面)模式相关内容,外观模式一定是我们平常使用最多的一种。

前言

  • 23种设计模式速记
  • 单例(singleton)模式
  • 工厂方法(factory method)模式
  • 抽象工厂(abstract factory)模式
  • 建造者/构建器(builder)模式
  • 原型(prototype)模式
  • 享元(flyweight)模式
  • 持续更新中......

23种设计模式快速记忆的请看上面第一篇,本篇和大家一起来学习外观(门面)模式相关内容,外观模式一定是我们平常使用最多的一种。 

总体概览

模式定义
为子系统中的一组接口提供一个一致的接口,Facade 模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。

通过创建一个统一的外观类,用来包装子系统中一个 / 多个复杂的类,客户端可通过调用外观类的方法来调用内部子系统中所有方法。

解决的问题

  • 避免了系统与系统之间的高耦合度
  • 使得复杂的子系统用法变得简单

实例说明
步骤1:定义subsystem角色

class SubSystemOne { 
    public void methodOne() { 
        System.out.println("子系统方法一"); 
    } 

 
class SubSystemTwo { 
    public void methodTwo() { 
        System.out.println("子系统方法二"); 
    } 

 
class SubSystemThree { 
    public void methodThree() { 
        System.out.println("子系统方法三"); 
    } 

 
class SubSystemFour { 
    public void methodFour() { 
        System.out.println("子系统方法四"); 
    } 

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.

步骤2:定义Facade角色

class Facade { 
    SubSystemOne one; 
    SubSystemTwo two; 
    SubSystemThree three; 
    SubSystemFour four; 
 
    public Facade() { 
        this.one = new SubSystemOne(); 
        this.two = new SubSystemTwo(); 
        this.three = new SubSystemThree(); 
        this.four = new SubSystemFour(); 
    } 
 
    public void MethodA() { 
        System.out.println("方法组A()----"); 
        one.methodOne(); 
        two.methodTwo(); 
        four.methodFour(); 
    } 
 
    public void MethodB() { 
        System.out.println("方法组B()----"); 
        two.methodTwo(); 
        three.methodThree(); 
    } 

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.

步骤3:验证输出结果

/** 
 * 外观/门面模式 
 */ 
public class FacadePattern { 
 
    public static void main(String[] args) { 
        Facade facade = new Facade(); 
        facade.MethodA(); 
        facade.MethodB(); 
        System.out.println("----over----"); 
    } 

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.

输出如下:

方法组A()---- 
子系统方法一 
子系统方法二 
子系统方法四 
方法组B()---- 
子系统方法二 
子系统方法三 
----over---- 
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.

优点

  • 减少系统的相互依赖;
  • 外观模式通过封装子系统,向上层模块提供统一的接口,从而降低的上层模块与子系统的过度耦合;
  • 提高了灵活性;
  • 提高安全性。

缺点
不符合开闭原则:在不对外观类进行抽象的时候,如果需要添加新的子系统,就需要对Facade类进行修改。

应用场景

  • 要为一个复杂的子系统对外提供一个简单的接口
  • 提供子系统的独立性
  • 客户程序与多个子系统之间存在很大的依赖性

           引入外观类将子系统与客户以及其他子系统解耦,可以提高子系统的独立性和可移植性。

  • 在层次化结构中,可以使用外观模式定义系统中每一层的入口

          层与层之间不直接产生联系,而通过外观类建立联系,降低层之间的耦合度。

与适配器模式的区别
外观模式的实现核心主要是:由外观类去保存各个子系统的引用,实现由一个统一的外观类去包装多个子系统类,然而客户端只需要引用这个外观类,然后由外观类来调用各个子系统中的方法。

这样的实现方式非常类似适配器模式,然而外观模式与适配器模式不同的是:适配器模式是将一个对象包装起来以改变其接口,而外观是将一群对象 ”包装“起来以简化其接口。它们的意图是不一样的,适配器是将接口转换为不同接口,而外观模式是提供一个统一的接口来简化接口。

源码中的应用

#tomcat 
org.apache.catalina.connector.RequestFacade 
org.apache.catalina.connector.ResponseFacade 
#mybatis 
Configuration 
...... 
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.

RequestFacade源码分析
Tomcat中门面模式使用的很多,因为Tomcat中有很多不同组件,每个组件要相互通信,但是又不能将自己的内部数据过多的暴露给其他组件。用门面模式隔离数据是很好的方法。

Tomcat 中 Request 除了实现了 ServletRequest 接口外,还会有额外的一些函数,而这些函数需要被其他类调用,但这些方法不应该暴露给上层,因为上层应该专注于 ServletRequest 的实现。于是在 Tomcat 中会使用 Facade 模式了。

未使用 Facade 模式前如下:

未使用 Facade 模式前的 process 处理请求是这样的

public class ServletProcess { 
    public void process(Request request, Response response){ 
        //.... 
        servlet = (Servlet) myClass.newInstance(); 
        servlet.service((ServletRequest) request, (ServletResponse) response); 
    } 

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.

而使用 Facade 模式之后如下:

而使用 Facade 后的 process 处理请求是这样的

public class ServletProcess { 
    public void process(Request request, Response response){ 
        //.... 
        RequestFacade requestFacade = new RequestFacade(request); 
        ResponseFacade responseFacade = new ResponseFacade(response); 
        servlet = (Servlet) myClass.newInstance(); 
        servlet.service((ServletRequest) requestFacade, (ServletResponse) responseFacade); 
    } 

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.

为了达到这种效果,RequestFacade 使用了类似代理模式的实现方式。

public class RequestFacade implements HttpServletRequest { 
 
   private ServletRequest request; 
 
    public RequestFacade(ServletRequest request) { 
        this.request = request; 
    } 
 
    @Override 
    public String getAuthType() { 
        return request.getAuthType(); 
    } 

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.

对象里有个 ServletRequest 对象,而 RequestFacade 的所有方法都会委托给 ServletRequest 调用。

Configuration源码分析

由上面的类图可以看出,client只需要调用Configuration的newMetaObject(Object object)方法就可以得到一个MetaObject对象,而具体的对象是怎么生成与client无关,下面我们可以看一下Configuration的部分源码分析。

Configuration部分源码

//Configuration 类: 
public class Configuration { 
 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); 
    } 

 
//MetaObject类 
public class MetaObject { 
 private Object originalObject; 
 private ObjectWrapper objectWrapper; 
 private ObjectFactory objectFactory; 
 private ObjectWrapperFactory objectWrapperFactory; 
 private ReflectorFactory 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); 
    } 
 } 

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.

由上面的部分源码可以看出,客户端只需要调用Configuration的newMetaObject(Object object)方法,并传递一个Object参数,就可以获取对应的MetaObject,至于具体的产生什么样的MetaObject,则有MetaObject的类的forObject(object, objectFactory, objectWrapperFactory, reflectorFactory)方法实现。

PS:以上代码提交在 Github :

https://github.com/Niuh-Study/niuh-designpatterns.git

责任编辑:姜华 来源: 今日头条
相关推荐

2021-03-18 15:33:22

设计模式外观

2022-02-15 22:45:00

前端设计模式

2022-01-12 13:33:25

工厂模式设计

2010-01-21 09:08:53

.NET设计模式

2020-11-03 13:05:18

命令模式

2020-11-04 08:54:54

状态模式

2021-06-09 08:53:34

设计模式策略模式工厂模式

2021-03-02 08:50:31

设计单例模式

2020-10-21 14:29:15

原型模式

2021-09-29 13:53:17

抽象工厂模式

2020-10-19 09:28:00

抽象工厂模式

2022-01-14 09:22:22

设计模式桥接

2013-11-26 15:48:53

Android设计模式SDK

2021-10-28 19:09:09

模式原型Java

2021-10-26 00:21:19

设计模式建造者

2020-11-09 08:20:33

解释器模式

2020-10-28 11:56:47

桥接模式

2012-01-13 15:59:07

2020-10-20 13:33:00

建造者模式

2020-11-05 09:38:07

中介者模式
点赞
收藏

51CTO技术栈公众号