极简设计模式 - 观察者模式

---

前言

设计模式系列目录
 
观察者模式（Observer Pattern） 在对象之间定义一对多依赖，这样一来，当一个对象改变状态，依赖它的对象都会收到通知，并自动更新。

---

类图

代码

https://github.com/software-market/design-pattern（欢迎star，谢谢各位大佬。）
这里只写一些调用代码学习思路，具体类代码根据上图进行设计。
Sub1 为具体的被观察对象，实现自Subject。持有观察者接口集合。
Ob1、Ob2为众多观察者。

Subject 接口

public interface Subject {
    void registerObserver(Observer subject);

    void removeObserver(Observer subject);

    void notifyObservers();
}

Sub1实现类

public class Sub1 implements Subject {
	    List<Observer> observerList = new ArrayList<>();
    int stat;

    @Override
    public void registerObserver(Observer subject) {
        observerList.add(subject);
    }

    @Override
    public void removeObserver(Observer subject) {
        observerList.remove(subject);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observerList) {
            observer.update(stat);
        }
    }

    /**
     * 如果是拉模型，则在观察者类中进行调用
     */
    public int getStat() {
        return stat;
    }

    void measurementsChanged(int stat) {
        this.stat = stat;
        this.notifyObservers();
    }
}

Observer接口

public interface Observer {
    void update(int stat);
}

Ob1、Ob2实现类

public class Ob1 implements Observer {
    Subject subject;
    String name;

    /**
     * @param subject 主题实例，持有它，方便随时调用一些逻辑。
     * @param name    没啥用，标识一下当前对象的名称
     */
    public Ob1(Subject subject, String name) {
        this.subject = subject;
        this.name = name;
    }

    @Override
    public void update(int stat) {
    	// 接收通知，接收并处理数据（拉模型这里需要主动获取再处理）
        System.out.println(this.name + " - " + stat);
    }
}

public class Ob2 implements Observer {
    Subject subject;
    String name;

    /**
     * @param subject 主题实例，持有它，方便随时调用一些逻辑。
     * @param name    没啥用，标识一下当前对象的名称
     */
    public Ob2(Subject subject, String name) {
        this.subject = subject;
        this.name = name;
    }

    @Override
    public void update(int stat) {
    	// 接收通知，接收并处理数据（拉模型这里需要主动获取再处理）
        System.out.println(this.name + " - " + (stat + 1));
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        Sub1 sub = new Sub1();

        Observer ob1 = new Ob1(sub, "这是原版输出的观察者");
        Observer ob2 = new Ob2(sub, "原版基础加一的观察者");

        sub.registerObserver(ob1);
        sub.registerObserver(ob2);

        // 有新状态发布
        // 此方法内部调用notifyObservers()通知各观察者。
        sub.measurementsChanged(10);
    }
}

执行结果：

这是原版输出的观察者 - 10
原版基础加一的观察者 - 11

总结

1. 主要思路是一对多，一处改变，通知多处。
2. 同时解耦，主题也通过接口实现。主题一侧并不知道观察者是干啥的，只知道它实现了观察者接口。
3. 两种数据模式，推模型和拉模型，一般推被认为政治正确，不必纠结，符合业务就好。
4. JDK内有个Observable类，实现了观察者模式，推拉均支持，由于此类需继承实现，导致其有一些局限性。
5. 建议自定义实现。