定义

观察者模式定义了对象之间的一对多依赖, 当一个对象改变状态时, 它的所有依赖者都会收到通知并自动更新
**

设计原则

  • 为交互对象之间的松耦合设计而努力

案例

背景: 一个气象观测站, 由weatherObject追踪天气, 温度, 气压, 有三种布告板分别显示目前的状况, 并希望布告板可以增加
image.png

建立Subject接口, 负责Observer的注册,移除以及通知

  1. public interface Subject {
  3.   void registerObserver(Observer observer);
  5.   void removeObserver(Observer observer);
  7.   void notifyObserver(String newTemp);
  9. }

WeatherData实现Subject接口, 持有List, 实现具体的注册(add), 移除(remove)以及通知(通知所有的观察者)

  1. public class WeatherData implements Subject {
  3.   private List<Observer> observerList;
  4.   private String temperature;
  6.   public WeatherData() {
  7.     observerList = new ArrayList<Observer>();
  8.   }
  10.   public void change(String newTemp) {
  11.     System.out.println("气候改变了!");
  12.     notifyObserver(newTemp);
  13.   }
  15.   public String getTemperature() {
  16.     return temperature;
  17.   }
  19.   public void setTemperature(String temperature) {
  20.     this.temperature = temperature;
  21.   }
  23.   @Override
  24.   public void registerObserver(Observer observer) {
  25.     observerList.add(observer);
  26.   }
  28.   @Override
  29.   public void removeObserver(Observer observer) {
  30.     int i = observerList.indexOf(observer);
  31.     if (i > 0) {
  32.       observerList.remove(i);
  33.     }
  34.   }
  36.   @Override
  37.   public void notifyObserver(String newTemp) {
  38.     for (Observer observer : observerList) {
  39.       observer.update(newTemp);
  40.     }
  41.   }
  42. }

Observer接口有更新方法

  1. public interface Observer {
  3.   void update(String newTemp);
  4. }

布告板实现Observer接口, 实现更新方法, 更新自己的变量
并持有weather对象, 在构造方法中将自身注册到Subject的List中

  1. public class OneDisplay implements Observer, Display {
  3.   private String temp;
  4.   private Subject weather;
  6.   public OneDisplay(Subject weather) {
  7.     this.weather = weather;
  8.     weather.registerObserver(this);
  9.   }
  11.   @Override
  12.   public void display() {
  13.     System.out.println("这里是一号公告板, 目前的温度是: " + this.temp);
  14.   }
  16.   public String getTemp() {
  17.     return temp;
  18.   }
  20.   public void setTemp(String temp) {
  21.     this.temp = temp;
  22.   }
  24.   @Override
  25.   public void update(String newTemp) {
  26.     this.temp = newTemp;
  27.   }
  28. }

测试:

  1. @Test
  2.   public void testObserver() {
  3.     WeatherData weatherData = new WeatherData();
  4.     OneDisplay oneDisplay = new OneDisplay(weatherData);
  5.     TwoDisplay twoDisplay = new TwoDisplay(weatherData);
  6.     weatherData.change("888");
  7.     oneDisplay.display();
  8.     twoDisplay.display();
  9.     weatherData.change("999");
  10.     oneDisplay.display();
  11.     twoDisplay.display();
  12.   }
  14. 结果:
  15. 气候改变了!
  16. 这里是一号公告板, 目前的温度是: 888
  17. 这里是二号公告板, 目前的温度是: 888
  18. 气候改变了!
  19. 这里是一号公告板, 目前的温度是: 999
  20. 这里是二号公告板, 目前的温度是: 999

这样做的好处:
1.Subject与Observer完全松耦合, Observer可以自由增加, 将自身注册到Subject中即可
2.面对接口编程
3.当Subject发生变化时, 通知所有的Observer, 所有的Observer会执行update
联系以上, 即容易理解概念

java内置的观察者模式
被观察者继承Observable类, 观察者实现Observer接口实现
相关方法有 setChange, clearChange, notifyObservers等

问题:
Observable类限制了复用, 继承的方法拓展性不好
java不支持多继承, 不是接口无法添加自己的实现和原有的API搭配使用, setChanged()等方法的保护级别为protected, 外部无法覆盖, 只能通过继承覆盖

image.png
**
被观测者继承 java.util.Observable 类
通知需要先setchange(), 再notifyObservers(arg);

  1. public class WeatherData extends Observable {
  3.   private String temp;
  5.   public void tempChange(String newTemp) {
  6.     this.setTemp(newTemp);
  7.     setChanged();
  8.     notifyObservers("测试传参");
  9.   }
  11.   public String getTemp() {
  12.     return temp;
  13.   }
  15.   public void setTemp(String temp) {
  16.     this.temp = temp;
  17.   }
  18. }

观察者实现java.util.Observer接口, 持有Observable属性
并在构造方法中将自身注册, 重写update方法接收消息

  1. public class Display1 implements Observer, Display {
  3.   Observable observable;
  4.   private String disTemp;
  6.   public Display1(Observable observable) {
  7.     this.observable = observable;
  8.     observable.addObserver(this);
  9.   }
  11.   @Override
  12.   public void update(Observable o, Object arg) {
  13.     if (o instanceof WeatherData) {
  14.       WeatherData data = (WeatherData) o;
  15.       this.disTemp = data.getTemp();
  16.       System.out.println("接收到的参数为: " + (String) arg);
  17.     }
  18.   }
  20.   public String getDisTemp() {
  21.     return disTemp;
  22.   }
  24.   public void setDisTemp(String disTemp) {
  25.     this.disTemp = disTemp;
  26.   }
  28.   @Override
  29.   public void display() {
  30.     System.out.println("这里是布告板1,现在的温度是: " + this.disTemp);
  31.   }
  32. }

**
测试

  1. @Test
  2.   public void testStrategy() {
  3.     WeatherData weatherData = new WeatherData();
  4.     weatherData.setTemp("12度");
  5.     Display1 display1 = new Display1(weatherData);
  6.     Display2 display2 = new Display2(weatherData);
  7.     display1.display();
  8.     display2.display();
  9.     weatherData.tempChange("20度");
  10.     display1.display();
  11.     display2.display();
  12.   }
  14. 结果:
  15. 这里是布告板1,现在的温度是: null
  16. 这里是布告板2,现在的温度是: null
  17. 接收到的参数为: 测试传参
  18. 接收到的参数为: 测试传参
  19. 这里是布告板1,现在的温度是: 20度
  20. 这里是布告板2,现在的温度是: 20度