了解23种设计模式之中介者模式

什么是中介者模式

Mediator模式也叫中介者模式，是由GoF提出的23种软件设计模式的一种。Mediator模式是行为模式之一，在Mediator的对象中，类之间的交互行为被统一放在Medator的对象中，对象通过Mediator对象同其他对象交互，Meiator 对象起着控制器的作用。

中介者（Mediator）模式的定义：定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。中介者模式又叫调停模式，它是迪米特法则的典型应用。

简单来说：如果两个类不必彼此直接通向，那么这两类就不应当发生直接的相互作用。如果其中一个类需要调用另一个类的某一个方法的话，可以通过第三者转发这个调用。（比如 房产中介，婚姻介绍所）

中介者模式是一种对象行为型模式，其主要优点如下。
1，降低了对象之间的耦合性，使得对象易于独立地被复用。
2，将对象间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展。

其主要缺点是：当同事类太多时，中介者的职责将很大，它会变得复杂而庞大，以至于系统难以维护。

中介者模式结构图

中介者模式包含以下主要角色。
1，抽象中介者（Mediator）角色：它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。
2，具体中介者（ConcreteMediator）角色：实现中介者接口，定义一个 List 来管理同事对象，协调各个同事角色之间的交互关系，因此它依赖于同事角色。
3，抽象同事类（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。
4，具体同事类（Concrete Colleague）角色：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。

结构图如下：

模式的应用场景

前面分析了中介者模式的结构与特点，下面分析其以下应用场景。

• 当对象之间存在复杂的网状结构关系而导致依赖关系混乱且难以复用时。
• 当想创建一个运行于多个类之间的对象，又不想生成新的子类时。

中介者模式代码实现

抽象中介者： 负责发送消息，同事对象注册

/**
 * @ClassName Mediator
 * @Description 抽象的中介类
 * @Version 1.0
 **/
public abstract class Mediator {

    /**
     * 发送消息
     * @param message
     * @param colleague
     */
    public abstract void send(String message, Colleague colleague);
}

具体中介者，实现中介者接口，协调各个同事角色之间 发送消息

/**
 * @ClassName ColleagueMediator
 * @Description 具体的中介类
 * @Version 1.0
 **/
public class ColleagueMediator extends Mediator {

    private ConcreteColleague1 concreteColleague1;
    private ConcreteColleague2 concreteColleague2;

	/**
	*协调同事，发送消息
	*/
    @Override
    public void send(String message, Colleague colleague) {
        if(colleague instanceof ConcreteColleague1){
            concreteColleague2.receive(message);
        }else{
            concreteColleague1.receive(message);
        }

    }

    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;
    }
}

抽象同事类（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。

/**
 * @ClassName Colleague
 * @Description 抽象的同事类
 * @Version 1.0
 **/
public abstract class Colleague {

    /**
     * 抽象的中介类
     */
    protected Mediator mediator;


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

    public abstract void receive(String message);

    public abstract void send(String message);
}

具体同事类（Concrete Colleague）角色：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。

/**
 * @ClassName ConcreteColleague1
 * @Description TODO
 * @Version 1.0
 **/
public class ConcreteColleague1 extends Colleague{

    /**
     * 构造方法得到 中介者对象
     *
     * @param mediator
     */
    public ConcreteColleague1(Mediator mediator) {
        super(mediator);
    }

    /**
     * 发送消息
     */
    @Override
    public void send(String message){
        //发送消息时由中介者去发送
        System.out.println("同事1发送消息："+message);
        mediator.send(message,this);

    }

    /**
     * 接收消息
     * @param message
     */
    @Override
    public void receive(String message){
        System.out.println("同事1得到消息:"+message);
    }


}

具体同事类（Concrete Colleague）角色：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。

/**
 * @ClassName ConcreteColleague2
 * @Description TODO
 * @Version 1.0
 **/
public class ConcreteColleague2 extends Colleague{
    /**
     * 构造方法得到 中介者对象
     *
     * @param mediator
     */
    public ConcreteColleague2(Mediator mediator) {
        super(mediator);
    }

    /**
     * 发送消息
     * @param message
     */
    @Override
    public void send(String message){
        //发送消息时由中介者去发送
        System.out.println("同事2发送消息："+message);
        mediator.send(message,this);
    }

    /**
     * 接收消息
     * @param message
     */
    @Override
    public void receive(String message){
        System.out.println("同事2得到消息:"+message);
    }
}

测试

public class MainClass {
    public static void main(String[] args) {

        //中介者
        ColleagueMediator mediator = new ColleagueMediator();

        //通过中介者让两者联系
        ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
        ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);

        mediator.setConcreteColleague1(colleague1);
        mediator.setConcreteColleague2(colleague2);

        //同事1发送消息
        colleague1.send("你在干什么！！！");
        System.out.println("----------------------------------");
        //同事2发送消息
        colleague2.send("我在想你呀！！！");

    }
}

中介者模式的扩展

在实际开发中，通常采用以下两种方法来简化中介者模式，使开发变得更简单。

• 不定义中介者接口，把具体中介者对象实现成为单例。
• 同事对象不持有中介者，而是在需要的时直接获取中介者对象并调用。

单例中介者

public class SimpleMediator{

    private static final SimpleMediator smd=new SimpleMediator();   
    
    //同事类集合
    private List<SimpleColleague> colleagues=new ArrayList<SimpleColleague>();   
    
    /**
    *私有化构造方法
    */
    private SimpleMediator(){
    
    }   
    
    /**
    *获得中介者
    */
    public static SimpleMediator getMediator(){ 
    		return(smd);   
    }
    
    //注册同事类
    public void register(SimpleColleague colleague) {
    
        if(!colleagues.contains(colleague)){
            colleagues.add(colleague);
        }
    }
    
    //发送消息
    public void relay(SimpleColleague scl){       
        for(SimpleColleague ob:colleagues){
            if(!ob.equals(scl))  {
                ((SimpleColleague)ob).receive();
            }   
        }
    }
}

其他的 跟之前的 中介者代码实现里的代码一致，就不多在编写