一、观察者模式概念

    观察者模式是指在对象之间定义一对多的依赖，当一个对象改变状态时，依赖它的对象都会收到通知并自动更新。

    就好比在足球比赛中，教练员会在场边发布命令，然后场上所有的队员都要根据它的命令作出响应，这时，场上的队员就是观察者，教练发出的口令就是主题。

二、使用场景

    在一个对象有改变其他依赖对象需要接到通知时

三、结构

     从上面的UML图中我们可以看出策略模式由三个部分组成：

        1. 主题（Subject）：也叫被观察者，如果主题发生改变那么观察者会接到通知

        2. 观察者（Observer）

四、实现

    在Java中可以通过继承JDK中的Observable类和实现Observer接口来实现观察者模式，但是不提倡这样做，因为Java是单继承语言，如果主题类需要用到观察者模式但同时它又继承了其他类，这样的情况就很尴尬。所以建议自己写主题类，况且这也不难实现。下面我们就从头开始自己实现观察者模式。

1. 定义主题接口

import observer.Observer;  /**  * Description: 主题  * Designer: jack  * Date: 2017/8/7  * Version: 1.0.0  */ public interface Subject<T extends Subject> {     void registerObserver(Observer<T> observer);    // 注册观察者      void removeObserver(Observer observer);      //删除观察者      void notifyObservers();      //当主题改变时，调用这个方法通知所有观察者 }

    接口中包含3个方法，注册观察者，删除观察者，和通知。这里对最基础的观察者模式做了一个小的拓展，那就是观察者可以自行注册和删除，当且仅当观察者在这个主题里注册了才会收到通知。

    （1）注册观察者：观察者如需订阅这个主题那么就调用注册方法，下一次主题改变时就会收到通知。

    （2）删除观察者：观察者如果不想再收到这个主题的通知则调用这个方法，以后主题再改变时也不会收到通知。

    （3）通知：主题发生改变时，调用这个方法通知已注册的观察者。

2. 观察者接口

import subject.Subject;  /**  * Description: 观察者接口  * Designer: jack  * Date: 2017/8/7  * Version: 1.0.0  */ public interface Observer<T extends Subject> {     void update(T t); //当需要改变战术时将新的战术通知给对应当球员 }

    观察者接口只需要一个update方法用于接受通知并做相应的处理。

3. 主题实现类

package subject;  import observer.Observer;  import java.util.ArrayList; import java.util.stream.Collectors;  /**  * Description: 球员战术指示  * Designer: jack  * Date: 2017/8/7  * Version: 1.0.0  */ public class PositionAndStrategy implements Subject<PositionAndStrategy>{      private ArrayList<Observer<PositionAndStrategy>> observers;  //观察者注册信息列表     private String strikerStrategy;     //前锋战术指令     private String defenderStrategy;    //后卫战术指令      public PositionAndStrategy() {         this.observers = new ArrayList<>();     }      @Override     public void registerObserver(Observer<PositionAndStrategy> observer) {         this.observers.add(observer);     }      @Override     public void removeObserver(Observer observer) {         this.observers = this.observers.stream()                 .filter(observer1 -> !observer1.equals(observer))                 .collect(Collectors.toCollection(ArrayList::new));     }      @Override     public void notifyObservers() {         this.observers.forEach(observer -> observer.update(this));     }      public void setStrategy(String strikerStrategy, String defenderStrategy) {         this.strikerStrategy = strikerStrategy;         this.defenderStrategy = defenderStrategy;         notifyObservers();     }      public String getStrikerStrategy() {         return strikerStrategy;     }      public String getDefenderStrategy() {         return defenderStrategy;     } } 

    主题实现类包含了所有观察者所需要的所有信息，并且在信息发生改变时（setStrategy）调用notifyObservers()方法向观察者发送通知。notifyObservers()实现的方法就是调用observers列表中的每一个观察者的update()方法。

4. 观察者实现

    第一个观察者：前锋

import subject.PositionAndStrategy;  /**  * Description: 前锋  * Designer: jack  * Date: 2017/8/7  * Version: 1.0.0  */ public class Striker implements Observer<PositionAndStrategy>{      @Override     public void update(PositionAndStrategy positionAndStrategy) {         //他只需要执行前锋的战术就好了，不用管后卫是什么战术         System.out.println("前锋：" + positionAndStrategy.getStrikerStrategy() );     }  }

    第二个观察者：后卫

import subject.PositionAndStrategy;  /**  * Description:  * Designer: jack  * Date: 2017/8/7  * Version: 1.0.0  */ public class Defender implements Observer<PositionAndStrategy>{      @Override     public void update(PositionAndStrategy positionAndStrategy) {         System.out.println("后卫：" + positionAndStrategy.getDefenderStrategy() );     }  }

    主题类将所有的信息都交给观察者，而观察者从里面取出自己需要的信息进行处理就可以了。

5. 实现类

import observer.Defender; import observer.Striker; import subject.PositionAndStrategy;  public class Main {     public static void main(String[] args) {         //创建战术板（主题类）         PositionAndStrategy positionAndStrategy = new PositionAndStrategy();          //创建前锋和后卫（观察者）         Striker striker = new Striker();         Defender defender = new Defender();          //在主题中注册观察者         positionAndStrategy.registerObserver(striker);         positionAndStrategy.registerObserver(defender);         //主题发生变化         System.out.println("主题第一次变化！");         positionAndStrategy.setStrategy("进攻", "防守");          //现在后卫距离太远，听不到教练的指令了（删除观察者）         positionAndStrategy.removeObserver(defender);         //主题发生变化         System.out.println("\n主题第二次变化");         positionAndStrategy.setStrategy("继续进攻", "压上支援");          //后卫现在又能听到指令了         positionAndStrategy.registerObserver(defender);         //主题发生变化         System.out.println("\n主题第三次变化");         positionAndStrategy.setStrategy("表现的不错，保持住", "后卫你们在干什么，叫你们压上支援");     } }

    执行main方法得到结果：

    可以看出主题每一次变化订阅了主题的观察者都能收到相应的通知，然后他们从里面提取自己需要的信息进行处理。这就是观察者模式。

五、优点

    1. 观察者与被观察者之间的耦合度低

    2. 有一套触发机制

六、局限性

    1. 如果一个主题中观察者过多会导致效率降低。

    2. 观察者只知道主题变化的结果而不知道主题是怎么变化的。

    世界上没有十全十美的模式，每个设计模式都有它适用的地方，只要我们的使用方式得当，那么观察者模式可以帮助我们写出漂亮优雅的代码。

附源码地址：http://git.oschina.net/jack90john/observer