中介者模式

一、模式简介

定义：定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。
场景：对象之间存在复杂的网状结构关系而导致依赖关系混乱且难以复用。

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

二、模式实现

public abstract class AbstractMediator { -> 抽象中介
    protected List<AbstractColleague> list = new ArrayList<>();

    public void add(AbstractColleague colleague){
        if(!list.contains(colleague)){
            colleague.setMediator(this);
            list.add(colleague);
        }
    }

    public void remove(AbstractColleague colleague){
        list.remove(colleague);
    }

    public abstract void relay(AbstractColleague colleague,String content);
}

public class ServerConcreteMediator extends AbstractMediator { -> 具体中介
    @Override
    public void relay(AbstractColleague colleague, String content) {
        list.forEach(c -> {
            if (!c.equals(colleague)) c.receive(colleague.getName(), content);
        });
    }
}

public abstract class AbstractColleague { -> 抽象同事
    private String name;
    private AbstractMediator mediator;

    public abstract void send(String content);

    protected abstract void receive(String name,String content);

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

    public AbstractMediator getMediator() {
        return mediator;
    }

    public void setMediator(AbstractMediator mediator) {
        this.mediator = mediator;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class ClientConcreteColleague extends AbstractColleague { -> 具体同事
    public ClientConcreteColleague(String name) {
        super(name);
    }

    @Override
    public void send(String content) {
        System.out.println(getName() + " send:" + content);
        if (getMediator() != null) getMediator().relay(this, content);
    }

    @Override
    protected void receive(String name, String content) {
        System.out.println(getName() + " receive:" + name + " send:" + content);
    }
}

以即时通讯聊天发送消息为例子，客户端A和B之间消息的发送和接收，是通过与消息服务器的交互来实现的，服务器则很好地充当了中介者的角色。

AbstractMediator mediator = new ServerConcreteMediator();
AbstractColleague clientA = new ClientConcreteColleague("A");
AbstractColleague clientB = new ClientConcreteColleague("B");
mediator.add(clientA);
mediator.add(clientB);
clientA.send("I am A");
clientB.send("I am B");