外观模式（Facade）---结构型模式

1 基础知识

定义：提供了一个统一的接口（外观类），用来访问子系统中的一群接口。特征：定义了一个高层接口让子系统更容易使用，减少了外部与子系统内多个模块的耦合。

本质：封装交互，简化调用。

优点：简化了调用过程，无需深入了解子系统；减少系统依赖、松散耦合；符合迪米特原则。缺点：增加子系统、扩展子系统行为时容易引入风险；不符合开闭原则当增加功能时外观类也要发生变化。

使用场景：

（1）如果你希望为一个复杂的子系统提供一个简单接口的时候，可以考虑使用外观模式。使用外观对象来实现大部分客户需要的功能，从而简化客户的使用。

（2）如果想要让客户程序和抽象类的实现部分松散耦合，可以考虑使用外观模式使用外观对象来将这个子系统与它的客户分离开来，从而提高子系统的独立性和可移植

（3）如果构建多层结构的系统，可以考虑使用外观模式，使用外观对象作为每层的入口，这样可以简化层间调用，也可以松散层次之间的依赖关系。

2 代码示例

 场景：以网站的积分兑换礼物为例，首先需要验证积分是否足够能兑换，然后扣除积分，最后进入物流，这样就涉及到三个子系统：

礼物类 PointsGift：

/**
 * 积分礼物类
 */
public class PointsGift {
    private String name;

    public PointsGift(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

积分验证子系统：QualifyService

public class QualifyService {
    
    public boolean isAvailable(PointsGift pointsGift){
        System.out.println("校验"+pointsGift.getName()+" 积分资格通过,库存通过");
        return true;
    }
}

支付积分子系统：PointsPaymentService 

public class PointsPaymentService {

    public boolean pay(PointsGift pointsGift){
        //扣减积分
        System.out.println("支付"+pointsGift.getName()+" 积分成功");
        return true;
    }

}

物流子系统：ShippingService

public class ShippingService {
    //运送商品
    public String shipGift(PointsGift pointsGift){
        //物流系统的对接逻辑
        System.out.println(pointsGift.getName()+"进入物流系统");
        //物流的订单号
        String shippingOrderNo = "666";
        return shippingOrderNo;
    }
}

这样就需要应用层一次与这三个子系统进行对接调用，还必要严格按照顺序，因此是比较麻烦的，故考虑设计一个类管理这三个系统，应用层只需要和这个管理类交换即可，这样充分满足了迪米特原则。

外观类：GiftExchangeService

public class GiftExchangeService {
    //注入三个子系统
    private QualifyService qualifyService = new QualifyService();
    private PointsPaymentService pointsPaymentService = new PointsPaymentService();
    private ShippingService shippingService = new ShippingService();

    public void giftExchange(PointsGift pointsGift){
        if(qualifyService.isAvailable(pointsGift)){
            //资格校验通过
            if(pointsPaymentService.pay(pointsGift)){
                //如果支付积分成功
                String shippingOrderNo = shippingService.shipGift(pointsGift);
                System.out.println("物流系统下单成功,订单号是:"+shippingOrderNo);
            }
        }
    }

}

应用层只需要简单的调用即可：

public class Test {
    public static void main(String[] args) {
        PointsGift pointsGift = new PointsGift("T恤");
        GiftExchangeService giftExchangeService = new GiftExchangeService();
        //兑换礼物
        giftExchangeService.giftExchange(pointsGift);
    }
}

其类关系图如下图所示：

外观模式的结构示意图：

可以看出应用层只与外观类发生了交互，这也是判断外观模式设置是否合理的重要标志。外观类相当于提供了一个接口，应用层直接通过接口操作三个子类，而不需要关心三个子类的具体实现，当然还可以把外观类做成一个接口，然后再实现，这样虽然增加了系统的复杂度但是减少了外观类的方法的暴露。可以理解为：外观类有些方法是让外部调用的，有些方法是处理子系统内部的，在接口中只写外部调用的方法，内部使用的方法写在接口的实现类中。当新增一个子系统时还要修改外观类，从这一角度分析其并不符合开闭原则的。

 3 源码中的使用

（1）JDBC中的使用

对JdbcUtils对象查看其方法，关注其参数可以看到有Connection、Statement、DataSource这些Jdbc中含的对象，这里JdbcUtils就是外观类，对原生态的Jdbc进行了封装。

 

（2）mybatis中的使用

在Connection类中有这些方法：

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

    public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
        ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
        parameterHandler = (ParameterHandler)this.interceptorChain.pluginAll(parameterHandler);
        return parameterHandler;
    }

    public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler, ResultHandler resultHandler, BoundSql boundSql) {
        ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
        ResultSetHandler resultSetHandler = (ResultSetHandler)this.interceptorChain.pluginAll(resultSetHandler);
        return resultSetHandler;
    }

    public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
        StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
        StatementHandler statementHandler = (StatementHandler)this.interceptorChain.pluginAll(statementHandler);
        return statementHandler;
    }

这些以new开头的方法均是外观模式的体现，应用层通过Connection类的某一方法来具体使用某一功能，若关注其中的第一个new的话也可以说是简单工厂模式，从整体上而言则是外观模式。

 4 相关模式

 （1）外观模式和中介者模式

这两个模式非常类似，但是却有本质的区别。中介者模式主要用来封装多个对象之间相互的交互，多用在系统内部的多个模块之间;而外观模式封装的是单向的交互，是从客端访问系统的调用，没有从系统中来访问客户端的调用。在中介者模式的实现里面，是需要实现具体的交互功能的;而外观模式的实现般是组合调用或是转调内部实现的功能，通常外观模式本身并不实现里面这些功能。中介者模式的目的主要是松散多个模块之间的耦合，把这些耦合关系全部放到中介者中去实现;而外观模式的目的是简化客户端的调用，这点和中介者模式也不同。

（2）外观模式和单例模式

通常一个子系统只需要一个外观实例，所以外观模式可以和单例模式组合使用，把 Facade类实现成为单例。当然，也可以把外观类的构造方法私有化，然后把提供给客户端的方法实现成为静态的。

（3）外观模式和抽象工厂模式

外观模式的外观类通常需要和系统内部的多个模块交互，每个模块一般都有自己的接口，所以在外观类的具体实现里面，需要获取这些接口，然后组合这些接口来完成客户端的功能。那么怎么获取这些接口呢?就可以和抽象工厂一起使用，外观类通过抽象工厂来获取所需要的接口，而抽象工厂也可以把模块内部的实现对 Facade进行屏蔽，也就是说 Facade也仅仅只是知道它从模块中获取它需要的功能，模块内部的细节， Facade也不知道。 

0