利用事件委托弥补观察者模式不足

前两篇我们自己首先实现了一个观察者模式，我们再利用Java自带的接口和类实现了观察者模式，但其实两种观察者模式存在不足的地方。之前两种观察者模式的观察者（订阅者）都是实现了一个同一个接口，实现了接口中的update方法，但是如果两个观察者风马牛不相及，完全无关呢？或者他们的方法名不一样这个时候该怎么办呢？《大话设计模式》中C#提供了事件委托，但在Java中比没有提供。此时，我们可以利用Java的反射机制来实现事件委托从而来弥补观察者模式的不足。

我们先来看看客户端的测试代码，直观的感受一下和之前的观察者模式有什么不同。

package day_11_event;

import java.util.Date;

/**
 * 利用事件委托
 * @author turbo
 *
 * 2016年9月16日
 */
public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Notifier notifier = new ConcreteNotifier();
        Observer1 observer1 = new Observer1();
        Observer2 observer2 = new Observer2();
        
        notifier.attach(observer1, "changeState1", new Date());
        notifier.attach(observer2, "changeState2", new Date());
        
        notifier.notifyObj();
    }

}

我们的观察者observer1、observer2是两个不相关的观察者，可以看到两者需要改变状态的方法分别是changeState1、changeState2，如果使用之前的观察者模式则是实现同一个接口实现同一个方法。如果遇到现在这种情况，则没办法了。

由于Java并没有为我们提供事件委托，我们首先需要自己实现一个事件类。

package day_11_event;

import java.lang.reflect.Method;

/**
 * 事件类
 * @author turbo
 *
 * 2016年9月16日
 */
public class Event {
    private Object object;
    private String methodName;
    private Object[] params;
    private Class[]    paramsType;
    
    public Event(Object object, String methodName, Object...args){
        this.object = object;
        this.methodName = methodName;
        this.params = args;
        contractParamTypes(this.params);
    }

    /**
     * @param params2
     */
    private void contractParamTypes(Object[] params2) {
        this.paramsType = new Class[params2.length];
        for (int i = 0; i < params.length; i++){
            this.paramsType[i] = params[i].getClass();
        }
    }
    
    public void invoke() throws Exception{
        Method method = object.getClass().getMethod(this.methodName, this.paramsType);
        if (null == method){
            return ;
        }
        method.invoke(this.object, this.params);
    }
}

利用反射实现一个事件类后，我们还需要实现一个管理事件的类。

package day_11_event;

import java.util.ArrayList;
import java.util.List;

/**
 * 管理事件类
 * @author turbo
 *
 * 2016年9月16日
 */
public class EventHandler {
    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 notifyObj() throws Exception{
        for (Event event : objects){
            event.invoke();
        }
    }
}

这样我们就利用Java完成了我们事件委托的基本模型。

基本工作做好后，我们来实现观察者模式。

package day_11_event;

/**
 * 抽象通知者
 * @author turbo
 *
 * 2016年9月16日
 */
public abstract class Notifier {
    private EventHandler eventHandler = new EventHandler();

    public EventHandler getEventHandler() {
        return eventHandler;
    }

    public void setEventHandler(EventHandler eventHandler) {
        this.eventHandler = eventHandler;
    }

    public abstract void attach(Object object, String methodName, Object...args);
    
    public abstract void notifyObj();
}

package day_11_event;

/**
 * 具体通知者
 * @author turbo
 *
 * 2016年9月16日
 */
public class ConcreteNotifier extends Notifier {

    /* (non-Javadoc)
     * @see day_11_event.Notifier#attach(java.lang.Object, java.lang.String, java.lang.Object[])
     */
    @Override
    public void attach(Object object, String methodName, Object... args) {
        this.getEventHandler().addEvent(object, methodName, args);
    }

    /* (non-Javadoc)
     * @see day_11_event.Notifier#notifyObj()
     */
    @Override
    public void notifyObj() {
        try {
            this.getEventHandler().notifyObj();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

通知者我们同样还是定义了一个抽象类，并实现了一个具体的通知类。

下面是两个观察者，两个观察者没有任何关系，不必实现同一个接口。

package day_11_event;

import java.util.Date;

/**
 * 观察者1
 * @author turbo
 *
 * 2016年9月16日
 */
public class Observer1 {
    public Observer1(){
        System.out.println("Observer1状态1");
    }
    
    public void changeState1(Date date){
        System.out.println("Observer1改变状态" + date);
    }
}

package day_11_event;

import java.util.Date;

/**
 * 观察者2
 * @author turbo
 *
 * 2016年9月16日
 */
public class Observer2 {
    public Observer2(){
        System.out.println("Obsever2状态1");
    }
    
    public void changeState2(Date date){
        System.out.println("Observer2改变状态" + date);
    }
}

客户端在开头给出，这里我们不再给出。利用事件委托确实为我们解决了观察者完全不相关，但是又想他们俩都收到通知的难题。这得归功于Java的反射机制，在之前的抽象工厂模式中我们也利用了Java的反射机制。看似平时用得不多的反射，但是却能为我们做很多事情，Java并不是想象中的那么简单。