模式说明

存在许多需要两两交互信息的同类对象，如果互相之间直接交互，将会形成网状结构，每一个对象都需要知道所有其他对象，且若某对象需要修改，那么其他对象可能也要做出修改，造成牵一发动全身的不良后果。针对这种场景，可以设置一个中介者，将对象间的网状两两交互，转变为通过中介者来居中传递信息，能够大大降低同类对象间的耦合，系统也会变得易扩展易维护。例如新增一个需要通信的成员(本设计模式中所谓的同事)，只需要创建它并注册到中介者中即可，不影响任何其他成员(同事)。

本示例展示中介者闲鱼平台如何向卖家转发买家的商品需求信息，向买家转发卖家的商品上架信息。当有一个买家发布一条商品需求信息时，所有卖家均能收到。当一个卖家发布一条商品上架信息时，所有买家均能收到。

结构

抽象中介者类
定义管理同事和传递信息的方法。本示例中为注册同事的方法register(User user)，转发信息的方法relay(User user, String message)。
具体中介者类
继承抽象中介者。持有一个已完成注册的同事的集合List，实现抽象中介者类中的抽象方法register和relay。
抽象同事类
持有一个中介者实例属性，一个名字属性，通过有参构造器初始化名字属性。定义三个抽象方法，设置中介者的方法setMediator，发送消息的方法send，接收消息的方法receive。
具体同事类
继承抽象同事类。实现抽象同事类中的三个抽象方法。

代码演示

  1. package com.yukiyama.pattern.behavior;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. /**
  7.  * 中介者模式
  8.  */
  9. public class MediatorDemo {
  11.     public static void main(String[] args) {
  12.         // 声明一个具体中介者实例闲鱼平台
  13.         Mediator xianyu = new XianyuMediator();
  14.         // 声明卖家1
  15.         User seller1 = new Seller("卖家1");
  16.         // 声明买家1
  17.         User buyer1 = new Buyer("买家1");
  18.         // 声明卖家2
  19.         User seller2 = new Seller("卖家2");
  20.         // 声明买家2
  21.         User buyer2 = new Buyer("买家2");
  22.         // 将买家和卖家都注册到闲鱼中介者上
  23.         xianyu.register(seller1);
  24.         xianyu.register(buyer1);
  25.         xianyu.register(seller2);
  26.         xianyu.register(buyer2);
  27.         // 当卖家1发布一条商品上架信息时，所有买家都能收到通过闲鱼中介者转发的该消息
  28.         seller1.send("上架了一台小米手机。");
  29.         // 当买家1发布一条商品需求信息时，所有卖家都能收到通过闲鱼中介者转发的该消息
  30.         buyer1.send("想要一个皮卡丘手办。");
  31.     }
  33. }
  35. /**
  36.  * 抽象中介者类
  37.  * 定义管理同事和传递信息的方法。本示例中为注册同事的方法register(User user)，
  38.  * 转发信息的方法relay(User user, String message)。
  39.  */
  40. abstract class Mediator{
  41.     public abstract void register(User user);
  42.     public abstract void relay(User user, String message);
  43. }
  45. /**
  46.  * 具体中介者类
  47.  * 继承抽象中介者。持有一个已完成注册的同事的集合List<User>，实现抽象
  48.  * 中介者类中的抽象方法register和relay。relay方法参数为用户User和消息
  49.  * message，判断User属于卖家Seller还是买家Buyer，如果是卖家则该消息是
  50.  * 一则商品上架消息，通知所有买家该消息。如果是买家则该消息是一则商品需求
  51.  * 消息，通知所有卖家该消息。
  52.  */
  53. class XianyuMediator extends Mediator{
  54.     private List<User> users = new ArrayList<>();
  56.     //将user添加到中介者持有的User类集合中，添加时执行User的setMediator方法
  57.     @Override
  58.     public void register(User user) {
  59.         if(!users.contains(user)) {
  60.             users.add(user);
  61.             user.setMediator(this);
  62.         }
  63.     }
  64.     @Override
  65.     public void relay(User user, String message) {
  66.         // 打印该用户发出的消息
  67.         System.out.println(user.getName()+message);
  68.         // 判断用户类型，如果是卖家
  69.         if(user instanceof Seller) {
  70.             // 所有买家接收该消息
  71.             for(User u : users) {
  72.                 if(u instanceof Buyer) {
  73.                     u.receive(user.getName()+message);
  74.                 }
  75.             }
  76.         }
  77.         // 判断用户类型，如果是买家
  78.         if(user instanceof Buyer) {
  79.             // 所有卖家接收该消息
  80.             for(User u : users) {
  81.                 if(u instanceof Seller) {
  82.                     u.receive(user.getName()+message);
  83.                 }
  84.             }
  85.         }
  86.     }
  87. }
  89. /**
  90.  * 抽象同事类
  91.  * 持有一个中介者实例属性，一个名字属性，通过有参构造器初始化名字属性，
  92.  * 并有一个名字属性的getter。
  93.  * 定义三个抽象方法，设置中介者的方法setMediator，发送消息的方法send，
  94.  * 接收消息的方法receive。
  95.  * 本例的同事类为User类。
  96.  */
  97. abstract class User{
  98.     protected Mediator mediator;
  99.     private String name;
  101.     public User(String name) {
  102.         this.name = name;
  103.     }
  104.     public String getName() {
  105.         return name;
  106.     }
  107.     public abstract void setMediator(Mediator mediator);
  108.     public abstract void send(String message);
  109.     public abstract void receive(String message);
  110. }
  112. /**
  113.  * 具体同事类
  114.  * 继承抽象同事类。实现抽象同事类中的三个抽象方法。setMediator方法传入
  115.  * 中介者实例，赋值给该同事类持有的中介者属性。send方法调用中介者的转发
  116.  * 方法relay，传入当前同事实例(this)和message。receive方法接收message
  117.  * 并打印出来。
  118.  * 下例是卖家类。
  119.  */
  120. class Seller extends User{
  121.     public Seller(String name) {
  122.         super(name);
  123.     }
  124.     @Override
  125.     public void setMediator(Mediator mediator) {
  126.         this.mediator = mediator;
  127.     }
  128.     @Override
  129.     public void send(String message) {
  130.         this.mediator.relay(this, message);
  131.     }
  132.     @Override
  133.     public void receive(String message) {
  134.         System.out.println(this.getName() + "收到一条商品需求信息：" + message);
  135.     }
  136. }
  138. /**
  139.  * 具体同事类
  140.  * 下例是买家类。
  141.  */
  142. class Buyer extends User{
  143.     public Buyer(String name) {
  144.         super(name);
  145.     }
  146.     @Override
  147.     public void setMediator(Mediator mediator) {
  148.         this.mediator = mediator;
  149.     }
  150.     @Override
  151.     public void send(String message) {
  152.         this.mediator.relay(this, message);
  153.     }
  154.     @Override
  155.     public void receive(String message) {
  156.         System.out.println(this.getName() + "收到一条商品发布信息：" + message);
  157.     }
  158. }