观察者模式

Posted 2020-10-16

1.什么是观察者模式

定义了对象之间的一对多的依赖，这样一来，当一个对象改变状态时，它的所有依赖都会收到通知并自动更新

2.设计原则

a.封装变化

b.多用组合少用继承

c.针对接口编程，不针对实现编程

d.为交互对象之间的松耦合设计而努力

3.代码示例：一个气象站与多个公布板

思路：气象站可以监测当前天气的种种数据，建立一个WeatherData对象，该对象可以注册，移除观察者，并且当从气象站获取数据（使用模拟数据）后，

它会执行相应的方法通知各个观察者，此处的观察者即为布告板

根据针对接口编程的原则，可以建立一个Subject接口，它包含注册，删除，通知观察者三个方法，让weatherData对象去实现它

又因为，布告板即为观察者，为实现解耦，我们应该提供一个统一的通知方法给WeatherData对象，当需要通知观察者时，WeatherData对象不需要关心观察者

都有谁，而是调用统一的方法去通知他们，因此，观察者都应该具有update()方法以便WeatherData对象通知，这是它们的共性，因此单独抽取出来建立一个只含有

update()方法的接口，所有的观察者都因该实现该接口

整理好思路开始编码实现

/*
 * 被观察者接口
 */
public interface Subject {

	public void registerObserver(Observer o);
	
	public void removeObserver(Observer o);
	
	public void notifyObserver();
}

/*
 * 观察者接口
 */
public interface Observer {

	public void update(float temp,float pressure,float humidity);
}

/*
 * 一个实现行为而已
 */
public interface DisplayElements {

	public void display();
}

/*
 * 被观察者实现
 */
public class WeatherData implements Subject {

	private float temp;
	private float pressure;
	private float humidity;
	private ArrayList observers;
	
	public WeatherData() {
		observers = new ArrayList();
	}
	
	@Override
	public void registerObserver(Observer o) {
		observers.add(o);
	}

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

	@Override
	public void notifyObserver() {
		for (int i = 0; i < observers.size(); i++) {
			Observer o = (Observer) observers.get(i);
			o.update(temp, pressure, humidity);
		}
	}

	/**
	 * 模拟该对象从气象站获取当前天气资料
	 */
	public void getMeasurementData(float temp,float pressure,float humidity) {
		this.temp = temp;
		this.pressure = pressure;
		this.humidity = humidity;
		//一旦数据更新便通知观察者们
		notifyObserver();
	}
}

/*
 * 一个观察者的具体实现
 */
public class CurrCondition implements Observer,DisplayElements {

	private float temp;
	private float pressure;
	private float humidity;
	private WeatherData weatherData;
	
	public CurrCondition(Subject weatherData) {
		this.weatherData = (WeatherData) weatherData;
		weatherData.registerObserver(this);
	}
	
	@Override
	public void display() {
		System.out.println("当前温度为 " + this.temp);
	}

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

public class TeatApp {

	public static void main(String[] args) {
		WeatherData weatherData = new WeatherData();
		CurrCondition currCondition = new CurrCondition(weatherData);
		weatherData.getMeasurementData(1f, 3.3f,2.09f);
		weatherData.getMeasurementData(100f, 3.3f,2.09f);
	}
}

总结：

观察者模式的核心同我们简单的接口调用一样，只是我们常用的接口调用的时候常用setXXXXX方法设置一个监听，当监听到的时候我们给设置了监听的一个对象一个回调方法，而观察者模式只是将多个监听对象放到了一个集合里，当变化时给所有的监听对象都回调一下。

4.使用Java提供的观察者实现观察者模式

    Java.Util包下有一个observable类和一个observer接口，他们分别是让被观察者和观察者继承从而实现观察者模式。下面是一个很简单的代码。

/*
 * 被观察者
 */
public class Person extends Observable {

	private String name;
	private String sex;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
		//标记此 Observable 对象为已改变的对象；现在 hasChanged 方法将返回 true。
		this.setChanged();
		//如果 hasChanged 方法指示对象已改变，则通知其所有观察者，并调用 clearChanged 方法来指示此对象不再改变。
		this.notifyObservers();
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
		//标记此 Observable 对象为已改变的对象；现在 hasChanged 方法将返回 true。
		this.setChanged();
		//如果 hasChanged 方法指示对象已改变，则通知其所有观察者，并调用 clearChanged 方法来指示此对象不再改变。
		this.notifyObservers();
	}
	
	
}

/*
 * 观察者
 */
public class MyObserver implements Observer {

	@Override
	public void update(Observable o, Object arg) {
		System.out.println("对象发生了改变");
	}

}

public class TestApp {

	public static void main(String[] args) {
		//被观察者对象
		Person p = new Person();
		//注册观察者
		p.addObserver(new MyObserver());
		//使对象发生变化
		p.setName("Jiaxx3");
		p.setSex("woman");
	}
}

实际中我们可采用jdk所提供的工具，大大简化了开发，其原理和前半部分我们的实现是一样的。