利用事件委托彌補觀察者模式不足

前兩篇我們自己首先實現了一個觀察者模式，我們再利用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並不是想象中的那么簡單。