事件其实就是系统级别的消息。消息的概念更广一些，通常一个对象向另一个对象的请求（Request）就是一条消息。而事件往往是由系统发出来的，经由操作系统到达应用程序来处理，是“反向”的消息。我们和一个应用程序（应用服务或应用系统）交互，看上去我们是和应用直接交互，事实上我们是先和OS交互，我们要先和硬件交互（敲击键盘，点击鼠标，触屏，其他输入设备），而硬件发出中断给驱动程序，这个时候才到软件处理层（此时的硬件“中断”已经转化成了软件中定义的“事件”）。OS是最先接触到这些事件的软件（驱动可以认为是OS的一部分）。OS通过事件调度把这些事件转化为相应的消息传递给合适的应用程序去处理。
 这个时候，才轮到我们的应用系统来响应这些事件。我们看上去好像是直接接收到用户的事件，其实在软件之下已经转了一圈，反向的抛给了我们上层的应用。所以事件有别于普通的消息，它是反向传递的。
   事件处理机制，一般都使用Observer设计模式。一个系统处理事件，就如同要处理回调一样。在当前的很多Framework里，处理事件一般都由框架来完成。我们自己的软件只要去实现框架给的事件处理接口就可以了。比如在symbian系统里，响应事件的类对象是控件（CCoeControl），其接口类似HandleKeyEventL( const
 TKeyEvent& aKeyEvent,TEventCode aType)。这样，要处理事件，只要override该函数就可以了。
  事件通常在系统构建前就是预先知道的。比如鼠标单击事件，双击事件，触屏手势（点击，长按，拖动，快速滑动，双击，捏，两个手指长按），键盘事件，定时器事件等等。只有预先知道，我们的系统才能写代码去处理各种事件（回调接口）。
 
  我们之所以要把事件定义为系统级别的消息，就是因为这些事件都包含了硬件“中断”，而我们软件内部，组件模块间也有很多类似的中断机制，我们把它们成为回调消息，这些消息是我们应用程序中的下层模块向上层模块抛出的消息，机制上很类似OS（Framework）向我们的应用程序抛事件。
  鉴于广大的文章都把事件做了扩充，即非系统事件的消息也统称为事件，这里也有必要继续扩充一下这个话题。
  除了硬件中断产生的事件，还有一类是软件自定义的事件（消息）：比如绘制消息就是这样一类。这类消息可以同系统事件一样进入事件（消息）队列，又框架来派发，也可以指定目标对象去处理。前者一般是postEvent,后者sendEvent。前者是异步的，后者是同步的。对于应用程序来说，有时可以不用区分消息的来源到底是系统硬件产生的还是程序自身产生的，只要做好各种事件（消息）的处理函数（回调）就可以了。这样的设计使得处理事件的模块（或派发模块）更加简单些。
  事件（消息）在对象间的传递一般是从底层向高层传递的。我们可以在每个可能处理事件的对象上设置消息过滤器，这样可以决定该对象是处理该事件（消息）还是忽略之，还可以决定是把消息继续向上传播还是就此中断消息的传递。
 
  关于消息，可以参考之间的文章：《消息的本质》

http://blog.csdn.net/coolmeme/archive/2010/11/29/6042464.aspx 

事件机制 

事件冒泡：事件从当前元素对象触发，然后向上层元素搜索相同对象事件并触发（直搜到document节点）。IE事件默认都只这种类型的事件。 

事件捕获：从document节点开始搜索事件，然后向下层搜索相同对象事件并触发，直到当前元素节点 

阻止事件冒泡的方法 

ie支持事件冒泡 

火狐支持 捕获和冒泡两种 

w3c支持 e.stopPropagation()，IE则是使用e.cancelBubble = true

Java事件机制包括三个部分：事件、事件源、事件监听器。

 

1. 事件

事件一般继承自java.util.EventObject类，封装了事件源对象及跟事件相关的信息。

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;  
    }  
}  

2. 事件源

事件源是事件发生的地方，由于事件源的某项属性或状态发生了改变(比如BUTTON被单击、TEXTBOX的值发生改变等等)导致某项事件发生。换句话说就是生成了相应的事件对象。因为事件监听器要注册在事件源上，所以事件源类中应该要有盛装监听器的容器(List、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的值发生变化时，触发事件。  
    public void setName(String name) {  
        if(!this.name.equals(name)){  
            this.name = name;  
            notifies();  
        }        
    }  
}

2. 事件监听器

事件监听器实现java.util.EventListener接口，注册在事件源上，当事件源的属性或状态改变时，取得相应的监听器调用其内部的回调方法。

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

测试类

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");  
    }  
}

事件、事件源、监听器三者之间的联系

事件源-----产生----->事件------>被事件监听器发现------>进入事件处理代码

import java.awt.Frame;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class DemoAction extends Frame {//窗口就是事件源
    public DemoAction() {
        this.setTitle("窗口关闭");
        this.setLocation(400, 200);
        this.setSize(360, 280);   
        //给窗口绑定一个事件监听器
        this.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {//事件WindowEvent
                System.exit(0);//关闭窗口事件, 那么退出jvm
            }
        });
        this.setVisible(true);
    }
 
    public static void main(String[] args) {
        new DemoAction();
    }
}

Java事件机与观察者模式的关系

Java事件机制抽象于设计模式中的观察者模式https://blog.csdn.net/pange1991/article/details/81187882

两者之间对比 https://blog.csdn.net/axuan_k/article/details/78803382

Java web项目中事件机制的运用

tomcat等容器启动时会解析web.xml配置。

<listener>标签就是监听器的配置。

例如Spring的监听器

<listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener>

ContextLoaderListener就是监听器，含有一个contextInitialized方法

    public void contextInitialized(ServletContextEvent event) {
        this.initWebApplicationContext(event.getServletContext());
    }

ServletContextEvent是事件

ServletContext是事件源

tomcat源码中StandardContext类的listenerStart()方法是关键入口，关键代码如下

...
fireContainerEvent("beforeContextInitialized", listener);
if (noPluggabilityListeners.contains(listener)) {
    listener.contextInitialized(tldEvent);
} else {
    listener.contextInitialized(event);
}
fireContainerEvent("afterContextInitialized", listener);
...

tomcat在加载完ServletContext后，就会触发web.xml中配置的监听器。

可以看下《Java Web项目启动加载顺序》

其他Java事件的应用例子

zookeeper对节点的监听也是基于Java事件机制的实现

redis事件机制

阅读数：725
redis并没有采用libevent库作为事件机制的底层实现，而是自己对io多路复用进行了封装，即可以采用select、epoll、evport、kqueue作为底层的实现。redis客户端与服务端进行通信时，redis提供了命令事件(也就是文件事件)。另外redis还提供了定时事件，用于对系统实时性要求进行处理，以及处理用户的业务需求。
先来看下redis事件机制的整体结构, 接下来的每个小结都围绕这个结构进行分析。

一、创建/监听socket
redis服务端在初始化函数initServer中会进行创建socket、绑定socket的操作。将服务端的指定ip或者所有ip都设置为可以监听来自客户端的连接请求。
//创建套接字、绑定套接字
int listenToPort(int port, int *fds, int *count);
参数port指绑定socket的具体端口
fds用于存储所有绑定的socket, 例如："假设服务端有两个ip：192.168.100.10 ， 192.168.100.11，如果对这两个ip都进行绑定，则fds中将存储绑定后的两个套接字fd"
count 用于存储具体有多少个套接字进行了绑定
          创建并绑定socket后、服务端可以在这些socket上监听来自客户端的连接请求。
二、创建事件管理器
redis服务端在初始化函数initServer中，会创建一个事件管理器对象，用于管理命令事件、时间事件。函数aeCreateEventLoop将创建一个事件管理器，setsize参数指的是socket描述符的个数，服务端初始化时将该参数设为最大socket个数。函数将返回一个事件管理器对象。
[cpp] view plain copy
aeEventLoop *aeCreateEventLoop(int setsize)   
{  
    aeEventLoop *eventLoop;  
    int i;  
    // 创建事件状态结构  
    if ((eventLoop = zmalloc(sizeof(*eventLoop))) == NULL)   
    goto err;  
  
    <span style="color:#ff0000;">// 创建未就绪事件表、就绪事件表</span>  
    eventLoop->events = zmalloc(sizeof(aeFileEvent)*setsize);  
    eventLoop->fired = zmalloc(sizeof(aeFiredEvent)*setsize);  
    if (eventLoop->events == NULL || eventLoop->fired == NULL)   
    goto err;  
      
    // 设置数组大小  
    eventLoop->setsize = setsize;  
    // 初始化执行最近一次执行时间  
    eventLoop->lastTime = time(NULL);  
  
    // 初始化时间事件结构  
    eventLoop->timeEventHead = NULL;  
    eventLoop->timeEventNextId = 0;  
<span style="color:#ff0000;">    //将多路复用io与事件管理器关联起来</span>  
    if (aeApiCreate(eventLoop) == -1)  
        goto err;  
  
    // 初始化监听事件  
    for (i = 0; i < setsize; i++)  
        eventLoop->events[i].mask = AE_NONE;  
  
    // 返回事件循环  
    return eventLoop;  
err:  
   ...  
}  
1、首先创建一个aeEventLoop对象
2、创建一个未就绪事件表、就绪事件表。events指针指向未就绪事件表、fired指针指向就绪事件表。表的内容在后面添加具体事件时进行初始化。
3、调用aeApiCreate创建一个epoll实例
[cpp] view plain copy
static int aeApiCreate(aeEventLoop *eventLoop)   
{  
    aeApiState *state = zmalloc(sizeof(aeApiState));  
  
    // 初始化epoll就绪事件表  
    state->events = zmalloc(sizeof(struct epoll_event)*eventLoop->setsize);  
  
    // 创建 epoll 实例  
    state->epfd = epoll_create(1024); /* 1024 is just a hint for the kernel */  
  
    // 事件管理器与epoll关联  
    eventLoop->apidata = state;  
    return 0;  
}  
[cpp] view plain copy
typedef struct aeApiState   
{  
    // epoll_event 实例描述符  
    int epfd;  
    <span style="color:#ff0000;">// 存储epoll就绪事件表</span>  
    struct epoll_event *events;  
} aeApiState;  
 aeApiCreate内部将创建一个aeApiState对象，并将对象存储在apidata中，这样aeApiCreate与aeApiState就关联起来了。
对象中epfd存储epoll的标识，events是一个就绪事件数组，当有事件发生时，所有发生的事件都将存储在这个数组中。这个就绪事件数组由应用层开辟空间、内核负责把所有发生的事件填充到该数组。
三、创建命令事件(也就是文件事件)
创建来事件管理器后、接下来就可以把具体的事件插入到事件管理器中。
[cpp] view plain copy
typedef struct aeFileEvent   
{  
    // 监听事件类型掩码，// 值可以是 AE_READABLE 或 AE_WRITABLE ，  
    // 或者 AE_READABLE | AE_WRITABLE  
    int mask;   
    // 读事件处理器  
    aeFileProc *rfileProc;  
    // 写事件处理器  
    aeFileProc *wfileProc;  
    // 多路复用库的私有数据  
    void *clientData;  
} aeFileEvent;  
 aeFileEvent是命令事件结构，对于每一个具体的事件，都有读处理函数、写处理函数等。
[cpp] view plain copy
int aeCreateFileEvent(aeEventLoop *eventLoop, int fd, int mask,aeFileProc *proc, void *clientData)  
{  
    // 取出文件事件结构  
    aeFileEvent *fe = &eventLoop->events[fd];  
  
    // 监听指定 fd 的指定事件  
    if (aeApiAddEvent(eventLoop, fd, mask) == -1)  
        return AE_ERR;  
  
    // 设置文件事件类型，以及事件的处理器  
    fe->mask |= mask;  
    if (mask & AE_READABLE)   
    fe->rfileProc = proc;  
    if (mask & AE_WRITABLE)   
    fe->wfileProc = proc;  
  
    // 私有数据  
    fe->clientData = clientData;  
    return AE_OK;  
}  
 创建一个具体命令事件时，参数fd指的是具体的soket套接字，proc指fd产生事件时，具体的处理过程。
根据fd为索引在未就绪表中找到相应的元素，该数组元素就被fd占用。这个过程就相当于把fd插入到未就绪事件表中。接下来填充事件的回调、参数、事件类型等参数。
除了将事件插入到未就绪表中外，还需要把fd对应的事件插入到具体的io复用中，本例为epoll。
[cpp] view plain copy
static int aeApiAddEvent(aeEventLoop *eventLoop, int fd, int mask)   
{  
    aeApiState *state = eventLoop->apidata;  
    struct epoll_event ee;  
  
    //如果 fd 没有关联任何事件，那么这是一个 ADD 操作。如果已经关联了某个/某些事件，那么这是一个 MOD 操作。  
    int op = eventLoop->events[fd].mask == AE_NONE ?  
           EPOLL_CTL_ADD : EPOLL_CTL_MOD;  
  
    // 注册事件到 epoll  
    ee.events = 0;  
    mask |= eventLoop->events[fd].mask; /* Merge old events */  
    if (mask & AE_READABLE)   
    ee.events |= EPOLLIN;  
    if (mask & AE_WRITABLE)   
    ee.events |= EPOLLOUT;  
  
    ee.data.u64 = 0; /* avoid valgrind warning */  
    ee.data.fd = fd;  
    //将事件加入epoll中  
    if (epoll_ctl(state->epfd,op,fd,&ee) == -1)  
        return -1;  
  
    return 0;  
}  
epoll内部使用红黑树维护每一个事件。红黑树中的每一个节点都代表一个fd。当应用层注册一个命令事件时，会将事件fd插入到红黑树中。应用层删除一个事件时，也相应会从红黑树中删除一个事件节点。
因此创建一个事件时、将会发生下面3个操作
1、创建事件并给事件赋值
2、将事件插入到未就绪事件表
3、将事件插入到epoll维护的红黑树中。
四、事件循环
程序将使用一个while死循环，一直维持着服务端的运转。
[cpp] view plain copy
//事件处理器的主循环  
void aeMain(aeEventLoop *eventLoop)   
{  
    eventLoop->stop = 0;  
  
    while (!eventLoop->stop)   
    {  
  
        // 如果有需要在事件处理前执行的函数，那么运行它  
        if (eventLoop->beforesleep != NULL)  
            eventLoop->beforesleep(eventLoop);  
  
        // 开始处理事件  
        aeProcessEvents(eventLoop, AE_ALL_EVENTS);  
    }  
}  
 aeProcessEvents将开始进行事件处理。即处理定时事件也处理命令事件。定时事件与命令事件可以同时发生。定时事件将在下一节讲述，本节只讲述命令事件。
[cpp] view plain copy
// 处理文件事件，阻塞时间由 tvp 决定  
numevents = aeApiPoll(eventLoop, tvp);  
for (j = 0; j < numevents; j++)   
{  
    // 从已就绪数组中获取事件  
<span style="white-space:pre">    </span>aeFileEvent *fe = &eventLoop->events[eventLoop->fired[j].fd];  
    int mask = eventLoop->fired[j].mask;  
    int fd = eventLoop->fired[j].fd;  
    int rfired = 0;  
  
    // 读事件  
    if (fe->mask & mask & AE_READABLE)   
    {  
          // rfired 确保读/写事件只能执行其中一个  
          rfired = 1;  
          //调用读处理函数  
          fe->rfileProc(eventLoop,fd,fe->clientData,mask);  
    }  
  
    // 写事件  
    if (fe->mask & mask & AE_WRITABLE)   
    {  
        //调用写处理函数  
         if (!rfired || fe->wfileProc != fe->rfileProc)  
          fe->wfileProc(eventLoop,fd,fe->clientData,mask);  
    }  
}  
aeApiPoll调用时将阻塞，直到有事件发生，或者超时，该函数才返回。函数返回时，已就绪表中存储了所有就绪事件。
遍历所有已经发生的事件，根据fd在未就绪表中找到相应的事件，然后调用事件处理函数。
当一轮事件执行完后，程序又进入最外层的事件循环中，接着处理剩于的事件。
aeApiPoll内部调用epoll系统调用，等待指定事件发生或者超时。如果有事件发生则eploo_wait返回非0，如果为超时，则返回0。
当有事件发生时，内核会把所有发生的事件由内核层拷贝到应用层。eploo_wait返回时state->events就是保存是由内核返回的就绪表。

[cpp] view plain copy
static int aeApiPoll(aeEventLoop *eventLoop, struct timeval *tvp)   
{  
    aeApiState *state = eventLoop->apidata;  
    int retval, numevents = 0;  
  
    // 等待时间  
    retval = epoll_wait(state->epfd,state->events,eventLoop->setsize,  
            tvp ? (tvp->tv_sec*1000 + tvp->tv_usec/1000) : -1);  
  
    // 有至少一个事件就绪？  
    if (retval > 0)   
    {  
        int j;  
  
        // 为已就绪事件设置相应的模式  
        // 并加入到 eventLoop 的 fired 数组中  
        numevents = retval;  
        for (j = 0; j < numevents; j++)   
    {  
            int mask = 0;  
            struct epoll_event *e = <span style="color:#ff0000;">state->events</span>+j;  
  
            if (e->events & EPOLLIN)  
        mask |= AE_READABLE;  
            if (e->events & EPOLLOUT)  
        mask |= AE_WRITABLE;  
            if (e->events & EPOLLERR)   
        mask |= AE_WRITABLE;  
            if (e->events & EPOLLHUP)  
        mask |= AE_WRITABLE;  
  
            eventLoop->fired[j].fd = e->data.fd;  
            eventLoop->fired[j].mask = mask;  
        }  
    }  
      
    // 返回已就绪事件个数  
    return numevents;  
}  
 内核已经把就绪事件从内核拷贝到了应用层的epoll就绪表state->events中。之后aeApiPoll会把epoll就绪表state->events中的就绪事件拷贝到fired就绪表中
五、删除事件
当不在需要某个事件时，需要把事件删除掉。例如: 如果fd同时监听读事件、写事件。当不在需要监听写事件时，可以把该fd的写事件删除。
[cpp] view plain copy
void aeDeleteFileEvent(aeEventLoop *eventLoop, int fd, int mask)  
{  
  
    // 取出文件事件结构  
    aeFileEvent *fe = &eventLoop->events[fd];  
  
    // 未设置监听的事件类型，直接返回  
    if (fe->mask == AE_NONE)  
    return;  
  
    // 计算新掩码  
    fe->mask = fe->mask & (~mask);  
  
    // 取消对给定 fd 的给定事件的监视  
    aeApiDelEvent(eventLoop, fd, mask);  
}  
[cpp] view plain copy
static void aeApiDelEvent(aeEventLoop *eventLoop, int fd, int delmask)   
{  
    aeApiState *state = eventLoop->apidata;  
    struct epoll_event ee;  
    int mask = eventLoop->events[fd].mask & (~delmask);  
  
    ee.events = 0;  
    if (mask & AE_READABLE)   
    ee.events |= EPOLLIN;  
    if (mask & AE_WRITABLE)   
    ee.events |= EPOLLOUT;  
      
    ee.data.u64 = 0; /* avoid valgrind warning */  
    ee.data.fd = fd;  
    if (mask != AE_NONE)   
    {  
        epoll_ctl(state->epfd,EPOLL_CTL_MOD,fd,&ee);  
    }   
    else   
    {  
        epoll_ctl(state->epfd,EPOLL_CTL_DEL,fd,&ee);  
    }  
}  
 删除的过程可以总结为以下几个步骤
1、根据fd在未就绪表中查找到事件
2、取消该fd对应的相应事件标识符
3、通知内核，内核会将红黑树上的相应事件也给取消。