【Java设计模式】- 观察者模式

概述

观察者模式又叫做发布订阅模式（ Publish/Subscribe），定义了一个目标管理对象（Subject）和多个观察者对象（Observer），形成一个一对多的关系，当满足某种条件的时候由目标管理对象像所有依赖与自己的观察者对象发送通知。这种模式多用于事件处理。

原理

观察者模式类图：

（图片来源于网络）

Subject：抽象主题（角色），内部用某种数据结构（List，Map等）保存了所有的依赖与自己的观察者的对象引用，同时提供增加，删除观察者的操作，同时提供一个通知所有观察者的方法，这里是notifyObserver。

ConcreteSubject：主题（角色）。继承Subject实现特定Subject的功能。

Observer：观察者接口。定义了一个update方法，这个方法是当当前对象所观察的目标对象的状态改变的时候将会调用这个方法（也就是notifyObserver中调用）。

ConcreteObserver：观察者实现。实现具体观察者的行为的对象。

观察者模式的原理：在Subject对象中通过容器保存依赖于自己的观察者对象引用，当状态改变时（改变的时机由程序员决定）调用notify*方法去调用容器中观察者对象的update方法。

实现

JDK的包中自身就带有观察者模式：

存在于java.uti包中，分别为：

java.util.Obervable：等同于Subject

java.util.Observer

源码：

Observer：

public interface Observer {

    void update(Observable o, Object arg);
}

这里update方法参数提供了被观察着的对象以及一个参数。

Observable：

public class Observable {
    private boolean changed = false;
    private Vector<Observer> obs;


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

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

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

    public void notifyObservers() {
        notifyObservers(null);
    }

    public void notifyObservers(Object arg) {
        Object[] arrLocal;

        synchronized (this) {
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

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

    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }

    protected synchronized void setChanged() {
        changed = true;
    }

    protected synchronized void clearChanged() {
        changed = false;
    }

    public synchronized boolean hasChanged() {
        return changed;
    }

    public synchronized int countObservers() {
        return obs.size();
    }
}

内部采用Vector作为容器，除了基本的操作之外，内部还维护了一个布尔型的变量changed用于Observable对象的状态记录，同时提供了setChanged，clearChanged，hasChanged方法来管理状态，并且setChanged，clearChanged方法设计成了protected，明显是为了子类继承的时候能够自行定义状态的管理方式而设计。同时还Vector和NotifyObservers方法都是线程安全的。

自己实现一个简单的观察者模式：

定义一个Clock类作为被观察者，和一个Watcher类作为观察者，每当Clock经过了一段时间便通知Watcher执行控制台打印操作。

Watcher：

public class Watcher implements Observer {

	private String name;
	
	public Watcher(String name) {
		this.name = name;
	}
	
	@Override
	public void update(Observable o, Object arg) {
		System.out.println("time changed --by " + name);
	}
	
	public String getName() {
		return name;
	}

}

每个Watcher初始化一个name。

Clock：

public class Clock extends Observable {
	
	private volatile boolean running = true;
	
	public void start(long noticeTime) {
		if (noticeTime < 0)
			throw new IllegalArgumentException();
		new Thread(new Runnable() {
			@Override
			public void run() {
				while (running) {
					setChanged();
					notifyObservers();
					try {
						Thread.sleep(noticeTime);
					} catch (InterruptedException e) {
						break;
					}
				}
			}
		}).start();
	}
	
	public void stop() {
		running = false;
	}
	
}

定义一个start方法，每隔一定的时间通知观察者。同时使用新的一个线程去执行避免阻塞主线程。同时可以调用stop方法停止。

测试：

public class Test {
	public static void main(String[] args) throws InterruptedException{
		 Clock clock = new Clock();
		 Watcher watcher1 = new Watcher("watcher1");
		 Watcher watcher2 = new Watcher("watcher2");
		 clock.addObserver(watcher1);
		 clock.addObserver(watcher2);
		 clock.start(2000);
		 
		 Thread.sleep(6000);
		 
		 clock.stop();
	}
}

将两个观察者对象依赖到Clock

输出：

time changed --by watcher2
time changed --by watcher1
time changed --by watcher2
time changed --by watcher1
time changed --by watcher2
time changed --by watcher1
time changed --by watcher2
time changed --by watcher1