精华内容
下载资源
问答
  • 事件机制

    千次阅读 2010-12-07 15:22:00
    事件其实就是系统级别的消息。消息的概念更广一些,通常一个对象向另一个对象的请求(Request)就是一条消息。而事件往往是由系统发出来的,经由操作系统到达应用程序来处理,是“反向”的消息。我们和一个应用程序...

        事件其实就是系统级别的消息。消息的概念更广一些,通常一个对象向另一个对象的请求(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 

    展开全文
  • ie事件机制和火狐事件机制

    千次阅读 2017-03-28 10:27:15
    事件机制 事件冒泡:事件从当前元素对象触发,然后向上层元素搜索相同对象事件并触发(直搜到document节点)。IE事件默认都只这种类型的事件。 事件捕获:从document节点开始搜索事件,然后向下层搜索相同对象事件...

    事件机制
    事件冒泡:事件从当前元素对象触发,然后向上层元素搜索相同对象事件并触发(直搜到document节点)。IE事件默认都只这种类型的事件。
    事件捕获:从document节点开始搜索事件,然后向下层搜索相同对象事件并触发,直到当前元素节点
    阻止事件冒泡的方法
    ie支持事件冒泡
    火狐支持 捕获和冒泡两种
    w3c支持 e.stopPropagation(),IE则是使用e.cancelBubble = true

    展开全文
  • Java事件机制

    千次阅读 2018-07-28 12:27:27
    Java事件机制包括三个部分:事件、事件源、事件监听器。 1. 事件 事件一般继承自java.util.EventObject类,封装了事件源对象及跟事件相关的信息。 importjava.util.EventObject; /** *事件类,用于封装事件源...

    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事件机制

    千次阅读 2018-06-03 22:09:09
    redis事件机制阅读数:725redis并没有采用libevent库作为事件机制的底层实现,而是自己对io多路复用进行了封装,即可以采用select、epoll、evport、kqueue作为底层的实现。redis客户端与服务端进行通信时,redis提供...

    redis事件机制

    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个数。函数将返回一个事件管理器对象。

    1. aeEventLoop *aeCreateEventLoop(int setsize)   
    2. {  
    3.     aeEventLoop *eventLoop;  
    4.     int i;  
    5.     // 创建事件状态结构  
    6.     if ((eventLoop = zmalloc(sizeof(*eventLoop))) == NULL)   
    7.     goto err;  
    8.   
    9.     <span style="color:#ff0000;">// 创建未就绪事件表、就绪事件表</span>  
    10.     eventLoop->events = zmalloc(sizeof(aeFileEvent)*setsize);  
    11.     eventLoop->fired = zmalloc(sizeof(aeFiredEvent)*setsize);  
    12.     if (eventLoop->events == NULL || eventLoop->fired == NULL)   
    13.     goto err;  
    14.       
    15.     // 设置数组大小  
    16.     eventLoop->setsize = setsize;  
    17.     // 初始化执行最近一次执行时间  
    18.     eventLoop->lastTime = time(NULL);  
    19.   
    20.     // 初始化时间事件结构  
    21.     eventLoop->timeEventHead = NULL;  
    22.     eventLoop->timeEventNextId = 0;  
    23. <span style="color:#ff0000;">    //将多路复用io与事件管理器关联起来</span>  
    24.     if (aeApiCreate(eventLoop) == -1)  
    25.         goto err;  
    26.   
    27.     // 初始化监听事件  
    28.     for (i = 0; i < setsize; i++)  
    29.         eventLoop->events[i].mask = AE_NONE;  
    30.   
    31.     // 返回事件循环  
    32.     return eventLoop;  
    33. err:  
    34.    ...  
    35. }  

    1、首先创建一个aeEventLoop对象

    2、创建一个未就绪事件表、就绪事件表。events指针指向未就绪事件表、fired指针指向就绪事件表。表的内容在后面添加具体事件时进行初始化。

    3、调用aeApiCreate创建一个epoll实例

    1. static int aeApiCreate(aeEventLoop *eventLoop)   
    2. {  
    3.     aeApiState *state = zmalloc(sizeof(aeApiState));  
    4.   
    5.     // 初始化epoll就绪事件表  
    6.     state->events = zmalloc(sizeof(struct epoll_event)*eventLoop->setsize);  
    7.   
    8.     // 创建 epoll 实例  
    9.     state->epfd = epoll_create(1024); /* 1024 is just a hint for the kernel */  
    10.   
    11.     // 事件管理器与epoll关联  
    12.     eventLoop->apidata = state;  
    13.     return 0;  
    14. }  
    1. typedef struct aeApiState   
    2. {  
    3.     // epoll_event 实例描述符  
    4.     int epfd;  
    5.     <span style="color:#ff0000;">// 存储epoll就绪事件表</span>  
    6.     struct epoll_event *events;  
    7. } aeApiState;  
    aeApiCreate内部将创建一个aeApiState对象,并将对象存储在apidata中,这样aeApiCreate与aeApiState就关联起来了。

    对象中epfd存储epoll的标识,events是一个就绪事件数组,当有事件发生时,所有发生的事件都将存储在这个数组中。这个就绪事件数组由应用层开辟空间、内核负责把所有发生的事件填充到该数组。

    三、创建命令事件(也就是文件事件)

    创建来事件管理器后、接下来就可以把具体的事件插入到事件管理器中。

    1. typedef struct aeFileEvent   
    2. {  
    3.     // 监听事件类型掩码,// 值可以是 AE_READABLE 或 AE_WRITABLE ,  
    4.     // 或者 AE_READABLE | AE_WRITABLE  
    5.     int mask;   
    6.     // 读事件处理器  
    7.     aeFileProc *rfileProc;  
    8.     // 写事件处理器  
    9.     aeFileProc *wfileProc;  
    10.     // 多路复用库的私有数据  
    11.     void *clientData;  
    12. } aeFileEvent;  
    aeFileEvent是命令事件结构,对于每一个具体的事件,都有读处理函数、写处理函数等。
    1. int aeCreateFileEvent(aeEventLoop *eventLoop, int fd, int mask,aeFileProc *proc, void *clientData)  
    2. {  
    3.     // 取出文件事件结构  
    4.     aeFileEvent *fe = &eventLoop->events[fd];  
    5.   
    6.     // 监听指定 fd 的指定事件  
    7.     if (aeApiAddEvent(eventLoop, fd, mask) == -1)  
    8.         return AE_ERR;  
    9.   
    10.     // 设置文件事件类型,以及事件的处理器  
    11.     fe->mask |= mask;  
    12.     if (mask & AE_READABLE)   
    13.     fe->rfileProc = proc;  
    14.     if (mask & AE_WRITABLE)   
    15.     fe->wfileProc = proc;  
    16.   
    17.     // 私有数据  
    18.     fe->clientData = clientData;  
    19.     return AE_OK;  
    20. }  
    创建一个具体命令事件时,参数fd指的是具体的soket套接字,proc指fd产生事件时,具体的处理过程。
    根据fd为索引在未就绪表中找到相应的元素,该数组元素就被fd占用。这个过程就相当于把fd插入到未就绪事件表中。接下来填充事件的回调、参数、事件类型等参数。

    除了将事件插入到未就绪表中外,还需要把fd对应的事件插入到具体的io复用中,本例为epoll。

    1. static int aeApiAddEvent(aeEventLoop *eventLoop, int fd, int mask)   
    2. {  
    3.     aeApiState *state = eventLoop->apidata;  
    4.     struct epoll_event ee;  
    5.   
    6.     //如果 fd 没有关联任何事件,那么这是一个 ADD 操作。如果已经关联了某个/某些事件,那么这是一个 MOD 操作。  
    7.     int op = eventLoop->events[fd].mask == AE_NONE ?  
    8.            EPOLL_CTL_ADD : EPOLL_CTL_MOD;  
    9.   
    10.     // 注册事件到 epoll  
    11.     ee.events = 0;  
    12.     mask |= eventLoop->events[fd].mask; /* Merge old events */  
    13.     if (mask & AE_READABLE)   
    14.     ee.events |= EPOLLIN;  
    15.     if (mask & AE_WRITABLE)   
    16.     ee.events |= EPOLLOUT;  
    17.   
    18.     ee.data.u64 = 0; /* avoid valgrind warning */  
    19.     ee.data.fd = fd;  
    20.     //将事件加入epoll中  
    21.     if (epoll_ctl(state->epfd,op,fd,&ee) == -1)  
    22.         return -1;  
    23.   
    24.     return 0;  
    25. }  
    epoll内部使用红黑树维护每一个事件。红黑树中的每一个节点都代表一个fd。当应用层注册一个命令事件时,会将事件fd插入到红黑树中。应用层删除一个事件时,也相应会从红黑树中删除一个事件节点。

    因此创建一个事件时、将会发生下面3个操作

    1、创建事件并给事件赋值

    2、将事件插入到未就绪事件表

    3、将事件插入到epoll维护的红黑树中。

    四、事件循环

    程序将使用一个while死循环,一直维持着服务端的运转。

    1. //事件处理器的主循环  
    2. void aeMain(aeEventLoop *eventLoop)   
    3. {  
    4.     eventLoop->stop = 0;  
    5.   
    6.     while (!eventLoop->stop)   
    7.     {  
    8.   
    9.         // 如果有需要在事件处理前执行的函数,那么运行它  
    10.         if (eventLoop->beforesleep != NULL)  
    11.             eventLoop->beforesleep(eventLoop);  
    12.   
    13.         // 开始处理事件  
    14.         aeProcessEvents(eventLoop, AE_ALL_EVENTS);  
    15.     }  
    16. }  
    aeProcessEvents将开始进行事件处理。即处理定时事件也处理命令事件。定时事件与命令事件可以同时发生。定时事件将在下一节讲述,本节只讲述命令事件。
    1. // 处理文件事件,阻塞时间由 tvp 决定  
    2. numevents = aeApiPoll(eventLoop, tvp);  
    3. for (j = 0; j < numevents; j++)   
    4. {  
    5.     // 从已就绪数组中获取事件  
    6. <span style="white-space:pre">    </span>aeFileEvent *fe = &eventLoop->events[eventLoop->fired[j].fd];  
    7.     int mask = eventLoop->fired[j].mask;  
    8.     int fd = eventLoop->fired[j].fd;  
    9.     int rfired = 0;  
    10.   
    11.     // 读事件  
    12.     if (fe->mask & mask & AE_READABLE)   
    13.     {  
    14.           // rfired 确保读/写事件只能执行其中一个  
    15.           rfired = 1;  
    16.           //调用读处理函数  
    17.           fe->rfileProc(eventLoop,fd,fe->clientData,mask);  
    18.     }  
    19.   
    20.     // 写事件  
    21.     if (fe->mask & mask & AE_WRITABLE)   
    22.     {  
    23.         //调用写处理函数  
    24.          if (!rfired || fe->wfileProc != fe->rfileProc)  
    25.           fe->wfileProc(eventLoop,fd,fe->clientData,mask);  
    26.     }  
    27. }  
    aeApiPoll调用时将阻塞,直到有事件发生,或者超时,该函数才返回。函数返回时,已就绪表中存储了所有就绪事件。

    遍历所有已经发生的事件,根据fd在未就绪表中找到相应的事件,然后调用事件处理函数。

    当一轮事件执行完后,程序又进入最外层的事件循环中,接着处理剩于的事件。

    aeApiPoll内部调用epoll系统调用,等待指定事件发生或者超时。如果有事件发生则eploo_wait返回非0,如果为超时,则返回0。

    当有事件发生时,内核会把所有发生的事件由内核层拷贝到应用层。eploo_wait返回时state->events就是保存是由内核返回的就绪表。


    1. static int aeApiPoll(aeEventLoop *eventLoop, struct timeval *tvp)   
    2. {  
    3.     aeApiState *state = eventLoop->apidata;  
    4.     int retval, numevents = 0;  
    5.   
    6.     // 等待时间  
    7.     retval = epoll_wait(state->epfd,state->events,eventLoop->setsize,  
    8.             tvp ? (tvp->tv_sec*1000 + tvp->tv_usec/1000) : -1);  
    9.   
    10.     // 有至少一个事件就绪?  
    11.     if (retval > 0)   
    12.     {  
    13.         int j;  
    14.   
    15.         // 为已就绪事件设置相应的模式  
    16.         // 并加入到 eventLoop 的 fired 数组中  
    17.         numevents = retval;  
    18.         for (j = 0; j < numevents; j++)   
    19.     {  
    20.             int mask = 0;  
    21.             struct epoll_event *e = <span style="color:#ff0000;">state->events</span>+j;  
    22.   
    23.             if (e->events & EPOLLIN)  
    24.         mask |= AE_READABLE;  
    25.             if (e->events & EPOLLOUT)  
    26.         mask |= AE_WRITABLE;  
    27.             if (e->events & EPOLLERR)   
    28.         mask |= AE_WRITABLE;  
    29.             if (e->events & EPOLLHUP)  
    30.         mask |= AE_WRITABLE;  
    31.   
    32.             eventLoop->fired[j].fd = e->data.fd;  
    33.             eventLoop->fired[j].mask = mask;  
    34.         }  
    35.     }  
    36.       
    37.     // 返回已就绪事件个数  
    38.     return numevents;  
    39. }  
    内核已经把就绪事件从内核拷贝到了应用层的epoll就绪表state->events中。之后aeApiPoll会把epoll就绪表state->events中的就绪事件拷贝到fired就绪表中

    五、删除事件

    当不在需要某个事件时,需要把事件删除掉。例如: 如果fd同时监听读事件、写事件。当不在需要监听写事件时,可以把该fd的写事件删除。

    1. void aeDeleteFileEvent(aeEventLoop *eventLoop, int fd, int mask)  
    2. {  
    3.   
    4.     // 取出文件事件结构  
    5.     aeFileEvent *fe = &eventLoop->events[fd];  
    6.   
    7.     // 未设置监听的事件类型,直接返回  
    8.     if (fe->mask == AE_NONE)  
    9.     return;  
    10.   
    11.     // 计算新掩码  
    12.     fe->mask = fe->mask & (~mask);  
    13.   
    14.     // 取消对给定 fd 的给定事件的监视  
    15.     aeApiDelEvent(eventLoop, fd, mask);  
    16. }  
    1. static void aeApiDelEvent(aeEventLoop *eventLoop, int fd, int delmask)   
    2. {  
    3.     aeApiState *state = eventLoop->apidata;  
    4.     struct epoll_event ee;  
    5.     int mask = eventLoop->events[fd].mask & (~delmask);  
    6.   
    7.     ee.events = 0;  
    8.     if (mask & AE_READABLE)   
    9.     ee.events |= EPOLLIN;  
    10.     if (mask & AE_WRITABLE)   
    11.     ee.events |= EPOLLOUT;  
    12.       
    13.     ee.data.u64 = 0; /* avoid valgrind warning */  
    14.     ee.data.fd = fd;  
    15.     if (mask != AE_NONE)   
    16.     {  
    17.         epoll_ctl(state->epfd,EPOLL_CTL_MOD,fd,&ee);  
    18.     }   
    19.     else   
    20.     {  
    21.         epoll_ctl(state->epfd,EPOLL_CTL_DEL,fd,&ee);  
    22.     }  
    23. }  
    删除的过程可以总结为以下几个步骤

    1、根据fd在未就绪表中查找到事件

    2、取消该fd对应的相应事件标识符

    3、通知内核,内核会将红黑树上的相应事件也给取消。

    展开全文
  • Qt事件机制概览

    千次阅读 多人点赞 2017-04-18 12:16:12
    Qt事件机制概览Qt事件机制概览 消息循环 Qt事件循环 简介 QEventLoop 跨线程的信号和槽与事件循环 模态窗口 Native widget or Alien widget 创建Native widget 派发事件的公共基础方法 source code QApplication的...
  • 在使用gtest做单元测试时,出现了多个测试均需要初始化某个环境的情况。在每一个TestCase事件中写入同样的前置和后置条件太过...gtest事件机制定义参考 https://www.cnblogs.com/coderzh/archive/2009/04/06/14303...
  • springboot publish event 事件机制demo

    千次阅读 2020-11-30 16:58:48
    springboot publish event 事件机制demo 复制下面全部代码,右键包名,粘贴即可生成java类,执行即可看到效果。 事件机制: 需要自定义一个事件类继承ApplicationEvent; 需要自定义一个监听器类实现Application...
  • 事件驱动模型事件监听机制观察者模式案例1.Spring事件机制(事件监听机制)案例2.基于Springboot事件监听机制整合EventBus应用案例3. 事件监听机制 熟悉Spring的同学,spring提供了一套完整的事件监听机制。要了解...
  • 事件机制 事件触发三阶段 window 往事件触发处传播,遇到注册的捕获事件会触发 传播到事件触发处时触发注册的事件 从事件触发处往 window 传播,遇到注册的冒泡事件会触发 事件触发一般来说会按照上面的顺序进行,...
  • ApplicationContext事件机制

    千次阅读 2014-11-03 20:35:30
    Spring中ApplicationContext中事件机制比较简单,容器事件:ApplicationEvent ,监听器:ApplicationListener,当事件发生时,触发监听器中方法。  看一个实例:  package applicationContextEvent; import org....
  • iOS事件机制

    千次阅读 2014-12-10 14:28:49
    本篇内容接上一篇iOS事件机制(一),本次主要介绍iOS事件中的多点触控事件和手势事件。 从上一篇的内容我们知道,在iOS中一个事件用一个UIEvent对象表示,UITouch用来表示一次对屏幕的操作动作,由多个UITouch对象...
  • AS3事件机制概述

    千次阅读 2015-06-10 21:34:56
    事件机制是AS3的核心功能之一,没有充分掌握事件机制的方方面面,就不能算是精通AS3语言。 1. AS3事件机制的主要成员 IEventDispatcher:事件派发对象接口,定义了添加、派发、移除、是否监听指定事件、是否触发...
  • Spring异步事件机制

    千次阅读 2019-02-13 11:53:36
    2、Spring的事件机制默认是同步方式 3、@Async可以使用到类级别,也可以到方法级别 开启异步支持 @EnableAsync @Configuration @EnableAsync public class AppCommonConfig implements AsyncConfigurer{ @Override ...
  • egret.Event触摸事件与事件机制

    千次阅读 2018-04-17 20:56:47
    事件机制包含4个步骤:注册侦听器,发送事件,侦听事件,移除侦听器。这四个步骤是按照顺序来执行的。 egret.TouchEvent.TOUCH_TAP //触摸事件 //注册侦听函数的定义 public addEventListener(type:string, ...
  • Java事件机制代码实现

    2018-11-22 23:52:01
    java事件机制包括三个部分:事件、事件监听器、事件源。 1、事件。 一般继承自java.util.EventObject类,封装了事件源对象及跟事件相关的信息。 CusEvent类 package com.liuxd.event; import java.util....
  • SpringBoot中的事件机制

    千次阅读 2019-02-25 10:58:52
    在这篇文章中聊一聊 Spring 中的扩展机制(一)中对Spring中的事件机制进行了分析。那么对于 SpringBoot 来说,它在 Spring 的基础上又做了哪些拓展呢?本篇将来聊一聊 SpringBoot 中的事件。 在 SpringBoot 的启动...
  • Qt事件机制浅析

    2016-08-23 11:08:55
    Qt事件机制 Qt程序是事件驱动的, 程序的每个动作都是由幕后某个事件所触发.。 Qt事件的发生和处理成为程序运行的主线,存在于程序整个生命周期。 Qt事件的类型很多, 常见的qt的事件如下: 键盘事件: 按键按下和...
  • Flex事件机制

    2010-10-15 15:50:00
    很多开发人员都知道如何使用事件机制,但却不理解事件机制的基本工作原理。在这里我们探讨一下ActionScript 3的事件机制(无论是新手还是老手,我相信看到最后肯定对你有所帮助 )。 1. 首先来看一下事件机制中的几个...
  • java中的事件机制的参与者有3种角色: 1.event object:事件状态对象,用于listener的相应的方法之中,作为参数,一般存在与listerner的方法之中 2.event source:具体的事件源,比如说,你点击一个button,那么...
  • 掌握Android Touch事件机制

    千次阅读 2015-05-05 18:15:16
    掌握Android Touch事件机制 DaveSmith @devunwired 要点涵盖 l Touch系统概述 l Framwork层的Touch事件 l Touch事件的处理 l 系统提供的TouchHandlers l 系统提供的GestureHandlers Android系统怎么...
  • DOM事件机制

    千次阅读 2019-07-28 15:34:56
    本文主要介绍DOM事件级别、DOM事件模型、事件流、事件代理和Event对象常见的应用,希望对你们有些帮助和启发! 本文首发地址为GitHub博客,写文章不易,请多多支持与关注! 一、DOM事件级别 DOM级别一共可以分为四个...
  • Android View事件机制一些事

    千次阅读 2016-04-12 17:05:59
    1.自己对View事件机制的一些理解 2.在项目中遇到的一些坑,解决方案 2.收集了一些View的事件机制问题事件的分发原理图:1 * 对于一个root viewgroup来说,如果接受了一个点击事件,那么首先会调用他的...
  • 【JavaScript】JS事件机制学习

    千次阅读 2019-09-25 11:41:33
    通过事件机制,达到与用户的交互,与java的swing交互类似。 主要是结合js的函数使用。 单 / 双击事件 鼠标事件 键盘事件 交点事件 页面加载事件 值改变事件 <html> <head> <title>js的事件...
  • JSF事件机制(一)

    千次阅读 热门讨论 2017-05-15 16:57:12
    今天就了解一下JSF的事件机制事件机制概述在JSF(一)中提到了,JSF的标签定了一强大的服务器组件,而且他允许组件直接和托管Bean进行绑定,而在托管Bean中定义的方法可以处理Action事件、处理值改变事件等。...
  • java事件机制包括三个部分:事件、事件监听器、事件源。   1、事件。一般继承自java.util.EventObject类,封装了事件源对象及跟事件相关的信息。 com.javaedu.event.CusEvent类 Java代码  ...
  • AS3事件机制

    2012-08-29 22:56:12
    事件机制是AS3的核心功能之一,没有充分掌握事件机制的方方面面,就不能算是精通AS3语言。 1. AS3事件机制的主要成员 IEventDispatcher:事件派发对象接口,定义了添加、派发、移除、是否监听指定事件、是否触发...
  • spring事件机制——异步配置

    千次阅读 2017-01-13 19:45:58
    这里讲解一下Spring对异步事件机制的支持,实现方式有两种:1、全局异步即只要是触发事件都是以异步执行,具体配置(spring-config-register.xml)如下:  通过注入taskExecutor来完成异步调用。具体...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 48,790
精华内容 19,516
关键字:

事件机制