观察者模式实际运用

观察者模式在项目开发中可以很好的实现模块解耦

1、传统的观察者模式

import java.util.Observable;
import java.util.Observer;

/**
 * 
 * <使用系统Observer接口实现观察者>
 * <功能详细描述>
 */
public class CurrentConditionsDisplay implements Observer
{
    Observable observable;
    private float temperature;
    
    public CurrentConditionsDisplay(Observable observable)
    {
        this.observable = observable;
        this.observable.addObserver(this);
    }
    
    @Override
    public void update(Observable o, Object arg)
    {
        if(o instanceof WeatherData){
            WeatherData weatherData = (WeatherData) o;
            this.temperature = weatherData.getTemperature();
            display();
        }
    }
    
    public void display(){
        System.out.println("系统观察者监听对象数据改变:"+temperature);
    }
}

import java.util.Observable;


/**
 * 
 * <使用系统Observable类实现被观察者>
 * <功能详细描述>
 * 
 */
public class WeatherData extends Observable
{
    private float temperature;
    
    public WeatherData()
    {
    }
    
    public void setMeasurements(float temperature){
        this.temperature = temperature;
        setChanged();
        notifyObservers();
    }


    public float getTemperature()
    {
        return temperature;
    }


    public void setTemperature(float temperature)
    {
        this.temperature = temperature;
    }
    
}

public class WeatherStation
{
    public static void main(String[] args)
    {
        WeatherData weatherData = new WeatherData();
        @SuppressWarnings("unused")
        CurrentConditionsDisplay dis = new CurrentConditionsDisplay(weatherData);


        weatherData.setMeasurements(30.0f);
        weatherData.setMeasurements(40.0f);
        weatherData.setMeasurements(50.0f);
        
    }
}

2、变形的观察者模式

import java.util.Observable;

/**
 * 
 * <定义一个观察者回调接口>
 * <功能详细描述>
 * 
 */
public interface IFriendObserver
{
    public void updateFriends(Observable observable, Object data);
}

import java.util.ArrayList;
import java.util.List;
import java.util.Observable;

/**
 * 
 * <通讯录更新被观察者>
 * <功能详细描述>
 * 
 * @author  x00355498
 * @version  [版本号, 2015年8月27日]
 * @see  [相关类/方法]
 * @since  [产品/模块版本]
 */
public class FriendObservable extends Observable
{
    private static List<IFriendObserver> list = new ArrayList<IFriendObserver>();
    
    /**
     * <注册监听>
     * <功能详细描述>
     * @param observer
     * @see [类、类#方法、类#成员]
     */
    public static void reject(IFriendObserver observer){
        list.add(observer);
    }
    
    /**
     * <删除监听>
     * <功能详细描述>
     * @param observer
     * @see [类、类#方法、类#成员]
     */
    public static void unreject(IFriendObserver observer){
        int index = list.indexOf(observer);
        if(index>-1){
            list.remove(index);
        }
    }
    
    /**
     * {@inheritDoc}
     * 通知监听
     */
    public static void notifyAllObservers(String userId)
    {
        for (IFriendObserver observer : list)
        {
            observer.updateFriends(null, userId);
        }
    }
    
}

总结：变形的观察者模式更加的灵活，由FriendObservable 提供了一个静态的工具类，这个类中提供了一些列的静态方法，包括注册监听、删除监听、通知监听，通过这个静态类，在整个项目中可以在任意地方任意位置实现注册监听和通知监听。