观察者模式

1. 观察者模式

观察者模式：一个或几个对象监听着另一个对象，只要被监听对象的状态发生改变，监听者要随之做出相应的反应。

concrete [ˈkɑːnkriːt] 具体的；实在的

以下是相关代码：

abstract class Subject {
    
    private ArrayList<Observer> observers;

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

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

    public void removeObserver(Observer observer) {
    
        observers.remove(observer);
    }

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

class ConcreteSubject extends Subject {
    
    private int subjectState;

    public int getState() {
    
        return subjectState;
    }

    public void setState(int newState) {
    
        subjectState = newState;
        System.out.println("subject's state change to " + newState);
        this.notifyObserver(subjectState);
    }
}

interface Observer {
    
    void update(int state);
}

class ConcreteObserver1 implements Observer {
    

    @Override
    public void update(int state) {
    
        System.out.println("ConcreteObserver1 knows state had changed to " + state);
        doSomething();
    }

    private void doSomething() {
    
        System.out.println("ConcreteObserver1 do something!");
    }
}

class ConcreteObserver2 implements Observer {
    

    @Override
    public void update(int state) {
    
        System.out.println("ConcreteObserver2 knows state had changed to " + state);
        doSomething();
    }

    private void doSomething() {
    
        System.out.println("ConcreteObserver2 do something!");
    }
}

class ConcreteObserver3 implements Observer {
    

    @Override
    public void update(int state) {
    
        System.out.println("ConcreteObserver3 knows state had changed to " + state);
        doSomething();
    }

    private void doSomething() {
    
        System.out.println("ConcreteObserver3 do something!");
    }
}

class Test {
    

    public static void main(String[] args) {
    
        ConcreteSubject subject = new ConcreteSubject();
        Observer o1 = new ConcreteObserver1();
        Observer o2 = new ConcreteObserver2();
        Observer o3 = new ConcreteObserver3();

        subject.addObserver(o1);
        subject.addObserver(o2);
        subject.addObserver(o3);

        subject.setState(2);
        subject.removeObserver(o2);

        subject.setState(5);
    }

}

// subject's state change to 2
// ConcreteObserver1 knows state had changed to 2
// ConcreteObserver1 do something!
// ConcreteObserver2 knows state had changed to 2
// ConcreteObserver2 do something!
// ConcreteObserver3 knows state had changed to 2
// ConcreteObserver3 do something!
// subject's state change to 5
// ConcreteObserver1 knows state had changed to 5
// ConcreteObserver1 do something!
// ConcreteObserver3 knows state had changed to 5
// ConcreteObserver3 do something!

2 发布订阅模式

有很多人认为发布订阅模式就是观察者模式，Publisher == Subject 被观察者，Subscriber == Observer 观察者 ，其实不然。在发布订阅模式中，被观察并不会直接通知订阅者，换句话说，发布者和订阅者并不相干。如果互不相干，它们之间是如何进行交流的？通过第三者——事件总线或者叫做经纪人（Broker）。

broker [ˈbroʊkər] 经纪人，中间人

如果说观察者模式实现了松耦合（loosely coupled），发布订阅模式就是完全解耦的。

loosely [ˈluːsli] 宽松地 coupled [ˈkʌpld] 耦合的

参考

设计模式之观察者模式
观察者模式 vs 发布订阅模式