3 观察者模式

时间：2023-02-11 22:49:14

　　观察者模式（有时又被称为发布（publish ）-订阅（Subscribe）模式、模型-视图（View）模式、源-收听者(Listener)模式或从属者模式）是软件设计模式的一种。在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实现事件处理系统。

　　观察者模式（Observer）完美的将观察者和被观察的对象分离开。举个例子，用户界面可以作为一个观察者，业务数据是被观察者，用户界面观察业务数据的变化，发现数据变化后，就显示在界面上。面向对象设计的一个原则是：系统中的每个类将重点放在某一个功能上，而不是其他方面。一个对象只做一件事情，并且将他做好。观察者模式在模块之间划定了清晰的界限，提高了应用程序的可维护性和重用性。

　　观察者设计模式定义了对象间的一种一对多的依赖关系，以便一个对象的状态发生变化时，所有依赖于它的对象都得到通知并自动刷新。

　　观察者模式必须包含两个角色，观察者和被观察者。刚才的例子中，业务数据属于被观察者，用户界面属于观察者。观察者和被观察者之间存在“观察”的逻辑关联，当被观察者发生改变后，观察者就会观察到这样的变化，并做出相应的响应。如果用户界面和业务数据使用这样的观察过程，可以确保界面和数据之间划清界限，假定应用程序的需求发生变化，需要修改界面的表现，只需重新构建一个用户界面，业务数据不发生变化。

观察者模式的实现

下面的例子是关于气象监测的应用，其中从气象站获得的天气数据对象WeatherData是被观察者，显示板是观察者，当天气数据发生变化时，各个显示板的显示也发生变化。天气数据一般有气压、温度和湿度等。

public interface Subject {
public void registerObserver(Observer o);
public void removeObserver(Observer o);
public void notifyObservers();
}
 
public interface Observer {
public void update(float temperature,float humidity,float pressure);
}
 
public interface DisplayElement {
public void display();
}
 
import java.util.ArrayList;
import java.util.List;
import com.wp.design.observer.Observer;
import com.wp.design.observer.Subject;
public class WeatherData implements Subject {
private List<Observer> observers;
private float temperature;
private float humidity;
private float pressure;

public WeatherData(){
        observers = new ArrayList<Observer>();
    }
    @Override
public void registerObserver(Observer o) {
        observers.add(o);
    }

    @Override
public void removeObserver(Observer o) {
int i = observers.indexOf(o);
if(i!=-1){
            observers.remove(i);
        }
    }

    @Override
public void notifyObservers() {
for(int i=0;i<observers.size();i++){
            Observer observer = observers.get(i);
            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();
    }

}
 
import com.wp.design.observer.DisplayElement;
import com.wp.design.observer.Observer;
import com.wp.design.observer.Subject;
public class CurrentConditionDisplay implements Observer, DisplayElement {
private float temperature;
private float humidity;
private float pressure;
private Subject weatherData;

public CurrentConditionDisplay(Subject weatherData){
this.weatherData = weatherData;
this.weatherData.registerObserver(this);
    }
    @Override
public void display() {
        System.out.println("Current conditions:"+temperature+"F degerees and "
                +humidity+"% humidity");

    }

    @Override
public void update(float temperature, float humidity, float pressure) {
this.temperature = temperature;
this.humidity = humidity;
this.pressure = pressure;
        display();
    }

}
 
import com.wp.design.observer.impl.CurrentConditionDisplay;
import com.wp.design.observer.impl.WeatherData;
public class WeatherStation {
public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();
        CurrentConditionDisplay ccd = new CurrentConditionDisplay(weatherData);
        weatherData.setMeasurements(85, 65, 30.4f);
    }
}

根据面向接口编程的设计原则，我们定义Subject主题（天气数据对象）接口，该接口提供三个方法，分别是registerObserver()：用来注册观察者（显示板）、removeObserver()：用来删除一个观察者（显示板）、notifyObservers()：自身状态改变时，用来通知观察者（显示板）。那么，只需实现给该接口和该接口的方法，便成为一个被观察者（天气数据对象）了。

定义Observer接口，提供update()方法，用来当被观察者（天气数据）状态改变时，更新观察者数据（显示板）。

被观察者和观察者是一对多的依赖关系。而且观察者和被观察者对象是分离的，便于系统的维护、更新。

 JDK内置的观察者模式

Java JDK有内置的观察者模式，java.util中包含Observer接口和Observable类，对应我们自己定义的Observer接口和Subject接口。只不过，Subject是接口，而Observable是类，里面有addOberver()、deleteObserver()、setChanged()等方法。

如同以前一样，实现观察者接口（java.util.Observer），然后调用任何Observable对象的addObserver()方法。不想当作观察者时，调用deleteObserver()方法即可。

继承java.util.Observable类，实现被观察者，然后，通过两个步骤给观察者发送通知。

  1. 先调用setChanged()方法，标记被观察者状态已经改变。
  2. 然后调用两种notifyObservers()方法中的一个。
  3. 获取Observer对象，通过update()方法进行通知。（封装到notifyObservers()方法中）
import java.util.Observable;
public class WeatherData extends Observable {
private float temperature;
private float humidity;
private float pressure;
public WeatherData(){

    }
public void measurementsChanged(){
this.setChanged();
this.notifyObservers();
    }
public void setMeasurement(float temperature,float humidity,float pressure){
this.temperature = temperature;
this.humidity = humidity;
this.pressure = pressure;
        measurementsChanged();
    }
public float getTemperature(){
return this.temperature;
    }
public float getHumidity(){
return this.humidity;
    }
public float getPressure(){
return this.pressure;
    }
}
 
import java.util.Observable;
import java.util.Observer;
import com.wp.design.observer.DisplayElement;
public class CurrentConditionDisplay implements Observer, DisplayElement {
private float temperature;
private float humidity;
private Observable obs;
public CurrentConditionDisplay(Observable obs){
this.obs = obs;
this.obs.addObserver(this);
    }
    @Override
public void display() {
        System.out.println("Current conditions:"+temperature+"F degerees and "
                +humidity+"% humidity");
    }
    @Override
public void update(Observable o, Object arg) {
if(o instanceof WeatherData){
            WeatherData wd = (WeatherData) o;
this.temperature = wd.getTemperature();
this.humidity = wd.getHumidity();
            display();
        }
    }
}
 
import com.wp.design.observer.jdk.CurrentConditionDisplay;
import com.wp.design.observer.jdk.WeatherData;
public class WeatherStationJDK {
public static void main(String[] args) {
        WeatherData wd = new WeatherData();
        CurrentConditionDisplay ccd = new CurrentConditionDisplay(wd);
        wd.setMeasurement(11, 12, 22.22f);
    }
}

 

标签：

相关文章