java监听mq事件 java监听事件原理

java事件监听器分为三部分：事件，事件源，监听器。

事件—事件状态对象,也就是发生了什么事件。用于listener的相应的方法之中，作为参数，一般存在与listerner的方法之中。（伴随着事件的发生，相应的状态通常都封装在事件状态对象中，该对象必须继承自java.util.EventObject。事件状态对象作为单参传递给应响应该事件的监听者方法中。发出某种特定事件的事件源的标识是：遵从规定的设计格式为事件监听者定义注册方法，并接受对指定事件监听者接口实例的引用。）

事件源—具体的事件源，比如说，你点击一个button，那么button就是event source，要想使button对某些事件进行响应，你就需要注册特定的listener（事件就是事件源中的一个状态）。这些方法都集中定义在事件监听者（EventListener）接口中，这个接口要继承 java.util.EventListener

监听器—对每个明确的事件的发生，都相应地定义一个明确的Java方法

—— 实例：

如果博客可以作为一个事件源，那么修改，新增，删除都是事件，可以这么写。

事件类

接口：

package event.events;

import java.util.EventObject;

public interface EventInfo{
    public String getDoType() ;
}

实现类：

package event.events;

import java.util.EventObject;

public class AddEvent extends EventObject implements EventInfo{
    private final String doType = "add";

    /**
     * Constructs a prototypical Event.
     *
     * @param source The object on which the Event initially occurred.
     * @throws IllegalArgumentException if source is null.
     */
    public AddEvent(Object source) {
        super(source);
    }

    @Override
    public String toString(){
        return doType;
    }

    @Override
    public String getDoType(){
        return doType;
    }
}

package event.events;

import java.util.EventObject;

public class DelEvent extends EventObject implements EventInfo {

    //事件类型
    public final String doType= "delete";

    /**
     * Constructs a prototypical Event.
     *
     * @param source The object on which the Event initially occurred.
     * @throws IllegalArgumentException if source is null.
     */
    public DelEvent(Object source) {
        super(source);
    }

    @Override
    public String toString(){
        return doType;
    }

    @Override
    public String getDoType() {
        return doType;
    }
}

package event.events;

import java.util.EventObject;

public class ModifyEvent extends EventObject implements EventInfo{
    private final String doType = "modify";

    /**
     * Constructs a prototypical Event.
     *
     * @param source The object on which the Event initially occurred.
     * @throws IllegalArgumentException if source is null.
     */
    public ModifyEvent(Object source) {
        super(source);
    }

    @Override
    public String toString(){
        return doType;
    }

    @Override
    public String getDoType() {
        return doType;
    }
}

监听器

接口

package event.eventListener;

import event.events.EventInfo;

import java.util.EventListener;

public interface EventListenerInfo extends EventListener {

    public default void handler(EventInfo eventInfo){
        System.out.println(eventInfo.toString());
    }

}

实现类

package event.eventListener;

import event.events.EventInfo;

public class AddEventListener implements EventListenerInfo{

    @Override
    public void handler(EventInfo object) {
        if(object.getDoType().equals("add"))
            System.out.println("新增文章。。。。");
        //进行后续操作
    }
}

package event.eventListener;

import event.events.EventInfo;

public class DelEventListener implements EventListenerInfo{

    @Override
    public void handler(EventInfo object) {
        if(object.getDoType().equals("delete"))
            System.out.println("删除文章。。。。");
        //进行后续操作
    }
}

package event.eventListener;

import event.events.EventInfo;

public class ModifyEventListener implements EventListenerInfo{

    @Override
    public void handler(EventInfo object) {
        if(object.getDoType().equals("modify"))
            System.out.println("修改文章。。。。");
        //进行后续操作
    }
}

事件源

package event;

import com.sun.org.apache.xpath.internal.SourceTree;
import event.eventListener.EventListenerInfo;
import event.events.AddEvent;
import event.events.DelEvent;
import event.events.EventInfo;
import event.events.ModifyEvent;

import java.util.Collection;
import java.util.EventObject;
import java.util.HashSet;
import java.util.Iterator;

/**
 * 1.事件源--事件发生的地方。如一个map集合，它上面发生的增删查改，就是事件；这个map
 *   就是事件源。
 * 2.这个事件源是一篇博客。
 * 3.我们可以创建多个事件源
 */
public class EventSource
{
    private Collection listeners;

    //给事件源注册监听器
    public void addDoListener(EventListenerInfo eventListener){
        if(listeners==null){
            listeners = new HashSet();
        }
        listeners.add(eventListener);
    }

    //给事件源注销监听器
    public void remvoeDolistener(EventListenerInfo eventListener){
        if(listeners == null){
            return;
        }
        listeners.remove(eventListener);
    }

    //触发删除事件
    public void fireDelEvent(){
        if(listeners==null)
            return;
        EventInfo ei = new DelEvent(this);
        notifies(ei);
    }

    //触发新建事件
    public void fireAddEvent(){
        if(listeners==null)
            return;
        EventInfo ei = new AddEvent(this);
        notifies(ei);
    }

    //触发修改事件
    public void fireModifyEvent(){
        if(listeners==null)
            return;
        EventInfo ei = new ModifyEvent(this);
        notifies(ei);
    }


    //当该事件源上有事件发生时，通知该事件源上的所有的监听器做出相应的反应
    public void notifies(EventInfo eventInfo){
        Iterator it = listeners.iterator();
        while (it.hasNext()){
            ((EventListenerInfo)it.next()).handler( eventInfo);
        }
    }
}

测试

package event;

import event.eventListener.AddEventListener;
import event.eventListener.DelEventListener;
import event.eventListener.ModifyEventListener;
import event.events.AddEvent;

public class Test {

    public static void main(String[] args) {
        EventSource es = new EventSource();      //一个博客事件源
        EventSource es2 = new EventSource();     //另一个博客的事件源

        //给每个事件源增加监听器
        es.addDoListener(new AddEventListener());
        es.addDoListener(new DelEventListener());
        es.addDoListener(new ModifyEventListener());

        es2.addDoListener(new AddEventListener());
        es2.addDoListener(new DelEventListener());
        es2.addDoListener(new ModifyEventListener());

        //事件发生
        es.fireAddEvent();
        es.fireModifyEvent();
        es.fireDelEvent();

        es2.fireAddEvent();
        es2.fireModifyEvent();
        es2.fireDelEvent();
    }
}

后记：其实可以把三个事件类放到一个类里面，用一个变量分别代表三种状态（新增，修改，删除），在EventListener中也可以放在同一个类中，可以根据事件的状态，进行不同的处理。这样做的可以随时根据当前状态判断发生的是什么事件。