OOP设计模式（2 / 23）：观察者模式

墨蓝 2022-09-05 11:28 158阅读 0赞

## 定义 ##

观察者（Observer）模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE4NjMwMjQ_size_16_color_FFFFFF_t_70_pic_center]

**OO设计原则：为了交互对象之间的松耦合设计而努力。**

## 案例：气象监测应用 ##

### 概括 ###

此系统中的三个部分是

1.  **气象站**（获取实际气象数据的物理装置）
2.  **WeatherData对象**（追踪来自气象站的数据，并更新布告板）
3.  **布告板**（显示目前天气状况给用户看）

WeatherData对象知道如何跟物理气象站联系，以取得更新的数据。

WeatherData对象会随即更新三个布告板的显示：

1.  目前状况（温度、湿度、气压）、
2.  气象统计
3.  天气预报。

目标是建立一个应用，利用WeatherData对象取得数据，并更新三个布告板：目前状况、气象统计和天气预报 。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE4NjMwMjQ_size_16_color_FFFFFF_t_70_pic_center 1]

### 设计图 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE4NjMwMjQ_size_16_color_FFFFFF_t_70_pic_center 2]

### 放码过来 ###

#### 气象站主程序 ####

public class WeatherStation { 
    
    	public static void main(String[] args) { 
    		WeatherData weatherData = new WeatherData();
    	
    		CurrentConditionsDisplay currentDisplay = 
    			new CurrentConditionsDisplay(weatherData);
    		StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
    		ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);
    
    		weatherData.setMeasurements(80, 65, 30.4f);
    		
    		System.out.println("---");
    		weatherData.setMeasurements(82, 70, 29.2f);
    		
    		System.out.println("---");
    		weatherData.setMeasurements(78, 90, 29.2f);
    		
    		System.out.println("---Remove Observer---");
    		weatherData.removeObserver(forecastDisplay);
    		weatherData.setMeasurements(62, 90, 28.1f);
    	}
    }

#### 布告板 ####

打印展现接口

public interface DisplayElement { 
    	public void display();
    }

#### 主题 ####

public interface Subject { 
    	public void registerObserver(Observer o);
    	public void removeObserver(Observer o);
    	public void notifyObservers();
    }

##### 实现主题接口的气象数据 #####

import java.util.*;
    
    public class WeatherData implements Subject { 
    	private List<Observer> observers;
    	private float temperature;
    	private float humidity;
    	private float pressure;
    	
    	public WeatherData() { 
    		observers = new ArrayList<Observer>();
    	}
    	
    	public void registerObserver(Observer o) { 
    		observers.add(o);
    	}
    	
    	public void removeObserver(Observer o) { 
    		observers.remove(o);
    	}
    	
    	public void notifyObservers() { 
    		for (Observer observer : observers) { 
    			observer.update(temperature, humidity, pressure);
    		}
    	}
    	
    	public void measurementsChanged() { 
    		notifyObservers();
    	}
    	
    	public void setMeasurements(float temperature, float humidity, float pressure) { 
    		this.temperature = temperature;
    		this.humidity = humidity;
    		this.pressure = pressure;
    		measurementsChanged();
    	}
    
    	public float getTemperature() { 
    		return temperature;
    	}
    	
    	public float getHumidity() { 
    		return humidity;
    	}
    	
    	public float getPressure() { 
    		return pressure;
    	}
    
    }

#### 观察者 ####

public interface Observer { 
    	public void update(float temp, float humidity, float pressure);
    }

##### 实现观察者接口的目前状况布告板 #####

public class CurrentConditionsDisplay implements Observer, DisplayElement { 
    	private float temperature;
    	private float humidity;
    	private WeatherData weatherData;
    	
    	public CurrentConditionsDisplay(WeatherData weatherData) { 
    		this.weatherData = weatherData;
    		weatherData.registerObserver(this);
    	}
    	
    	public void update(float temperature, float humidity, float pressure) { 
    		this.temperature = temperature;
    		this.humidity = humidity;
    		display();
    	}
    	
    	public void display() { 
    		System.out.println("Current conditions: " + temperature 
    			+ "F degrees and " + humidity + "% humidity");
    	}
    }

##### 实现观察者接口的气象统计布告板 #####

public class StatisticsDisplay implements Observer, DisplayElement { 
    	private float maxTemp = 0.0f;
    	private float minTemp = 200;
    	private float tempSum= 0.0f;
    	private int numReadings;
    	private WeatherData weatherData;
    
    	public StatisticsDisplay(WeatherData weatherData) { 
    		this.weatherData = weatherData;
    		weatherData.registerObserver(this);
    	}
    
    	public void update(float temp, float humidity, float pressure) { 
    		tempSum += temp;
    		numReadings++;
    
    		if (temp > maxTemp) { 
    			maxTemp = temp;
    		}
     
    		if (temp < minTemp) { 
    			minTemp = temp;
    		}
    
    		display();
    	}
    
    	public void display() { 
    		System.out.println("Avg/Max/Min temperature = " + (tempSum / numReadings)
    			+ "/" + maxTemp + "/" + minTemp);
    	}
    }

##### 实现观察者接口的天气预报布告板 #####

public class ForecastDisplay implements Observer, DisplayElement { 
    	private float currentPressure = 29.92f;  
    	private float lastPressure;
    	private WeatherData weatherData;
    
    	public ForecastDisplay(WeatherData weatherData) { 
    		this.weatherData = weatherData;
    		weatherData.registerObserver(this);
    	}
    
    	public void update(float temp, float humidity, float pressure) { 
            lastPressure = currentPressure;
    		currentPressure = pressure;
    
    		display();
    	}
    
    	public void display() { 
    		System.out.print("Forecast: ");
    		if (currentPressure > lastPressure) { 
    			System.out.println("Improving weather on the way!");
    		} else if (currentPressure == lastPressure) { 
    			System.out.println("More of the same");
    		} else if (currentPressure < lastPressure) { 
    			System.out.println("Watch out for cooler, rainy weather");
    		}
    	}
    }

#### 运行结果 ####

气象站主程序运行结果：

Current conditions: 80.0F degrees and 65.0% humidity
    Avg/Max/Min temperature = 80.0/80.0/80.0
    Forecast: Improving weather on the way!
    ---
    Current conditions: 82.0F degrees and 70.0% humidity
    Avg/Max/Min temperature = 81.0/82.0/80.0
    Forecast: Watch out for cooler, rainy weather
    ---
    Current conditions: 78.0F degrees and 90.0% humidity
    Avg/Max/Min temperature = 80.0/82.0/78.0
    Forecast: More of the same
    ---Remove Observer---
    Current conditions: 62.0F degrees and 90.0% humidity
    Avg/Max/Min temperature = 75.5/82.0/62.0

## 现成轮子 ##

Java API有内置的观察者模式。java.util包内包含最基本的Observer接口与Observable类，这和案例的Subject接口与Observer接口很相似。

Observer接口与Observable类使用上更方便，因为许多功能都已经事先准备好了。

package java.util;
    
    @Deprecated(since="9")
    public interface Observer { 
    
        void update(Observable o, Object arg);
    }

package java.util;
    
    @Deprecated(since="9")
    public class Observable { 
        private boolean changed = false;
        private Vector<Observer> obs;
    
        public Observable() { 
            obs = new Vector<>();
        }
    
        public synchronized void addObserver(Observer o) { 
            if (o == null)
                throw new NullPointerException();
            if (!obs.contains(o)) { 
                obs.addElement(o);
            }
        }
    
        public synchronized void deleteObserver(Observer o) { 
            obs.removeElement(o);
        }
    
        public void notifyObservers() { 
            notifyObservers(null);
        }
    
        public void notifyObservers(Object arg) { 
            /* * a temporary array buffer, used as a snapshot of the state of * current Observers. */
            Object[] arrLocal;
    
            synchronized (this) { 
                /* We don't want the Observer doing callbacks into * arbitrary code while holding its own Monitor. * The code where we extract each Observable from * the Vector and store the state of the Observer * needs synchronization, but notifying observers * does not (should not). The worst result of any * potential race-condition here is that: * 1) a newly-added Observer will miss a * notification in progress * 2) a recently unregistered Observer will be * wrongly notified when it doesn't care */
                if (!changed)
                    return;
                arrLocal = obs.toArray();
                clearChanged();
            }
    
            for (int i = arrLocal.length-1; i>=0; i--)
                ((Observer)arrLocal[i]).update(this, arg);
        }
    
        public synchronized void deleteObservers() { 
            obs.removeAllElements();
        }
    
        protected synchronized void setChanged() { 
            changed = true;
        }
    
        protected synchronized void clearChanged() { 
            changed = false;
        }
    
        public synchronized boolean hasChanged() { 
            return changed;
        }
    
        public synchronized int countObservers() { 
            return obs.size();
        }
    }

**注意**：Observer和Observable在Java 9标记为废弃。

> **Deprecated.** This class and the `Observer` interface have been deprecated. The event model supported by `Observer` and `Observable` is quite limited, the order of notifications delivered by `Observable` is unspecified, and state changes are not in one-for-one correspondence with notifications. For a richer event model, consider using the `java.beans` package. For reliable and ordered messaging among threads, consider using one of the concurrent data structures in the `java.util.concurrent` package. For reactive streams style programming, see the `java.util.concurrent.Flow` API.
> 
> [Link][]

## 参考资料 ##

1.  《Head First 设计模式》
2.  [Observable (Java SE 9 & JDK 9 )][Link]
3.  [Java 9：Observer和Observable废弃原因及解决方案][Java 9_Observer_Observable]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE4NjMwMjQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20220829/c0cb21b7a7194794b0295d8b1b25db54.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE4NjMwMjQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20220829/4d9e16d4bb744f378901948c7c974c92.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE4NjMwMjQ_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20220829/1aea142933474d4ca70ee3d76e9ef674.png
[Link]: https://docs.oracle.com/javase/9/docs/api/java/util/Observable.html
[Java 9_Observer_Observable]: https://majing.io/posts/10000001281162