没有中介的情况（网状结构）
有中介的情况（星形结构）
定义与特点
- 定义：定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。中介者模式又叫调停模式，它是迪米特法则的典型应用，是对象行为型模式。
参与角色
- 抽象中介者（Mediator）角色：提供了（同事对象注册）与（转发同事对象信息）的抽象方法。
- 具体中介者（ConcreteMediator）角色：实现抽象中介者的方法，所有的具体同事类都由它来管理（list），同时做同事间的信息接收、转发工作。
- 抽象同事类（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。
- 具体同事类（Concrete Colleague）角色：每个具体同事类都只需要知道自己的行为即可，但是他们都需要认识中介者。
- 类结构图
结构代码示例
定义抽象中介者
abstract class Mediator { public abstract void register(Colleague colleague); public abstract void relay(Colleague cl); // 转发 }定义抽象同事类
abstract class Colleague { protected Mediator mediator; public void setMedium(Mediator mediator) { this.mediator = mediator; } public abstract void receive(); public abstract void send(); }定义具体中介者
class ConcreteMediator extends Mediator { private List<Colleague> colleagues = new ArrayList<Colleague>(); public void register(Colleague colleague) { if (!colleagues.contains(colleague)) { colleagues.add(colleague); colleague.setMedium(this); } } public void relay(Colleague cl) { for (Colleague ob : colleagues) { if (!ob.equals(cl)) { ((Colleague) ob).receive(); } } } }定义具体同事类
//具体同事类 class ConcreteColleague1 extends Colleague { public void receive() { System.out.println("具体同事类1收到请求。"); } public void send() { System.out.println("具体同事类1发出请求。"); mediator.relay(this); // 请中介者转发 } } //具体同事类 class ConcreteColleague2 extends Colleague { public void receive() { System.out.println("具体同事类2收到请求。"); } public void send() { System.out.println("具体同事类2发出请求。"); mediator.relay(this); // 请中介者转发 } }客户端调用
public class MediatorTest { public static void main(String[] args) { //声明中介者 Mediator mediator = new ConcreteMediator(); Colleague colleague1 = new ConcreteColleague1(); Colleague colleague2 = new ConcreteColleague2(); //同事相继注册 mediator.register(colleague1); mediator.register(colleague2); colleague1.send(); System.out.println("---------------"); colleague2.send(); } } //运行结果 具体同事类1发出请求。 具体同事类2收到请求。 --------------- 具体同事类2发出请求。 具体同事类1收到请求。
案例分析
租客租房案例，租客在寻找房源时与中介联系，中介再与房东联系
定义抽象中介者
//抽象中介者：中介公司 interface Medium { void register(Customer member); // 客户注册 void relay(String from, String message); // 转发 }定义抽象同事类
//抽象同事类：客户 abstract class Customer { protected Medium medium; private String name; public Customer(String name) { this.name = name; } public void setMedium(Medium medium) { this.medium = medium; } public String getName() { return name; } public abstract void send(String message); public abstract void receive(String from, String message); }定义具体中介者
//具体中介者：房地产中介 class EstateMedium implements Medium { private List<Customer> members = new ArrayList<Customer>(); public void register(Customer member) { if (!members.contains(member)) { members.add(member); member.setMedium(this); } } public void relay(String from , String message) { for (Customer ob : members) { String name = ob.getName(); if (!name.equals(from)) { ((Customer) ob).receive(from, message); } } } }定义具体同事类
//具体同事类：卖方 class Seller extends Customer { public Seller(String name) { super(name); } @Override public void send(String message) { medium.relay(getName() , message); } @Override public void receive(String from, String message) { System.out.println(from + "说: " + message); } } //具体同事类：买方 class Buyer extends Customer { public Buyer(String name) { super(name); } @Override public void send(String message) { medium.relay(getName() , message); } @Override public void receive(String from, String message) { System.out.println(from + "说: " + message); } }调用客户端
public class MediatorTest { public static void main(String[] args) { // 声明中介者 Medium mediator = new EstateMedium(); Customer seller = new Seller("张房东"); Customer buyer = new Buyer("李租客"); // 同事相继注册 mediator.register(seller); mediator.register(buyer); buyer.send("你好，房子多少钱一个月"); System.out.println("--------------"); seller.send("3000,少一分不租"); } } //运行结果 李租客说: 你好，房子多少钱一个月 -------------- 张房东说: 3000,少一分不租
总结
优点
- 降低了系统对象之间的耦合性，使得对象易于独立的被复用。
- 提高系统的灵活性，使得系统易于扩展和维护。
- 缺点
模式使系统更加复杂，使得系统维护比较困难，当业务复杂时，中介者承担的责任非常大
适用场景
- 一组对象以定义良好但是复杂的方式进行通信。产生的相互依赖关系结构混乱且难以理解。
- 一个对象引用其他很多对象并且直接与这些对象通信,导致难以复用该对象。
- 想定制一个分布在多个类中的行为，而又不想生成太多的子类。
