Conceito:
Modo de observador:
O padrão observador define dependências de um para muitos entre objetos, de modo que quando um objeto muda de estado, todos os seus dependentes serão notificados e atualizados automaticamente. -> Comunique o estado entre uma série de objetos de maneira pouco acoplada.
O artigo anterior implementou o modo observador com código personalizado.Este artigo explica principalmente a implementação do jdk e explora as vantagens e desvantagens desse modo no jdk:
Cenário de negócios:
Existe uma estação de observação meteorológica que pode detectar dados meteorológicos específicos, como temperatura, umidade e pressão barométrica. Agora existem três painéis de exibição específicos. Quando os dados meteorológicos são atualizados, o observador pode notificar os três painéis de exibição para atualizar os dados em tempo real. Esse cenário de negócios se encaixa no nosso modelo de observador, a estação de observação meteorológica é o assunto e o painel de exibição é o observador. Desta vez, o negócio é implementado através do jdk Observerable embutido:
Primeiro, as classes e interfaces incorporadas no jdk são introduzidas:
- interface pública Observer {…}
A interface que o observador precisa implementar, existe apenas um método de atualização, chamado quando a notificação de tópico é recebida
/*
package java.util;
public interface Observer {
void update(Observable o, Object arg);
}
- public class Observable {…}
A classe da qual o tema precisa herdar e sua implementação não é difícil.
package java.util;
public class Observable {
private boolean changed = false;
private Vector<Observer> obs;//使用线程安全的Vector类来存储观察者
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) {
Object[] arrLocal;
synchronized (this) {
if (!changed)
return;
arrLocal = obs.toArray();
clearChanged();
}
//循环遍历，并且在changed为true的时候才会通知
for (int i = arrLocal.length-1; i>=0; i--)
((Observer)arrLocal[i]).update(this, arg);
}
//删除观察者
public synchronized void deleteObservers() {
obs.removeAllElements();
}
//改变状态，为true才会通知观察者
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();
}
}
Pode-se observar que a implementação do jdk não é difícil.O tema só precisa herdar a classe Observable e chamar o método setChanged () e, em seguida, o método notifyObservers () onde a notificação é necessária, e o observador implementa a interface Observer e se implementa. O método de atualização pode atingir a meta.
Vejamos o código de implementação deste caso climático:
- Tópicos específicos:
package observer.weatherobservable;
import java.util.Observable;
/**
* 主题，需要继承Observable类
*/
public class WeatherData extends Observable {
private float temperature;
private float humidity;
private float pressure;
public WeatherData() {
}
public void measurementsChanged(){
setChanged();
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;
}
}
- A interface que o painel da tela precisa implementar:
package observer.weatherobservable;
/**
* 显示面板需要实现的接口，这个根据具体的场景设计
*/
public interface DisplayElement {
public void display();
}
- Painel de exibição de temperatura atual:
package observer.weatherobservable;
import java.util.Observable;
import java.util.Observer;
/**
* 当前温度面板
*/
public class CurrentConditionsDisplay implements Observer, DisplayElement {
private Observable observable;
private float temperature;
private float humidity;
public CurrentConditionsDisplay(Observable observable) {
this.observable = observable;
observable.addObserver(this);
}
@Override
public void display() {
System.out.println("当前状态是 " + temperature
+ "华氏度 和 " + humidity + "% 湿度");
}
@Override
public void update(Observable o, Object arg) {
if (o instanceof WeatherData) {
WeatherData weatherData = (WeatherData) o;
this.temperature = weatherData.getTemperature();
this.humidity = weatherData.getHumidity();
display();
}
}
}
- Painel de exibição de previsão:
package observer.weatherobservable;
import java.util.Observable;
import java.util.Observer;
/**
* 预报的显示面板
*/
public class ForecastDisplay implements Observer, DisplayElement {
private float currentPressure = 29.92f;
private float lastPressure;
public ForecastDisplay(Observable observable) {
observable.addObserver(this);
}
@Override
public void display() {
System.out.print("预报: ");
if (currentPressure > lastPressure) {
System.out.println("温度正在上升!");
} else if (currentPressure == lastPressure) {
System.out.println("气温没有变化");
} else if (currentPressure < lastPressure) {
System.out.println("天气变冷了");
}
}
@Override
public void update(Observable o, Object arg) {
if (o instanceof WeatherData) {
WeatherData weatherData = (WeatherData) o;
lastPressure = currentPressure;
currentPressure = weatherData.getPressure();
display();
}
}
}
- Painel de exibição do índice de calor:
package observer.weatherobservable;
import java.util.Observable;
import java.util.Observer;
/**
* heat index的显示面板
*/
public class HeatIndexDisplay implements Observer, DisplayElement {
float heatIndex = 0.0f;
public HeatIndexDisplay(Observable observable) {
observable.addObserver(this);
}
public void update(Observable observable, Object arg) {
if (observable instanceof WeatherData) {
WeatherData weatherData = (WeatherData)observable;
float t = weatherData.getTemperature();
float rh = weatherData.getHumidity();
heatIndex = (float)
(
(16.923 + (0.185212 * t)) +
(5.37941 * rh) -
(0.100254 * t * rh) +
(0.00941695 * (t * t)) +
(0.00728898 * (rh * rh)) +
(0.000345372 * (t * t * rh)) -
(0.000814971 * (t * rh * rh)) +
(0.0000102102 * (t * t * rh * rh)) -
(0.000038646 * (t * t * t)) +
(0.0000291583 * (rh * rh * rh)) +
(0.00000142721 * (t * t * t * rh)) +
(0.000000197483 * (t * rh * rh * rh)) -
(0.0000000218429 * (t * t * t * rh * rh)) +
(0.000000000843296 * (t * t * rh * rh * rh)) -
(0.0000000000481975 * (t * t * t * rh * rh * rh)));
display();
}
}
public void display() {
System.out.println("Heat index 是 " + heatIndex);
}
}
- Painel de exibição de temperatura:
package observer.weatherobservable;
import java.util.Observable;
import java.util.Observer;
/**
* 溫度顯示面板
*/
public class StatisticsDisplay implements Observer, DisplayElement {
private float maxTemp = 0.0f;
private float minTemp = 200;
private float tempSum= 0.0f;
private int numReadings;
public StatisticsDisplay(Observable observable) {
observable.addObserver(this);
}
public void update(Observable observable, Object arg) {
if (observable instanceof WeatherData) {
WeatherData weatherData = (WeatherData)observable;
float temp = weatherData.getTemperature();
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);
}
}
- Código do teste:
package observer.weatherobservable;
/**
* 測試
*/
public class WeatherStationHeatIndex {
public static void main(String[] args) {
WeatherData weatherData = new WeatherData();
CurrentConditionsDisplay currentConditions = new CurrentConditionsDisplay(weatherData);//当前状态是
StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);//Avg/Max/Min
ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);//预报:
HeatIndexDisplay heatIndexDisplay = new HeatIndexDisplay(weatherData);//Heat index 是
weatherData.setMeasurements(80, 65, 30.4f);
weatherData.setMeasurements(82, 70, 29.2f);
weatherData.setMeasurements(78, 90, 29.2f);
}
}
Resultados do teste:
Heat index 是 82.95535
预报: 温度正在上升!
Avg/Max/Min temperature = 80.0/80.0/80.0
当前状态是 80.0华氏度 和 65.0% 湿度
Heat index 是 86.90124
预报: 天气变冷了
Avg/Max/Min temperature = 81.0/82.0/80.0
当前状态是 82.0华氏度 和 70.0% 湿度
Heat index 是 83.64967
预报: 气温没有变化
Avg/Max/Min temperature = 80.0/82.0/78.0
当前状态是 78.0华氏度 和 90.0% 湿度
Obviamente, isso também pode obter os resultados do modo de observador que queremos.Quando a estação meteorológica detecta alterações nos dados climáticos, cada painel de exibição pode exibir os dados climáticos mais recentes no tempo.No
entanto, você encontrará os resultados obtidos e adicionamos A ordem dos observadores é inconsistente, por quê?
Observe atentamente o código-fonte do Observer: você descobrirá que ele percorre a coleção para trás, haha, não sabe por quê?
Por fim, mencione o booleano privado alterado = falso; o papel dessa variável é permitir que notifiquemos quando for necessário notificar, embora o tema tenha mudado, desde que essa variável não tenha sido alterada, não podemos ser notificados.
Por fim, resuma as vantagens e desvantagens da classe java.util.Observable e da interface Observer para obter o padrão de observador:
- Observador é uma classe, portanto, você deve projetar uma classe para herdar essa classe, e a classe java é uma herança única, o que limita nossas idéias de design;
- O setchanged () do observador é protegido, ou seja, você deve alterá-lo em sua subclasse, o que viola os princípios de design: mais uso da composição, menos uso da herança;
- O método de notificar os observadores é executado seqüencialmente no thread principal: qual observador para participar é bloqueado e os observadores subsequentes precisam esperar, o que é muito hostil;
- Além das deficiências acima, o restante são todas as vantagens.
Tendo em vista as deficiências acima, se queremos resolver os problemas acima, finalmente personalizamos a implementação de um padrão de observador.Se as deficiências acima puderem ser aceitas, podemos reutilizar o código jdk para obter
