JDK内部的观察者模式

观察者模式是比较常用的，以至于JDK内部就已经为开发者人员准备了一套观察者模式的实现。它位于java.util包下。包括java.util.Observable类和java.util.Observer接口。

通过api可知，Observable类已经为我们提供了管理观察者的方法，比如addObserver(Observer o), deleteObserver(Observer o)和notifyObservers(Object arg)等。而在Observer接口中只有一个update(Observable o, Object arg)方法，该方法在Observable的notifyObservers(Object arg)中得到调用。下面就通过继承和实现这两个类来完成观察者模式。

具体主题

public class JObservable extends Observable
{
	private Vector<Observer> observers = new Vector<Observer>();
	
	@Override
	public synchronized void addObserver(Observer o)
	{
		observers.add(o);
	}
	
	@Override
	public synchronized void deleteObserver(Observer o)
	{
		observers.removeElement(o);
	}
	
	@Override
	public void notifyObservers(Object arg)
	{
		for(Observer observer : observers)
		{
			observer.update(this, arg);
		}
	}
}

具体观察者

public class JObserver implements Observer
{
	@Override
	public void update(Observable o, Object arg)
	{
		System.out.println(arg);
	}
}

测试类

public class JMain
{
	public static void main(String[] args)
	{
		Observer s1 = new JObserver();
		Observer s2 = new JObserver();
		Observer s3 = new JObserver();
		Observer s4 = new JObserver();
		Observer s5 = new JObserver();
		
		Observable subject = new JObservable();
		subject.addObserver(s1);
		subject.addObserver(s2);
		subject.addObserver(s3);
		subject.addObserver(s4);
		subject.addObserver(s5);
		
		subject.notifyObservers("高兴");
	}
}

下面对Observable源码进行分析

通过源码可知，Observable维护着一个Vector obs对象。当调用addObserver(Observer o)时，底层的实现为

public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }

即首先判断传进来的对象是否为空，若为空则抛空指针异常，接着在判断obs中是否已经包含有该对象，如果没有则添加到obs中。

deleteObserver(Observer o)源码

public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }

notifyObservers(Object arg)源码

 public void notifyObservers(Object arg) {
        /*
         * a temporary array buffer, used as a snapshot of the state of
         * current Observers.
         */
        Object[] arrLocal;

        synchronized (this) {
            /* We don't want the Observer doing callbacks into
             * arbitrary code while holding its own Monitor.
             * The code where we extract each Observable from
             * the Vector and store the state of the Observer
             * needs synchronization, but notifying observers
             * does not (should not).  The worst result of any
             * potential race-condition here is that:
             * 1) a newly-added Observer will miss a
             *   notification in progress
             * 2) a recently unregistered Observer will be
             *   wrongly notified when it doesn't care
             */
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }

可以看到在该方法的最后会循环遍历Vector链表并调用其update()方法。

观察者模式在Swing中的实现

JButton继承AbstractButton，在AbstractButton中通过listenerList来维护观察者，当按钮被单击时，通过AbstractButton的fireActionPermed()方法回调ActionListener.actionPerformed()方法实现。