班主任来啦之观察者模式，事件委托等Java实现---如果你还不懂，看完此文，就一定会懂

班主任来啦！

小A对小B说：“今天真是笑死人了，我们班一位同学在仔细的时候看NBA球赛，被班主任抓了个正着。班主任脸都绿了，哈哈，真是笑死我了。

小B说：”啊，你们怎么同学怎么敢在课上看电视啊？“

小A说：”没有的，他们那帮子男生经常自习的时候看球赛的。我们班有个女生坐在前排，那些男生就给她送写小礼物啊什么的。班主任来了，那个女生就去通知敲一下桌子。“

小B说：”好吧。这也行。那今天怎么会有人被抓？“

小A说：”这是因为刚好班主任来的时候，那个女生去上厕所了。结果一个看漫画的男生没被抓，那个看NBA球赛的男生被抓了。手机都被没收了呢！”

小B说：“好吧。你说的这个场景，让我想起了一个设计模式，叫做观察者模式。要不给你讲讲？”

小A吐血，倒地不起。。。。。。

观察者模式

我们先来看看观察者模式的定义：观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使他们能够自动更新自己。在上面的场景中，观察者就是指各位苦逼同学啦，而监听的主题对象就是万恶的班主任了，班主任来的时候，通知者通知所有的同学，那么所有的同学都去自动更新自己，看NBA球赛的停下来看书，看漫画的也停下来看书。怎么样？是不是炒鸡形象，下面我们就用代码来实现上面场景里面发生的事情：

import java.util.*;

//负责帮忙监听的女同学
class GirlClassMate {
	private String action;         //前台秘书发现的情况

	//给她送过礼的男同学们
	private ArrayList<NbaWatcher> observers = new ArrayList<NbaWatcher>();

	//增加，就是有几个同学请她帮们关照，就在集合中增加几个对象
	public void Attach(NbaWatcher observer) {
		observers.add(observer);
	}

	//从关照对象中删除对象
	public void Delete(NbaWatcher observer) {
		observers.remove(observer);
	}

	//通知关照看NBA的每一位同学，班主任来啦!
	public void Notify() {
		for (NbaWatcher observer : observers) {
			observer.Update();
		}
	}

	public void setAction(String action) {
		this.action = action;
	}

	public String getAction() {
		return action;
	}
}

//看NBA的同学
class NbaWatcher {
	private String name;          //该同学的名字
	private GirlClassMate wodi;   //前排卧底MM
	public void Update() {
		// TODO Auto-generated method stub
		System.out.println(wodi.getAction() + name + "别看球赛啦，继续学习！");
	}
	public NbaWatcher(String name, GirlClassMate wodi) {
		this.name = name;
		this.wodi = wodi;
	}
}

public class MainClass {
	public static void main(String[] args) {
		GirlClassMate MM = new GirlClassMate();     //前台MM对象
		NbaWatcher diaosi1 = new NbaWatcher("屌丝1", MM);   //看股票的同事1
		NbaWatcher diaosi2 = new NbaWatcher("屌丝2", MM);   //看股票的同事1

		//将两位屌丝同事加进前台MM的关照对象列表中
		MM.Attach(diaosi1);
		MM.Attach(diaosi2);

		//前台MM发现老板回来了
		MM.setAction("班主任回来啦！");

		//通知关照列表中的每一位同事，老板回来了
		MM.Notify();
	}
}

输出结果：

班主任回来啦！屌丝1别看球赛啦，继续学习！
班主任回来啦！屌丝2别看球赛啦，继续学习！

你来评一评，这代码写的怎么样？肯定不好啦！前排女同学对象依赖于具体的看NBA同学对象，而NBA同学对象依赖于前排女同学对象。那么这样就形成了一种双向耦合的关系。在一段代码里面，耦合度过高可不是什么好事。用依赖倒转原则专业的话来说就是：具体应该依赖于抽象，抽象不应该依赖于具体。按照这个原则，我们将看NBA球赛的观察者，看漫画的观察者等等抽象出来一个观察者类。而无论是前排MM通知者，还是班主任这个通知者都是通知者，所以也可以抽象为一个通知者类。改进之后的代码如下：

import java.util.*;

//通知者，可能是班主任自己，也可能是前排女同学
abstract class Notifier {

	private ArrayList<Observer> observers = new ArrayList<Observer>();

	public void Attach(Observer observer) {
		observers.add(observer);
	}

	public void Delete(Observer observer) {
		observers.remove(observer);
	}

	//通知关照同学列表中每一位同事，班主任来了
	public void Notify() {
		for (Observer observer : observers) {
			observer.Update();
		}
	}

	abstract public void setAction(String action);
	abstract public String getAction();
}

class Boss extends Notifier{

	private String action;         //通知者发现的情况

	//老板发现的情况
	public void setAction(String action) {
		this.action = action;
	}

	public String getAction() {
		return action;
	}
}

class GirlClassMate extends Notifier{
	private String action;         //通知者发现的情况

	//前台MM发现的情况
	public void setAction(String action) {
		this.action = action;
	}

	public String getAction() {
		return action;
	}
}

//Observer师祖
abstract class Observer {
	protected String name;          //该同学的名字
	protected Notifier notifier;        //事件通知者
	abstract void Update();

	public Observer(String name, Notifier notifier) {
		this.name = name;
		this.notifier = notifier;
	}

}

//看NBA的的同事
class NbaWatcher extends Observer{

	public NbaWatcher(String name, Notifier notifier) {
		super(name, notifier);
		// TODO Auto-generated constructor stub
	}

	public void Update() {
		// TODO Auto-generated method stub
		System.out.println(notifier.getAction() + name + "别看球赛啦，继续学习！");
	}
}

//看世界杯的同事
class ComicReader extends Observer{

	public ComicReader(String name, Notifier notifier) {
		super(name, notifier);
		// TODO Auto-generated constructor stub
	}

	public void Update() {
		// TODO Auto-generated method stub
		System.out.println(notifier.getAction() + name + "别看漫画啦，继续学习");
	}
}

public class MainClass {
	public static void main(String[] args) {

		Notifier tuhao = new Boss();     //通知者换成班主任自己了
		Observer diaosi1 = new NbaWatcher("倒霉的屌丝1", tuhao);   //看NBA的同学
		Observer diaosi2 = new ComicReader("幸运的屌丝2", tuhao);   //看NBA的同学

		//将两位屌丝同事加进前台MM的关照对象列表中
		//tuhao.Attach(diaosi1);  //倒霉的屌丝1，没有加进老板的关照列表，所以被抓住了
		tuhao.Attach(diaosi2);

		//前台MM发现老板回来了
		tuhao.setAction("班主任我回来啦！");

		//通知关照列表中的每一位同事，老板回来了
		tuhao.Notify();
	}
}

观察者模式的不足之处

“上面该机的代码中抽象通知者还是依赖了抽象观察者，万一没有抽象观察者，那岂不是功能都完成不了啦！还有你这上面代码写的，所以对象更新的动作都一样的。万一我对象更新不一样呢？比如，看NBA球赛的听见班主任来了就跑去上厕所，而看漫画的听见班主任来了就继续看书。代码又应该怎么写呢？”小A，揉了揉惺忪的睡眼，疑惑地问道。

小B说：“我去，我还以为你睡着了呢！原来你在听啊！我太高兴了。下面我们就利用一种叫做“事件委托”的东东去解决这个问题哈！”

小A说：“我滴个神，什么叫事件委托啊？”

观察者模式改进-反射版事件委托

小B说：“你先别着急哈！我们先来看看该怎么用哈！”

代码中，我们去除了抽象观察者这个类，由客户端去决定需要通知哪个观察者。PS：Java中是没有像c#里面的delegation，所以我用Java中的反射来实现，见如下代码。

import java.util.*;
import java.lang.reflect.*;

//通知者，可能是老板，也可能是前台秘书
abstract class Notifier {
	protected Method Update;
	abstract public void setAction(String action);
	abstract public void Notify(Object object);
}

class Boss extends Notifier{

	private String action;         //通知者发现的情况

	//老板发现的情况
	public void setAction(String action) {
		this.action = action;
	}

	public void Notify(Object object) {
		if (Update != null) {
			try {
				Update.invoke(object, action);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
}

class GirlClassMate extends Notifier{
	private String action;         //通知者发现的情况
	public Method Update;          //反射事件

	//老板发现的情况
	public void setAction(String action) {
		this.action = action;
	}

	public void Notify(Object object) {
		if (Update != null) {
			try {
				Update.invoke(object, action);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
}

//看股票的同事
class NbaWatcher {

	protected String name;          //该同事的名字
	protected Notifier notifier;        //前台卧底MM

	public NbaWatcher(String name, Notifier notifier) {
		this.name = name;
		this.notifier = notifier;
	}

	public void CloseNbaWatcher(String action) {
		// TODO Auto-generated method stub
		System.out.println(action + name + "别看球赛啦，继续学习");
	}
}

//看世界杯的同事
class ComicReader {

	protected String name;          //该同事的名字
	protected Notifier notifier;        //前台卧底MM

	public ComicReader(String name, Notifier notifier) {
		this.name = name;
		this.notifier = notifier;
	}

	public void CloseComicReader(String action) {
		// TODO Auto-generated method stub
		System.out.println(action + name + "别看漫画啦，继续学习");
	}
}

public class MainClass {
	public static void main(String[] args) {

		Notifier tuhao = new Boss();
		NbaWatcher diaosi1 = new NbaWatcher("倒霉的屌丝1", tuhao);
		ComicReader diaosi2 = new ComicReader("幸运的屌丝2", tuhao);  

		tuhao.setAction("班主任我回来啦！");

		try {
			tuhao.Update = diaosi1.getClass().getMethod("CloseNbaWatcher", new Class[] {String.class});
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		tuhao.Notify((Object)diaosi1);

		try {
			tuhao.Update = diaosi2.getClass().getMethod("CloseComicReader", new Class[] {String.class});
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		tuhao.Notify((Object)diaosi2);
	}
}

发射实现委托核心：

protected Method Update;

if (Update != null) {
			try {
				Update.invoke(object, action);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

try {
			tuhao.Update = diaosi2.getClass().getMethod("CloseComicReader", new Class[] {String.class});
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		tuhao.Notify((Object)diaosi2);

右上面代码可以看出，反射能够实现根据类的不同而调用不同的方法。就好像是C#中，一个委托可以搭载多个方法，所有方法一次被唤起。感觉上，也有点像c语言里面的钩子函数。

后继

小A说：哇！小B你好厉害哦，我真的懂了观察模式诶，另外发射模式真的好好用啊！

小B说：O(∩_∩)O哈哈~你学到东西就好！其实该感谢本文作者的吐血整理，我，笑了~~~~~~~你们都懂了就好！