**定义**:定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。 ## 一般模式  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); } } ~~~ 观察者模式的优点 ---|观察者和被观察者之间是抽象耦合 ---|建立一套触发机制 观察者模式的缺点: ---|观察者模式的效率问题 观察者的使用场景 ---|关联行为场景，需要注意的是，关联行为是可拆分的，而不是”组合“关系 ---|事件多级触发场景 ---|跨系统的消息交换场景，如消息队列的处理机制