一天学习一个设计模式之中介者模式

中介者模式（Mediator），用一个中介对象来封装一系列对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

 

代码如下：

/**
 * 抽象中介者类
 */
public abstract class Mediator {
    /**
     * 定义一个抽象的发送消息方法，得到同事对象和发送信息
     * @param message
     * @param colleague
     */
    public abstract void Send(String message,Colleague colleague);
}

/**
 * 抽象同事类
 */
public abstract class Colleague {
    protected Mediator mediator;

    /**
     * 构造方法，传入中介者对象
     * @param mediator
     */
    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }
}

 

/**
 * 具体同事类1
 */
public class ConcreteColleague1 extends Colleague{
    /**
     * 构造方法，传入中介者对象
     *
     * @param mediator
     */
    public ConcreteColleague1(Mediator mediator) {
        super(mediator);
    }

    /**
     * 发送信息时通常是中介者发送的
     * @param message
     */
    public void Send(String message){
        mediator.Send(message,this);
    }

    public void NotifyMessage(String message){
        System.out.println("同事1得到信息："+message);
    }
}

/**
 * 同事2
 */
public class ConcreteColleague2 extends Colleague{
    /**
     * 构造方法，传入中介者对象
     *
     * @param mediator
     */
    public ConcreteColleague2(Mediator mediator) {
        super(mediator);
    }

    public void Send(String message){
        mediator.Send(message,this);
    }


    public void NotifyMessage(String message){
        System.out.println("同事2得到信息："+message);
    }
}

/**
 * 具体中介者类
 */
public class ConcreteMediator extends Mediator {

    public ConcreteColleague1 getConcreteColleague1() {
        return concreteColleague1;
    }

    public void setConcreteColleague1(ConcreteColleague1 concreteColleague1) {
        this.concreteColleague1 = concreteColleague1;
    }

    public ConcreteColleague2 getConcreteColleague2() {
        return concreteColleague2;
    }

    public void setConcreteColleague2(ConcreteColleague2 concreteColleague2) {
        this.concreteColleague2 = concreteColleague2;
    }

    private ConcreteColleague1 concreteColleague1;
    private ConcreteColleague2 concreteColleague2;
    @Override
    public void Send(String message, Colleague colleague) {
        if (colleague==concreteColleague1){
            concreteColleague2.NotifyMessage(message);
        }
        else {
            concreteColleague1.NotifyMessage(message);
        }
    }
}

/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        ConcreteMediator m=new ConcreteMediator();
        ConcreteColleague1 c1=new ConcreteColleague1(m);
        ConcreteColleague2 c2=new ConcreteColleague2(m);
        m.setConcreteColleague1(c1);
        m.setConcreteColleague2(c2);
        c1.Send("c2吃饭了吗");
        c2.Send("没有呢，你打算请客？");
    }
}

1、一对多的对象依赖转化为一对一依赖

　　当一个软件结构中出现了多个对象之间相互依赖的关系，错综复杂的对象关系让我们很难理清，维护上更是无从下手，这个时候，我们需要将这种错综复杂的多个对象相互依赖的关系转化一下，通过增加中介者角色，将多个对象的一对多对象关系转化为一对一的关系，将多个对象之间的耦合度降低，使其都通过中介者角色来相互联系。从而，可以大大减少类间依赖，更有利于系统后期的扩展和维护。

2、集中控制提高类的利用性

　　中介者角色的出现，将原本分散在多个类中的不同功能方法，都统一地集中在了中介者角色上，这样有利于程序功能的复用，也增强 了类的管理性，对于软件结构的扩展和修改的控制几乎都集中在了中介者角色上，便于集中写得。另外中介者模式的应用要慎重，因为随着依赖对象的增加而被放大。因此，使用中介模式时，一定要考虑实际情况，只有那种超级复杂的对象相互依赖关系，我们难以理清时，使用中介者模式会使原本混乱的关系变得清晰简单；而对于 那种一般性的对象之间的依赖关系，使用中介者模式反而会增加处理逻辑的复杂度。