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

时间  2019-11-06
标签 设计 模式 观察者 天气 推送 两种 实现 繁體版
原文   原文链接

需求说明：

目前咱们须要实现一种天气实时更新的程序（天气推送），当气象站数据更新后，天气接口程序去获取最新天气数据，而后将数据分发给全部订阅过“天气日报”程序的用户，即便更新数据。java

（案例来源于《Head First 设计模式》）设计模式

总体结构图：

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

观察者模式

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

观察者模式组成

抽象主题角色：把全部对观察者对象的引用保存在一个集合中，每一个抽象主题角色均可以有任意数量的观察者。抽象主题提供一个接口，能够增长和删除观察者角色。通常用一个抽象类和接口来实现。spa

抽象观察者角色：为全部具体的观察者定义一个接口，在获得主题的通知时更新本身。.net

具体主题角色：在具体主题内部状态改变时，给全部登记过的观察者发出通知。具体主题角色一般用一个子类实现。设计

具体观察者角色：该角色实现抽象观察者角色所要求的更新接口，以便使自己的状态与主题的状态相协调。一般用一个子类实现。若是须要，具体观察者角色能够保存一个指向具体主题角色的引用。code

观察者模式原型

观察者实现方式

1.主题主动推送数据

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

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官方提供的实现方式，毕竟继承的形式有必定的弊端。在数据获取方面，最好采用具体观察者拉取的形式，这样更有利于后期进行扩展。具体的代码实现，我就不共享出来了，仔细看了这篇文章的人基本均可以本身去实现。

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

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程