前言：
观察者模式在实际项目中使用的也是非常频繁的，它最常用的地方是GUI系统（Graphical User Interface 即图形用户界面）、订阅——发布系统等。因为这个模式的一个重要作用就是解耦，使得它们之间的依赖性更小，甚至做到毫无依赖。以GUI系统来说，应用的UI具有易变性，尤其是前期随着业务的改变或者产品的需求修改，应用界面也经常性变化，但是业务逻辑基本变化不大，此时，GUI系统需要一套机制来应对这种情况，使得UI层与具体的业务逻辑解耦，观察者模式此时就派上用场了。

观察者模式

• 观察者模式 概述
  观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。观察者模式又被称作发布--订阅模式，

• 模式中的角色

  
  
  image.png
  • 抽象主题（Subject）：它把所有观察者对象的引用保存到一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象。
  • 具体主题（ConcreteSubject）：将有关状态存入具体观察者对象；在具体主题内部状态改变时，给所有登记过的观察者发出通知。
  • 抽象观察者（Observer）：为所有的具体观察者定义一个接口，在得到主题通知时更新自己。
  • 具体观察者（ConcreteObserver）：实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题状态协调。

观察者模式的分类 -- 推模型和拉模型

• 推模型
  主题对象向观察者推送主题的详细信息，不管观察者是否需要，推送的信息通常是主题对象的全部或部分数据。

• 拉模型
  主题对象在通知观察者的时候，只传递少量信息。如果观察者需要更具体的信息，由观察者主动到主题对象中获取，相当于是观察者从主题对象中拉数据。一般这种模型的实现中，会把主题对象自身通过update()方法传递给观察者，这样在观察者需要获取数据的时候，就可以通过这个引用来获取了。

• 两者的区别：

  • 推模式的Observer模式的好处：
    当有消息时，所有的观察者都会直接得到全部的消息，并进行相应的处理程序，与主体对象没什么关系，两者之间的关系是一种松散耦合。
  • 但是它也有缺陷：
    第一是所有的观察者得到的消息是一样的，也许有些信息对某个观察者来说根本就用不上，也就是观察者不能“按需所取”；
    第二，当通知消息的参数有变化时，所有的观察者对象都要变化。鉴于以上问题，拉模式就应运而生了，它是由观察者自己主动去取消息，需要什么信息，就可以取什么，不会像推模式那样得到所有的消息参数。

代码实现

写一个简单的demo Tom要搞事情，准备偷一台三桑note7，由于Tom经常偷东西，被警察和很多人盯着，当Tom偷到了三桑note7，就被盯着他的人发现了，交给了警察了

• 定义抽象主题

    /**
     * 被观察者，抽象主题
     */
public interface Subject<T> {

    /**
     * 注册一个观察者
     * @param o
     */
    void registerObserver(Observer<T> o);

    /**
     * 通知观察者
     * @param t
     */
    void notifyObserver(T t);
    
    /**
     * 在你需要的时候调用这个方法，防止内存泄露
     */
    void removeObserver();
}

• 抽象观察者

    /**
     * 观察者
     */
public interface Observer<T> {

    /**
     * 被观察者触发更新
     * @param t
     */
    void update(T t);
}

• 定义被观察者，具体被观察者（Tom）

    /**
     * 要搞事情的Tom
     */
public class Tom<T> implements Subject<T> {
    Observer<T> o;

    /**
     * 发布信息 ，搞事情
     */
    public void publishEvent(T t) {
        if (o == null)
            throw new NullPointerException("you must register Observer first!");
        System.out.println("tom 开始搞事情");
        notifyObserver(t);
    }

    /**
     * 通知订阅者，通知长眼睛的，Tom搞事情
     */
    @Override
    public void notifyObserver(T t) {
        o.update(t);
    }

    /**
     * 注册一个观察者，长眼睛的已经开始蹲点
     */
    @Override
    public void registerObserver(Observer<T> o) {
        this.o = o;
    }

    /**
     * 在你需要的时候调用这个方法，防止内存泄露
     */
    @Override
    public void removeObserver() {
        this.o = null;
    }
}

• 测试

 public static void main(String[] args) {
        // 要搞事情的人 Tom 来了
        Tom<String> tom = new Tom<>();

        /**
         * 观察者  长眼睛的
         */
        People people = new People() {
            @Override
            public void discover() {
                System.out.println("tom搞事情被发现了，交给警察了");
            }
        };
        // 注册观察者   听说tom要搞事情，引起了长眼睛的注意了
        tom.registerObserver(people);
        tom.publishEvent("Tom偷到了一台三桑note7"); // 开始搞事情
    }

• 打印信息

  
  
  image.png

模式总结

• 优点
  观察者模式解除了主题和具体观察者的耦合，让耦合的双方都依赖于抽象，而不是依赖具体。从而使得各自的变化都不会影响另一边的变化。

• 缺点
  依赖关系并未完全解除，抽象通知者依旧依赖抽象的观察者。

• 适用场景

  • 当一个对象的改变需要给变其它对象时，而且它不知道具体有多少个对象有待改变时。
  • 一个抽象某型有两个方面，当其中一个方面依赖于另一个方面，这时用观察者模式可以将这两者封装在独立的对象中使它们各自独立地改变和复用。