使用Observer模式改善现有软件设计——构建简便的通知

[quote]Observer又叫观察者模式，它的意图是当一个对象进行改变时，所有依赖于它的对象都可以得到通知。（观察者模式定义了一种一对多地依赖模式，让多个观察者同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有的观察者对象，使它们能够自动更新自己。这里的主题对象就是指通知者，又叫做发布者。观察者又叫订阅者。）[/quote]

听起来这个模式似乎非常有用，它属于对象行为型模式，一般在一个系统中，把一个功能分割成由多个类共同完成，如果此时每个类之间需要进行同步的协作，怎么办？使用Observer解决问题。一般来说Observer适用于任何情况。

一般来说，我们可以在系统中让每个相关联的类再类与类中调用互相自己的引用来解决问题，达到通知的效果，但是这样一来有个问题，类与类的关联太大，偶合太大，而且过多引用容易产生碎对象。不过我想，现在有了DI框架，已经不是个问题了，但是如果不使用DI呢？问题还是有，我们种不会一直DI，当然，有些人愿意这样一直引入个SPRING IOC包，这个另当别论。如果在系统在设计时已经说明，对哪个类不可以修改，这个时候你要在类里添加一个引用怎么办？（当然，这种情况不大可能发生。），如果你不停的引用，虽然你有IOC，但是有个问题你确无法很好解决，每次添加一个新类，你总是要修改原有类的方法，怎么样可以不改变代码？很简单，一个新类，继承抽象基类，这就是Observer的用处所在，之后只需要把添加的新类注册到一个列表里既可。而本身这个类似于一个小容器的东西不仅可以提供注册，它还有删除和修改的列表的方法。

对于Observer模式，本身比较繁杂，但是有了JDK类库内建的支持，使得使用Observer模式变的简单，不需要进行类似于跟踪观察者，对通知的管理等等。但是JDK内建支持也有些问题，它必须要你使用继承，一般直接继承会有些问题，最重要的问题是内建的支持不够灵活，所有为了完成自己的业务规则，必须自己手动去实现整个Observer模式。

关于观察者模式，在CSDN上有个很好的博文。地址：http://blog.csdn.net/wanghao72214/archive/2009/03/23/4017507.aspx
以下的代码是从这个帖子里复制来的。

//主题基类
import java.util.Vector;
public abstract class Subject {
	//观察者列表
	private Vector<Observer> vectObserver = new Vector<Observer>();
	//增加一个观察者
	public void attach(Observer observer){
		vectObserver.add(observer);
	}
	//去除一个观察者
	public void detach(Observer observer){
		vectObserver.remove(observer);
	}
	//通知观察者更新
	public void notifyObservers(){
		for(int i=0; i<vectObserver.size(); i++){
			Observer observer = vectObserver.get(i);
			observer.update();
		}
	}	
	//获取主题信息
	public abstract String getSubject();
}
//银行柜台类
public class Counter extends Subject{
	//当前业务号
	private String bizNo;
	//柜台名称
	private String name;
	//构造函数
	public Counter(String name){
		this.name = name;
	}
	//获取当前业务号
	public String getBizNo(){
		return this.bizNo;
	}
	//设置当前业务号
	public void setBizNo(String bizNo){
		this.bizNo = bizNo;
	}
	//获取主题信息
	public String getSubject(){
		return "请" + this.bizNo + "号到" + this.name + "号柜台办理业务";
	}
}
//管理部门类
public class Manager extends Subject{
	//管理部门名称
	private String name;
	//构造函数
	public Manager(String name){
		this.name = name;
	}
	//获取主题信息
	public String getSubject(){
		return this.name + "发布最新紧急公告";
	}
}
//观察者基类
public abstract class Observer {
	protected String name;
	protected Subject subject;
	//构造函数
	public Observer(String name,Subject subject){
		this.name = name;
		this.subject = subject;
	}	
	//更新信息
	public abstract void update();
}
//小显示屏类
public class SmallScreen extends Observer{
	//构造函数
	public SmallScreen(String name,Subject subject){
		super(name,subject);
	}	
	//更新显示屏
	public void update(){
		try{
			System.out.println(this.name + ":" + subject.getSubject());
		}
		catch(Exception err){
		}
	}		
}
//音箱类
public class Speaker extends Observer{
	//构造函数
	public Speaker(String name,Subject subject){
		super(name,subject);
	}	
	//更新音箱
	public void update(){
		try{
			System.out.println(this.name + ":" + subject.getSubject());
		}
		catch(Exception err){
		}
	}	
}
//业务系统类
public class BankBiz {
	public static void main(String[] args) {
		//银行柜台
		Counter counter = new Counter("1号柜台");
		//1,2号小屏、3号音箱
		SmallScreen smallScreen1 = new SmallScreen("1号小屏",counter);
		SmallScreen smallScreen2 = new SmallScreen("2号小屏",counter);
		Speaker speaker = new Speaker("3号音箱",counter);
		//银行柜台加入观察者
		counter.attach(smallScreen1);
		counter.attach(smallScreen2);
		counter.attach(speaker);
		//9号办理业务
		counter.setBizNo("9");
		//通知更新
		counter.notifyObservers();

		//管理部门
		Manager manager = new Manager("风险控制部");	
		//1号小屏
		smallScreen1 = new SmallScreen("1号小屏",manager);		
		//管理部门加入观察者
		manager.attach(smallScreen1);
		//通知更新
		manager.notifyObservers();
	}
}

把主题与观察者分别抽象出来，因为主题与观察者之间有可以公用的方法，之后让每一个需要变成主题的类去继承抽象主题基类，让需要被观察的类继承观察者抽象基类就可以了。

但是基于抽象基类的主题与观察者还有些缺点，有的时候改变了注册，删除的业务规则时，我们还得修改代码，有的时候为了方便，我们可以直接把主题与观察者抽像基类抽象成一个接口。之后在继承接口类中去实现注册，删除，修改的方法。

光知道一个Observer的实现又有何用，要把Observer灵活运用到系统中才是王道。有的时候，我们的反映需要不是既时的，有的时候需要延时，有的时候甚至需要让各子通知后的程序运行在不同的线层当中，或者有的时候这些对象需要跨越多个不同的生命周期，这时问题就开始复杂起来了。