观察者模式

观察者模式观察者模式是软件设计模式的一种。在此种模式中，一个目标对象管理所有相依于它的观察者对象，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实时事件处理系统。–维基百科
生活中,顾客(Customer)去商店购买电器,但是由于缺货,顾客留下手机号码,告知店主(Manager)有货时及时通知;即顾客(观察者)订阅了店主(被订阅者)的到货的服务,当有货时,店家立即通知顾客.
下面通过demo说明,观察者抽象类Observer:

public abstract class Observer {
    abstract void notice();
}

观察者A、B:

public class CustomerA extends Observer{
    @Override
    void notice() {
        System.out.println("CustomerA已经收到到货通知");
    }
}
public class CustomerB extends Observer{
    @Override
    void notice() {
        System.out.println("CustomerB已经收到到货通知");
    }
}

被观察者抽象类Observable:

public abstract class Observable {
    List<Observer> observers = new ArrayList<>();
    // 添加观察者(注册观察者;观察者订阅通知)
    protected Observable addObserver(Observer observer){
        observers.add(observer);
        return this;
    }
    // 删除观察者
    protected Observable delObserver(Observer observer){
        observers.remove(observer);
        return this;
    }
    // 通知
    protected void notice(){
        observers.forEach(p->{
            p.notice();
        });
    }

}

被观察者:

public class Manager extends Observable{
    @Override
    protected void notice() {
        observers.forEach(p->{
            p.notice();
        });
    }
}

测试:

public class Test {
    public static void main(String[] args) {
        Observer observerA = new CustomerA();
        Observer observerB = new CustomerB();
        Observable observable = new Manager();
        // 观察者订阅通知
        observable.addObserver(observerA)
                .addObserver(observerB);
        observable.notice();
    }
}

java.util包下的Observer、Observable,是java为观察者模式提供的支持类,上面的demo完全可以通过这两个类去完成:
观察者Customer:

   public class Customer implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("Customer已经收到消息");
        // 删除当前订阅者
        o.deleteObserver(this);
    }
}

被观察者Manager:

public class Manager extends Observable{
    public Manager() {
        super();
    }

    // 添加观察者
    @Override
    public synchronized void addObserver(Observer o) {
        super.addObserver(o);
        // 标记被订阅者已改变,否则无法通知到观察者
        super.setChanged();
    }
    // 删除观察者
    @Override
    public synchronized void deleteObserver(Observer o) {
        super.deleteObserver(o);
    }
    // 发送通知
    @Override
    public void notifyObservers() {
        super.notifyObservers();
    }

    @Override
    public void notifyObservers(Object arg) {
        super.notifyObservers(arg);
    }

    @Override
    public synchronized void deleteObservers() {
        super.deleteObservers();
    }

    @Override
    protected synchronized void setChanged() {
        super.setChanged();
    }

    @Override
    protected synchronized void clearChanged() {
        super.clearChanged();
    }

    @Override
    public synchronized boolean hasChanged() {
        return super.hasChanged();
    }

    @Override
    public synchronized int countObservers() {
        return super.countObservers();
    }
}

测试:

public class Test {
    public static void main(String[] args) {
        Observer observer = new Customer();
        Observable observable = new Manager();
        observable.addObserver(observer);
        observable.notifyObservers();
    }
}