JDK自带的监听器模式

 《观察者模式与监听模式

 《JDK自带的观察者模式

JDK自带的监听器模式

ApplicationEvent事件机制源码分析

监听模式

   当事件源对象上发生操作时,将会调用事件监听器的一个方法,并在调用该方法时把事件对象传递过去。

监听器模式中的3个角色:

  • 事件源:具体的事件源,注册特定的监听,才可以对事件进行响应。
  • 事件对象:封装了事件源对象以及事件相关的信息,是在事件源和事件监听器之间传递信息的角色。
  • 事件监听器:监听事件,并进行事件处理或者转发,必须注册在事件源上。

一句话,事件源产生事件,事件带有事件源,监听器监听事件。

 

JDK中当然有现成的事件模型类 

监听器模式和观察者模式大同小异,但要比观察者模式复杂一些。一些逻辑需要手动实现,比如注册监听器,删除监听器,获取监听器数量等等,这里的eventObject也是你自己实现的。

先看看JDK中的监听器类图

角色之三:事件监听器

package java.util;

/**
 * A tagging interface that all event listener interfaces must extend.
 * @since JDK1.1
 */
public interface EventListener {
}

简单到不能再简单了,对吧,甚至连一个声明的方法都没有,那它存在的意义在哪?还记得面向对象中的上溯造型吗,所以它的意义就在于告诉所有的调用者,我是一个监听器。

角色之二&一:事件对象及事件对象里的事件源

再来看看事件,即Event或EventObject结尾的那个类,里面含有getSource方法,返回的就是事件源,

package java.util;

/**
 * <p>
 * The root class from which all event state objects shall be derived.
 * <p>
 * All Events are constructed with a reference to the object, the "source",
 * that is logically deemed to be the object upon which the Event in question
 * initially occurred upon.
 *
 * @since JDK1.1
 */

public class EventObject implements java.io.Serializable {

    private static final long serialVersionUID = 5516075349620653480L;

    /**
     * The object on which the Event initially occurred.
     */
    protected transient Object  source;

    /**
     * Constructs a prototypical Event.
     *
     * @param    source    The object on which the Event initially occurred.
     * @exception  IllegalArgumentException  if source is null.
     */
    public EventObject(Object source) {
        if (source == null)
            throw new IllegalArgumentException("null source");

        this.source = source;
    }

    /**
     * The object on which the Event initially occurred.
     *
     * @return   The object on which the Event initially occurred.
     */
    public Object getSource() {
        return source;
    }

    /**
     * Returns a String representation of this EventObject.
     *
     * @return  A a String representation of this EventObject.
     */
    public String toString() {
        return getClass().getName() + "[source=" + source + "]";
    }
}

这个类也很简单,如果说观察者模式中的上层类和结果还带了不少逻辑不少方法的话,那么事件驱动模型中的上层类和接口简直看不到任何东西。没错,

事件驱动模型中,JDK的设计者们进行了最高级的抽象,就是让上层类只是代表了:我是一个事件(含有事件源),或,我是一个监听者!

 示例:

package com.dxz.listener2;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/**
 * 事件源.
 */
public class EventSourceObject {
    private String name;
    // 监听器容器
    private Set<CusEventListener> listener;

    public EventSourceObject() {
        this.listener = new HashSet<CusEventListener>();
        this.name = "defaultname";
    }

    // 给事件源注册监听器
    public void addCusListener(CusEventListener cel) {
        this.listener.add(cel);
    }

    // 当事件发生时,通知注册在该事件源上的所有监听器做出相应的反应(调用回调方法)
    protected void notifies() {
        CusEventListener cel = null;
        Iterator<CusEventListener> iterator = this.listener.iterator();
        while (iterator.hasNext()) {
            cel = iterator.next();
            cel.fireCusEvent(new CusEvent(this));
        }
    }

    public String getName() {
        return name;
    }

    /**
     * 模拟事件触发器,当成员变量name的值发生变化时,触发事件。
     * @param name
     */
    public void setName(String name) {
        if (!this.name.equals(name)) {
            this.name = name;
            notifies();
        }
    }
}

package com.dxz.listener2;

import java.util.EventListener;

/**
 * 事件监听器,实现java.util.EventListener接口。定义回调方法,将你想要做的事放到这个方法下,因为事件源发生相应的事件时会调用这个方法。
 */
public class CusEventListener implements EventListener {
    // 事件发生后的回调方法
    public void fireCusEvent(CusEvent e) {
        EventSourceObject eObject = (EventSourceObject) e.getSource();
        System.out.println("My name has been changed!");
        System.out.println("I got a new name,named \"" + eObject.getName() + "\"");
    }
}

package com.dxz.listener2;

import java.util.EventObject;

/**
 * 事件类,用于封装事件源及一些与事件相关的参数.
 */
public class CusEvent extends EventObject {
    private static final long serialVersionUID = 1L;
    private Object source;// 事件源

    public CusEvent(Object source) {
        super(source);
        this.source = source;
    }

    public Object getSource() {
        return source;
    }

    public void setSource(Object source) {
        this.source = source;
    }
}

package com.dxz.listener2;

public class MainTest {

    public static void main(String[] args) {
        EventSourceObject object = new EventSourceObject();
        // 注册监听器
        object.addCusListener(new CusEventListener() {
            @Override
            public void fireCusEvent(CusEvent e) {
                super.fireCusEvent(e);
            }
        });
        // 触发事件
        object.setName("AiLu");
    }
}

结果:

My name has been changed!
I got a new name,named "AiLu"

 1. 事件

事件一般继承自java.util.EventObject类,封装了事件源对象及跟事件相关的信息。
2. 事件源
事件源是事件发生的地方,由于事件源的某项属性或状态发生了改变(比如BUTTON被单击、TEXTBOX的值发生改变等等)导致某项事件发生。换句话说就是生成了相应的事件对象。因为事件监听器要注册在事件源上,所以事件源类中应该要有盛装监听器的容器(List、Set等等)。
3. 事件监听器
事件监听器实现java.util.EventListener接口,注册在事件源上,当事件源的属性或状态改变时,取得相应的监听器调用其内部的回调方法。
事件、事件源、监听器三者之间的联系
事件源-----产生----->事件------>被事件监听器发现------>进入事件处理代码

 

posted on 2013-01-11 10:49  duanxz  阅读(10352)  评论(0编辑  收藏  举报