定义和特点

定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立的改变他们之间的交互。它是迪米特法则的典型应用。

优点

  • 类之间各司其职，符合迪米特法则
  • 降低了对象之间的耦合性，使得对象易于独立地被复用
  • 将对象间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展

缺点：

中介者模式将原本多个对象直接的复现依赖变成了中介者和多个同事类的依赖关系。当同事类越多时，中介者就会越臃肿，变得复杂且难以维护。

模式的应用场景

  • 当对象之间存在复杂的网状结构关系而导致依赖关系混乱且难以复用时。
  • 当想创建一个运行于多个类之间的对象，又不想生成新的子类时

代码结构和实现

  • 抽象中介者（Mediator）：中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。
  • 具体中介者（Concrete Mediator）:实现中介者接口，定义一个list来管理同事对象，协调各个同事角色之间的交互关系，因此它依赖于同事角色。
  • 抽象同事类（Colleague）：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。
  • 具体同事类（Concrete Colleague）:是抽象同事的实现，当需要与其他同事对象相互交互时，由中介者对象负责后续交互。

样例代码实现

抽象中介者

  1. public abstract class Mediator {
  2.     //注册
  3.     public abstract void register(Colleague colleague);
  4.     //传达
  5.     public abstract void relay(Colleague colleague);
  6. }

抽象同事类

  1. public abstract class Colleague {
  2.     protected Mediator mediator;
  3.     public void setMediator(Mediator mediator){
  4.         this.mediator = mediator;
  5.     }
  6.     //接收
  7.     public abstract void receive();
  8.     //发送
  9.     public abstract void send();
  10. }

具体中介者

  1. public class ConcreteMediator extends Mediator{
  2.     private ArrayList<Colleague> list = new ArrayList<>();
  3.     @Override
  4.     public void register(Colleague colleague) {
  5.         if(!list.contains(colleague)){
  6.             list.add(colleague);
  7.             colleague.setMediator(this);
  8.         }
  9.     }
  10.     @Override
  11.     public void relay(Colleague colleague) {
  12.         for (Colleague co:list) {
  13.             //不转发给自己本身
  14.             if(!co.equals(colleague)){
  15.                 ((Colleague)co).receive();
  16.             }
  17.         }
  18.     }
  19. }

具体同事类

  1. public class ConcreteColleague1 extends Colleague{
  2.     @Override
  3.     public void receive() {
  4.         System.out.println("同事1 收到请求");
  5.     }
  6.     @Override
  7.     public void send() {
  8.         System.out.println("同事1 发送请求");
  9.         mediator.relay(this);
  10.     }
  11. }
  13. public class ConcreteColleague2 extends Colleague{
  14.     @Override
  15.     public void receive() {
  16.         System.out.println("同事2 收到请求");
  17.     }
  18.     @Override
  19.     public void send() {
  20.         System.out.println("同事2 发送请求");
  21.         mediator.relay(this);
  22.     }
  23. }
  25. public class ConcreteColleague3 extends Colleague{
  26.     @Override
  27.     public void receive() {
  28.         System.out.println("同事3 收到请求");
  29.     }
  30.     @Override
  31.     public void send() {
  32.         System.out.println("同事3 发送请求");
  33.         mediator.relay(this);
  34.     }
  35. }

调用

  1. public class MediationSimpleMain {
  2.     public static void main(String[] args) {
  3.         Mediator mediator = new ConcreteMediator();
  4.         Colleague c1 = new ConcreteColleague1();
  5.         Colleague c2 = new ConcreteColleague2();
  6.         Colleague c3 = new ConcreteColleague3();
  8.         mediator.register(c1);
  9.         mediator.register(c2);
  10.         mediator.register(c3);
  12.         c2.send();
  13.     }
  14. }
  16. 同事2 发送请求
  17. 同事1 收到请求
  18. 同事3 收到请求

房地产样例

房地产交流平台是“房地产中介公司”提供给“卖方客户”与“买方客户”进行信息交流的平台，比较适合用中介者模式来实现

  • 中介公司（抽象中介者：medium）：包含注册方法（register()）、信息转达方法（relay()）；
    • 具体的中介公司：包含保存客户信息的list，并实现相应的方法。
  • 客户（抽象同事类：Customer）：包含了中介者对象，发送信息的方法（send()），与接收信息的方法（receive()）。
    • 卖方（Seller）/买方（Buyer）：都是具体的同事类，实现父类的抽象方法，通过中介者进行交流

模式的扩展

  1. 不定义中介者的接口，把具体中介者对象实现成为单例
  2. 同事对象不持有中介者，而是在需要的时候直接获取中介者对象并调用。

代码结构说明

  • 中介者对象使用单例模式，所以只有一个中介者对象。
  • 具体同事类利用构造函数的时候就注册到中介者中去
  1. package com.loneyfeather.bootdemo.mediation.simple;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. /**
  7.  * 单例模式+中介者模式，并且同事类对象不持有中介者对象
  8.  *
  9.  * @Author: LoneyFeather
  10.  * @Date: Created in 10:56 2021/12/21
  11.  */
  12. public class SimpleMediatorPattern {
  13.     public static void main(String[] args) {
  14.         SimpleColleague c1, c2;
  15.         c1 = new SimpleConcreteColleague1();
  16.         c2 = new SimpleConcreteColleague2();
  17.         c1.send();
  18.         System.out.println("-----------------");
  19.         c2.send();
  20.     }
  21. }
  23. //简单单例中介者
  24. class SimpleMediator {
  25.     private static SimpleMediator smd = new SimpleMediator();
  26.     private List<SimpleColleague> colleagues = new ArrayList<SimpleColleague>();
  28.     private SimpleMediator() {
  29.     }
  31.     public static SimpleMediator getMedium() {
  32.         return (smd);
  33.     }
  35.     public void register(SimpleColleague colleague) {
  36.         if (!colleagues.contains(colleague)) {
  37.             colleagues.add(colleague);
  38.         }
  39.     }
  41.     public void relay(SimpleColleague scl) {
  42.         for (SimpleColleague ob : colleagues) {
  43.             if (!ob.equals(scl)) {
  44.                 ((SimpleColleague) ob).receive();
  45.             }
  46.         }
  47.     }
  48. }
  50. //抽象同事类
  51. interface SimpleColleague {
  52.     //并没有持有中介者对象
  54.     void receive();
  55.     void send();
  56. }
  58. //具体同事类
  59. class SimpleConcreteColleague1 implements SimpleColleague {
  60.     //构造函数，当new的时候就会注册到中介者对象中
  61.     SimpleConcreteColleague1() {
  62.         //需要的时候调用中介者对象
  63.         SimpleMediator smd = SimpleMediator.getMedium();
  64.         smd.register(this);
  65.     }
  67.     @Override
  68.     public void receive() {
  69.         System.out.println("具体同事类1：收到请求。");
  70.     }
  72.     @Override
  73.     public void send() {
  74.         //单例模式的获取中介者对象
  75.         SimpleMediator smd = SimpleMediator.getMedium();
  76.         System.out.println("具体同事类1：发出请求...");
  77.         //请中介者转发
  78.         smd.relay(this);
  79.     }
  80. }
  82. //具体同事类
  83. class SimpleConcreteColleague2 implements SimpleColleague {
  84.     SimpleConcreteColleague2() {
  85.         SimpleMediator smd = SimpleMediator.getMedium();
  86.         smd.register(this);
  87.     }
  89.     @Override
  90.     public void receive() {
  91.         System.out.println("具体同事类2：收到请求。");
  92.     }
  94.     @Override
  95.     public void send() {
  96.         SimpleMediator smd = SimpleMediator.getMedium();
  97.         System.out.println("具体同事类2：发出请求...");
  98.         //请中介者转发
  99.         smd.relay(this);
  100.     }
  101. }