语言与模式-20中介者模式

意图

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

适用性

• 一组对象以定义良好但是复杂的方式进行通信。产生的相互依赖关系结构混乱且难以理解。
• 一个对象引用其他很多对象并且直接与这些对象通信,导致难以复用该对象。
• 想定制一个分布在多个类中的行为，而又不想生成太多的子类。

Java实现

//抽象同事类
public abstract class Person {
    // 维持一个抽象中介者的引用
    protected Mediator mediator;

    protected String name;

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

    /**
     * 设置中介者对象
     * @param mediator
     */
    public void setMediator(Mediator mediator){
        this.mediator = mediator;
    }

    /**
     * 向中介 发送消息
     */
    protected abstract void sendMessage(String msg);

    /**
     * 从中介 获取消息
     */
    protected abstract void getMessage(String msg);
}

 //具体同事类：这里的角色是 租房者
public class Renter extends Person {

    public Renter(String name, Mediator mediator) {
        super(name, mediator);
    }

    @Override
    protected void sendMessage(String msg) {
        mediator.operation(this, msg);
    }

    @Override
    protected void getMessage(String msg) {
        System.out.println("求租者[" + name + "]收到中介发来的消息： " + msg);
    }
}

 //具体同事类：这里的角色是 房东
public class Landlord extends Person {

    public Landlord(String name, Mediator mediator) {
        super(name,mediator);
    }

    @Override
    protected void sendMessage(String msg) {
        mediator.operation(this, msg);
    }

    @Override
    protected void getMessage(String msg) {
        System.out.println("房东["+ name +"]收到中介发来的消息：" + msg);
    }
}

 //抽象中介者类
public abstract class Mediator {
    // 用于添加储存 "房东"角色
    protected List<Person> landlordList = new ArrayList<Person>();

    // 用于添加储存 "求租者"角色
    protected List<Person> renterList = new ArrayList<Person>();

    /**
     * 中介者注册房东信息
     * @param landlord 房东实体
     */
    public void registerLandlord(Person landlord){
        landlordList.add(landlord);
    }

    /**
     * 中介者注册 求租者信息
     * @param landlord 房东实体
     */
    public void registerRenter(Person landlord){
        renterList.add(landlord);
    }

    /**
     * 声明抽象方法 由具体中介者子类实现 消息的中转和协调
     */
    public abstract void operation(Person person, String message);

}

 //具体中介者类：这里的角色是 房屋出租中介
public class HouseMediator extends Mediator {

    @Override
    public void operation(Person person, String message) {
        if(person instanceof Renter){
            // 将租屋的需求消息传递给 注册了的房东们
            for(Person landlord: landlordList){
                landlord.getMessage(message);
            }
        } else if(person instanceof Landlord){
            // 将房东的出租房消息传递给 注册了的 房屋求租者们
            for(Person renter : renterList){
                renter.getMessage(message);
            }
        }
    }
}

//客户端测试类
public class Client {

    public static void main(String[] args) {
        // 实例化房屋中介
        Mediator mediator = new HouseMediator();

        Person landlordA, landlordB, renter;
        landlordA = new Landlord("房东李", mediator);
        landlordB = new Landlord("房东黎", mediator);

        renter = new Renter("小吕",mediator);

        // 房东注册中介
        mediator.registerLandlord(landlordA);
        mediator.registerLandlord(landlordB);
        // 求租者注册中介
        mediator.registerRenter(renter);

        // 求租者 发送求租消息
        renter.sendMessage("在天河公园附近租套房子，价格1000元左右一个月");
        System.out.println("--------------------------");
        // 房东A 发送房屋出租消息
        landlordA.sendMessage("天河公园学院站三巷27号四楼有一房一厅出租  1200/月  光线好 近公交站");
    }
}

Clojure实现

中介者模式类似双向的观察者模式！

观察者模式是单向的，从Subject向多个Observer传递信息！

中介者模式相当与ObserverA向Subject传递信息，再通过Subject传递给ObserverB,反之亦然!

那么就可以通过实现两个add-watch来实现类似中介者模式!

(def a (atom {}))
(def b (atom {}))

(defn func-a []
   (println "func-a invoke"))

(defn func-b []
  (println "func-b invoke"))

(add-watch a :watcherA
           (fn [key atom old-state new-state]
             (func-a)))

(add-watch b :watcherB
           (fn [key atom old-state new-state]
             (func-b)))

(reset! a {:foo "bar"})
(reset! b {:foo "bar"})