中介者模式

行为型-中介者模式&观察者 - 图1

中介者模式(Mediator Pattern)：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，减少对象间混乱的依赖关系，从而使其耦合松散，而且可以独立地改变它们之间的交互。对象行为型模式。将网状关系变成星状关系

实例-飞机降落

只有一条跑道，每个飞机降落的时候需要先和各个机长确认

  1. /**
  2.  * 抽象机长
  3.  */
  4. public abstract class Captain {
  5.     //起飞
  6.     abstract void fly();
  7.     //降落
  8.     abstract void land();
  9.     //完成
  10.     abstract void success();
  12. }
  1. /**
  2.  * 海南8778
  3.  */
  4. public class HU8778 extends Captain{
  6.     ControlTower controlTower;//注意：这里塔台不能自己new，需要使用同一个塔台，也可以将塔台设置成单例
  8.     public void setControlTower(ControlTower controlTower) {
  9.         this.controlTower = controlTower;
  10.     }
  12.     @Override
  13.     void fly() {
  14.         System.out.println("HU8778请求起飞......");
  15.         //问每个机长能否起飞？
  16.         controlTower.acceptRequest(this,"fly");
  17.     }
  19.     @Override
  20.     void land() {
  21.         System.out.println("HU8778请求降落......");
  22.         controlTower.acceptRequest(this,"land");
  23.     }
  25.     @Override
  26.     void success() {
  27.         System.out.println("完成......");
  28.         controlTower.acceptRequest(this,"success");
  29.     }
  30. }
  1. /**
  2.  * 四川8633机长
  3.  */
  4. public class SC8633 extends Captain{
  5.     ControlTower controlTower ;  //注意：这里塔台不能自己new，需要使用同一个塔台，也可以将塔台设置成单例
  7.     public void setControlTower(ControlTower controlTower) {
  8.         this.controlTower = controlTower;
  9.     }
  11.     @Override
  12.     void fly() {
  13.         System.out.println("SC8633 请求起飞......");
  14.         //问每个机长能否起飞？
  15.         controlTower.acceptRequest(this,"fly");
  17.     }
  19.     @Override
  20.     void land() {
  22.         System.out.println("SC8633 请求降落......");
  23.         //问每个机长能否起飞？
  24.         controlTower.acceptRequest(this,";land");
  25.     }
  27.     @Override
  28.     void success() {
  30.         System.out.println("SC8633 完成......");
  31.         //问每个机长能否起飞？
  32.         controlTower.acceptRequest(this,"success");
  33.     }
  34. }
  1. /**
  2.  * 塔台：中介者
  3.  *
  4.  * 网状变为星状
  5.  */
  6. public class ControlTower {
  9.     private boolean canDo = true;
  11.     //接受请求...
  12.     public void acceptRequest(Captain captain,String action){
  13.         if("fly".equals(action)||"land".equals(action)){
  14.             //
  15.             if(canDo == true){
  16.                 System.out.println("允许......");
  17.                 canDo = false;
  18.             }else {
  19.                 System.out.println("不允许.....");
  20.             }
  21.         }
  22.         if("success".equals(action)){ //如果完成了，将状态变成true。其他飞机可以起飞或者降落
  23.             canDo = true;
  24.         }
  27.     }
  28. }
  1. /**
  2.  * 中介者：
  3.  *
  4.  */
  5. public class MainTest {
  7.     public static void main(String[] args) {
  8.         HU8778 hu8778 = new HU8778();
  9.         SC8633 sc8633 = new SC8633();
  11.         ControlTower tower = new ControlTower();
  12.         hu8778.setControlTower(tower);
  13.         sc8633.setControlTower(tower); //使用同一个塔台，使用同一个状态
  15.         hu8778.fly();
  17.         hu8778.success();
  19.         sc8633.fly();
  21.     }
  22. }

场景

观察者模式(Observer Pattern)：定义对象间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。观察者模式又叫做发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。对象行为型模式

观察者模式

观察者模式(Observer Pattern)：定义对象间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。观察者模式又叫做发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。对象行为型模式

行为型-中介者模式&观察者 - 图2

实例-气象台

  1. 气象站可以将每天测量到的温度，湿度，气压等等以公告的形式发布出去(比如发布到自己的网站或第三方)。
  2. 需要设计开放型 API，便于其他第三方也能接入气象站获取数据。
  3. 提供温度、气压和湿度的接口
  4. 测量数据更新时，要能实时的通知给第三方

WeatherData

  1. JAVA
  2. /**
  3.  * 类是核心
  4.  * 1. 包含最新的天气情况信息 
  5.  * 2. 含有 CurrentConditions 对象
  6.  * 3. 当数据有更新时，就主动的调用   CurrentConditions对象update方法(含 display), 这样他们（接入方）就看到最新的信息
  7.  *
  8.  */
  9. public class WeatherData {
  10.    private float temperatrue;
  11.    private float pressure;
  12.    private float humidity;
  13.    private CurrentConditions currentConditions;
  14.    //加入新的第三方
  16.    public WeatherData(CurrentConditions currentConditions) {
  17.       this.currentConditions = currentConditions;
  18.    }
  20.    public float getTemperature() {
  21.       return temperatrue;
  22.    }
  24.    public float getPressure() {
  25.       return pressure;
  26.    }
  28.    public float getHumidity() {
  29.       return humidity;
  30.    }
  32.    public void dataChange() {
  33.       //调用 接入方的 update
  34.       currentConditions.update(getTemperature(), getPressure(), getHumidity());
  35.    }
  37.    //当数据有更新时，就调用 setData
  38.    public void setData(float temperature, float pressure, float humidity) {
  39.       this.temperatrue = temperature;
  40.       this.pressure = pressure;
  41.       this.humidity = humidity;
  42.       //调用dataChange， 将最新的信息 推送给 接入方 currentConditions
  43.       dataChange();
  44.    }
  45. }

CurrentConditions

  1. JAVA
  2. /**
  3.  * 显示当前天气情况（可以理解成是气象站自己的网站）
  4.  *
  5.  */
  6. public class CurrentConditions {
  7.    // 温度，气压，湿度
  8.    private float temperature;
  9.    private float pressure;
  10.    private float humidity;
  12.    //更新 天气情况，是由 WeatherData 来调用，我使用推送模式
  13.    public void update(float temperature, float pressure, float humidity) {
  14.       this.temperature = temperature;
  15.       this.pressure = pressure;
  16.       this.humidity = humidity;
  17.       display();
  18.    }
  20.    //显示
  21.    public void display() {
  22.       System.out.println("***Today mTemperature: " + temperature + "***");
  23.       System.out.println("***Today mPressure: " + pressure + "***");
  24.       System.out.println("***Today mHumidity: " + humidity + "***");
  25.    }
  26. }

Client

  1. JAVA
  2. public class Client {
  3.   public static void main(String[] args) {
  4.     // 创建接入方 currentConditions
  5.     CurrentConditions currentConditions = new CurrentConditions();
  6.     // 创建 WeatherData 并将 接入方 currentConditions 传递到 WeatherData中
  7.     WeatherData weatherData = new WeatherData(currentConditions);
  9.     // 更新天气情况
  10.     weatherData.setData(30, 150, 40);
  12.     // 天气情况变化
  13.     System.out.println("============天气情况变化=============");
  14.     weatherData.setData(40, 160, 20);
  15.   }
  16. }

问题分析

  1. 其他第三方接入气象站获取数据的问题，无法在运行时动态的添加第三方 (新浪网站)
  2. 违反 ocp 原则，当加入第三方时，需要修改WeatherData代码，不利于维护。

观察者模式方案

Subject【接口】

  1. JAVA
  2. //接口, 让WeatherData 来实现 
  3. public interface Subject {
  5.    public void registerObserver(Observer o);
  6.    public void removeObserver(Observer o);
  7.    public void notifyObservers();
  8. }

Observer【接口】

  1. JAVA
  2. //观察者接口，有观察者来实现
  3. public interface Observer {
  5.    public void update(float temperature, float pressure, float humidity);
  6. }

WeatherData

  1. JAVA
  2. public class WeatherData implements Subject {
  3.    private float temperatrue;
  4.    private float pressure;
  5.    private float humidity;
  6.    //观察者集合
  7.    private ArrayList<Observer> observers;
  9.    //加入新的第三方
  11.    public WeatherData() {
  12.       observers = new ArrayList<Observer>();
  13.    }
  15.    public float getTemperature() {
  16.       return temperatrue;
  17.    }
  19.    public float getPressure() {
  20.       return pressure;
  21.    }
  23.    public float getHumidity() {
  24.       return humidity;
  25.    }
  27.    public void dataChange() {
  28.       //调用 接入方的 update
  30.       notifyObservers();
  31.    }
  33.    //当数据有更新时，就调用 setData
  34.    public void setData(float temperature, float pressure, float humidity) {
  35.       this.temperatrue = temperature;
  36.       this.pressure = pressure;
  37.       this.humidity = humidity;
  38.       //调用dataChange， 将最新的信息 推送给 接入方 currentConditions
  39.       dataChange();
  40.    }
  42.    //注册一个观察者
  43.    @Override
  44.    public void registerObserver(Observer o) {
  45.       // TODO Auto-generated method stub
  46.       observers.add(o);
  47.    }
  49.    //移除一个观察者
  50.    @Override
  51.    public void removeObserver(Observer o) {
  52.       // TODO Auto-generated method stub
  53.       if(observers.contains(o)) {
  54.          observers.remove(o);
  55.       }
  56.    }
  58.    //遍历所有的观察者，并通知
  59.    @Override
  60.    public void notifyObservers() {
  61.       // TODO Auto-generated method stub
  62.       for(int i = 0; i < observers.size(); i++) {
  63.          observers.get(i).update(this.temperatrue, this.pressure, this.humidity);
  64.       }
  65.    }
  66. }

CurrentConditions

  1. JAVA
  2. public class CurrentConditions implements Observer {
  4.    // 温度，气压，湿度
  5.    private float temperature;
  6.    private float pressure;
  7.    private float humidity;
  9.    // 更新 天气情况，是由 WeatherData 来调用，我使用推送模式
  10.    public void update(float temperature, float pressure, float humidity) {
  11.       this.temperature = temperature;
  12.       this.pressure = pressure;
  13.       this.humidity = humidity;
  14.       display();
  15.    }
  17.    // 显示
  18.    public void display() {
  19.       System.out.println("***Today mTemperature: " + temperature + "***");
  20.       System.out.println("***Today mPressure: " + pressure + "***");
  21.       System.out.println("***Today mHumidity: " + humidity + "***");
  22.    }
  23. }

BaiduSite

  1. JAVA
  2. public class BaiduSite implements Observer {
  4.   // 温度，气压，湿度
  5.   private float temperature;
  6.   private float pressure;
  7.   private float humidity;
  9.   // 更新 天气情况，是由 WeatherData 来调用，我使用推送模式
  10.   public void update(float temperature, float pressure, float humidity) {
  11.     this.temperature = temperature;
  12.     this.pressure = pressure;
  13.     this.humidity = humidity;
  14.     display();
  15.   }
  17.   // 显示
  18.   public void display() {
  19.     System.out.println("===百度网站====");
  20.     System.out.println("***百度网站 气温 : " + temperature + "***");
  21.     System.out.println("***百度网站 气压: " + pressure + "***");
  22.     System.out.println("***百度网站 湿度: " + humidity + "***");
  23.   }
  24. }

Client

  1. JAVA
  2. public class Client {
  4.   public static void main(String[] args) {
  5.     // TODO Auto-generated method stub
  6.     // 创建一个WeatherData
  7.     WeatherData weatherData = new WeatherData();
  9.     // 创建观察者
  10.     CurrentConditions currentConditions = new CurrentConditions();
  11.     BaiduSite baiduSite = new BaiduSite();
  13.     // 注册到weatherData
  14.     weatherData.registerObserver(currentConditions);
  15.     weatherData.registerObserver(baiduSite);
  17.     // 测试
  18.     System.out.println("通知各个注册的观察者, 看看信息");
  19.     weatherData.setData(10f, 100f, 30.3f);
  21.     weatherData.removeObserver(currentConditions);
  22.     // 测试
  23.     System.out.println();
  24.     System.out.println("通知各个注册的观察者, 看看信息");
  25.     weatherData.setData(10f, 100f, 30.3f);
  26.   }
  27. }

原理及应用场景剖析

观察者模式也被称为发布订阅模式（Publish-Subscribe Design Pattern）。在 GoF 的《设计模式》一书中，它的定义是这样的：

Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

翻译成中文就是：在对象之间定义一个一对多的依赖，当一个对象状态改变的时候，所有依赖的对象都会自动收到通知。

  1. 一般情况下，被依赖的对象叫作被观察者（Observable），依赖的对象叫作观察者（Observer）。不过，在实际的项目开发中，这两种对象的称呼是比较灵活的，有各种不同的叫法，比如：Subject-Observer、Publisher-Subscriber、Producer-Consumer、EventEmitter-EventListener、Dispatcher-Listener。不管怎么称呼，只要应用场景符合刚刚给出的定义，都可以看作观察者模式。
  2. 实际上，观察者模式是一个比较抽象的模式，根据不同的应用场景和需求，有完全不同的实现方式，待会我们会详细地讲到。现在，我们先来看其中最经典的一种实现方式。这也是在讲到这种模式的时候，很多书籍或资料给出的最常见的实现方式。具体的代码如下所示：
  1. import java.util.ArrayList;
  2. import java.util.List;
  4. public interface Subject {
  5.   void registerObserver(Observer observer);
  7.   void removeObserver(Observer observer);
  9.   void notifyObservers(Message message);
  10. }
  12. public interface Observer {
  13.   void update(Message message);
  14. }
  16. public class ConcreteSubject implements Subject {
  17.   private List<Observer> observers = new ArrayList<Observer>();
  19.   @Override
  20.   public void registerObserver(Observer observer) {
  21.     observers.add(observer);
  22.   }
  24.   @Override
  25.   public void removeObserver(Observer observer) {
  26.     observers.remove(observer);
  27.   }
  29.   @Override
  30.   public void notifyObservers(Message message) {
  31.     for (Observer observer : observers) {
  32.       observer.update(message);
  33.     }
  34.   }
  35. }
  37. public class ConcreteObserverOne implements Observer {
  39.   @Override
  40.   public void update(Message message) {
  41.     // TODO: 获取消息通知，执行自己的逻辑...
  42.     System.out.println("ConcreteObserverOne is notified.");
  43.   }
  44. }
  46. public class ConcreteObserverTwo implements Observer {
  48.   @Override
  49.   public void update(Message message) {
  50.     // TODO: 获取消息通知，执行自己的逻辑...
  51.     System.out.println("ConcreteObserverTwo is notified.");
  52.   }
  53. }
  55. public class Demo {
  57.   public static void main(String[] args) {
  58.     ConcreteSubject subject = new ConcreteSubject();
  59.     subject.registerObserver(new ConcreteObserverOne());
  60.     subject.registerObserver(new ConcreteObserverTwo());
  61.     subject.notifyObservers(new Message());
  62.   }
  63. }
  1. 实际上，上面的代码算是观察者模式的“模板代码”，只能反映大体的设计思路。在真实的软件开发中，并不需要照搬上面的模板代码。观察者模式的实现方法各式各样，函数、类的命名等会根据业务场景的不同有很大的差别，比如 register 函数还可以叫作 attach，remove 函数还可以叫作 detach 等等。不过，万变不离其宗，设计思路都是差不多的。
  2. 原理和代码实现都非常简单，也比较好理解，不需要我过多的解释。我们还是通过一个具体的例子来重点讲一下，什么情况下需要用到这种设计模式？或者说，这种设计模式能解决什么问题呢？
  3. 假设我们在开发一个 P2P 投资理财系统，用户注册成功之后，我们会给用户发放投资体验金。代码实现大致是下面这个样子的：
  1. import java.util.ArrayList;
  2. import java.util.List;
  4. public interface RegObserver {
  5.   void handleRegSuccess(long userId);
  6. }
  8. public class RegPromotionObserver implements RegObserver {
  9.   private PromotionService promotionService; // 依赖注入
  11.   @Override
  12.   public void handleRegSuccess(long userId) {
  13.     promotionService.issueNewUserExperienceCash(userId);
  14.   }
  15. }
  17. public class RegNotificationObserver implements RegObserver {
  18.   private NotificationService notificationService;
  20.   @Override
  21.   public void handleRegSuccess(long userId) {
  22.     notificationService.sendInboxMessage(userId, "Welcome...");
  23.   }
  24. }
  26. public class UserController {
  27.   private UserService userService; // 依赖注入
  28.   private List<RegObserver> regObservers = new ArrayList<>();
  30.   // 一次性设置好，之后也不可能动态的修改
  31.   public void setRegObservers(List<RegObserver> observers) {
  32.     regObservers.addAll(observers);
  33.   }
  35.   public Long register(String telephone, String password) {
  36.     // 省略输入参数的校验代码
  37.     // 省略userService.register()异常的try-catch代码
  38.     long userId = userService.register(telephone, password);
  40.     for (RegObserver observer : regObservers) {
  41.       observer.handleRegSuccess(userId);
  42.     }
  44.     return userId;
  45.   }
  46. }
  1. 当我们需要添加新的观察者的时候，比如，用户注册成功之后，推送用户注册信息给大数据征信系统，基于观察者模式的代码实现，UserController 类的 register() 函数完全不需要修改，只需要再添加一个实现了 RegObserver 接口的类，并且通过 setRegObservers() 函数将它注册到 UserController 类中即可。
  2. 不过，你可能会说，当我们把发送体验金替换为发送优惠券的时候，需要修改 RegPromotionObserver 类中 handleRegSuccess() 函数的代码，这还是违反开闭原则呀？你说得没错，不过，相对于 register() 函数来说，handleRegSuccess() 函数的逻辑要简单很多，修改更不容易出错，引入 bug 的风险更低。
  3. 前面我们已经学习了很多设计模式，不知道你有没有发现，实际上，设计模式要干的事情就是解耦。创建型模式是将创建和使用代码解耦，结构型模式是将不同功能代码解耦，行为型模式是将不同的行为代码解耦，具体到观察者模式，它是将观察者和被观察者代码解耦。借助设计模式，我们利用更好的代码结构，将一大坨代码拆分成职责更单一的小类，让其满足开闭原则、高内聚松耦合等特性，以此来控制和应对代码的复杂性，提高代码的可扩展性。

基于不同应用场景的不同实现方式

  1. 观察者模式的应用场景非常广泛，小到代码层面的解耦，大到架构层面的系统解耦，再或者一些产品的设计思路，都有这种模式的影子，比如，邮件订阅、RSS Feeds，本质上都是观察者模式。
  2. 不同的应用场景和需求下，这个模式也有截然不同的实现方式，开篇的时候我们也提到，有同步阻塞的实现方式，也有异步非阻塞的实现方式；有进程内的实现方式，也有跨进程的实现方式。
  3. 之前讲到的实现方式，从刚刚的分类方式上来看，它是一种同步阻塞的实现方式。观察者和被观察者代码在同一个线程内执行，被观察者一直阻塞，直到所有的观察者代码都执行完成之后，才执行后续的代码。对照上面讲到的用户注册的例子，register() 函数依次调用执行每个观察者的 handleRegSuccess() 函数，等到都执行完成之后，才会返回结果给客户端。
  4. 如果注册接口是一个调用比较频繁的接口，对性能非常敏感，希望接口的响应时间尽可能短，那我们可以将同步阻塞的实现方式改为异步非阻塞的实现方式，以此来减少响应时间。具体来讲，当 userService.register() 函数执行完成之后，我们启动一个新的线程来执行观察者的 handleRegSuccess() 函数，这样 userController.register() 函数就不需要等到所有的 handleRegSuccess() 函数都执行完成之后才返回结果给客户端。userController.register() 函数从执行 3 个 SQL 语句才返回，减少到只需要执行 1 个 SQL 语句就返回，响应时间粗略来讲减少为原来的 1/3。
  5. 那如何实现一个异步非阻塞的观察者模式呢？简单一点的做法是，在每个 handleRegSuccess() 函数中，创建一个新的线程执行代码。不过，我们还有更加优雅的实现方式，那就是基于 EventBus 来实现。今天，我们就不展开讲解了。在下一讲中，我会用一节的时间，借鉴 Google Guava EventBus 框架的设计思想，手把手带你开发一个支持异步非阻塞的 EventBus 框架。它可以复用在任何需要异步非阻塞观察者模式的应用场景中。
  6. 刚刚讲到的两个场景，不管是同步阻塞实现方式还是异步非阻塞实现方式，都是进程内的实现方式。如果用户注册成功之后，我们需要发送用户信息给大数据征信系统，而大数据征信系统是一个独立的系统，跟它之间的交互是跨不同进程的，那如何实现一个跨进程的观察者模式呢？
  7. 如果大数据征信系统提供了发送用户注册信息的 RPC 接口，我们仍然可以沿用之前的实现思路，在 handleRegSuccess() 函数中调用 RPC 接口来发送数据。但是，我们还有更加优雅、更加常用的一种实现方式，那就是基于消息队列（Message Queue，比如 ActiveMQ）来实现。
  8. 当然，这种实现方式也有弊端，那就是需要引入一个新的系统（消息队列），增加了维护成本。不过，它的好处也非常明显。在原来的实现方式中，观察者需要注册到被观察者中，被观察者需要依次遍历观察者来发送消息。而基于消息队列的实现方式，被观察者和观察者解耦更加彻底，两部分的耦合更小。被观察者完全不感知观察者，同理，观察者也完全不感知被观察者。被观察者只管发送消息到消息队列，观察者只管从消息队列中读取消息来执行相应的逻辑。

场景

什么场景用到？
Spring事件机制如何实现？
Vue的双向绑定核心
响应式编程核心思想
……