前言

• 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("子系统方法四");
    }
}

步骤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();
    }
}

步骤3：验证输出结果

/**
 * 外观/门面模式
 */
public class FacadePattern {

    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.MethodA();
        facade.MethodB();
        System.out.println("----over----");
    }
}

输出如下：

方法组A()----
子系统方法一
子系统方法二
子系统方法四
方法组B()----
子系统方法二
子系统方法三
----over----

优点

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

缺点

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

应用场景

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

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

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

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

与适配器模式的区别

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

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

源码中的应用

#tomcat
org.apache.catalina.connector.RequestFacade
org.apache.catalina.connector.ResponseFacade
#mybatis
Configuration
......

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);
    }
}

而使用 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);
    }
}

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

public class RequestFacade implements HttpServletRequest {

   private ServletRequest request;

    public RequestFacade(ServletRequest request) {
        this.request = request;
    }

    @Override
    public String getAuthType() {
        return request.getAuthType();
    }
}

对象里有个 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);
    }
 }
}

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

部分图片来源于网络，版权归原作者，侵删。

👇点击阅读原文，查看往期内容！

                                快留言👇和我互动吧～