设计模式系列—外观模式

前言

创新互联专注于企业成都全网营销推广、网站重做改版、新泰网站定制设计、自适应品牌网站建设、H5场景定制、购物商城网站建设、集团公司官网建设、外贸网站建设、高端网站制作、响应式网页设计等建站业务，价格优惠性价比高，为新泰等各大城市提供网站开发制作服务。

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

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

总体概览

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

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

解决的问题

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

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

 
 
 
 
      
  
  
  
  1. class SubSystemOne { 
    2.   
  
  
  
  2.     public void methodOne() { 
    3.   
  
  
  
  3.         System.out.println("子系统方法一"); 
    4.   
  
  
  
  4.     } 
    5.   
  
  
  
  5. } 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. class SubSystemTwo { 
    8.   
  
  
  
  8.     public void methodTwo() { 
    9.   
  
  
  
  9.         System.out.println("子系统方法二"); 
    10.   
  
  
  
  10.     } 
    11.   
  
  
  
  11. } 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13. class SubSystemThree { 
    14.   
  
  
  
  14.     public void methodThree() { 
    15.   
  
  
  
  15.         System.out.println("子系统方法三"); 
    16.   
  
  
  
  16.     } 
    17.   
  
  
  
  17. } 
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19. class SubSystemFour { 
    20.   
  
  
  
  20.     public void methodFour() { 
    21.   
  
  
  
  21.         System.out.println("子系统方法四"); 
    22.   
  
  
  
  22.     } 
    23.   
  
  
  
  23. } 
    24.

步骤2：定义Facade角色

 
 
 
 
      
  
  
  
  1. class Facade { 
    2.   
  
  
  
  2.     SubSystemOne one; 
    3.   
  
  
  
  3.     SubSystemTwo two; 
    4.   
  
  
  
  4.     SubSystemThree three; 
    5.   
  
  
  
  5.     SubSystemFour four; 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7.     public Facade() { 
    8.   
  
  
  
  8.         this.one = new SubSystemOne(); 
    9.   
  
  
  
  9.         this.two = new SubSystemTwo(); 
    10.   
  
  
  
  10.         this.three = new SubSystemThree(); 
    11.   
  
  
  
  11.         this.four = new SubSystemFour(); 
    12.   
  
  
  
  12.     } 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.     public void MethodA() { 
    15.   
  
  
  
  15.         System.out.println("方法组A()----"); 
    16.   
  
  
  
  16.         one.methodOne(); 
    17.   
  
  
  
  17.         two.methodTwo(); 
    18.   
  
  
  
  18.         four.methodFour(); 
    19.   
  
  
  
  19.     } 
    20.   
  
  
  
  20.  
    21.   
  
  
  
  21.     public void MethodB() { 
    22.   
  
  
  
  22.         System.out.println("方法组B()----"); 
    23.   
  
  
  
  23.         two.methodTwo(); 
    24.   
  
  
  
  24.         three.methodThree(); 
    25.   
  
  
  
  25.     } 
    26.   
  
  
  
  26. } 
    27.

步骤3：验证输出结果

 
 
 
 
      
  
  
  
  1. /** 
    2.   
  
  
  
  2.  * 外观/门面模式 
    3.   
  
  
  
  3.  */ 
    4.   
  
  
  
  4. public class FacadePattern { 
    5.   
  
  
  
  5.  
    6.   
  
  
  
  6.     public static void main(String[] args) { 
    7.   
  
  
  
  7.         Facade facade = new Facade(); 
    8.   
  
  
  
  8.         facade.MethodA(); 
    9.   
  
  
  
  9.         facade.MethodB(); 
    10.   
  
  
  
  10.         System.out.println("----over----"); 
    11.   
  
  
  
  11.     } 
    12.   
  
  
  
  12. } 
    13.

输出如下：

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

优点

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

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

应用场景

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

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

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

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

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

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

源码中的应用

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

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

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

未使用 Facade 模式前如下：

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

 
 
 
 
      
  
  
  
  1. public class ServletProcess { 
    2.   
  
  
  
  2.     public void process(Request request, Response response){ 
    3.   
  
  
  
  3.         //.... 
    4.   
  
  
  
  4.         servlet = (Servlet) myClass.newInstance(); 
    5.   
  
  
  
  5.         servlet.service((ServletRequest) request, (ServletResponse) response); 
    6.   
  
  
  
  6.     } 
    7.   
  
  
  
  7. } 
    8.

而使用 Facade 模式之后如下：

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

 
 
 
 
      
  
  
  
  1. public class ServletProcess { 
    2.   
  
  
  
  2.     public void process(Request request, Response response){ 
    3.   
  
  
  
  3.         //.... 
    4.   
  
  
  
  4.         RequestFacade requestFacade = new RequestFacade(request); 
    5.   
  
  
  
  5.         ResponseFacade responseFacade = new ResponseFacade(response); 
    6.   
  
  
  
  6.         servlet = (Servlet) myClass.newInstance(); 
    7.   
  
  
  
  7.         servlet.service((ServletRequest) requestFacade, (ServletResponse) responseFacade); 
    8.   
  
  
  
  8.     } 
    9.   
  
  
  
  9. } 
    10.

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

 
 
 
 
      
  
  
  
  1. public class RequestFacade implements HttpServletRequest { 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.    private ServletRequest request; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.     public RequestFacade(ServletRequest request) { 
    6.   
  
  
  
  6.         this.request = request; 
    7.   
  
  
  
  7.     } 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9.     @Override 
    10.   
  
  
  
  10.     public String getAuthType() { 
    11.   
  
  
  
  11.         return request.getAuthType(); 
    12.   
  
  
  
  12.     } 
    13.   
  
  
  
  13. } 
    14.

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

Configuration源码分析

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

Configuration部分源码

 
 
 
 
      
  
  
  
  1. //Configuration 类： 
    2.   
  
  
  
  2. public class Configuration { 
    3.   
  
  
  
  3.  protected ReflectorFactory reflectorFactory = new DefaultReflectorFactory(); 
    4.   
  
  
  
  4.  protected ObjectFactory objectFactory = new DefaultObjectFactory(); 
    5.   
  
  
  
  5.    protected ObjectWrapperFactory objectWrapperFactory = new DefaultObjectWrapperFactory(); 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7.   public MetaObject newMetaObject(Object object) { 
    8.   
  
  
  
  8.      return MetaObject.forObject(object, objectFactory, objectWrapperFactory, reflectorFactory); 
    9.   
  
  
  
  9.     } 
    10.   
  
  
  
  10. } 
    11.   
  
  
  
  11.  
    12.   
  
  
  
  12. //MetaObject类 
    13.   
  
  
  
  13. public class MetaObject { 
    14.   
  
  
  
  14.  private Object originalObject; 
    15.   
  
  
  
  15.  private ObjectWrapper objectWrapper; 
    16.   
  
  
  
  16.  private ObjectFactory objectFactory; 
    17.   
  
  
  
  17.  private ObjectWrapperFactory objectWrapperFactory; 
    18.   
  
  
  
  18.  private ReflectorFactory reflectorFactory; 
    19.   
  
  
  
  19.  
    20.   
  
  
  
  20.  public static MetaObject forObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory, ReflectorFactory reflectorFactory) { 
    21.   
  
  
  
  21.      if (object == null) { 
    22.   
  
  
  
  22.       return SystemMetaObject.NULL_META_OBJECT; 
    23.   
  
  
  
  23.      } else { 
    24.   
  
  
  
  24.         return new MetaObject(object, objectFactory, objectWrapperFactory, reflectorFactory); 
    25.   
  
  
  
  25.      } 
    26.   
  
  
  
  26.   } 
    27.   
  
  
  
  27.  
    28.   
  
  
  
  28.  private MetaObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory, ReflectorFactory reflectorFactory) { 
    29.   
  
  
  
  29.      this.originalObject = object; 
    30.   
  
  
  
  30.      this.objectFactory = objectFactory; 
    31.   
  
  
  
  31.      this.objectWrapperFactory = objectWrapperFactory; 
    32.   
  
  
  
  32.      this.reflectorFactory = reflectorFactory; 
    33.   
  
  
  
  33.  
    34.   
  
  
  
  34.      if (object instanceof ObjectWrapper) { 
    35.   
  
  
  
  35.         this.objectWrapper = (ObjectWrapper) object; 
    36.   
  
  
  
  36.      } else if (objectWrapperFactory.hasWrapperFor(object)) { 
    37.   
  
  
  
  37.         this.objectWrapper = objectWrapperFactory.getWrapperFor(this, object); 
    38.   
  
  
  
  38.      } else if (object instanceof Map) { 
    39.   
  
  
  
  39.         this.objectWrapper = new MapWrapper(this, (Map) object); 
    40.   
  
  
  
  40.      } else if (object instanceof Collection) { 
    41.   
  
  
  
  41.        this.objectWrapper = new CollectionWrapper(this, (Collection) object); 
    42.   
  
  
  
  42.      } else { 
    43.   
  
  
  
  43.         this.objectWrapper = new BeanWrapper(this, object); 
    44.   
  
  
  
  44.     } 
    45.   
  
  
  
  45.  } 
    46.   
  
  
  
  46. } 
    47.

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

PS：以上代码提交在 Github ：

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

本文题目：设计模式系列—外观模式
链接URL：http://www.shufengxianlan.com/qtweb/news37/218387.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站收录知识

分类信息网

网站制作公司　　 　圣月阀门　　 　网站域名　　 　成都网站排名　　 　绵阳服务器托管　　 　定制级高端网站建设　　 　买友情链接　　 　网站seo　　 　成都圣月服饰　　 　网站建设公司　　 　成都网站设计　　 　云锦斋建筑　　 　普特斯腐植酸　　 　成都网站运营维护　　 　达州网站设计　　 　云服务器　　 　全网营销推广　　 　成都网站设计　　 　成都雨棚定制　　 　成都网站建设