Mediator模式

Mediator模式

Mediator的意思是“仲裁者”，“中介者”。一方面，当发生麻烦事情的时候，通知仲裁者；当发生涉及全体组员的事情时，也通知仲裁者。当仲裁者下达指示时，组员会立即执行。团队组员之间不再互相沟通并私自作出决定，而是发生任何事情都向仲裁者报告。另一方面，仲裁者站在整个团队的角度上对组员上报的事情做决定。这就是Mediator模式。

在Mediator模式中，“仲裁者”被称为Mediator，各组员别称为Colleague（同事）。

调整多个对象之间的关系时，就需要用到Mediator模式了。即不让各个对象之间互相通信，而是增加一个仲裁者角色，让他们各自与仲裁者通信。

示例程序

类和接口的一览表

名字	说明
Mediator	定义“仲裁者”的接口（API）的接口
Colleague	定义“组员”的接口（API）的接口
ColleagueButton	表示按钮的类。它实现了Colleague接口
ColleagueTextField	表示文本输入框的类。它实现了Colleague接口
ColleagueCheckbox	表示勾选框（此处是单选按钮）的类。它实现了Colleague接口
LoginFrame	表示登录对话框的类。它实现了Mediator接口
Main	测试程序行为的类

示例程序类图

#### 示例程序的时序图

Mediator

public interface Mediator {
     /**
     * 用于生成Mediator要管理的组员
     */
    void createColleagues();

    /**
     * 会被各个Colleague组员调用
     */
    void colleagueChanged();
}

Colleague

public interface Colleague {
    /**
     * 
     * @param mediator
     */
    void setMediator(Mediator mediator);

    /**
     * 告知组员仲裁者所下达的指示
     * @param enabled
     */
    void setColleagueEnabled(boolean enabled);
}

ColleagueButton

import java.awt.Button;

public class ColleagueButton extends Button implements Colleague {
    private Mediator mediator;
    public ColleagueButton(String caption) {
        super(caption);
    }
    @Override
    public void setMediator(Mediator mediator) {            // 保存Mediator
        this.mediator = mediator;
    }
    @Override
    public void setColleagueEnabled(boolean enabled) {      // Mediator下达启用/禁用的指示
        setEnabled(enabled);
    }
}

ColleagueCheckbox

import java.awt.Checkbox;
import java.awt.CheckboxGroup;
import java.awt.event.ItemListener;
import java.awt.event.ItemEvent;

public class ColleagueCheckbox extends Checkbox implements ItemListener, Colleague {
    private Mediator mediator;
    public ColleagueCheckbox(String caption, CheckboxGroup group, boolean state) {  // 构造函数 
        super(caption, group, state);
    }
    @Override
    public void setMediator(Mediator mediator) {            // 保存Mediator
        this.mediator = mediator;
    }
    @Override
    public void setColleagueEnabled(boolean enabled) {      // Mediator下达启用/禁用指示
        setEnabled(enabled);
    }
    @Override
    public void itemStateChanged(ItemEvent e) {             // 当状态发生变化时通知Mediator
        mediator.colleagueChanged();
    }
}

ColleagueTextField

public class ColleagueTextField extends TextField implements TextListener, Colleague {
    private Mediator mediator;
    public ColleagueTextField(String text, int columns) {   // 构造函数
        super(text, columns);
    }
    @Override
    public void setMediator(Mediator mediator) {            // 保存Mediator
        this.mediator = mediator;
    }
    @Override
    public void setColleagueEnabled(boolean enabled) {      // Mediator下达启用/禁用的指示
        setEnabled(enabled);
        setBackground(enabled ? Color.white : Color.lightGray);
    }
    @Override
    public void textValueChanged(TextEvent e) {             // 当文字发生变化时通知Mediator
        mediator.colleagueChanged();
    }
}

LoginFrame

import java.awt.Frame;
import java.awt.Label;
import java.awt.Color;
import java.awt.CheckboxGroup;
import java.awt.GridLayout;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;

public class LoginFrame extends Frame implements ActionListener, Mediator {
    private ColleagueCheckbox checkGuest;
    private ColleagueCheckbox checkLogin;
    private ColleagueTextField textUser;
    private ColleagueTextField textPass;
    private ColleagueButton buttonOk;
    private ColleagueButton buttonCancel;

    // 构造函数。
    // 生成并配置各个Colleague后，显示对话框。
    public LoginFrame(String title) {
        super(title);
        setBackground(Color.lightGray);
        // 使用布局管理器生成4×2窗格
        setLayout(new GridLayout(4, 2));
        // 生成各个Colleague
        createColleagues();
        // 配置
        add(checkGuest);
        add(checkLogin);
        add(new Label("Username:"));
        add(textUser);
        add(new Label("Password:"));
        add(textPass);
        add(buttonOk);
        add(buttonCancel);
        // 设置初始的启用起用/禁用状态
        colleagueChanged();
        // 显示
        pack();
        show();
    }

    // 生成各个Colleague。
    @Override
    public void createColleagues() {
        // 生成
        CheckboxGroup g = new CheckboxGroup();
        checkGuest = new ColleagueCheckbox("Guest", g, true);
        checkLogin = new ColleagueCheckbox("Login", g, false);
        textUser = new ColleagueTextField("", 10);
        textPass = new ColleagueTextField("", 10);
        textPass.setEchoChar('*');
        buttonOk = new ColleagueButton("OK");
        buttonCancel = new ColleagueButton("Cancel");
        // 设置Mediator
        checkGuest.setMediator(this);
        checkLogin.setMediator(this);
        textUser.setMediator(this);
        textPass.setMediator(this);
        buttonOk.setMediator(this);
        buttonCancel.setMediator(this);
        // 设置Listener
        checkGuest.addItemListener(checkGuest);
        checkLogin.addItemListener(checkLogin);
        textUser.addTextListener(textUser);
        textPass.addTextListener(textPass);
        buttonOk.addActionListener(this);
        buttonCancel.addActionListener(this);
    }

    // 接收来自于Colleage的通知然后判断各Colleage的启用/禁用状态。
    @Override
    public void colleagueChanged() {
        if (checkGuest.getState()) { // Guest mode
            textUser.setColleagueEnabled(false);
            textPass.setColleagueEnabled(false);
            buttonOk.setColleagueEnabled(true);
        } else { // Login mode
            textUser.setColleagueEnabled(true);
            userpassChanged();
        }
    }
    // 当textUser或是textPass文本输入框中的文字发生变化时
    // 判断各Colleage的启用/禁用状态
    private void userpassChanged() {
        if (textUser.getText().length() > 0) {
            textPass.setColleagueEnabled(true);
            if (textPass.getText().length() > 0) {
                buttonOk.setColleagueEnabled(true);
            } else {
                buttonOk.setColleagueEnabled(false);
            }
        } else {
            textPass.setColleagueEnabled(false);
            buttonOk.setColleagueEnabled(false);
        }
    }
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println(e.toString());
        System.exit(0);
    }
}

Main

public class Main {
    static public void main(String args[]) {
        new LoginFrame("Mediator Sample");
    }
}

Mediator模式中的登场角色

1.Mediator（仲裁者、中介者）

Mediator角色负责定义与Colleague角色进行通信和做出决定的接口（API）。在示例程序中。由Mediator接口扮演此角色。

2.ConcreteMediator（具体的仲裁者、中介者）

ConcreteMediator角色负责实现Mediator角色的接口（API），负责实际做出决定。在示例程序中，由LoginFrame类扮演此角色。

3.Colleague（同事）

Colleague角色负责定义与Mediator角色进行通信的接口（API）。在示例程序中，由Colleague接口扮演此角色。

4.ConcreteColleague（具体的同事）

ConcreteColleague角色负责实现Colleague角色的接口（API）。在示例程序中，由ColleagueButton类、ColleagueTextField类和ColleagueCheckbox类扮演此角色。

通用类图