2.7设计模式之外观模式（Facade）

2.7.1 模式意图:

系统中常含有多个子系统，随着子系统不断增多，如果始终保持对子系统的直接调用，会明显提高业务逻辑和子系统间的耦合度，造成系统混乱，加大阅读困难，这时我们可以使用外观模式，用此模式持有多个子系统的引用，通过外观这个中间层达到由原来的多对多转变为一对多的情况，对多个子系统的调用就像使用菜单一样，一目了然，利于代码的阅读理解和维护。

2.7.2 模式概念:

又称为门面模式，属于结构型模式。为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

2.7.3 模式元素:

• 外观（Facade）
• 子系统（IPhysicalSystem、IRenderingSystem、IMoveSystem）

2.7.4 代码示例:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Custom.Log;

interface IPhysicalSystem
{
    void Initialize();
    void Update();
}
interface IRenderingSystem
{
    void Initialize();
    void Update();
}
interface IMoveSystem
{
    void Initialize();
    void Update();
}

public class PhysicalSystem : IPhysicalSystem
{
    public void Initialize() { Degbug.Log($"初始化{nameof(PhysicalSystem)}"); }
    public void Update() { Degbug.Log($"更新{nameof(PhysicalSystem)}"); }
}
public class RenderingSystem : IRenderingSystem
{
    public void Initialize() { Degbug.Log($"初始化{nameof(RenderingSystem)}"); }
    public void Update() { Degbug.Log($"更新{nameof(RenderingSystem)}"); }
}
public class MoveSystem : IMoveSystem
{
    public void Initialize() { Degbug.Log($"初始化{nameof(MoveSystem)}"); }
    public void Update() { Degbug.Log($"更新{nameof(MoveSystem)}"); }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Custom.Log;
public class Facade
{
    #region Facade
    static Facade() { }
    private Facade() { }

    private readonly static object staticsync = new object();

    private volatile static Facade instance = null;

    public static Facade Instance
    {
        get
        {
            if (instance == null)
            {
                lock (staticsync)
                {
                    if (instance == null)
                    {
                        instance = new Facade();
                    }
                }
            }
            return instance;
        }
    }
    #endregion

    private IMoveSystem moveSystem = new MoveSystem();
    private IPhysicalSystem physicalSystem = new PhysicalSystem();
    private IRenderingSystem renderingSystem = new RenderingSystem();
    public void Initialize()
    {
        moveSystem.Initialize();
        physicalSystem.Initialize();
        renderingSystem.Initialize();
    }

    public void Update()
    {
        moveSystem.Update();
        physicalSystem.Update();
        renderingSystem.Update();
    }
}

调用

public class FacadeComponent : MonoBehaviour
{
    Facade facade = null;

    void Start()
    {
        facade = Facade.Instance;
        facade.Initialize();
    }

    private void Update()
    {
        facade.Update();
    }
}

2.7.5 写法对比:

略

2.7.6 模式分析:

外观模式相对于其他设计模式来讲是一种既简单又实用的编程技巧。
其实外观模式的这种思想在生活中也有很广的应用，例如： 1.我们去餐厅吃饭时菜单和点菜器，这就是一种外观模式的体现，我们不需要跟各类厨师进行交互，只需要对菜单发出“指令”即可。 2.电脑的开机键，一键开机，不需要通知CPU、显卡、内存、硬盘等电子元件开始工作。

这种结构，使得我们上层调用的时候不需要知道明确的子系统，只需要知道Facade定义的对应函数即可，降低耦合度，符合迪米特法则，但它的缺点就是破坏了开闭原则，如果后期子系统有改动，Facade会变动比较频繁。

还有一个要注意的是，Facade只能调用其子系统中含有的函数，完成对各个子系统自带函数的拼装，不能自建新的业务逻辑，例如我们的示例，要在Facade类里面根据moveSystem添加新的业务逻辑这个是不允许的，，而且外观模式封装的是单向交互，是从客户端访问系统的调用，不允许从系统中来访问客户端的调用。

这些注意要素其实在PureMVCFramework中就有很好的体现，在对应的Facade类中（如下所示），仅仅就是模型、视图、控制层这些子系统的单向调用自身函数，并没有添加一些其他的自建业务逻辑。

namespace PureMVC.Patterns.Facade
{
    public class Facade : IFacade
    {
        //省略其他代码***
        public virtual void RegisterCommand(string notificationName, Func commandFunc)
        {
            controller.RegisterCommand(notificationName, commandFunc);
        }

        public virtual void RemoveCommand(string notificationName)
        {
            controller.RemoveCommand(notificationName);
        }

        public virtual bool HasCommand(string notificationName)
        {
            return controller.HasCommand(notificationName);
        }

        public virtual void RegisterProxy(IProxy proxy)
        {
            model.RegisterProxy(proxy);
        }

        public virtual IProxy RetrieveProxy(string proxyName)
        {
            return model.RetrieveProxy(proxyName);
        }

        public virtual IProxy RemoveProxy(string proxyName)
        {
            return model.RemoveProxy(proxyName);
        }

        public virtual bool HasProxy(string proxyName)
        {
            return model.HasProxy(proxyName);
        }
    }
}

2.7.7 应用场景:

需要对多个子系统的单向调用。

2.7.8 小结:

利用外观模式来降低业务逻辑与各子系统间的耦合度，同时也要注意后续频繁改动需求，引起的Facade类发生一系列改变而带来的风险。

---

更多设计模式详见：设计模式全家桶