23种设计模式【Java】解析 - 观察者模式

观察者模式

目的

定义对象之间的一对多依赖，当一个对象状态改变时，它的所有依赖都会收到通知并且做出反应。
发生改变的对象称为观察目标，而被通知的对象称为观察者，一个观察目标可以对应多个观察者，而且这些观察者之间没有相互联系。

类图

角色

• Subject: 目标
• ConcreteSubject: 具体目标
• Observer: 观察者
• ConcreteObserver: 具体观察者
  

实现

目标

public interface Subject {
    
    void resisterObserver(Observer o);

    void removeObserver(Observer o);

    void notifyObserver();
}

具体目标

public class ConcreteSubject implements Subject {
    private List<Observer> observers;
    private int state;

    public ConcreteSubject() {
        observers = new ArrayList<>();
    }

    public void setState(int state) {
        this.state = state;
        notifyObserver();
    }

    @Override
    public void resisterObserver(Observer o) {
        observers.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        int i = observers.indexOf(o);
        if (i >= 0) {
            observers.remove(i);
        }
    }

    @Override
    public void notifyObserver() {
        for (Observer o : observers) {
            o.update(state);
        }
    }
}

观察者

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

具体观察者

public class ConcreteObserver1 implements Observer {

    public ConcreteObserver1(Subject subject) {
        subject.resisterObserver(this);
    }

    @Override
    public void update(int state) {
       ...
    }
}

public class ConcreteObserver2 implements Observer {

    public ConcreteObserver2(Subject subject) {
        subject.resisterObserver(this);
    }

    @Override
    public void update(int state) {
       ...
    }
}

调用类

public class Client {
    public static void main(String[] args) {
        ConcreteSubject concreteSubject  = new ConcreteSubject();
        ConcreteObserver1 concreteObserver1 = new ConcreteObserver1(concreteSubject);
        ConcreteObserver2 concreteObserver2 = new ConcreteObserver2(concreteSubject);

        concreteSubject.setState(0);
        concreteSubject.setState(1);
    }
}

优缺点

优点

1. 观察者和被观察者是抽象耦合的。
2. 建立一套触发机制。
3. 符合开闭原则。

缺点

1. 如果有很多观察者的话，通知所有观察者会花费很多时间。
2. 如果在观察者和观察目标之间有循环依赖的话，可能会导致循环调用，=。
3. 没有相应机制让观察者知道所观察的目标对象是怎么发生变化的，仅仅知道观察目标发生了变化。

使用场景

• 一个抽象模型有两个方面，其中一个方面依赖于另一个方面。
• 一个对象的改变将导致其他一个或多个对象也发生改变。
• 一个对象必须通知其他对象，而并不知道这些对象是谁。
• 需要创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……。

JDK中的使用

• java.util.Observer
• java.util.EventListener
• javax.servlet.http.HttpSessionBindingListener
• RxJava