Java设计模式（二十三） 之行为型模式（中介者模式）

一、定义

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

二、角色

• 1、Mediator（抽象中介者）：它定义一个接口用于与各同事对象之间进行通信。
• 2、ConcreteMediator(具体中介者):它继承了抽象中介者，通过协调各个同时队象来实现协作行为，它维持了对各个同时对象的引用。
• 3、Colleague(抽象同事类) :它定义各个同时类共有的方法，并声明了一些抽象方法供子类实现，同时他维持了一个对抽象中介者类的引用，其子类可以通过该引用进行通讯。
• 4、ConcreteColleague(具体同事类)：它是抽象同事类的子类，每一个同事对象在需要和其他同事对象通信时先与中介者通信。

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

主要解决：对象与对象之间存在大量的关联关系，这样势必会导致系统的结构变得很复杂，同时若一个对象发生改变，我们也需要跟踪与之相关联的对象，同时做出相应的处理。

何时使用：多个类相互耦合，形成了网状结构。

如何解决：将上述网状结构分离为星型结构。

关键代码：对象 Colleague 之间的通信封装到一个类中单独处理。

应用实例： 1、中国加入 WTO 之前是各个国家相互贸易，结构复杂，现在是各个国家通过 WTO 来互相贸易。 2、机场调度系统。 3、MVC 框架，其中C（控制器）就是 M（模型）和 V（视图）的中介者。

三、场景展示

抽象中介者类：Mediator

package mediatorPattern;
 
public abstract class Mediator {
    public abstract void componentChanged(Component c);
}

2、具体中介者类：concreteMediator

package mediatorPattern;
 
public class ConcreteMediator extends Mediator{
 
    //维持对各个同事类的引用
    public Button addButton;
    public List list;
    public TextBox userNameTextBox;
    public Combox cb;
    @Override
    public void componentChanged(Component c) {
        // TODO Auto-generated method stub
        //单击按钮
        if(c==addButton) {
            System.out.println("---单击增加按钮");
            list.update();
            cb.update();
            userNameTextBox.update();
            
        }
        //从列表框选择客户
        else if(c==list) {
            System.out.println("--从列表中选择客户");
            cb.selected();
            userNameTextBox.setText();
        }
        else if(c==cb) {
            System.out.println("--从组合框中选择用户");
            cb.selected();
            userNameTextBox.setText();
        }
 
        
    }
 
}

3、抽象组件类：Component

package mediatorPattern;
 
public abstract  class Component {
    
    //抽象组件类，相当于同事类。
    protected Mediator mediator;
    
    public void setMediator(Mediator m) {
        mediator=m;
    }
    
    //转发调用
    public void changed() {
        mediator.componentChanged(this);
    }
    
    public abstract void update();
}

4、按钮类，充当具体同事类：Button

package mediatorPattern;
 
public class Button extends Component{
 
    @Override
    public void update() {
        // TODO Auto-generated method stub
        
    }
 
}

 5、列表类，充当具体同事类:List

package mediatorPattern;
 
public class List extends Component {
 
    @Override
    public void update() {
        System.out.println("列表框增加一项：杨过");
    }
    public void selected() {
        System.out.println("列表框选中项：小龙女");
    }
}

6、组合框类，充当具体同事类：ComboBox

package mediatorPattern;
 
public class Combox extends Component{
 
    @Override
    public void update() {
        
    
        System.out.println("组合框增加一项：杨过");
    }
    public void selected() {
        System.out.println("组合框选中项：小龙女");
    }
}

7、文本框类，充当具体同事类：TextBox

package mediatorPattern;
 
public class TextBox extends Component{
 
    @Override
    public void update() {
        System.out.println("客户信息增加成功后文本框清空");
    }
    public void setText() {
        System.out.println("文本框显示：小龙女");
    }
    
    
 
}

8、测试类：Client

package mediatorPattern;
 
public class Client {
 
        public static void main(String[] args) {
            ConcreteMediator mediator;
            mediator = new ConcreteMediator();
            
            //定义同事类》
            Button addBT = new Button();
            List list = new List();
            Combox cb = new Combox();
            TextBox userNameTB = new TextBox();
            
            addBT.setMediator(mediator);
            list.setMediator(mediator);
            cb.setMediator(mediator);
            userNameTB.setMediator(mediator);
            
            mediator.addButton = addBT;
            mediator.list = list;
            mediator.cb = cb;
            mediator.userNameTextBox = userNameTB;
            
            addBT.changed();
            System.out.println("-------------------------");
            list.changed();
            
        }
}

优点

中介中模式简化了对象之间的相互交互，它用中介者和同事的一对多交互替代了原来同事类之间的多对多的交互，一对多关系更容易理解、维护和扩展，将原本难以理解的网状结构换成相对接单的星状结构。
可将各个同事类对象进行解耦。中介者有利于各同事之间的耦合，可以独立地改变和复用各个同事类和中介者。
可以减少子类的生成。
缺点

     在具体中介中包含了大量的同事类之间的交互细节，可能会使具体中介者非常复杂，使得系统难以维护。

使用的场景

系统中对象之间存在复杂的引用关系，系统结构混乱难以理解。
一个对象由于引用了其他很多对象并且直接和这戏对象进行通信，导致难以复用该对象。