职责型设计模式之中介者模式_职责设计模式-优快云博客

本文链接：https://blog.youkuaiyun.com/fanxiaobin577328725/article/details/52838199

本文介绍中介者模式，一种用于减少对象间直接交互的设计模式。通过一个中心化的中介者对象协调各个同事对象之间的通信，降低系统中对象之间的耦合度。

一、前言

面向对象开发要求尽可能恰当地分配职责，要求对象能够独立完成自己的任务。例如观察者模式，就是通过最小化对象与对象之间的职责交互，从而支持职责的合理分配。单例模式是将职责集中在某个对象中以便其他对象的访问与重用。与单例模式相似，调停者模式也是集中职责，但是它是针对一组特殊的对象，而不是系统中全部对象。

当对象间的交互趋向复杂，而每个对象都需要知道其他对象的情况时，提供一个集中的控制权是很有用的。当相关对象的交互逻辑独立于对象的其他行为时，职责的集中同样有用。
《设计模式之禅》中引入的例子不错，在这里不详细赘述。公司中的采购、销售和库存是一个公司的最基本的架构，其关系图如下：

这三个部门在面向对象中可以设计成三个模块，而这三个模块又相互关联者，这是就这三个模块，但是在实际开发中可不止者三个模块或者说实际情况中公司可不是就这三个部门，而所有模块之间都需要交互，逻辑复杂度可想而知。

迪米特法则认为“每个类只和朋友类交流”，这个朋友类并非越多越好，朋友类越多，耦合性越大，要想修改一个就得修改一片，这不是面向对象设计所期望的，我们对上面的示例进行优化如下：

加入了一个中介者作为三个模块的交流核心，每个模块之间不再相互交流，要交流就通过中介者进行。每个模块只负责自己的业务逻辑，不属于自己的则丢给中介者来处理，简化了各模块之间的耦合关系。

二、简介

中介者模式也叫调停者：用一个中介对象封装一系列的对象交互，中介者使各对象不需要显示地相互作用，从而使其耦合松散，而且可以独立改变他们之间的交互。

中介者通用类图

中介者模式中的角色：

Mediator（抽象中介者角色）：定义统一的接口，用于各同事角色之间的通信。
ConcreteMediator（具体中介者角色）：协调各同事角色实现协作行为。
Colleague（同事角色）：每一个同事角色都知道中介者角色，而且互相通信的时候，一定要通过中介者角色协作。

每一个同事角色都知道中介者角色，而且与其他的同事角色通信的时候，一定要通过中介者角色协作。

同事类的两种行为：

自发行为（Self-Method）：同事类本身的行为，比如改变对象本身的状态，处理自己的行为，这种行为与其他的同时类或中介者没有任何的依赖。
依赖方法（Dep-Method）：必须依赖中介者才能完成的行为。

通用的代码：

抽象中介者

public abstract class Mediator {
    // 定义同事类
    protected ConcreteColleague1 c1;
    protected ConcreteColleague2 c2;
    // 通过方法getter/setter把同事类注入进来
    public ConcreteColleague1 getC1() {
        return c1;
    }
    public void setC1(ConcreteColleague1 c1) {
        this.c1 = c1;
    }
    public ConcreteColleague2 getC2() {
        return c2;
    }
    public void setC2(ConcreteColleague2 c2) {
    this.c2 = c2;
    }

    // 中介者模式的业务逻辑
    public abstract void doSomething1();
    public abstract void doSomething2();
}

具体中介者：

public class ConcreteMediator extends Mediator {
    @Override
    public void doSomething1() {
        //调用同事类的方法，只要是public方法都可以调用
        super.c1.selfMethod1();
        super.c2.selfMethod2();
    }

    @Override
    public void doSomething2() {
        super.c1.selfMethod1();
        super.c2.selfMethod2();
    }
}

抽象同事类：

public abstract class Colleague {
    protected Mediator mediator;
    public Colleague(Mediator _mediator){
        this.mediator=_mediator;
    }
}

具体同事类：

public class ConcreteColleague1 extends Colleague {
    //通过构造函数传递中介者
    public ConcreteColleague1(Mediator _mediator) {
        super(_mediator);
    }
    //自由方法
    public void selfMethod1(){
        //处理自己的业务逻辑
    }
    //依赖方法
    public void depMethod1(){
        //处理自己的业务逻辑
        //自己不能处理的业务逻辑，委托给中介者处理
        super.mediator.doSomething1();
    }
}

public class ConcreteColleague2 extends Colleague {
    //通过构造函数传递中介者
    public ConcreteColleague2(Mediator _mediator) {
        super(_mediator);
    }
    //自由方法
    public void selfMethod2(){
        //处理自己的业务逻辑
    }
    //依赖方法
    public void depMethod2(){
        //处理自己的业务逻辑
        //自己不能处理的业务逻辑，委托给中介者处理
        super.mediator.doSomething2();
    }
}