调停者模式整理

调停者模式：

 

  调停者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显引用。从而使他们可以较松散地耦合。

  定义： 在调停者模式中，所有的成员对象都可以协调工作，但是又不直接相互管理，这些对象都与一个处于中心地位的调停者对象发生紧密的关系，由这个调停者对象进行协调工作。这个协调者对象叫做调停者，而调停者所协调的成员对象称作同事（Colleague）对象。

 

 

 

public abstract class Colleague {

 

    private Mediator mediator;

   

    /**构造函数，作为参数接收调停者对象*/

    public Colleague(Mediator m){

       mediator = m;

    }

   

    /**取值方法，提供调停者对象*/

    public Mediator getMediator(){

       return mediator;

    }

   

    /**行动方法，由子类实现*/

    public abstract void action();

   

    /**示意性的商业方法，调用此方法

     * 可以改变对象的内部状态

     */

    public void change(){

       mediator.colleagueChanged(this);

    }

}

 

 

 

public class Colleague1 extends Colleague {

 

    /**构造方法，作为参数接收调停者对象*/

    public Colleague1(Mediator m) {

       super(m);

    }

   

    /**行动方法的具体实现*/

    @Override

    public void action() {

       System.out.println("This is an action from Colleague 1");

    }

}

 

 

public class Colleague2 extends Colleague {

 

    /**构造函数，作为参量接收调停者对象*/

    public Colleague2(Mediator m) {

       super(m);

    }

 

    /**行动方法的具体实现*/

    @Override

    public void action() {

       System.out.println("This is an action from Colleague 2");

    }

}

 

 

public abstract class Mediator {

 

    /**事件方法， 由子类实现*/

    public abstract void colleagueChanged(Colleague c);

   

    public static void main(String args[]){

       ConcreteMediator mediator = new ConcreteMediator();

       mediator.createConcreteMediator();

       Colleague c1 = new Colleague1(mediator);

       Colleague c2 = new Colleague2(mediator);

       mediator.colleagueChanged(c1);

    }

}

 

 

 

public class ConcreteMediator extends Mediator {

 

    private Colleague1 colleague1;

    private Colleague2 colleague2;

   

    /**事件方法的具体实现*/

    @Override

    public void colleagueChanged(Colleague c) {

       colleague1.action();

       colleague2.action();

    }

   

    /**工厂方法，创建同事对象*/

    public void createConcreteMediator(){

       colleague1 = new Colleague1(this);

       colleague2 = new Colleague2(this);

    }

   

    /**取值方法，提供同事对象*/

    public Colleague1 getColleague1(){

       return colleague1;

    }

   

    /**取值方法，提供同事对象*/

    public Colleague2 getColleague2(){

       return colleague2;

    }

}

 

 

==========下面是另一个版本介绍该模式(摘自《设计模式：java语言中的应用》)-=============== 

 

 

public interface Mediator {

    public abstract void createColleagues();

    public abstract void colleagueChanged(Colleague colleague);

}

 

 

import java.awt.CheckboxGroup;

import java.awt.Color;

import java.awt.Frame;

import java.awt.GridLayout;

import java.awt.Label;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

 

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(checkGuest);

       //输出到画面上

       pack();

       show();

    }

   

    /**根据Colleague的消息，判断各Colleague的有效/无效*/

    @Override

    public void colleagueChanged(Colleague c) {

       if(c == checkGuest || c == checkLogin){

           if(checkGuest.getState()){  //Guest模式

              textUser.setColleagueEnable(false);

              textPass.setColleagueEnable(false);

              buttonOk.setColleagueEnable(true);

           }else{

              textUser.setColleagueEnable(true);

              userpassChanged();

           }

       }else if(c == textUser || c == textPass){

           userpassChanged();

       }else{

           System.out.println("colleagueChanged: unknow colleague = " + c);

       }

    }

 

    /**产生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);

    }

   

    /**

     * textUser或textPass有变动

     * 判断各Colleague的有效/无效

     */

    private void userpassChanged(){

       if(textUser.getText().length() > 0){

           textPass.setColleagueEnable(true);

           if(textPass.getText().length() > 0){

              buttonOk.setColleagueEnable(true);

           }else{

              buttonOk.setColleagueEnable(false);

           }

       }else{

           textPass.setColleagueEnable(false);

           buttonOk.setColleagueEnable(false);

       }

    }

 

    @Override

    public void actionPerformed(ActionEvent e) {

       System.out.println("" + e);

       System.exit(0);

    }

}

 

 

public interface Colleague {

    public abstract void setMediator(Mediator mediator);

    public abstract void setColleagueEnable(boolean enabled);

}

 

 

public class ColleagueButton extends Button implements Colleague{

    private Mediator mediator;

    public ColleagueButton(String caption){

       super(caption);

    }

   

    @Override

    public void setColleagueEnable(boolean enabled) {

       //Mediator指示有效/无效

       setEnabled(enabled);

    }

 

    @Override

    public void setMediator(Mediator mediator) {

       this.mediator = mediator;

    }

}

 

 

import java.awt.Checkbox;

import java.awt.CheckboxGroup;

import java.awt.event.ItemEvent;

import java.awt.event.ItemListener;

 

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 setColleagueEnable(boolean enabled) {

       //Mediator指示有效/无效

       setEnabled(enabled);

    }

 

    @Override

    public void setMediator(Mediator mediator) {

       //保留Mediator

       this.mediator = mediator;

    }

 

    @Override

    public void itemStateChanged(ItemEvent e) {

       // 若状态有变，通知Mediator

       mediator.colleagueChanged(this);

    }

}

 

 

import java.awt.Color;

import java.awt.TextField;

import java.awt.event.TextEvent;

import java.awt.event.TextListener;

 

public class ColleagueTextField extends TextField implements TextListener, Colleague{

    private Mediator mediator;

    public ColleagueTextField(String text, int columns){

       super(text, columns);

    }

    @Override

    public void setColleagueEnable(boolean enabled) {

       //Mediator指示有效/无效

       setEnabled(enabled);

       setBackground(enabled ? Color.white : Color.lightGray);

    }

 

    /**保留Mediator*/

    @Override

    public void setMediator(Mediator mediator) {

       this.mediator = mediator;

    }

 

    @Override

    public void textValueChanged(TextEvent e) {

       //字符串若有变化，则通知Mediator

       mediator.colleagueChanged(this);

    }

}