观察者模式observer

问题引人：订阅报纸的过程：
订阅者---》邮局-----》报社  （订阅过程） ，当报社按照出报时间推出报纸时，将报纸交给邮局，邮局再交给订阅者，当报社有新报纸出版的时候，如何让多个订阅者知道呢？进一步抽象描述这个问题：当一个对象的状态发生改变的时候，如何让依赖于它的所有对象得到通知，并进行相应的处理呢？------》观察者模式
定义：定义对象间的一种一对多的关系，当一个对象状态发生变化，依赖于此对象的所有对象都会得到通知，并自动更新。
一个报纸对象会有多个人阅读，当报纸状态改变时，需要通知所有的订阅者。这就是典型的一对多关系。
观察者模式将多个订阅者称为观察者，obeserver，多个观察者观察的对象被称为目标：subject。
观察者模式的结构：
Subject：目标对象，一个目标可以被多个观察者观察，目标提供对观察者的注册和退订的维护，目标状态变化时，目标负责通知所有的观察者
Observer：定义观察者接口，提供目标通知时的更新方法。
ConcreteSubject：具体目标对象，用来维护目标状态。
ConcreteObserver：观察者具体实现对象，用来接收目标的通知，并进行相应的后续处理，比如更新自己的状态等。
其示例代码见包observer中。

package observer;
//观察者接口，定义一个更新的接口，当目标发生变化时，更新
public interface Observer {

	public void update(Subject subject);
}

package observer;

public class ConcreteObserver implements Observer {

	private String observerState; // 观察者状态

	@Override
	public void update(Subject subject) {
		// 示意方法，使其与目标对象状态一致
		observerState = ((ConcreteSubject) subject).getSubjectState();
	}

}

package observer;

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

//目标对象，它知道观察它的观察者，如报社知道报纸订阅人
public class Subject {

	//用于保存注册的观察者对象，如报社包含报纸的订阅人列表
	private List<Observer> observers = new ArrayList<Observer>();
	
//	注册观察者
	public void attach(Observer observer){
		observers.add(observer);
	}
	
//	删除观察者
	public void detach(Observer observer){
		observers.remove(observer);
	}
	
	//通知所有注册的观察者对象，
	protected void notifyObservers(){
		for(Observer observer:observers){
			observer.update(this);
		}
	}
}

package observer;
//具体的目标对象
public class ConcreteSubject extends Subject {

//	示意，目标对象的状态
	private String subjectState;

	public String getSubjectState() {
		return subjectState;
	}

	public void setSubjectState(String subjectState) {
		this.subjectState = subjectState;
//		状态发生变化，通知所有的观察者
		this.notifyObservers();
	}
	
	
}

解决上述问题：报纸为目标对象，阅报人为观察者，见observerSolve包

package observerSolve;
//观察者接口，定义一个更新的接口，当目标发生变化时，更新
public interface Observer {

	public void update(Subject subject);
}

package observerSolve;

public class Reader implements Observer {

	private String name;
	@Override
	public void update(Subject subject) {

		//被通知后执行的操作，这里是拉的方式，观察者会回调目标对象的方法
		
		System.out.println(name+"收到报纸了，阅读它。内容是==="+((NewsPaper) subject).getContent());
		
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	

}

package observerSolve;

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

//目标对象，它知道观察它的观察者，如报社知道报纸订阅人
public class Subject {

	//用于保存注册的观察者对象，如报社包含报纸的订阅人列表
	private List<Observer> observers = new ArrayList<Observer>();
	
//	注册观察者，即订阅人
	public void attach(Observer observer){
		observers.add(observer);
	}
	
//	删除观察者，可以取消订阅
	public void detach(Observer observer){
		observers.remove(observer);
	}
	
	//通知所有注册的观察者对象，每当报纸印刷出来后，就迅速通知读者
	protected void notifyObservers(){
		for(Observer observer:observers){
			observer.update(this);
		}
	}
}

package observerSolve;

public class NewsPaper extends Subject {

//	报纸的内容
	private String content;

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
		this.notifyObservers(); //内容有了，说明出了新报纸了，就通知所有的读者
	}
	
	
}

package observerSolve;

public class Client {

	public static void main(String[] args){
		//创建目标对象，报纸
		NewsPaper news  = new NewsPaper();
		
//		创建观察者，即阅读者
		Reader r1 = new Reader();
		r1.setName("张三");
		
		Reader r2 = new Reader();
		r2.setName("李四");
		
		Reader r3 = new Reader();
		r3.setName("王五");
		
//		将观察者注册到目标对象中去
		news.attach(r3);
		news.attach(r2);
		news.attach(r1);
		
//		目标对象内容改变，即要出报纸了
		news.setContent("学习设计模式");
		
	}
}

观察者和目标是单向的，即只有观察者依赖目标，目标是处于主动地位的，如果一个观察者观察多个目标，就需要定义多个回调函数，即多个update函数。
在观察者模式中，又存在推模型和拉模型
推：目标对象主动向观察者推送目标的详细信息，不管观察者是否需要，相当于在广播通信。
拉：目标对象通知观察者时，只传递少量信息。如果观察者需要更多，由观察者到目标对象主动获取。前面实例是典型的拉模型
推模型实例见pushObserver
java中的观察者模式，java.util包中的Observer接口，定义了update方法，就是观察者接口，Observable类，实现类大部分我们需要的目标的功能

package javaObserver;

import java.util.Observable;

//报纸对象，具体的目标实现，利用java的类，无需Subject类
public class NewsPaper extends Observable {

//	报纸的内容
	private String content;

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
		
		
		this.setChanged();//在用java中的观察者模式时，这句必不可少
		this.notifyObservers(this.content); //内容有了，说明出了新报纸了，就通知所有的读者，推的方式
//		this.notifyObservers();//拉的方式
	}
	
	public String toString(){
		return content;
	}
	
	
}

package javaObserver;

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

public class Reader implements Observer {

	private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public void update(Observable o, Object arg) {

		System.out.println(name+"收到报纸了，阅读它。目标对象推过来的内容是==="+o); //推方式
		System.out.println(name+"收到报纸了，阅读它。主动去目标对象去拉的内容是==="+((NewsPaper) o).getContent()); //拉方式

	}
}

package javaObserver;

public class Client {

	public static void main(String[] args){
		//创建目标对象，报纸
		NewsPaper news  = new NewsPaper();
		
//		创建观察者，即阅读者
		Reader r1 = new Reader();
		r1.setName("张三");
		
		Reader r2 = new Reader();
		r2.setName("李四");
		
		Reader r3 = new Reader();
		r3.setName("王五");
		
//		将观察者注册到目标对象中去,java中的类方法
		news.addObserver(r1);
		news.addObserver(r2);
		news.addObserver(r3);
		
//		目标对象内容改变，即要出报纸了
		news.setContent("学习设计模式");
		
	}
}

本质：触发联动
swing就相当于观察者模式
简单变形示例=====区别对待观察者（前面的示例中，观察者对于目标对象而言都是平等的）
水质监测，涉及到监测员，预警人，和监测部门领导，水质正常污染，无需将状态传递给所有的观察者，传给监测员，以此类推。。。
见waterPollution包中示例

package waterPollution;
//水质观察者的接口
public interface WatcherObserver {
	public void update(WaterQualitySubject subject);
	public void setJob(String job); //设置观察者职务
	public String getJob();
}

package waterPollution;

import javaObserver.NewsPaper;

//具体的观察者实现
public class Watcher implements WatcherObserver {
	
	private String job;

	@Override
	public String getJob() {
		return job;
	}

	@Override
	public void setJob(String job) {

		this.job = job;
	}

	@Override
	public void update(WaterQualitySubject subject) {
//   采用拉方式
		System.out.println(job+"获取到通知，当前污染级别为："+subject.getPolluteLevel()); //拉方式
	}

}

package waterPollution;

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

import observer.Observer;

public abstract class WaterQualitySubject {

	

	protected List<WatcherObserver> observers = new ArrayList<WatcherObserver>();
	
	
//	注册观察者
	public void attach(WatcherObserver observer){
		observers.add(observer);
	}
	
//	删除观察者
	public void detach(WatcherObserver observer){
		observers.remove(observer);
	}
	
	//通知所有注册的观察者对象，
	public abstract void notifyWatchers();
	public abstract int getPolluteLevel();
	
}

package waterPollution;

//具体的水质监测对象
public class WaterQuality extends WaterQualitySubject {

	private int polluteLevel = 0;

	@Override
	public int getPolluteLevel() {
		return polluteLevel;
	}

	public void setPolluteLevel(int polluteLevel) {
		this.polluteLevel = polluteLevel;
		this.notifyWatchers();
	}

	@Override
	public void notifyWatchers() { // 根据污染级别不同，通知的人员也不同，这里观察者不是同级的了
		// 循环所有注册的观察者
		for (WatcherObserver observer : observers) {
			// 根据污染级别判断是否需要通知，
			if (this.polluteLevel >= 0) {
				// 通知监测员做记录
				if ("监测员".equals(observer.getJob())) {
					observer.update(this);
				}
			}
			if (polluteLevel >= 1) {
				// 通知预警人员
				if ("预警人员".equals(observer.getJob())) {
					observer.update(this);
				}
			}
			if (this.polluteLevel >= 2) {
				// 通知监测部门领导
				if ("监测部门领导".equals(observer.getJob())) {
					observer.update(this);
				}
			}

		}

	}

}

package waterPollution;

public class Client {

public static void main(String[] args) {

WaterQuality subject = new WaterQuality();//创建水质对象

// 创建几个观察者
WatcherObserver w1 = new Watcher();
w1.setJob("监测员");
WatcherObserver w2 = new Watcher();
w2.setJob("预警人员");
WatcherObserver w3 = new Watcher();
w3.setJob("监测部门领导");

// 注册观察者
subject.attach(w3);
subject.attach(w2);
subject.attach(w1);

System.out.println("当水质为正常的时候------------");
subject.setPolluteLevel(0);

System.out.println("当水质为轻度污染的时候------------");
subject.setPolluteLevel(1);

System.out.println("当水质为中度污染的时候------------");
subject.setPolluteLevel(2);

}

}
执行结果：
当水质为正常的时候------------
监测员获取到通知，当前污染级别为：0
当水质为轻度污染的时候------------
预警人员获取到通知，当前污染级别为：1
监测员获取到通知，当前污染级别为：1
当水质为中度污染的时候------------
监测部门领导获取到通知，当前污染级别为：2
预警人员获取到通知，当前污染级别为：2
监测员获取到通知，当前污染级别为：2