观察者模式_观察者模式观察者数量太多-CSDN博客

本文链接：https://blog.csdn.net/litengit/article/details/73223101

观察者模式

定义

定义对象间的一种一对多的依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆能收到通知并自动更新。

观察者模式又叫做发布-订阅模式(Publish/Subscribe)；模型-视图模式(Model/View)；源-监听器模式(Source/Listener)；从属者模式(Dependents)。

观察者模式可以类比我们现在比较常见的微信订阅号。当我们订阅了某个订阅号之后，当该订阅有了新的文章都会在第一时间发送到我们的微信上。这里的订阅号就属于发布者，我们的就属于订阅者。一对多就是一个订阅号对应多个订阅用户。

组成角色

Subject：主题/目标；一般为抽象类或者是接口。它就是我们的抽象的发布者，观察者观察的目标。它一般会包含一些抽象方法。比如：注册观察者；解除观察者，更新观察者等。
ConcreteSubject：具体的主题/目标；它是Subject的实现类，是具体的的发布者。
Observer：观察者；一般为抽象类或者是接口。它是抽象的接收者。它至少会包含一个抽象方法，那就是更新自己的方法。
ConcreteObserver：具体观察者；该类为具体的观察者。它是具体的接收者。

它的结构图如下：

时序图如下：

具体示例

抽象的主题：

public abstract class Subject {

    //记录当前的状态；将该状态分发给各个观察者
    protected String mState;

    //将观察者 注册、依附 到主题
    public abstract void attach(Observer observer);

    //将观察者从主题分离
    public abstract void detach(Observer observer);

    //主题发生改变通知所有的观察者更新
    public abstract void notifyAllObserver(Subject subject);

    //当前主题的状态，会将该状态分发给观察者
    public abstract String getState();

    //设置当前主题的状态
    public abstract void setState(String state);
}

具体的主题：

public class ConcreteSubject extends Subject {

    @Override
    public String getState() {
        return mState;
    }

    @Override
    public void setState(String state) {
        this.mState = state;
    }

    private List<Observer> mObservers = new ArrayList<>();


    @Override
    public void attach(Observer observer) {
        if (observer != null) {
            mObservers.add(observer);
        }
    }

    @Override
    public void detach(Observer observer) {
        if (observer != null && mObservers.contains(observer)) {
            mObservers.remove(observer);
        }
    }

    @Override
    public void notifyAllObserver(Subject subject) {
        for (Observer o : mObservers) {
            o.update(subject);
        }
    }
}

抽象的观察者：

public abstract class Observer {
    public abstract void update(Subject subject);
}

具体观察者：

public class ConcreteObserver extends Observer {

    @Override
    public void update(Subject subject) {
        System.out.println("当前的状态 = " + subject.getState());
    }
}

所有的代码都写完。我们在主题里添加了两个额外的方法，由来设置和获取当前的主题状态。然后把设置的状态分发给各个观察者。我们在具体观察者里更新获取的状态。

我们测试一下：

    Subject subject1 = new ConcreteSubject();

    Observer observer1 = new ConcreteObserver();
    Observer observer2 = new ConcreteObserver();
    Observer observer3 = new ConcreteObserver();

    subject1.attach(observer1);
    subject1.attach(observer2);
    subject1.attach(observer3);

    subject1.setState("当前Subject1的状态");
    subject1.notifyAllObserver(subject1);

    System.out.println("----- Subject1 和 Subject2 的分割线 -----");

    Subject subject2 = new ConcreteSubject();

    subject2.attach(observer1);
    subject2.attach(observer2);
    subject2.attach(observer3);

    subject2.setState("当前Subject2的状态");
    subject2.notifyAllObserver(subject2);
}

这里使用的两个主题。两个主题设置不同的状态，然后把两个状态分发给观察者。输出内容如下：

当前的状态 = 当前Subject1的状态
当前的状态 = 当前Subject1的状态
当前的状态 = 当前Subject1的状态
——– Subject1 和 Subject2 的分割线 ——–
当前的状态 = 当前Subject2的状态
当前的状态 = 当前Subject2的状态
当前的状态 = 当前Subject2的状态