设计模式-行为型-中介者模式（Mediator）

定义

又称调停者模式

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

角色

抽象中介者（Mediator）：定义好同事类对象到中介者对象的接口，用于各个同事类之间的通信

中介者（WeChat）：继承自抽象中介者，并实现其方法；从一个同事类接收消息，通过消息影响其它同事类

同事类（Colleage）：如果一个对象会影响其它对象，也会被其它对象影响，那么这些对象互为同事类

优点

• 降低了系统对象之间的耦合性，使得对象易于独立的被复用
• 提高系统的灵活性，使得系统易于扩展和维护
• 将对象间关系由多对多转换为一对多，将网状结构变为星状结构

缺点

中介者承担了较多的责任，如果中介者出现问题，对整个系统影响很大

适用场景

• 一个类依赖多个类的情况较多
• 同事类关系较为复杂

类图

package com.vapy.behavior.Mediator;
/**
 * 
 * @author vapy
 *
 */
public abstract class Colleage {
    private String name;
    private String context;

    public Colleage(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getContext() {
        return context;
    }
    public void setContext(String context) {
        this.context = context;
    }
    public abstract void send();
    public void receive(String str) {
        System.out.println(this.getName() + " receive \"" + str + "\"");
    }
}

package com.vapy.behavior.Mediator;
/**
 * 
 * @author vapy
 *
 */
public class Monitor extends Colleage {
    public Monitor(String name) {
        super(name);
    }

    @Override
    public void send() {
        System.out.println("monitor say \"" + this.getContext() + "\"");
    }
}

package com.vapy.behavior.Mediator;
/**
 * 
 * @author vapy
 *
 */
public class StudentA extends Colleage {
    public StudentA(String name) {
        super(name);
    }

    @Override
    public void send() {
        System.out.println("studentA say \"" + this.getContext() + "\"");
    }
}

package com.vapy.behavior.Mediator;
/**
 * 
 * @author vapy
 *
 */
public class StudentB extends Colleage {
    public StudentB(String name) {
        super(name);
    }

    @Override
    public void send() {
        System.out.println("studentB say \"" + this.getContext() + "\"");
    }
}

package com.vapy.behavior.Mediator;
/**
 * 
 */
import java.util.ArrayList;
import java.util.List;

public abstract class Mediator {
    List<Colleage> list = new ArrayList<Colleage>();

    public void add(Colleage colleage) {
        list.add(colleage);
    }
    public abstract void groupChat(Colleage col);
    public abstract void chat(Colleage col1, Colleage col2);
}

package com.vapy.behavior.Mediator;
/**
 * 
 * @author vapy
 *
 */
public class WeChat extends Mediator {
    @Override
    public void groupChat(Colleage col) {
        if (list.contains(col)) {
            col.send();
            String str = col.getContext();
            for (Colleage c : list) {
                c.receive(str);
            }
        }
    }

    @Override
    public void chat(Colleage col1, Colleage col2) {
        col1.send();
        col2.receive(col1.getContext());
    }
}

package com.vapy.behavior.Mediator;
/**
 * 
 * @author vapy
 *
 */
public class Client {
    public static void main(String[] args) {
        Colleage m = new Monitor("monitor");
        Colleage a = new StudentA("studentA");
        Colleage b = new StudentB("studentB");
        Mediator weChat = new WeChat();
        weChat.add(m);
        weChat.add(a);
        weChat.add(b);
        m.setContext("group chat!");
        weChat.groupChat(m);
System.out.println("-----------------------------");
        a.setContext("private chat");
        weChat.chat(a, b);
    }
}

本文代码可在github查看：点击此处