Java 实现观察者(Observer)模式

1. Java自带的实现

类图

/**
 * 观察目标 继承自 java.util.Observable
 * @author stone
 *
 */
public class UpdateObservable extends Observable {

	private int data;

	public UpdateObservable(Observer observer) {
		addObserver(observer);
		/*
		 * add other observer
		 */
	}

	public int getData() {
		return data;
	}

	public void setData(int data) {
		if (data != this.data) {
			this.data = data;
			setChanged(); //标记 改变, 仅仅有标记后才干通知到
			notifyObservers(); //通知
		}

	}

	@Override
	public synchronized void addObserver(Observer o) {
		super.addObserver(o);
	}

	@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();
	}

}

/**
 * 观察者	实现 java.util.Observer接口
 * @author stone
 *
 */
public class UpdateObserver implements Observer {

	@Override
	public void update(Observable o, Object arg) {
		System.out.println("接收到数据变化的通知:");
		if (o instanceof UpdateObservable) {
			UpdateObservable uo = (UpdateObservable) o;
			System.out.print("数据变更为：" + uo.getData());
		}
	}

}

2. 自己定义的观察模型

类图

/**
 * 抽象观察者	Observer
 * 观察 更新
 * @author stone
 *
 */
public interface IWatcher {
	/*
	 * 通知接口：
	 * 1. 简单通知
	 * 2. 观察者须要目标的变化的数据，那么能够将目标用作參数, 见Java的Observer和Observable
	 */
//	void update(IWatched watched);

	void update();

}

/**
 * 抽象目标	Subject
 * 	提供注冊和删除观察者对象的接口, 及通知观察者进行观察的接口
 *  及目标 自身被观察的业务的接口
 * @author stone
 *
 */
public interface IWatchedSubject {

	public void add(IWatcher watch);

	public void remove(IWatcher watch);

	public void notifyWhatchers();

	public void update();//被观察业务变化的接口
}

/**
 * 详细观察者		Concrete Observer
 *
 * @author stone
 *
 */
public class UpdateWatcher implements IWatcher {

	@Override
	public void update() {
		System.out.println(this + "观察到：目标已经更新了");
	}

}

/**
 * 详细目标角色	Concrete Subject
 * @author stone
 *
 */
public class UpdateWatchedSubject implements IWatchedSubject {
	private List<IWatcher> list;

	public UpdateWatchedSubject() {
		this.list = new ArrayList<IWatcher>();
	}

	@Override
	public void add(IWatcher watch) {
		this.list.add(watch);
	}

	@Override
	public void remove(IWatcher watch) {
		this.list.remove(watch);
	}

	@Override
	public void notifyWhatchers() {
		for (IWatcher watcher : list) {
			watcher.update();
		}
	}

	@Override
	public void update() {
		System.out.println("目标更新中....");
		notifyWhatchers();
	}

}

监听器是观察者的一种实现

类图

/**
 * 监听 用户在注冊后
 * @author stone
 *
 */
public interface IRegisterListener {
	void onRegistered();
}

/**
 * 监听 当用户登录后
 * @author stone
 *
 */
public interface ILoginListener {
	void onLogined();
}

/*
 * 监听器 是观察者模式的一种实现
 * 一些须要监听的业务接口上加入 监听器，调用监听器的对应方法，实现监听
 */
public class User {

	public void register(IRegisterListener register) {
		/*
		 * do ... register
		 */
		System.out.println("正在注冊中...");
		//注冊后
		register.onRegistered();
	}

	public void login(ILoginListener login) {
		/*
		 * do ... login
		 */
		System.out.println("正在登录中...");
		//登录后
		login.onLogined();
	}

}

/**
 * 观察者(Observer)模式	行为型模式
 *   观察者模式定义了一种一对多的依赖关系，让多个观察者对象同一时候观察某一个目标对象。
 *   这个目标对象在状态上发生变化时，会通知全部观察者对象，让它们可以自己主动更新自己
 * 目标对象中须要有加入、移除、通知 观察者的接口
 *
 * @author stone
 */
public class Test {

	public static void main(String[] args) {
		/*
		 * 使用Java自带的Observer接口和Observable类
		 */
		UpdateObservable observable = new UpdateObservable(new UpdateObserver());
		observable.setData(99);
		System.out.println("");
		System.out.println("");
		/*
		 * 自己定义的观察者模型
		 */
		IWatchedSubject watched = new UpdateWatchedSubject();
		watched.add(new UpdateWatcher());
		watched.add(new UpdateWatcher());
		watched.update();
		System.out.println("");

		/*
		 * 子模式-监听器
		 */

		User user = new User();
		user.register(new IRegisterListener() {

			@Override
			public void onRegistered() {
				System.out.println("监听到注冊后。。。");
			}
		});
		user.login(new ILoginListener() {

			@Override
			public void onLogined() {
				System.out.println("监听到登录后。。。");
			}
		});

	}
}

打印

接收到数据变化的通知:
数据变更为：99

目标更新中....
observer.UpdateWatcher@457471e0观察到：目标已经更新了
observer.UpdateWatcher@5fe04cbf观察到：目标已经更新了

正在注冊中...
监听到注冊后。。。
正在登录中...
监听到登录后。。。