定义:定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。

一般模式

Subject被观察者
---|定义被观察者必须实现的职责，它必须能够动态的增加、取消观察者，一般是抽象类或者实现类，完成管理观察者并通知观察者。
Observer观察者
---|观察者接到信息后，进行update操作
ConcreteSubject具体的被观察者
---|定义被观察者自己的业务逻辑，同时定义对那些事件进行通知
ConcreteObserver具体的观察者

---|每个观察者在接收到信息后的处理反应是不同的，各个观察者有自己的处理逻辑。

public class ObserverTest {
	public static void main(String[] args) {
		//创建一个呗观察者
		ConcreteSubject con = new ConcreteSubject();
		//创建一个观察者
		Observer observer = new ConcreteObserver();
		//添加到被观察者类中
		con.addObserver(observer);
		//完成某项任务，实现更新
		con.doSomething();
	}
}
/**
 * 观察者接口，所有观察者要实现该接口。
 * 实现方法， 处理不同的业务逻辑。
 * @author admin
 *
 */
interface Observer{
	
	public void update();
}
/**
 * 具体的观察者实现类。
 * @author admin
 *
 */
class ConcreteObserver implements Observer{
	@Override
	public void update() {
		System.out.println("观察者接收到信息，去实现业务逻辑.......");
	}
}
/**
 * 被观察者抽象类，
 * 主要对观察者的操作，增加、删除、通知所有观察者等方法。
 * @author admin
 *
 */
abstract class Subject{
	//定义一个观察者集合
	private List<Observer> observerList = new ArrayList<Observer>();
	
	//添加一个观察者
	public void addObserver(Observer o){
		this.observerList.add(o);
	}
	//删除一个观察者
	public void removeObserver(Observer o){
		this.observerList.remove(o);
	}
	//通知所有的观察者
	public void notifyObserver(){
		for(Observer o : observerList){
			o.update();
		}
	}
}
/**
 * 被观察者的具体实现类，
 * 当被观察者完成某种操作以后，
 * 观察者会产生相应的更新操作
 * @author admin
 */
class ConcreteSubject extends Subject{
	public void doSomething(){
		System.out.println("被观察者完成操作....");
		super.notifyObserver();
	}
}

一个例子:

韩国的韩非子是一个十分重要的任务，因此他身边被安插好多各个国家的间谍，来监视他的一举一动。
当韩非子有任何的行动间谍都要做相应的变化。

public class ObserverT {
	public static void main(String[] args) {
		//创建一个被观察者
		HanFeiZi hfz = new HanFeiZi();
		//创建一个李斯观察者
		IObserver lisi = new Lisi();
		//创建一个序言观察者
		IObserver xuyan = new XuYan();
		//添加观察者..
		hfz.addOberver(lisi);
		hfz.addOberver(xuyan);
		//韩非子吃饭..
		hfz.haveBreakfast();
	}
}
/**
 * 被观察者的接口类，
 * 定义其日常的行为方法。
 * @author admin
 *
 */
interface IHanFeiZi{
	//吃饭
	void haveBreakfast();
	//娱乐
	void haveFun();
}
/**
 * 被观察者的接口类，
 * 定义其对身边间谍的增加、删除、通知所有间谍的方法
 * @author admin
 *
 */
interface IObservable{
	void addOberver(IObserver o);
	void removeObserver(IObserver o);
	void notifyObserver(String context);
}
class HanFeiZi implements IHanFeiZi,IObservable{
	//定义一个监听者集合
	private List<IObserver> observerList = new ArrayList<IObserver>();
	
	@Override
	public void addOberver(IObserver o) {
		this.observerList.add(o);
	}

	@Override
	public void removeObserver(IObserver o) {
		this.observerList.remove(o);
	}

	@Override
	public void notifyObserver(String context) {
		for(IObserver o : observerList){
			o.update(context);
		}
	}

	@Override
	public void haveBreakfast() {
		System.out.println("----韩非子开始吃饭了...");
		this.notifyObserver("----韩非子在吃饭.....");
	}

	@Override
	public void haveFun() {
		System.out.println("----韩非子开始娱乐了...");
		this.notifyObserver("----韩非子在娱乐.....");
	}
	
}
/**
 * 观察者接口类，
 * 实现该类的子类，对被观察者的举动进行相应的业务逻辑更新。
 * @author admin
 *
 */
interface IObserver{
	public void update(String context);
}
/**
 * 具体是观察者实现类..
 * @author admin
 */
class Lisi implements IObserver{
	@Override
	public void update(String context) {
		System.out.println("李斯接收到消息,向皇帝报告:");
		this.reportToBoss(context);
		System.out.println("皇帝没有责罚我，我很开心...");
	}
	private void reportToBoss(String info){
		System.out.println("报告老板,"+info);
	}
}
class XuYan implements IObserver{
	@Override
	public void update(String context) {
		System.out.println("序言接收到消息，想丈夫汇报:");
		this.reportToHasband(context);
		System.out.println("序言表现很好..");
	}
	public void reportToHasband(String info){
		System.out.println("报告老公:"+info);
	}
	
}

观察者模式 的扩展

---|java世界中的观察者模式
java.util.Observer接口和java.util.Observable实现类
为我们提供了观察者模式。
被观察者只需要继承Observable类，就可以实现对监听者的添加、删除、通知等方法，
观察者只要实现Observer接口，就可以完成相应的更新操作。

public class ObserverT {
	public static void main(String[] args) {
		//创建一个被观察者
		HanFeiZi hfz = new HanFeiZi();
		//创建一个李斯观察者
		Observer lisi = new Lisi();
		//创建一个序言观察者
		Observer xuyan = new XuYan();
		//添加观察者..
		hfz.addObserver(lisi);
		hfz.addObserver(xuyan);
		//韩非子吃饭..
		hfz.haveBreakfast();
	}
}
/**
 * 被观察者的接口类，
 * 定义其日常的行为方法。
 * @author admin
 *
 */
interface IHanFeiZi{
	//吃饭
	void haveBreakfast();
	//娱乐
	void haveFun();
}

class HanFeiZi extends Observable implements IHanFeiZi {
	@Override
	public void haveBreakfast() {
		System.out.println("----韩非子开始吃饭了...");
		/*
		 * 如果 hasChanged 方法指示对象已改变，则通知其所有观察者，
		 * 并调用 clearChanged 方法来指示此对象不再改变。
		 */
		super.setChanged();
		super.notifyObservers("韩非子在吃饭...");
	}

	@Override
	public void haveFun() {
		System.out.println("----韩非子开始娱乐了...");
		/*
		 * 如果 hasChanged 方法指示对象已改变，则通知其所有观察者，
		 * 并调用 clearChanged 方法来指示此对象不再改变。
		 */
		super.setChanged();
		super.notifyObservers("韩非子在娱乐...");
	}
	
}
/**
 * 具体是观察者实现类..
 * @author admin
 */
class Lisi implements Observer{
	@Override
	public void update(Observable o, Object arg) {
		System.out.println("李斯接收到消息,向皇帝报告:");
		this.reportToBoss(arg);
		System.out.println("皇帝没有责罚我，我很开心...");
	}
	
	private void reportToBoss(Object info){
		System.out.println("报告老板,"+info);
	}

}
/**
 * 具体是观察者实现类..
 * @author admin
 */
class XuYan implements Observer{
	@Override
	public void update(Observable o, Object arg) {
		System.out.println("序言接收到消息，想丈夫汇报:");
		this.reportToHasband(arg);
		System.out.println("序言表现很好..");
	}
	
	public void reportToHasband(Object info){
		System.out.println("报告老公:"+info);
	}
	
}

观察者模式的优点
---|观察者和被观察者之间是抽象耦合
---|建立一套触发机制
观察者模式的缺点:
---|观察者模式的效率问题
观察者的使用场景
---|关联行为场景，需要注意的是，关联行为是可拆分的，而不是”组合“关系
---|事件多级触发场景
---|跨系统的消息交换场景，如消息队列的处理机制