设计模式-行为型-中介者模式

设计模式

---

---

前言

在复杂系统中，大多存在对象之间混乱无序的依赖关系，对软件的维护造成困扰，所以通过引入中介者模式，来限制对象间的直接交互，强迫对象之间通过一个中介者类来进行合作。

---

一、中介者模式（调解者，调停者，Mediator Pattern）

用一个中介对象封装一系列对象的交互，中介者使各个对象不直接相互作用，从而达到松散耦合，而且可以独立改变他们之间的交互。
例如：原本有A,B,C,D…N，N个对象，他们之间存在互相复杂的依赖交互，导致他们之间的关系结构为网状结构，形成了过渡耦合的状态，这样的结构不利于复用也不利于扩展，所以引入了一个调解者类，使对象间的之间依赖结构通过中介者类进行依赖，形成星状结构，来提高代码的可扩展型，达到松散耦合的目的。

二、 角色

1. 抽象中介者（IMediator）:抽象统一的接口，用于同事类之间的通信。
2. 具体中介者（ConcreteMediator）：从具体的同事对象接受消息，像具体同事对象发出命令，协调同事之间的协作。
3. 抽象同事类（IColleague）：每个同时对象都需要依赖中介者角色，与其他同事间通讯时，交由中介者进行转发协作。
4. 具体同事类（ConcreteColleague）：负责实现自发行为，转发依赖方法，交友中介者进行协调。

三 、应用场景

• 系统中对象之间存在复杂的引用关系，产生的相互依赖关系结构混乱且难以理解。
• 交互的公共行为，如果需要该百年行为，则可以增加新的中介者类。

二、代码实现

1. 基础周边类

代码如下（示例）：依赖于抽象中介者接口，将中介者属性进行共享，被具体周边类继承。

	/// 

    /// 基础周边类
    /// 依赖于抽象中介者接口，将中介者属性进行共享
    /// 
    public abstract class BaseComponent
    {
        /// 

        /// 抽象中介者属性，被子类共享调用
        /// 
        protected IMediator mediator;
        public BaseComponent(IMediator mediator = null)
        {
            this.mediator = mediator;
        }
        public virtual void setThisData(IMediator mediator) {
            this.mediator = mediator;
        }
    }
    

2.周边类

代码如下（示例）： 继承基础周边类，实现内部方法，及通过父级定义的抽象中介者来访问其他关联类

	/// 

    /// 周边类A
    /// 继承基础周边类，实现内部方法，及通过父级定义的抽象中介者来访问其他关联类
    /// 周边A------->BaseComponent.mediator(父级的属性)------->IMediator（抽象中介者）------->ConcreteMediator（具体中介者类）------->周边B
    /// 原流程：周边A------->周边B
    /// 
    public class A_Component : BaseComponent
    {       
        public void DoA()
        {
            Console.WriteLine("Component 1 does A.");
            this.mediator.Notify(this, "A");
        }
        public void DoB()
        {
            Console.WriteLine("Component 1 does B.");
            this.mediator.Notify(this, "B");
        }
    }
    /// 

    /// 周边类B
    /// 
    public class B_Component : BaseComponent
    {

        public void DoC()
        {
            Console.WriteLine("Component 2 does C.");
            this.mediator.Notify(this, "C");
        }
        public void DoD()
        {
            Console.WriteLine("Component 2 does D.");
            this.mediator.Notify(this, "D");
        }
    }

3.抽象中介者接口

代码如下（示例）：定义抽象统一接口，用于周边类的互相调用的抽象策略。

	/// 

    /// 抽象中介者接口
    /// 
    public interface IMediator
    {
        void Notify(object sender, string ev);
    }

4.中介者类

代码如下（示例）：抽象中介者接口的实现，完成对象方法的转发及交互行为

	/// 

    /// 实现中介者类
    /// 完成对象方法的转发及交互行为
    /// 
    public class ConcreteMediator : IMediator
    {
        private A_Component a_Component;
        private B_Component b_Component;
        /// 

        /// 构造中介者类，使周边类可以访问中介者类中的所有对象。
        /// 
        /// 
        /// 
        public ConcreteMediator(A_Component a_Component, B_Component b_Component)
        {
            this.a_Component = a_Component;
            //将当前对象添加到
            this.a_Component.setThisData(this);
            this.b_Component = b_Component;
            this.b_Component.setThisData(this);
        }
        /// 

        /// 实现抽象统一接口的不同实现，用于周边类的互相调用。
        /// 
        /// 
        /// 
        public void Notify(object sender, string ev)
        {
            if (ev == "A")
            {
                this.b_Component.DoC();
            }
            if (ev == "D")
            {
                this.a_Component.DoB();
                this.b_Component.DoC();
            }
        }
    }

5.客户端

代码如下（示例）：客户端调用逻辑

	/// 

    /// 客户端
    /// 
    public class MediatorClienter
    {
        public void ClientMain()
        {
           //周边类实例化
            A_Component a = new A_Component();
            B_Component b = new B_Component();
            //创建一个中间件对象,并对周边类的IMediator对象进行赋值
            var centerClass=new ConcreteMediator(a, b);
            Console.WriteLine("Client triggets operation A");
            a.DoA();
            Console.WriteLine("Client triggets operation D");
            b.DoD();
        }
    }

6.代码输出

Client triggets operation A
Component 1 does A.
Component 2 does C.
Client triggets operation D
Component 2 does D.
Component 1 does B.
Component 2 does C.

---

总结

优点

• 减少了类之间的直接依赖，将多对多依赖转化成一对多，降低了类间耦合。
• 类间各司其职，复合单一职责及迪米特法则。

缺点

-将多个对象直接相互依赖编程中介者和多周边类的依赖关系，周边类越多，代码就会越臃肿，变得复杂难以维护。