设计模式之观察者模式

  观察者模式定义对象一对多的关系，他希望一个对象的状态发生改变时，其他依赖于它的对象能够接到通知并执行相应的处理逻辑。例如微信订阅某个公众号，当公众号发布新文章时，所有订阅该公众号的人都会收到文章推送消息。spring的事件机制是采用观察者模式，进行业务的解耦的。
   观察模式简单分为被观察者和观察者，实现原理为被观察者有一个存放观察者的集合，当被观察者发生状态改变时，通知所有的观察者，观察者处理相应的逻辑。

被观察者

   这里简单用一个类来描述被观察者，它可以接收观察者类型，和更新状态，当状态更新时，会通知所有观察者的onMessage()方法，处理相应的逻辑。

import java.util.ArrayList;
import java.util.List;

@Data
public class Subject {
    private List observers = new ArrayList();

    public void update(){
        notifyObervers();
    }
    
    public void addObserver(Observer observer) {
        observers.add(observer);
    }
    
    private void notifyObervers(){
        for (Observer observer: observers) {
            observer.onMessage();
        }
    }
}

观察者

这里定义观察者，它有一个指定具体名称的构造方法，和一个onMessage()方法，在被观察者状态发生改变时被调用

import lombok.Data;

@Data
public class Observer{
    private String name;

    public Observer(String name) {
        this.name = name;
    }

    public void onMessage() {
        System.out.println(name + "监听到发布事件");
    }
}

客户端

当我们定义好了被观察者和观察者，使用一个类来模拟相应的测试流程。
这里定义了一个被观察者和两个观察者，然后被观察者更新状态，那么其他的观察者就会接到通知，然后处理事件。

public class App {
    public static void main(String[] args) {
        Subject subject = new Subject();

        Observer firstObserver = new Observer("firstObserver");
        Observer secondObserver = new Observer("secondObserver");
        subject.addObserver(firstObserver);
        subject.addObserver(secondObserver);

        subject.update();
    }
}

输出

firstObserver监听到发布事件
secondObserver监听到发布事件

升级版本

考虑到被观察者进行状态更新时，不需要通知所有观察者进行状态更新，而是只需要关注它的状态更新的观察者才需要接到通知。

观察者

我们先来定义观察者的逻辑，这里通过泛型，来定义观察者只关注具体的被观察者的实现。

import lombok.Data;

@Data
public class Observer{
    private String name;

    private T subject;

    public Observer (String name, T subject) {
        this.name = name;
        this.subject = subject;
        subject.addObserver(this);
    }

    public void onMessage() {
        System.out.println(this.name + "监听到事件");
    }
}

被观察者

被观察的notifyObervers()方法，在通知观察者进行状态更新时，只有该观察者关注的是自己的实现时，才更新。

import java.util.ArrayList;
import java.util.List;

@Data
public class Subject {

    private List observers = new ArrayList();

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void update(){
        notifyObervers();
    }

    public void notifyObervers(){
        for (Observer observer: observers) {
            if (observer.getSubject().getClass() == this.getClass()) {
                observer.onMessage();
            }
        }
    }
}

我们这里定义两个被观察者的实现类。

public class FirstSubject extends Subject {}

public class SecondSubject extends Subject {}

客户端

这里客户端的使用代码为,实例化了一个FirstSubject对象和一个SecondSubject。和两个Observer对象，他们都只关注各自的Subject。在把secondObserver也加到firstSubject对象的观察者集合里面，这时

public class App {
    public static void main(String[] args) {
        Subject firstSubject = new FirstSubject();
        Subject secondSubject = new SecondSubject();

        Observer firstObserver = new Observer("firstObserver", (FirstSubject) firstSubject);
        Observer secondObserver = new Observer("secondObserver", (SecondSubject) secondSubject);

        firstSubject.addObserver(secondObserver);

        firstSubject.update();
    }
}

输出

firstObserver监听到事件

这样就实现了一个泛型类的观察者，这里的实现感觉有些蹩脚，还需要看看别人时怎么实现的。