门面设计模式

​

我的理解什么是门面模式：就是把一个业务模块所有的的接口放在一个门面接口里面，我去访问某个业务模块里的接口的时候，我就只访问，这一个门面接口就可以了，用户仅仅跟门面接口打交道就可以了不用在去管门面接口里面的接口怎么调用的，好处就是当我访问一个业务模块的时候就只用访问一个接口就可以了不用逐个接口的访问。

举个生活中的例子

又有一位农民，有了钱想要去建造一个自己小房子，怎么办呢，首先，我要雇一个搬砖的和一个和泥的，还要一个会砌墙的人；可是我到哪里去找这些人，还要一个一个跟他们谈价钱；不知道他们和不和得来，会不会干一半不干了；

要是有一个人什么都会就好，我只要跟他谈，他一个人就能帮我把房子建好，现在就有了一个包工头，他说它啥都会，可以帮你搬砖，帮你和泥，帮你砌墙，总计就可以帮你完成建房子的业务。
总之，我就是想省心；

怎么实现呢

找到能搬砖，和泥和砌墙的人。

砌墙

package com.门面模式;

public interface IqiQiang {
    void qiQiang();
}

​砌砖

package com.门面模式;

public interface IqiZhuan {
    void qiZhuan();
}

和水泥

package com.门面模式;

public interface IheHuiNi {
    void heHuiNi();
}

包工头接口

package com.门面模式;

public interface BaoGongPerson extends IqiQiang , IheHuiNi, IqiZhuan{
        void doSome();
}

包公头的实现类

package com.门面模式;

public class BaoGongTouImp implements BaoGongPerson{
    @Override
    public void heHuiNi() {
        System.out.println("我能和水泥");
    }

    @Override
    public void qiQiang() {
        System.out.println("我能砌墙");
    }
    @Override
    public void qiZhuan() {
        System.out.println("我能砌砖");
    }

    @Override
    public void doSome() {
        System.out.println("我要干点其他事");
    }
}

场景类

package com.门面模式;

public class Client {

public static void main(String[] args) {
    //模拟我去建造房子

    BaoGongPerson baoGongPerson = new BaoGongTouImp();

//    我需要 砌砖的
    baoGongPerson.qiZhuan();
//    我需要 和水泥的
    baoGongPerson.heHuiNi();
//    我需要 砌墙的
    baoGongPerson.qiQiang();
//盖房子了
    baoGongPerson.doSome();
}
}

结果

这样的话就极大的方便了，农民要想盖房子的过程了。
门面模式的定义
门面模式（Facade Pattern）也叫做外观模式，是一种比较常用的封装模式，其定义如下：

要求一个子系统的外部与其内部的通信必须通
过一个统一的对象进行。门面模式提供一个高层次的接口，使得子系统更易于使用。
门面模式注重“统一的对象”，也就是提供一个访问子系统的接口，除了这个接口不允许
有任何访问子系统的行为发生，子接口之间不会发送行为关系。
类图是

类图就这么简单，但是它代表的意义可是异常复杂，Subsystem Classes是子系统
所有类的简称，它可能代表一个类，也可能代表几十个对象的集合。甭管多少对象，我们把
这些对象全部圈入子系统的范畴

再简单地说，门面对象是外界访问子系统内部的唯一通道，不管子系统内部是多么杂乱
无章，只要有门面对象在，就必须访问门面系统

● Facade门面角色 //包工头类

客户端可以调用这个角色的方法。此角色知晓子系统的所有功能和责任。一般情况下，
本角色会将所有从客户端发来的请求委派到相应的子系统去，也就说该角色没有实际的业务
逻辑，只是一个委托类
subsystem子系统角色
可以同时有一个或者多个子系统。每一个子系统都不是一个单独的类，而是一个类的集
合。子系统并不知道门面的存在。对于子系统而言，门面仅仅是另外一个客户端而已
由于子系统是类的集合，因
此要描述该集合很花费精力，每一个子系统都不相同，我们使用3个相互无关的类来代表

代码清单23-8 子系统
public class ClassA {
public void doSomethingA(){
//业务逻辑
}
}
public class ClassB {
public void doSomethingB(){
//业务逻辑
}
}
public class ClassC {
public void doSomethingC(){
//业务逻辑
}
}

我们认为这3个类属于近邻，处理相关的业务，因此应该被认为是一个子系统的不同逻
辑处理模块，对于此子系统的访问需要通过门面进行，

public class Facade {
//被委托的对象
private ClassA a = new ClassA();
private ClassB b = new ClassB();
private ClassC c = new ClassC();
//提供给外部访问的方法
public void methodA(){
this.a.doSomethingA();
}
public void methodB(){
this.b.doSomethingB();
}
public void methodC() {
	this.c.doSomething	C();
}

优点：
● 减少系统的相互依赖
想想看，如果我们不使用门面模式，外界访问直接深入到子系统内部，相互之间是一种
强耦合关系，你死我就死，你活我才能活，这样的强依赖是系统设计所不能接受的，门面模
式的出现就很好地解决了该问题，所有的依赖都是对门面对象的依赖，与子系统无关。
● 提高了灵活性
依赖减少了，灵活性自然提高了。不管子系统内部如何变化，只要不影响到门面对象，
任你自由活动。
● 提高安全性
想让你访问子系统的哪些业务就开通哪些逻辑，不在门面上开通的方法，你休想访问
到。
门面模式的缺点
门面模式最大的缺点就是不符合开闭原则，对修改关闭，对扩展开放，看看我们那个门
面对象吧，它可是重中之重，一旦在系统投产后发现有一个小错误，你怎么解决？完全遵从
开闭原则，根本没办法解决。继承？覆写？都顶不上用，唯一能做的一件事就是修改门面角
色的代码，
使用场景
● 为一个复杂的模块或子系统提供一个供外界访问的接口
● 子系统相对独立——外界对子系统的访问只要黑箱操作即可
一个子系统可以有多个门面

代码清单23-10 新增门面
public class Facade2 {
//引用原有的门面
private Facade facade = new Facade();
//对外提供唯一的访问子系统的方法
public void methodB(){
this.facade.methodB();
}
}

门面不参与子系统内的业务逻辑
我们举一个例子来说明，还是以通用源代码为例。我们
把门面上的methodC上的逻辑修改一下，它必须先调用ClassA的doSomethingA方法，然后再
调用ClassC的doSomethingC方法，如代码清单23-11所示。

public class Facade {
//被委托的对象
private ClassA a = new ClassA();
private ClassB b = new ClassB();
private ClassC c = new ClassC();
//提供给外部访问的方法
public void methodA(){
this.a.doSomethingA();
}
public void methodB(){
this.b.doSomethingB();
}
public void methodC(){
this.a.doSomethingA();
this.c.doSomethingC();
}
}

因为你已经让门面对象参与了业务逻辑，门面对象只是提供一个访问子系统的一个路径而已，，它不应该也不能参与具体的业务逻辑，否则就会产生一个倒依赖的问题：子系统必须依赖门面才能被访问，这是设计上一个严重错误，不仅违反了单一职责原则，同时也破坏了系统的封装性。

说了这么多，那对于这种情况该怎么处理呢？建立一个封装类，封装完毕后提供给门面
对象。我们先建立一个封装类，如代码清单23-12所示。

代码清单23-12 封装类
public class Context {
//委托处理
private ClassA a = new ClassA();
private ClassC c = new ClassC();
//复杂的计算
public void complexMethod(){
this.a.doSomethingA();
this.c.doSomethingC();
}
}

该封装类的作用就是产生一个业务规则complexMethod，并且它的生存环境是在子系统
内，仅仅依赖两个相关的对象，门面对象通过对它的访问完成一个复杂的业务逻辑，如代码

代码清单23-13 门面类
public class Facade {
//被委托的对象
private ClassA a = new ClassA();
private ClassB b = new ClassB();
private Context context = new Context();
//提供给外部访问的方法
public void methodA(){
this.a.doSomethingA();
}
public void methodB(){
this.b.doSomethingB();
}
public void methodC(){
this.context.complexMethod();
}
}