[5] [接口隔离] ( 4 ) 中介者 mediator

总结

• GOF定义?
  用一个中介对象来封装(封装变化)一系列的对象交互.
  中介者使各对象不需要显式的相互引用(编译时依赖→运行时依赖),
  从而使其耦合松散(管理变化),
  而且可以独立地改变它们之间的交互.
  .
  .
  
  .
  .
  
  
  
  

• 中介者模式的作用?
  可以有效简化对象之间的关系, 降低模块耦合性.
  
  
  

• 中介者模式是用来解耦谁的?
  通过引入一个独立的"中介对象",
  来管理对象之间的关联关系,
  将一组对象的交互关系,
  从N对N转化成1对N,
  简化对象之间的关系,
  避免相互交互的对象之间紧耦合,
  更好的抵御变化.
  
  
  

• Facade模式和Mediator模式的区别?
  Facade模式是解耦系统间(单向)的对象关联关系.
  Mediator模式是解耦系统内各个对象之间(双向)的关联关系.
  
  
  

• Mediator模式的缺点?
  由于中介者需要处理所有的对象交互,
  中介者对象可能变得很庞大.
  
  
  

• 什么时候用中介者模式?
  (1) 复杂通讯的一组对象组
  (2) 想要重用一个对象, 又不希望它和其他对象过度耦合.
  
  
  

• 案例
  聊天室
  交通控制中心系统
  GUI框架/MVC框架
  
  
  
  
  

java例子1

重构前

package v26_mediator.java;

class Airplane {
    private String name;

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

    public void send(String message, Airplane receiver) {
        System.out.println(this.name + " sends message to " + receiver.getName() + ": " + message);
        receiver.receive(message, this);
    }

    public void receive(String message, Airplane sender) {
        System.out.println(this.name + " receives message from " + sender.getName() + ": " + message);
    }

    public String getName() {
        return this.name;
    }
}

public class AirMain1 {
    public static void main(String[] args) {
        Airplane airplane1 = new Airplane("Airplane1");
        Airplane airplane2 = new Airplane("Airplane2");
        Airplane airplane3 = new Airplane("Airplane3");

        airplane1.send("Hello, Airplane2!", airplane2);
        airplane2.send("Hello, Airplane3!", airplane3);
        airplane3.send("Hello, Airplane1!", airplane1);
    }
}

重构后

package v26_mediator.java;

import java.util.ArrayList;
import java.util.List;

// 中介接口
interface Mediator {
    void send(String message, Airplane sender);
}

// 飞机类
class Airplane {
    private String name;
    private Mediator mediator;

    public Airplane(String name, Mediator mediator) {
        this.name = name;
        this.mediator = mediator;
    }

    // 发送信息
    public void send(String message) {
        // 飞机通过中介来向外接发送信息
        System.out.println(this.name + " sends message: " + message);
        mediator.send(message, this);
    }

    // 接收信息
    public void receive(String message) {
        System.out.println(this.name + " receives message: " + message);
    }

    public String getName() {
        return this.name;
    }
}


// 指挥中心
class AirTrafficControl implements Mediator {
    // 飞机列表
    private List<Airplane> airplanes;

    public AirTrafficControl() {
        this.airplanes = new ArrayList<>();
    }

    // 注册飞机, 将新飞机添加到指挥中心的list中.
    public void registerAirplane(Airplane airplane) {
        this.airplanes.add(airplane);
    }

    // 发送信息
    public void send(String message, Airplane sender) {
        // 遍历飞机列表, 让所有飞机接收信息
        for (Airplane airplane : airplanes) {
            if (airplane != sender) {
                airplane.receive(message);
            }
        }
    }
}


public class AirMain2 {
    public static void main(String[] args) {
        AirTrafficControl atc = new AirTrafficControl();

        Airplane airplane1 = new Airplane("Airplane1", atc);
        Airplane airplane2 = new Airplane("Airplane2", atc);
        Airplane airplane3 = new Airplane("Airplane3", atc);

        atc.registerAirplane(airplane1);
        atc.registerAirplane(airplane2);
        atc.registerAirplane(airplane3);

        airplane1.send("Hello, everyone!");
        airplane2.send("Hello, everyone!");
        airplane3.send("Hello, everyone!");
    }
}

java例子2

package v26_mediator.java;

// 抽象中介者, 负责组件之间的通讯
interface Mediator {
    void notify(Component sender, String event); // 传递事件的方法
}

// 具体中介者
class ConcreteMediator implements Mediator {
    private Button button;
    private TextBox textBox;
    private Label label;

    // 构造函数
    public ConcreteMediator(Button button, TextBox textBox, Label label) {
        // 注册GUI组件
        this.button = button;
        this.button.setMediator(this);
        this.textBox = textBox;
        this.textBox.setMediator(this);
        this.label = label;
        this.label.setMediator(this);
    }

    // 通知
    @Override
    public void notify(Component sender, String event) {
        if (sender == button && event.equals("clicked")) {
            textBox.clear();
            label.show("Button was clicked");
        }
    }
}




// 所有GUI组件的基类
abstract class Component {
    protected Mediator mediator;

    // 给这个组件设置中介者对象
    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

    // 通知其他组件有事件发生(内部通过中介者来传递)
    public void changed(String event) {
        mediator.notify(this, event);
    }
}

class Button extends Component {
    public void click() {
        System.out.println("Button clicked");
        changed("clicked");
    }
}

class TextBox extends Component {
    public void clear() {
        System.out.println("TextBox cleared");
    }
}

class Label extends Component {
    public void show(String message) {
        System.out.println("Label shows: " + message);
    }
}



// Main
public class GUIMain {
    public static void main(String[] args) {
        Button button = new Button();
        TextBox textBox = new TextBox();
        Label label = new Label();
        new ConcreteMediator(button, textBox, label);

        // Simulate a button click
        button.click();
    }
}