一文带你彻底搞懂发布与订阅设计

public abstract class AbstractSubject {

    /** 用来保存注册的观察者对象 */
    private List<Observer> list = new ArrayList<Observer>();

    /**
     * 注册观察者对象
     */
    public void add(Observer observer){
        list.add(observer);
        System.out.println("add an observer");
    }

    /**
     * 删除观察者对象
     * @param observer
     */
    public void remove(Observer observer){
        list.remove(observer);
        System.out.println("delete an observer");
    }

    /**
     * 通知所有注册的观察者对象
     * @param state
     */
    public void notifyObservers(String state){
        for (int i = 0; i < list.size(); i++) {
            list.get(i).update(state);
        }
    }
}

public class ConcreteSubject extends AbstractSubject{

    private String state;

    public void change(String newState){
        state = newState;
        System.out.println("主题状态：" + state);

        //状态发生改变，通知所有的观察者
        super.notifyObservers(state);
    }
}

public interface Observer {

    /**
     * 修改状态
     * @param state
     */
    void update(String state);
}

public class ConcreteObserver implements Observer{

    @Override
    public void update(String state) {
        System.out.println("观察者，收到状态：" + state);
    }
}

public class ObserverClient {

    public static void main(String[] args) {
        //创建一个主题角色
        ConcreteSubject subject = new ConcreteSubject();

        //创建观察者对象
        ConcreteObserver observer = new ConcreteObserver();

        //将观察者加入主题对象上
        subject.add(observer);

        //改变主题状态
        subject.change("hello world");
    }
}

add an observer
主题状态：hello world
观察者，收到状态：hello world

public interface Observer {
    /**
     * This method is called whenever the observed object is changed. An
     * application calls an <tt>Observable</tt> object's
     * <code>notifyObservers</code> method to have all the object's
     * observers notified of the change.
     *
     * @param   o     the observable object.
     * @param   arg   an argument passed to the <code>notifyObservers</code>
     *                 method.
     */
    void update(Observable o, Object arg);
}

public class Observable {
    private boolean changed = false;
    private Vector obs;
   
    /** Construct an Observable with zero Observers. */

    public Observable() {
    obs = new Vector();
    }

    /**
     * Adds an observer to the set of observers for this object, provided 
     * that it is not the same as some observer already in the set. 
     * The order in which notifications will be delivered to multiple 
     * observers is not specified. See the class comment.
     *
     * @param   o   an observer to be added.
     * @throws NullPointerException   if the parameter o is null.
     */
    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
    if (!obs.contains(o)) {
        obs.addElement(o);
    }
    }
    ...
}

import java.util.Observable;
import java.util.Observer;

public class Watched implements Observer {

    @Override
    public void update(Observable o, Object arg) {
        System.out.println("观察者，收到状态：" + arg);
    }
}

import java.util.Observable;

public class Subject extends Observable {

    private String data;

    public void setData(String newData){
        System.out.println("主题状态：" + newData);
        data = newData;
        setChanged();
        notifyObservers(data);
    }
}

public class WatchedClient {

    public static void main(String[] args) {
        //创建观察者对象
        Watched watched = new Watched();

        //创建主题
        Subject subject = new Subject();

        //将观察者对象加入主题
        subject.addObserver(watched);

        //修改主题状态
        subject.setData("hello world");

    }
}

主题状态：hello world
观察者，收到状态：hello world