设计模式——观察者模式:天气推送的两种实现

原创
2016/10/14 17:16
阅读数 7.8K

需求说明:

目前我们需要实现一种天气实时更新的程序(天气推送),当气象站数据更新后,天气接口程序去获取最新天气数据,然后将数据分发给所有订阅过“天气日报”程序的用户,即使更新数据。

(案例来源于《Head First 设计模式》)

整体结构图:

由上图可以看出,气象站负责去检测天气情况,当数据发生变化时,天气服务获取了变化的数据并且需要将数据分发给众多订阅“天气推送”的用户,如果我们采用一个个去通知的形式去实现的话,那么当我们新增了一个观察者,我们又需要单独重复编写发布信息代码,当我们想去掉一个观察者的时候,又需要去删减部分代码,这样的操作实在很繁琐,耦合度也比较高。接下来我们采用观察者模式来实现这个需求,来看看有没有什么神奇的地方。

观察者模式

观察者模式定义了一系列对象之间的一对多关系,当一个对象(主题)改变状态,其他依赖者都会收到通知。

观察者模式组成

抽象主题角色:把所有对观察者对象的引用保存在一个集合中,每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口,可以增加和删除观察者角色。一般用一个抽象类和接口来实现。

抽象观察者角色:为所有具体的观察者定义一个接口,在得到主题的通知时更新自己。

具体主题角色:在具体主题内部状态改变时,给所有登记过的观察者发出通知。具体主题角色通常用一个子类实现。

具体观察者角色:该角色实现抽象观察者角色所要求的更新接口,以便使本身的状态与主题的状态相协调。通常用一个子类实现。如果需要,具体观察者角色可以保存一个指向具体主题角色的引用。

观察者模式原型

观察者实现方式

1.主题主动推送数据

当数据更新后,主题会将所有更新数据都推送给观察者,而观察者只能被动接受主题的推送信息。

2.观察者主动拉取数据

当数据更新后,主题会通知观察者数据更新了,并暴露出相关数据的getter方法,观察者们可根据自己的需要去拉取自己需要的信息。

两种方式的代码实现

方式一:主题推送数据

这里我们采取自己编写抽象主题与抽象观察者代码的方式来实现。

抽象主题:SubjectInterface.java

package observer.one.subject;

import observer.one.observers.ObserverInterface;

public interface SubjectInterface {
	public void registerObserver(ObserverInterface o);
	public void removeObserver(ObserverInterface o);
	public void notifyObservers();
}

具体主题:WeatherData.java

package observer.one.subject.impl;

import java.util.ArrayList;

import observer.one.observers.ObserverInterface;
import observer.one.subject.SubjectInterface;

public class WeatherData implements SubjectInterface{
	
	private ArrayList<ObserverInterface> observers;
	//温度
	private String temperature;
	//湿度
	private String humidity;
	//气压
	private String pressure;
	
	public WeatherData() {
		observers=new ArrayList<ObserverInterface>();
	}
	/**
	 * 订阅
	 */
	public void registerObserver(ObserverInterface o) {
		observers.add(o);
	}
	/**
	 * 取消订阅
	 */
	public void removeObserver(ObserverInterface o) {
		if(observers.indexOf(o)>=0){
			observers.remove(o);
		}
	}
	/**
	 * 通知观察者
	 */
	public void notifyObservers() {
		for(ObserverInterface o:observers){
			o.update(temperature, humidity, pressure);
		}
	}
	public void setDataChange() {
		notifyObservers();
	}
	/**
	 * 数据改变后,通知观察者
	 * @param temperature
	 * @param humidity
	 * @param pressure
	 */
	public void setNewData(String temperature,String humidity,String pressure){
		this.temperature=temperature;
		this.humidity=humidity;
		this.pressure=pressure;
		setDataChange();
	}
}

抽象观察者:ObserverInterface.java

package observer.one.observers;

public interface ObserverInterface {
	void update(String temperature,String humidity,String pressure);
}

实际上,我们看到这里就会发现有点问题,一旦我们的数据参数发生变化,就需要去修改抽象观察者方法,而具体观察者也需要去修改相关方法的实现,耦合性较大。

具体观察者:Observer1.java

package observer.one.observers.impl;

import java.util.Date;

import observer.one.observers.ObserverInterface;
import observer.one.subject.SubjectInterface;

public class Observer1 implements ObserverInterface{
	
	private SubjectInterface subject;
	
	//温度
	private String temperature;
	//湿度
	private String humidity;
	//气压
	private String pressure;
	
	public Observer1(SubjectInterface subject) {
		this.subject = subject;
		subject.registerObserver(this);
	}
	
	public void register(){
		System.out.println("------观察者1订阅成功-------");
		subject.registerObserver(this);
	}
	
	public void cancelRegister(){
		System.out.println("------观察者1取消订阅了-------");
		subject.removeObserver(this);
	}
	
	public void update(String temperature, String humidity, String pressure) {
		this.humidity=humidity;
		this.pressure=pressure;
		this.temperature=temperature;
		display();
	}

	private void display() {
		System.out.println("观察者1----数据更新了("+new Date()+")-温度:"+temperature+"-湿度:"+humidity+"-气压:"+pressure);
	}
	
}

测试方法

这里为了方便演示,我写了两个具体观察者(Observer1 ,Observer2 ),实际上在具体实现中只需要写一个,实例化多个即可。

package observer.one;

import observer.one.observers.impl.Observer1;
import observer.one.observers.impl.Observer2;
import observer.one.subject.impl.WeatherData;

public class Test {
	
	public static void main(String[] args) {
		WeatherData weatherData=new WeatherData();
		//订阅天气日报
		Observer1 observer1=new Observer1(weatherData);
		//订阅天气日报
		Observer2 observer2=new Observer2(weatherData);
		
		weatherData.setNewData("10", "20", "30");
		observer1.cancelRegister();
		weatherData.setNewData("10.5", "14.23", "15.65");
		observer1.register();
		weatherData.setNewData("15.5", "18.23", "17");
	}
}

输出结果:

方式二:观察者主动拉取数据

这里我们采取JDK自己提供的抽象主题与抽象观察者的方式来实现。

抽象主题:java.util.Observable

抽象观察者:java.util.Observer

具体主题:WeatherData.java

package observer.two.subject;

import java.util.Observable;

public class WeatherData extends Observable{
	//温度
	private String temperature;
	//湿度
	private String humidity;
	//气压
	private String pressure;
	/**
	 * 数据更新方法
	 * @param temperature
	 * @param humidity
	 * @param pressure
	 */
	public void setNewData(String temperature,String humidity,String pressure){
		this.temperature=temperature;
		this.humidity=humidity;
		this.pressure=pressure;
		setChanged();
		notifyObservers("数据更新了,快来获取吧");
	}
	
	public String getTemperature() {
		return temperature;
	}
	public String getHumidity() {
		return humidity;
	}
	public String getPressure() {
		return pressure;
	}
}

由上面代码可以看出,具体主题主动暴露出属性的getter方法,当数据更新时调用setChange()方法,通知观察者此时有数据更新,你可以来获取了。

具体观察者:Observer1.java

package observer.two.observers;

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

import observer.two.subject.WeatherData;

public class Observer1 implements Observer{
	
	private Observable observable;
	
	//温度
	private String temperature;
	//湿度
	private String humidity;
	//气压
	private String pressure;
		
	public Observer1(Observable observable) {
		super();
		this.observable = observable;
		System.out.println("------观察者1订阅了-------");
		observable.addObserver(this);
	}
	
	public void cancelRegister(){
		System.out.println("------观察者1取消订阅了-------");
		observable.deleteObserver(this);
	}
	/**
	 * 数据更新通知
	 */
	public void update(Observable o, Object arg) {
		System.out.println("气象台说:"+arg+"");
		System.out.println("观察者1:嗯,这就去");
		if(o instanceof WeatherData){
			WeatherData data=(WeatherData)o;
			this.humidity=data.getHumidity();
			this.pressure=data.getPressure();
			this.temperature=data.getTemperature();
		}
		display();
		System.out.println("数据提取完毕,并已展示");
	}
	/**
	 * 数据打印
	 */
	private void display() {
		System.out.println("观察者1----数据更新了("+new Date()+")-温度:"+temperature+"-湿度:"+humidity+"-气压:"+pressure);
	}

}

此时,具体观察者调用update方法,主动拉取主题的最新数据,并显示出来。

测试方法:

package observer.two;

import observer.two.observers.Observer1;
import observer.two.subject.WeatherData;

public class Test {
	public static void main(String[] args) {
		WeatherData weatherData=new WeatherData();
		/*观察者1订阅天气日报*/
		Observer1 observer1=new Observer1(weatherData);
		Observer1 observer2=new Observer1(weatherData);
		weatherData.setNewData("10", "79", "18");
	}
}

输出结果:

两种实现方式对比

细心的同学应该可以发现,自己编写抽象主题代码时,我们编写的接口(interface),而JDK官方提供的观察者模式中,抽象主题采用的是继承的形式实现。归根结底这两种实现方式的对比,是主题推送数据和观察者拉取数据的对比,以及实现接口和继承父类的对比。

推送数据和拉取数据的对比:

推送数据的实现方式主题需要把所有的参数都推送给观察者们,这里就需要事先在update方法中指定所有的参数,一旦参数发生改变,不仅要改变主题的方法,还需要改变观察者接口方法。
而拉取数据的实现方式只需要改变主题参数,不需要改变观察者接口方法,观察者们依旧根据自己的需要去获取数据。  

实现接口和继承父类的对比:

由于JAVA只支持单继承,实现接口和继承父类的优劣势大家也应该都很清楚。

对比结果:如果可以的话,我们应该自己去实现自己的抽象主题,而不采用JDK官方提供的实现方式,毕竟继承的形式有一定的弊端。在数据获取方面,最好采用具体观察者拉取的形式,这样更有利于后期进行扩展。具体的代码实现,我就不共享出来了,仔细看了这篇文章的人基本都可以自己去实现。

相关文章:《设计模式——策略模式:会员价格体系的简单实现

展开阅读全文
打赏
4
87 收藏
分享
加载中
麻烦博主把代码提交一下,正好需要这个~~~
2017/08/20 16:29
回复
举报
博主的编译器是什么
2016/11/18 17:24
回复
举报
AlanVision博主

引用来自“刘亚涛”的评论

话说博主的画图工具是什么啊?看着很高大上的感觉
大微软的visio
2016/10/18 14:37
回复
举报
话说博主的画图工具是什么啊?看着很高大上的感觉
2016/10/18 14:12
回复
举报
更多评论
打赏
4 评论
87 收藏
4
分享
返回顶部
顶部