设计模式19 中介者模式

中介者模式(Mediator)定义：定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。中介者模式又叫调停模式，它是迪米特法则的典型应用。

中介者模式的优点有：

1、降低了对象之间的耦合性，使得对象易于独立地被复用。

2、将对象间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展。

中介者：

public abstract class Mediator {
    public abstract void register(Colleague colleague);
    
    public abstract void remove(Colleague colleague);

    public abstract void relay(Colleague colleague);
}

public class ConcreteMediator extends Mediator {
    private List<Colleague> colleagues = new ArrayList<Colleague>();

    @Override
    public void register(Colleague colleague) {
        // TODO Auto-generated method stub
        if (!colleagues.contains(colleague)) {
            colleagues.add(colleague);
            colleague.setMedium(this);
        }
    }

    @Override
    public void remove(Colleague colleague) {
        // TODO Auto-generated method stub
        if (colleagues.contains(colleague)) {
            colleagues.remove(colleague);
        }
    }

    @Override
    public void relay(Colleague colleague) {
        // TODO Auto-generated method stub
        for (Colleague cl : colleagues) {
            if (!cl.equals(colleague)) {
                cl.setMsg(colleague.getMsg());
                cl.receive();
            }
        }
    }
}

同事类：

public abstract class Colleague {
    protected Mediator mediator;
    
    private String Msg;

    public String getMsg() {
        return Msg;
    }

    public void setMsg(String msg) {
        Msg = msg;
    }

    public void setMedium(Mediator mediator) {
        this.mediator = mediator;
    }
    
    public abstract void receive();
    
    public abstract void send();
}

public class ConcreteColleagueA extends Colleague {
    @Override
    public void receive() {
        System.out.println("A收到请求<-" + getMsg());
    }

    @Override
    public void send() {
        System.out.println("A发出请求->" + getMsg());
        mediator.relay(this); // 请中介者转发
    }
}

public class ConcreteColleagueB extends Colleague {
    @Override
    public void receive() {
        System.out.println("B收到请求<-" + getMsg());
    }

    @Override
    public void send() {
        System.out.println("B发出请求->" + getMsg());
        mediator.relay(this); // 请中介者转发
    }
}

public class ConcreteColleagueC extends Colleague {
    @Override
    public void receive() {
        System.out.println("C收到请求<-" + getMsg());

    }

    @Override
    public void send() {
        System.out.println("C发出请求->" + getMsg());
        mediator.relay(this); // 请中介者转发
    }
}

调用方式：

public class Client {
    /*
     * 定义一个中介对象来封装一系列对象之间的交互， 使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。
     */
    public static void main(String[] args) {
        // 声明中介者对象
        Mediator md = new ConcreteMediator();

        // 在中介者的用户列表中进行登记
        Colleague c1 = new ConcreteColleagueA();
        Colleague c2 = new ConcreteColleagueB();
        Colleague c3 = new ConcreteColleagueC();

        md.register(c1);
        md.register(c2);
        md.register(c3);

        // 用户A发送消息
        c1.setMsg("B你退出吧!");
        c1.send();
        
        //用户B退出
        md.remove(c2);
        
        System.out.println("-------------------");
        // 用户C发送消息
        c3.setMsg("B你还在吗？");
        c3.send();
    }
}

执行结果：

 中介者模式是星形网络拓扑结构的体现。