观察者模式

最近查看SpringBoot启动方式，其中监听器涉及到观察者模式（发布-订阅）

SimpleApplicationEventMulticaster 在spring中负责事件（event）广播

总结一篇观察者模式

 

1、模式简介

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。

2、实现

2.1、定义抽象主题

//抽象主题（被观察者）
public abstract class Subject {

    //内部维护一个观察者集合
    protected List<Observer> observers = new ArrayList<Observer>();

    //添加观察者
    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    //删除观察者
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    //通知观察者
    public void notifyAllObServer() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

2.2、观察者接口 

public interface Observer {
    void update();
}

2.3 、实现接口和主题，并测试

public class ObserverTest {
    public static void main(String[] args) {
        //观察者
        Observer1 observer1 = new Observer1();
        Observer2 observer2 = new Observer2();
        //主题
        BeanFactorySubject beanFactorySubject = new BeanFactorySubject();
        //添加观察者
        beanFactorySubject.addObserver(observer1);
        beanFactorySubject.addObserver(observer2);
        beanFactorySubject.doSomething();

    }
}

class BeanFactorySubject extends Subject {
    public void doSomething() {
        notifyAllObServer();
    }
}
class Observer1 implements Observer {

    public void update() {
        Thread t = Thread.currentThread();
        System.out.println("线程：" + t.getName() + ":Observer1 收到。。");
    }
}
class Observer2 implements Observer {

    public void update() {
        Thread t = Thread.currentThread();
        System.out.println("线程：" + t.getName() + ":Observer2 收到。。");
    }
}

3、注意事项

• 如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间
• 如果观察者和观察目标间有循环依赖，可能导致系统崩溃
• 没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的

4、异步观察者模式

4.1修改主题（被观察者，添加线程池）

//抽象主题（被观察者）
public abstract class SubjectAsync {

    //内部维护一个观察者集合
    protected List<ObserverAsync> observers = new ArrayList<ObserverAsync>();

    private ExecutorService taskExecutor = Executors.newFixedThreadPool(2);

    //添加观察者
    public void addObserverAsync(ObserverAsync observer) {
        observers.add(observer);
    }


    //删除观察者
    public void removeObserverAsync(ObserverAsync observer) {
        observers.remove(observer);
    }

    //通知观察者
    public void notifyAllObServer() {
        for (ObserverAsync observerAsync : observers) {
            taskExecutor.execute(observerAsync);
        }
    }

    //关闭线程池
    public void shutdown() {
        taskExecutor.shutdown();
    }

}

4.2、修改观察者接口

//抽象观察者
public interface ObserverAsync extends Runnable {
    void update();
}

4.3、测试

public class ObserverAsyncTest {
    public static void main(String[] args) {
        ObserverAsync1 observerAsync1 = new ObserverAsync1();
        ObserverAsync2 observerAsync2 = new ObserverAsync2();

        BeanFactoryAsyncSubject beanFactoryAsyncSubject = new BeanFactoryAsyncSubject();
        beanFactoryAsyncSubject.addObserverAsync(observerAsync1);
        beanFactoryAsyncSubject.addObserverAsync(observerAsync2);
        beanFactoryAsyncSubject.doSomething();

        beanFactoryAsyncSubject.shutdown();
    }
}

class BeanFactoryAsyncSubject extends SubjectAsync {
    public void doSomething() {
        notifyAllObServer();
    }
}

class ObserverAsync1 implements ObserverAsync {

    public void update() {
        Thread t = Thread.currentThread();
        System.out.println("线程：" + t.getName() + "Observer1 收到。。");
    }

    public void run() {
        update();
    }
}

class ObserverAsync2 implements ObserverAsync {

    public void update() {
        Thread t = Thread.currentThread();
        System.out.println("线程：" + t.getName() + "Observer2 收到。。");
    }

    public void run() {
        update();
    }
}