观察者模式

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

观察者模式提供了一种对象设计，让主题和观察者之间松耦合，Android中的事件机制是典型的观察者模式。

两种实现方式：1、自定义主题和观察者接口；2、使用Java内置观察者模式支持。

举例1：（自定义接口）

    定义subject和observer接口：

package com.nwpulisz.observerpattren;
public interface Subject {
    public void registerObserver(Observer o);
    public void removeObserver(Observer o);
    public void notifyObservers();
}

package com.nwpulisz.observerpattren;
public interface Observer {
    public void update(float temp,float humidity,float pressure);
}

 

定义display接口，用于显示相应的内容：

package com.nwpulisz.observerpattren;
public interface Display {
    public void display();
}

 

定义一个主题类，继承subject接口： 

package com.nwpulisz.observerpattren;
import java.util.ArrayList;
public class WeatherData implements Subject {
    private ArrayList observers;
    private float temperature;
    private float humidity;
    private float pressure;
    public WeatherData(){
        observers = new ArrayList();
    }
    @Override
    public void registerObserver(Observer o) {
        // TODO Auto-generated method stub
        observers.add(o);
    }
    @Override
    public void removeObserver(Observer o) {
        // TODO Auto-generated method stub
        int i = observers.indexOf(o);
        if (i>=0) {
            observers.remove(i);
        }
    }
    @Override
    public void notifyObservers() {
        // TODO Auto-generated method stub
        for (int i = 0; i < observers.size(); i++) {
            Observer observer = (Observer)observers.get(i);
            observer.update(temperature, humidity, pressure);
        }
    }
    
    public void measurementChanged(){
        notifyObservers();
    }
    
    public void setMeasurements(float tempture,float humidity,float pressure){ //用于测试，可以设定数据
        this.temperature=tempture;
        this.humidity=humidity;
        this.pressure=pressure;
        measurementChanged();
    }
}

 

定义一个观察者类CurrentConditionDisplay类，实现observer接口：

package com.nwpulisz.observerpattren;
public class CurrentConditionDisplay implements Observer,Display {
    private float temperature;
    private float humidity;
    private float pressure;
    private Subject weatherData;
    
    public CurrentConditionDisplay(Subject weatherData){
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }
    
    public void update(float temperature, float humidity, float pressure) {
        // TODO Auto-generated method stub
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        display();
    }
    @Override
    public void display() {
        // TODO Auto-generated method stub
        System.out.println("Current conditions,temperature:"+temperature+" humidity:"+
                    humidity+" pressure:"+pressure);
    }
}

 

定义测试类WeatherStaticon:

package com.nwpulisz.observerpattren;
public class WeatherStation {
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        WeatherData weatherData = new WeatherData();
        Observer currentConditionDisplay = new CurrentConditionDisplay(weatherData);
        
        weatherData.setMeasurements(22.0f, 23.0f, 25.0f); //output:Current conditions,temperature:22.0 humidity:23.0 pressure:25.0
        weatherData.setMeasurements(19.0f, 22.3f, 78.9f); //output:Current conditions,temperature:19.0 humidity:22.3 pressure:78.9
        
    }
}

 

2、使用Java内置的观察者模式

 主题继承observable类，观察者继承observer接口，下面的列子用java内置模式实现：

package com.nwpulisz.observerjavapattern;
import java.util.Observable;
public class WeatherData extends Observable {
    private float temperature;
    private float humidity;
    private float pressure;
    
    public WeatherData(){
        
    }
    
    public void measurementChanged(){
        setChanged();  //Observalbe内置方法，标记状态已经改变的事实；
                       //查看源码，其实setChanged就是将Changed=true;另外jdk源码中还有方法clearChanged(),通知观察者之前,将changed=false;
        notifyObservers(); //Observable接口内置方法；
                        //setChanged之后，才能调用notify方法，这样更有弹性，否则主题变换过于频繁的话，导致主题会不断的通知观察者
    }
    
    public void setMeasurements(float temperature,float humidity,float pressure){
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        measurementChanged();
    }
    public float getTemperature() { //不仅仅是主题推送，观察者可以通过get方法，主动“拉”数据；
        return temperature;
    }
    public float getHumidity() {
        return humidity;
    }
    public float getPressure() {
        return pressure;
    }
    
}

package com.nwpulisz.observerjavapattern;
import java.util.Observable;
import java.util.Observer;
public class CurrentConditionDisplay implements Observer,Display {
    private Observable observable;
    private float temperature;
    private float humidity;
    private float pressure;
    
    public CurrentConditionDisplay(Observable observable){
        this.observable = observable;
        observable.addObserver(this);
    }
    
    @Override
    public void update(Observable o, Object arg) {
        // TODO Auto-generated method stub
        if (o instanceof WeatherData) {
            WeatherData weatherData = (WeatherData)o;
            this.temperature = weatherData.getTemperature();
            this.humidity = weatherData.getHumidity();
            //this.pressure = weatherData.getPressure();
            display();
        }
    }
    @Override
    public void display() {
        // TODO Auto-generated method stub
        System.out.println("Current conditions,temperature:"+temperature+" humidity:"+
                humidity+" pressure:"+pressure);
    }
}

 

定义测试类WeatherStaticon:

package com.nwpulisz.observerjavapattern;
import java.util.Observer;
public class WeatherStation {
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        WeatherData weatherData = new WeatherData();
        Observer currentConditionDisplay = new CurrentConditionDisplay(weatherData);
        
        weatherData.setMeasurements(25.0f, 23.0f, 25.0f); //output:观察者中没有getpress,所以输出结果Current conditions,temperature:25.0 humidity:23.0 pressure:0.0
        weatherData.setMeasurements(18.0f, 44.3f, 78.9f); //output:观察者中没有getpress,所以输出结果Current conditions,temperature:18.0 humidity:44.3 pressure:0.0
        
    }
}

 

虽然Java内置了对观察者模式的支持，但是Observable是一个类，而不是一个接口，但是java不支持多继承，可能限制了Observable的复用的能力。

并且看setChanged()方法设计的源码：

/**
     * Marks this <tt>Observable</tt> object as having been changed; the
     * <tt>hasChanged</tt> method will now return <tt>true</tt>.
     */
    protected synchronized void setChanged() {
        changed = true;
    }

用protected修饰，因此，除非继承Observable，否则无法创建Observable实例并组合到自己的对象中来，这样就违背了“多用组合，少用继承”的原则。但是Java内置的观察者模式支持也为开发提供了方便，某些情况下只要符合需求也可以直接使用。

在android开发中，事件响应机制，比如构建内部类，对Button的响应，属于观察者模式；同时Android应用开发使用的典型的MVC设计模式，也是观察者模式。

 

 

 

来自为知笔记(Wiz)