设计模式之观察者模式

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

被观察者

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

import lombok.Data;

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

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

    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<T extends Subject>{  
    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<Observer> observers = new ArrayList<Observer>();

    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<FirstSubject> firstObserver = new Observer<FirstSubject>("firstObserver", (FirstSubject) firstSubject);  
        Observer<SecondSubject> secondObserver = new Observer<SecondSubject>("secondObserver", (SecondSubject) secondSubject);

        firstSubject.addObserver(secondObserver);

        firstSubject.update();  
    }  
}  

输出

firstObserver监听到事件  

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

转载于:https://my.oschina.net/u/3562205/blog/3086230