java观察者模式与时间委托机制l

在前面我们说过：

观察者模式所涉及的角色有：

　　●　　抽象主题(Subject)角色：抽象主题角色把所有对观察者对象的引用保存在一个聚集（比如ArrayList对象）里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象，抽象主题角色又叫做抽象被观察者(Observable)角色。

　　●　　具体主题(ConcreteSubject)角色：将有关状态存入具体观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色又叫做具体被观察者(Concrete Observable)角色。

　　●　　抽象观察者(Observer)角色：为所有的具体观察者定义一个接口，在得到主题的通知时更新自己，这个接口叫做更新接口。

　　●　　具体观察者(ConcreteObserver)角色：存储与主题的状态自恰的状态。具体观察者角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。如果需要，具体观察者角色可以保持一个指向具体主题对象的引用。

但是这里面有一个问题，我们抽象出了一个抽象的观察者，但是在现实中，并不是所有的观察者都能抽象出一个抽象观察者（具有相同的动作和方法）例如：假设领导说我们今天放假，这里面领导就是我们的通知者，观察者呢，例如：有我，小张，我听说放假了，我比较宅，回家打游戏去。小张呢？喜欢购物，逛超市去。这就有了不同的行为，无法抽象，这个时候该怎么办呢？这就用到了事件委托机制。

这里还是以我喜欢的笔记本为例：

 这里用到了反射机制：其实思考一下，跟我们原来的观察者模式哪个地方不同呢？就是方法的调用，不是同一个方法，为了区分方法的不同，我们需要传入方法的名字，参数，还有哪个类的方法。

具体事件：

     

public class Event {
	// 要执行方法的对象
	private Object object;
	// 要执行的方法名称
	private String methodName;
	// 要执行方法的参数
	private Object[] params;
	// 要执行方法的参数类型
	private Class[] paramTypes;

	public String getMethodName() {
		return methodName;
	}

	public void setMethodName(String methodName) {
		this.methodName = methodName;
	}

	public Object[] getParams() {
		return params;
	}

	public void setParams(Object[] params) {
		this.params = params;
	}

	public Event() {

	}

	public Event(Object object, String methodName, Object... args) {
		this.object = object;
		this.methodName = methodName;
		this.params = args;
		contractParamTypes(this.params);
	}

	// 根据参数数组生成参数类型数组
	private void contractParamTypes(Object[] params) {
		this.paramTypes = new Class[params.length];
		for (int i = 0; i < params.length; i++) {
			this.paramTypes[i] = params[i].getClass(); //获取参数的类型，应该都是封装类
		}
	}

	public Object getObject() {
		return object;
	}

	// 若干setter getter省略
	public void setParamTypes(Class[] paramTypes) {
		this.paramTypes = paramTypes;
	}

	// 执行该 对象的该方法
	public void invoke() throws Exception {
		Method method = object.getClass().getMethod(this.getMethodName(),
				this.getParamTypes());
		if (null == method) {
			return;
		}
		method.invoke(this.getObject(), this.getParams());
	}

	public Class[] getParamTypes() {
		return paramTypes;
	}
}

事件处理：

public class EventHandler {
	 //是用一个List   
    private List<Event> objects;   
       
    public EventHandler(){   
        objects=new ArrayList<Event>();   
    }   
    //添加某个对象要执行的事件，及需要的参数   
    public void addEvent(Object object,String methodName,Object...args){   
    	
        objects.add(new Event(object,methodName,args));   
    }   
    //通知所有的对象执行指定的事件   
    public void notifyX() throws Exception{   
        for(Event e : objects){   
            e.invoke();   
          
        }   
        
    }   
    
}

抽象的通知者：

//抽象类的通知者
public abstract class Notifyers {

	EventHandler e = new EventHandler();

	abstract void change();

	void addListener(Object object, String methodName, Object... args) {

		e.addEvent(object, methodName, args);

	}

	public void Notify(){
		
		try {
			e.notifyX();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	
}

具体的通知者：

public class NotifyA extends Notifyers {

	//具体的通知者
	public NotifyA() {
		
		
	}

	@Override
	public void change() {
		
		System.out.println("京东新年笔记本大减价！");

		this.Notify();
	}

}

具体的观察者：平民

public class Nomer {

	public Nomer() {

	}

	// 具体类的观察者平民，不依赖于抽象，毕竟有时候，执行相同的方法和动作是不现实的
	public void buy() {

		System.out.println("哈哈，太好了，我等屌丝也可以用雷神了！");

	}

}

具体的观察者：土豪

	public Tuhao() {

	}

	// 具体类的观察者土豪，不依赖于抽象，毕竟有时候，执行相同的方法和动作是不现实的
	public void buyAlot(String str) {

		System.out.println("买几个外星人呢？" + " 送弟弟妹妹！有钱就是任性！！" + str);

	}

}

测试：

	public static void main(String[] args) {

		Notifyers n = new NotifyA();
		Nomer nm = new Nomer();
		Tuhao t = new Tuhao();
		n.addListener(nm, "buy");
		n.addListener(t, "buyAlot", "哈哈哈哈！！好爽！");
		n.change();

	}

结果：

京东新年笔记本大减价！
哈哈，太好了，我等屌丝也可以用雷神了！
买几个外星人呢？ 送弟弟妹妹！有钱就是任性！！哈哈哈哈！！好爽！