设计模式之监听器模式

监听器模式，主要由3个角色组成：事件（EventObject），监听器（EventListener），事件发布者（EventPublish）。

其核心流程便是，由事件发布者发布事件，在事件发布前后分别放置监听器。

其代码示例如下：

1.事件

public class MethodExecutionEvent   extends EventObject {
    private static final long serialVersionUID = -71960369269303337L;
    private String methodName;
    public MethodExecutionEvent(Object source) {
        super(source);
    }
    public MethodExecutionEvent(Object source,String methodName)
    {
        super(source);
        this.methodName = methodName;
    }
    public String getMethodName() {
        return methodName;
    }
    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }
}

2.监听器

public interface MethodExecutionEventListener extends EventListener {
    /**
     3
     * 处理方法开始执行的时候发布的MethodExecutionEvent事件
     */
    void onMethodBegin(MethodExecutionEvent evt);
    /**
     4
     * 处理方法执行将结束时候发布的MethodExecutionEvent事件
     */
    void onMethodEnd(MethodExecutionEvent evt);

}


public class SimpleMethodExecutionEventListener implements MethodExecutionEventListener {

    public void onMethodBegin(MethodExecutionEvent evt) {
        String methodName = evt.getMethodName();
        System.out.println("start to execute the method[" + methodName + "].");
    }

    public void onMethodEnd(MethodExecutionEvent evt) {
        String methodName = evt.getMethodName();
        System.out.println("finished to execute the method[" + methodName + "].");
    }
}

3.事件发布，设置监听器

public class MethodExeuctionEventPublisher {
    private List<MethodExecutionEventListener> listeners = new
            ArrayList<MethodExecutionEventListener>();

    public void methodToMonitor() {
        MethodExecutionEvent event2Publish =
                new MethodExecutionEvent(this, "methodToMonitor");
        publishEvent("BEGIN", event2Publish);
// 执行实际的方法逻辑
        System.out.println("执行方法逻辑。。。。");
// ...
        publishEvent("END", event2Publish);
    }

    protected void publishEvent(String status,
                                MethodExecutionEvent methodExecutionEvent) {
        List<MethodExecutionEventListener> copyListeners =
                new ArrayList<MethodExecutionEventListener>(listeners);
        for (MethodExecutionEventListener listener : copyListeners) {
            if ("BEGIN".equals(status))
                listener.onMethodBegin(methodExecutionEvent);
            else
                listener.onMethodEnd(methodExecutionEvent);
        }
    }

    public void addMethodExecutionEventListener(MethodExecutionEventListener listener) {
        this.listeners.add(listener);
    }

    public void removeListener(MethodExecutionEventListener listener) {
        if (this.listeners.contains(listener))
            this.listeners.remove(listener);
    }

    public void removeAllListeners() {
        this.listeners.clear();
    }

    public static void main(String[] args) {
        MethodExeuctionEventPublisher eventPublisher =
                new MethodExeuctionEventPublisher();
        eventPublisher.addMethodExecutionEventListener(new
                SimpleMethodExecutionEventListener());
        eventPublisher.methodToMonitor();
    }
}

可以看到，监听器模式其实和AOP有一定的相似之处。