精华内容
下载资源
问答
  • Android 实时监测(监听)网络连接状态变化

    千次下载 热门讨论 2016-11-28 11:26:45
    android网络监听变化,判断当前是什么网络类型,实时监听。android网络监听变化,判断当前是什么网络类型,实时监听。android网络监听变化,判断当前是什么网络类型,实时监听。android网络监听变化,判断当前是什么...
  • 查阅JavaDoc API文档 读者可根据JavaDoc API文档来了解如何实现单击item选项监听事件 如下列出的setItems 方法第2个参数易知只要为第2个参数提供OnClickListener实例即可实现监听事件 读者可通过这种方式触类旁通...
  • 设置手机WiFi便携热点,并且监听热点打开与关闭,详情请参见我的博客http://blog.csdn.net/u011520181/article/details/46496377
  • Java监听器详解

    千次阅读 2019-08-17 18:47:42
    一.监听器的定义 ...web监听器由servlet规范提供的,它可以监听客户端的请求,服务端的操作,监听的对象包括ServletContext,HttpSession,ServletRequest三个预对象(内置对象),分别对应aplication,s...

    一.监听器的定义

    是指专门用于对其他对象身上发生的事件或状态改变进行监听和相应处理的对象,当被监视的对象发生变化时,立即采取相应的行动。

    Web应用当中监听器是什么?

    在这里插入图片描述
    web监听器由servlet规范提供的,它可以监听客户端的请求,服务端的操作,监听的对象包括ServletContext,HttpSession,ServletRequest三个预对象(内置对象),分别对应aplication,session,request。
    在这里插入图片描述

    内置对象

    JSP中一共预先定义了9个这样的内置对象,分别为:request、response、session、application、out、pagecontext、config、page、exception
    内置对象(又叫隐含对象)特点:

    1. 由JSP规范提供,不用编写者实例化。
    2. 通过Web容器实现和管理
    3. 所有JSP页面均可使用
    4. 只有在脚本元素的表达式或代码段中才可使用(<%=使用内置对象%>或<%使用内置对象%>)
    request对象

    request 对象是 javax.servlet.httpServletRequest类型的对象。 该对象代表了客户端的请求信息,主要用于接受通过HTTP协议传送到服务器的数据。(包括头信息、系统信息、请求方式以及请求参数等)。request对象的作用域为一次请求。

    session对象

    session 对象是由服务器自动创建的与用户请求相关的对象。服务器为每个用户都生成一个session对象,用于保存该用户的信息,跟踪用户的操作状态。session对象内部使用Map类来保存数据,因此保存数据的格式为 “Key/value”。 session对象的value可以使复杂的对象类型,而不仅仅局限于字符串类型。

    application对象

    application 对象可将信息保存在服务器中,直到服务器关闭,否则application对象中保存的信息会在整个应用中都有效。与session对象相比,application对象生命周期更长,类似于系统的“全局变量”。

    Web监听器概念

    Servlet规范中定义的一种特殊类
    用于监听ServletContext,HttpSession和ServletRequest等域对象的创建与销毁事件用于监听域对象的属性发生修改的事件可以在事件发生前,发生后做一些必要的处理

    二.Web监听器的用途

    1.统计在线人数和在线用户
    2.系统启动时加载初始化信息
    3.统计网站访问量
    4.跟Spring结合

    三.第一个Web监听器

    实现步骤

    1.创建一个实现监听器接口的类

    在这里插入图片描述
    在这里插入图片描述
    代码如下:

    package com.java.listener;
    
    import javax.servlet.ServletContextEvent;
    import javax.servlet.ServletContextListener;
    
    /**
     * @author : xiayj
     * @date : 2019/8/3 17:58
     */
    public class FirstListener implements ServletContextListener {
        @Override
        public void contextInitialized(ServletContextEvent sce) {
            System.out.println("contextInitialized");
        }
    
        @Override
        public void contextDestroyed(ServletContextEvent sce) {
            System.out.println("contextDestroyed");
        }
    }
    
    2.配置web.xml进行注册

    把监听对象放到web.xml中

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
             version="4.0">
        <listener>
            <listener-class>com.java.listener.FirstListener</listener-class>
        </listener>
        <welcome-file-list>
            <welcome-file>index.jsp</welcome-file>
        </welcome-file-list>
        <login-config>
            <auth-method>BASIC</auth-method>
        </login-config>
    </web-app>
    

    启动tomcat,控制台输出如下说明当web应用启动时会自动创建一个application对象,且只有一个
    在这里插入图片描述
    关闭tomcat,如下表示当前应用销毁
    在这里插入图片描述

    监听器的启动顺序

    在这里插入图片描述

    四.监听器的分类

    1.按监听的对象划分

    1)用于监听应用程序环境对象(ServletContext)的事件监听器
    2)用于监听用户会话对象(HttpSession)的事件监听器
    3)用于监听请求消息对象(ServletRequest)的事件监听器

    2.按监听的事件划分

    1)监听域对象自身的创建和销毁的事件监听器

    在这里插入图片描述

    ServletContext的创建与销毁

    ServletContext实现了ServletContextListener用于监听它的创建与销毁事件,一个web项目可以定义多个ServletContextListener,但一个web项目只有一个ServletContext对象。
    ServletContextListener有两个事件处理方法,这两个方法都会传入ServletContextEvent事件对象,可以获取ServletContext对象以及一些初始化参数。ServletContextListener主要用途:可以做定时器,加载全局属性对象,创建全局的数据库连接,加载一些缓存信息。
    在这里插入图片描述
    web.xml配置如下

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
             version="4.0">
        <listener>
            <listener-class>com.java.listener.FirstListener</listener-class>
        </listener>
        <welcome-file-list>
            <welcome-file>index.jsp</welcome-file>
        </welcome-file-list>
        <login-config>
            <auth-method>BASIC</auth-method>
        </login-config>
    <!--配置初始化参数-->
        <context-param>
            <param-name>initParam</param-name>
            <param-value>listener</param-value>
        </context-param>
    </web-app>
    

    代码实现:

    package com.java.listener;
    
    import javax.servlet.ServletContextEvent;
    import javax.servlet.ServletContextListener;
    
    /**
     * @author : xiayj
     * @date : 2019/8/3 17:58
     */
    public class FirstListener implements ServletContextListener {
        //ServletContext是上下文对象,当web应用启动时创建,web应用销毁时销毁
        @Override
        public void contextInitialized(ServletContextEvent sce) {
    //项目启动时获取初始化参数
            String initParam = sce.getServletContext().getInitParameter("initParam");
            System.out.println("contextInitialized : initParam = " + initParam);
        }
    
        @Override
        public void contextDestroyed(ServletContextEvent sce) {
    //销毁主要用于当数据库连接关闭时释放一些不必要的资源
            System.out.println("contextDestroyed");
        }
    }
    

    项目启动结果如下,说明当项目启动时就加载了在web.xml中配置的参数
    在这里插入图片描述

    HttpSession的创建与销毁

    与ServletContext类似,HttpSession实现了HttpSessionListener用于监听它的创建与销毁事件,一个web项目可以定义多个HttpSessionListener,但一个web项目只有一个HttpSession对象。HttpSessionEvent事件对象,可以获取当前被创建的HttpSession对象。HttpSessionListener主要用途:统计在线人数,记录访问日志。
    在这里插入图片描述
    Session创建:用户打开浏览器第一次访问我们应用时,这次会话web容器会分配一个session,可以在session中保存一些信息
    Session销毁:1.手动点退出,关闭服务器2.关闭浏览器一段时间直到session过期3.不关闭浏览器,session超时
    实现HttpSessionListener:

    package com.java.listener;
    
    import javax.servlet.http.HttpSessionEvent;
    import javax.servlet.http.HttpSessionListener;
    
    /**
     * @author : xiayj
     * @date : 2019/8/4 16:59
     */
    public class MyHttpSessionListener implements HttpSessionListener {
        @Override
        public void sessionCreated(HttpSessionEvent se) {
            System.out.println("sessionCreated");
        }
    
        @Override
        public void sessionDestroyed(HttpSessionEvent se) {
            System.out.println("sessionDestroyed");
        }
    }
    

    web.xml文件加如下配置

    <!--配置session超时时间,1表示1分钟0表示没有超时限制-->
    <session-config>
        <session-timeout>1</session-timeout>
    </session-config>
    

    访问项目
    在这里插入图片描述
    控制台输出如下Listener监听到session创建
    在这里插入图片描述
    等一分钟后,监听到session被销毁
    在这里插入图片描述

    ServletRequest的创建与销毁

    ServletRequest实现了ServletRequestListener用于监听它的创建与销毁事件,一个web项目可以定义多个ServletRequestListener,但一个web项目只有一个ServletRequest对象。ServletRequestListener主要用途:读取request里的参数,记录访问历史,路径。
    在这里插入图片描述
    实现ServletRequestListener

    package com.java.listener;
    
    import javax.servlet.ServletRequestEvent;
    import javax.servlet.ServletRequestListener;
    
    /**
     * @author : xiayj
     * @date : 2019/8/4 17:54
     */
    public class MyServletRequestListener implements ServletRequestListener {
        @Override
        public void requestInitialized(ServletRequestEvent sre) {
            //获取当前的请求参数
            String name = sre.getServletRequest().getParameter("name");
            System.out.println("requestInitialized");
        }
    
        @Override
        public void requestDestroyed(ServletRequestEvent sre) {
            System.out.println("requestDestroyed");
        }
    }
    

    Web.xml中增加监听器配置信息

    <listener>
        <listener-class>com.java.listener.MyServletRequestListener</listener-class>
    </listener>
    

    启动项目,打开浏览器,查看控制台如下,可知request监听到了用户的访问请求,并在请求结束后销毁
    在这里插入图片描述

    2)监听域对象中的属性的增加和删除的事件监听器

    在这里插入图片描述
    代码实现:
    新建三个类

    package com.java.listener;
    
    import javax.servlet.ServletRequestAttributeEvent;
    import javax.servlet.ServletRequestAttributeListener;
    
    /**
     * @author : xiayj
     * @date : 2019/8/10 17:18
     */
    public class MyServletRequestAttributeListener implements ServletRequestAttributeListener {
        @Override
        public void attributeAdded(ServletRequestAttributeEvent srae) {
    //可知是什么对象添加了什么属性,移除了什么属性       System.out.println("ServletRequest_attributeAdded:"+srae.getName());
        }
    
        @Override
        public void attributeRemoved(ServletRequestAttributeEvent srae) {
            System.out.println("ServletRequest_attributeRemoved:"+srae.getName());
        }
    
        @Override
        public void attributeReplaced(ServletRequestAttributeEvent srae) {
            System.out.println("ServletRequest_attributeReplaced:"+srae.getName());
        }
    }
    
    package com.java.listener;
    
    import javax.servlet.http.HttpSessionAttributeListener;
    import javax.servlet.http.HttpSessionBindingEvent;
    
    /**
     * @author : xiayj
     * @date : 2019/8/10 16:55
     */
    public class MyHttpSessionAttributeListener implements HttpSessionAttributeListener {
        @Override
        public void attributeAdded(HttpSessionBindingEvent se) {
            System.out.println("HttpSession_attributeAdded:"+se.getName());
        }
    
        @Override
        public void attributeRemoved(HttpSessionBindingEvent se) {
            System.out.println("HttpSession_attributeRemoved:"+se.getName());
        }
    
        @Override
        public void attributeReplaced(HttpSessionBindingEvent se) {
            System.out.println("HttpSession_attributeReplaced:"+se.getName());
        }
    }
    
    package com.java.listener;
    
    import javax.servlet.ServletContextAttributeEvent;
    import javax.servlet.ServletContextAttributeListener;
    
    /**
     * @author : xiayj
     * @date : 2019/8/10 16:52
     */
    public class MyServletContextAttributeListener implements ServletContextAttributeListener {
        @Override
        public void attributeAdded(ServletContextAttributeEvent scae) {
            System.out.println("ServletContext_attributeAdded:"+scae.getName());
        }
    
        @Override
        public void attributeRemoved(ServletContextAttributeEvent scae) {
            System.out.println("ServletContext_attributeRemoved:"+scae.getName());
        }
    
        @Override
        public void attributeReplaced(ServletContextAttributeEvent scae) {
            System.out.println("ServletContext_attributeReplaced:"+scae.getName());
        }
    }
    

    Web.xml文件中注册监听器

    <listener>
        <listener-class>com.java.listener.MyHttpSessionAttributeListener</listener-class>
    </listener>
    <listener>
        <listener-class>com.java.listener.MyServletContextAttributeListener</listener-class>
    </listener>
    <listener>
        <listener-class>com.java.listener.MyServletRequestAttributeListener</listener-class>
    </listener>
    

    创建新增各个属性值得jsp界面,为了方便在每个页面都加上了初始化,销毁的按钮
    index.jsp

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
      <head>
        <title>这是myweb应用</title>
      </head>
      <body>
      你好!这是一个listener
      <button onclick="location.href='<%=request.getContextPath()%>/init.jsp';">Init</button>
      <button onclick="location.href='<%=request.getContextPath()%>/destory.jsp';">Destory</button>
      </body>
    </html>
    

    init.jsp

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <%
    String path = request.getContextPath();
    String basePath = request.getScheme()+"://"+request.getServletPath();
    //添加属性,让Listener监听执行attributeAdded方法
    request.setAttribute("requestName","requestValue");
    request.getSession().setAttribute("sessionName","sessionValue");
    request.getSession().getServletContext().setAttribute("contextName","contextValue");
    %>
    <html>
    <head>
        <title>Title</title>
    </head>
    <body>
    这是初始化值得界面
    <button onclick="location.href='<%=request.getContextPath()%>/init.jsp';">Init</button>
    <button onclick="location.href='<%=request.getContextPath()%>/destory.jsp';">Destory</button>
    </body>
    </html>
    

    destory.jsp

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <%
        String path = request.getContextPath();
        String basePath = request.getScheme()+"://"+request.getServletPath();
        //移除属性,让Listener监听执行attributeRemoved方法
        request.removeAttribute("requestName");
        request.getSession().removeAttribute("sessionName");
        request.getSession().getServletContext().removeAttribute("contextName");
    %>
    <html>
    <head>
        <title>Title</title>
    </head>
    <body>
    这是销毁界面
    <button onclick="location.href='<%=request.getContextPath()%>/init.jsp';">Init</button>
    <button onclick="location.href='<%=request.getContextPath()%>/destory.jsp';">Destory</button>
    </body>
    </html>
    

    超时时间改为0

    <!--配置session超时时间,1表示1分钟0表示没有超时限制-->
    <session-config>
        <session-timeout>0</session-timeout>
    </session-config>
    

    打开主页面
    在这里插入图片描述
    点击init,控制台输出如下
    在这里插入图片描述
    再次点击init
    在这里插入图片描述
    点击destory,属性被移除,request对象因为已经被销毁了,域中已没有requestName属性,所以没有移除信息
    在这里插入图片描述

    3)监听绑定到HttpSession域中的某个对象的状态的事件监听器

    在这里插入图片描述
    绑定:通过getSession().setAttribute将对象保存到session对象中
    解除绑定:通过getSession().removeAttribute将对象从session对象中移除
    钝化:将session对象持久化到存储设备上
    活化:将session对象从存储设备上恢复

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    代码实现:
    新建user类

    package com.java.entity;
    
    import javax.servlet.http.HttpSessionActivationListener;
    import javax.servlet.http.HttpSessionBindingEvent;
    import javax.servlet.http.HttpSessionBindingListener;
    import javax.servlet.http.HttpSessionEvent;
    import java.io.Serializable;
    
    /**
     * @author : xiayj
     * @date : 2019/8/17 16:09
     */
    /** 想要钝化或活化必须实现Serializable接口*/
    public class User implements HttpSessionBindingListener, HttpSessionActivationListener, Serializable {
        private String username;
        private String password;
        /** 对象绑定执行*/
        @Override
        public void valueBound(HttpSessionBindingEvent event) {
            System.out.println("valueBound Name:"+event.getName());
        }
        /** 对象解除绑定执行*/
        @Override
        public void valueUnbound(HttpSessionBindingEvent event) {
            System.out.println("valueUnbound Name:"+event.getName());
        }
        /** 钝化*/
        @Override
        public void sessionWillPassivate(HttpSessionEvent se) {
            System.out.println("sessionWillPassivate"+se.getSource());
        }
        /** 活化*/
        @Override
        public void sessionDidActivate(HttpSessionEvent se) {
            System.out.println("sessionDidActivate"+se.getSource());
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    }
    
    绑定/解除绑定测试:

    在init文件里增加如下:

    //将用户实例放到session中
    request.getSession().setAttribute("currentUser",new com.java.entity.User());
    

    在destory文件里增加如下:

    request.getSession().removeAttribute("currentUser");
    

    启动项目,打开首页:
    在这里插入图片描述
    点击init和destory,控制台分别输出如下,表明当对象实现HttpSessionBindingListener接口后,只要对象被session绑定,就会触发事件,执行valueBound方法,当解除绑定后,执行valueUnBound方法
    在这里插入图片描述
    在这里插入图片描述

    钝化/活化测试

    启动tomcat,打开项目,可以看到控制台已经创建session
    在这里插入图片描述
    点击init,可以看到session中保存了几个属性值
    在这里插入图片描述
    关闭tomcat,控制输出如下,sessionWillPassivateorg.apache.catalina.session.StandardSessionFacade@1e7c7811 就是session钝化的输出,StandardSession是默认的钝化管理器
    在这里插入图片描述
    钝化的文件保存位置如下
    在这里插入图片描述
    在首页新增如下:

    <!-- 在首页获取用户对象 正常情况下因为tomcat已关闭,session中用户对象应该已被销毁,
    但因为实现了HttpSessionActivationListener接口,tomcat重新启动时会活化保存的session文件-->
    <%=request.getSession().getAttribute("currentUser")%>
    你好!这是一个listener
    <button onclick="location.href='<%=request.getContextPath()%>/init.jsp';">Init</button>
    <button onclick="location.href='<%=request.getContextPath()%>/destory.jsp';">Destory</button>
    

    重启tomcat,控制台输出如下:
    在这里插入图片描述
    打开首页,可以看到之前钝化的user对象被输出
    在这里插入图片描述
    Ps:如果出现可以活化,但是无法钝化的问题即重启tomcat没有调用 sessionDidActivate()方法,浏览器端也获取不到重启前存入的对象
    这是因为每次重启tomcat会将如下目录删除并重新生成,之前钝化的session文件也会被一起删除
    在这里插入图片描述
    解决方法:在tomcat安装目录下conf/context.xml配置文件里增加如下配置,directory里是自定义的session文件存储路径

    <Manager className="org.apache.catalina.session.PersistentManager" saveOnRestart="true">
            <Store className="org.apache.catalina.session.FileStore" directory="D:\tomcat\session"/>
    </Manager>
    

    在Servlet3.0版本以上提供@WebListener注解将一个实现了特定监听器接口(比如ServletContextListener,HttpSessionListener)的类定义为监听器,这样在web应用中使用监听器时不需要在web.xml文件中配置监听器的相关描述信息,感兴趣的可以自己去研究一下,用法差不多。

    参考文章:Jsp:九大内置对象https://my.oschina.net/u/3805464/blog/1813805
    本文章内容是对慕课网课程内容的一个总结,感兴趣的同学可以去慕课网学习该课程
    地址如下:https://www.imooc.com/learn/271

    展开全文
  • 监听打开/关闭APP

    2013-11-22 17:31:56
    监听打开/关闭APP 在接收动作的位置添加你所想要做的事情
  • Android监听输入法软键盘按键demo

    千次下载 热门讨论 2014-02-08 10:35:31
    Android App监听软键盘按键的三种方式(http://blog.csdn.net/zhufuing/article/details/18964725)博文中所用的demo
  • android中监听软键盘的弹出与隐藏,并获取软键盘的高度,在adjustPan,adjustResize,adjustUnspecified下都可以
  • Android应用监听自身卸载

    热门讨论 2015-01-08 17:27:26
    详情请参考我的博客:http://blog.csdn.net/allen315410/article/details/42521251
  • android监听蓝牙设备的连接状态

    千次下载 热门讨论 2013-09-10 10:22:03
    通过系统广播监听蓝牙设备的连接状态,当蓝牙搜索发现设备时提示对应的蓝牙设备已发现,当蓝牙设备连接或断开显示蓝牙设备连接或断开。
  • 监听器设计模式

    千次阅读 2019-05-27 13:01:32
    监听器设计模式设计模式创建型结构型行为型观察者设计模式观察者接口(IObserve)观察者实现类(FirstObserve、SecondObserve)被观察者接口(IObservable)被观察者实现类测试类监听器设计模式事件接口(ICurdEvent...

    设计模式

    设计模式(Design pattern)代表了最佳的实践,通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

    创建型

    通过特定的方式创建特定对象的设计模式
    

    工厂方法模式,抽象工厂模式,单例模式,建造者模式,原型模式)

    结构型

    为了解决某一特定问题所搭建的特定代码结构的设计模式
    

    适配器模式装饰器模式,代理模式,外观模式,桥接模式,组合模式,享元模式)

    行为型

    通过构建不同的角色来完成某一特定功能的设计模式
    

    (策略模式、模板方法模式观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式)

    通过了解以上我们知道设计模式的大概 接下来进入重点 监听器设计模式,监听器设计模式是观察者设计模式的衍生,所以得先了解观察者设计模式。

    观察者设计模式

    观察者设计模式从名字上来看,首先得有观察者和被观察者,所以它有两个接口:IObserveIObservable,其主要实现的功能就是当被观察者对象的状态有更改的时候,观察者时时会有相应的通知并做出相应的操作
    原理:就是在目标对象中耦合观察者的对象,并且在注册观察者对象的时候调用相应操作的方法; 两者之间的关系是单向关联的;目标类和观察类之间维护的是松耦合的关系;
    在这里插入图片描述

    观察者接口(IObserve)

    需要实现的功能

    1. 接收并处理被观察者发送来的信息
    package IObserve;
    public interface IObserve {
    //    观察者处理被观察者发送过来额信息
        void handleNotify(String message);
    }
    

    观察者实现类(FirstObserve、SecondObserve)

    有多个观察者,所以需要写多个实现类,第一个观察者

    package IObserve;
    public class FistObserve implements IObserve {
        @Override
        public void handleNotify(String message) {
            System.out.println("1号接受的消息"+message );
        }
    }
    

    第二个观察者

    package IObserve;
    public class SecondObserve implements IObserve {
        @Override
        public void handleNotify(String message) {
            System.out.println("2号接受的消息"+message);
        }
    }
    

    被观察者接口(IObservable)

    需要实现的功能

    1. 可以添加观察者
      添加操作可以通过Array List的add()方法实现。
    2. 删除观察者
      删除操作通过ArrayList的remove()方法实现。
    3. 向观察者发送信息
    package IObservable;
    import IObserve.IObserve;
    
    public interface IObservable {
    //    添加观察者
        void addObserve(IObserve observable);
    //    删除观察者
        void removeObserve(IObserve observable);
    //    向观察者发送信息
        void notifyObservers(String message);
    }
    

    被观察者实现类

    由于一个被观察者可以有多个观察者,所以可以创建一个ArrayList来存放多个观察者。

    package IObservable;
    import IObserve.IObserve;
    import java.util.ArrayList;
    import java.util.List;
    
    public class Some implements IObservable{
    //    由于一个被观察者可以被多个观察者所观察,所以要设置一个观察者链表里
        private List<IObserve> observes;
        public Some(){
            //在被观察者对象被创建时,就将集合创建
            observes = new ArrayList<>();
        }
        @Override
        public void addObserve(IObserve observe) {
            observes.add(observe);
        }
        @Override
        public void removeObserve(IObserve observe) {
            observes.remove(observe);
        }
        @Override
        public void notifyObservers(String message) {
            for (IObserve observe :
                    observes) {
                observe.handleNotify(message);
            }
        }
    }
    

    测试类

    首先需要创建观察者类的对象,然后创建被观察者类的对象,因为在被观察者类中写入的构造方法中有ArrayList的创建,所以在创建其对象的时候就已经准备好一个链表observes来存放观察者的对象observe,被观察者类Some其对象调用notifyObservers()方法,向观察者发送信息,最后通过遍历observes来调用观察者实现类的handleNotify(message)方法来实现观察者实现的操作。

    package test;
    
    import IObservable.Some;
    import IObserve.SecondObserve;
    import IObserve.FistObserve;
    import IObserve.IObserve;
    
    public class Test {
        public static void main(String[] args) {
            //创建多个观察者
            IObserve iObserve1 = new FistObserve();
            IObserve iObserve2 = new SecondObserve();
            //创建被观察者
            Some some =new Some();
            //被观察者添加观察者
            some.addObserve(iObserve1);
            some.addObserve(iObserve2);
            //被观察者向观察者发送信息
            some.notifyObservers("GOGOGOGOGOGO");
            //删除观察者后
            some.removeObserve(iObserve1);
            some.notifyObservers("GO ");
        }
    }
    

    这样就会实现,只有被观察者有动态变化,观察者就会有所反应。
    在这里插入图片描述

    监听器设计模式

    监听器设计模式是观察者设计模式的一种实现。他与观察者设计模式不同点有

    1. 一个被观察者只能有一个观察者对象,而不是多个
    2. 被监听者(事件源)的状态改变,被定义为一个对象,称为事件,而不是字符串
    • 监听器(监听者)
      负责监听发生在事件源上的事件
    • 事件源(被监听对象,产生事件的对象)
      提供订阅与取消监听者的方法,并负责维护监听者列表,发送事件给监听者
    • 事件处理器
      监听器的成员方法,当时事件发生后会触发对应的处理器(成员方法)。

    一般情况下,监听器对象被事件触发后,都是需要从事件中获取到事件源对象,然后再从事件源中获取一些数据。也就是说,在事件对象中一般需要提供获取事件源对象的方法,当然,除了获取事件源方法外,根据业务需求,事件对象一般还需要提供一些其他的数据,以便让监听器获取。

    监听器在进行工作时,可以分为以下步骤

    1. 将监听器绑定到事件源(注册监听器)
    2. 事件发生后触发监听器的成员方法,即事件处理器,传递事件对象
    3. 事件处理器通过事件对象获得事件源,并对事件源进行处理。

    在这里插入图片描述

    事件接口(ICurdEvent)

    package event;
    //定义增删改查事件
    //C: Create
    //U: Update
    //R: Retrieve
    //D: Delete
    //通常对于事件对象,我们一般需要从事件对象中获取到事件源对象
    public interface ICurdEvent{
        //声明事件类型
        String Create_EVENT = "create event";
        String Update_EVENT = "update event";
        String Retrieve_EVENT = "retrieve event";
        String Delete_EVENT = "delete event";
        //获取事件源对象
        IListenerable getEventSource();
        //获取事件类型
        String getEventType();
    
    }
    

    事件实现类

    package implement;
    import event.ICurdEvent;
    import event.IListenerable;
    
    public class CurdEvent implements ICurdEvent {
        private IListenerable eventSource;  //事件源
        private String methodname;          //事件源所执行的方法名称
        public CurdEvent(IListenerable eventSource,String methodname){
            super();
            this.eventSource = eventSource;
            this.methodname = methodname;
        }
        @Override
        public IListenerable getEventSource() {
            return eventSource;
        }
        //根据事件源所执行的不同的方法返回不同的事件类型
        @Override
        public String getEventType() {
            String eventType = null;
            if (methodname.startsWith("save")){
                eventType = Create_EVENT;
            }else if (methodname.startsWith("remove")){
                eventType = Delete_EVENT;
            }else if (methodname.startsWith("modify")){//修改
                eventType = Update_EVENT;
            }else if (methodname.startsWith("find")){
                eventType = Retrieve_EVENT;
            }else {
                eventType = "have not this event type";
            }
            return eventType;
        }
    }
    

    监听器接口(IListener)

    package event;
    //监听器接口(观察者)
    //作用:处理消息(事件)
    public interface IListener {
        void handle(ICurdEvent event);
    }
    

    监听器实现类

    package implement;
    
    import event.ICurdEvent;
    import event.IListener;
    //定义监听器类
    public class Listener implements IListener {
        @Override
        public void handle(ICurdEvent event) {
            String eventType = event.getEventType();
            if (ICurdEvent.Create_EVENT.equals(eventType)){
                System.out.println("添加操作");
            }else if (ICurdEvent.Delete_EVENT.equals(eventType)){
                System.out.println("删除操作");
            }else if (ICurdEvent.Update_EVENT.equals(eventType)){
                System.out.println("修改操作");
            }else if (ICurdEvent.Retrieve_EVENT.equals(eventType)){
                System.out.println("查找操作");
            }
        }
    }
    

    事件源接口(IListenerable)

    package event;
    //事件源接口(被观察者)
    public interface IListenerable {
        //为事件源注册监听器
        void setListener(IListener listener);
        //触发监听器
        void triggerListener(ICurdEvent event);
    }
    

    事件源实现类

    package implement;
    
    import event.ICurdEvent;
    import event.IListener;
    import event.IListenerable;
    
    //事件源类
    public class Some implements IListenerable {
        private IListener listener;
        //注册监听器
        @Override
        public void setListener(IListener listener) {
            this.listener = listener;
        }
        //触发监听器
        @Override
        public void triggerListener(ICurdEvent event) {
            listener.handle(event);
        }
        public void saveStudent(){
            System.out.println("插入了一条数据");
            ICurdEvent event = new CurdEvent(this,"saveStudent");
            this.triggerListener(event);
        }
        public void removeStudent(){
            System.out.println("删除了一条数据");
            ICurdEvent event = new CurdEvent(this,"removeStudent");
            this.triggerListener(event);
        }
        public void modifyStudent(){
            System.out.println("修改了一条数据");
            ICurdEvent event = new CurdEvent(this,"modifyStudent");
            this.triggerListener(event);
        }
        public void findStudent(){
            System.out.println("插入了一条数据");
            ICurdEvent event = new CurdEvent(this,"findStudent");
            this.triggerListener(event);
        }
    }
    

    测试类

    package test;
    import event.IListener;
    import implement.Listener;
    import implement.Some;
    
    public class Test {
        public static void main(String[] args) {
            //定义监听器
            IListener listener = new Listener();
            //定义事件源
            Some some = new Some();
            //事件源注册监听器
            some.setListener(listener);
            some.saveStudent();
            some.removeStudent();
        }
    }
    

    在这里插入图片描述

    展开全文
  • jquery监听鼠标滚轮事件+js监听滚轮事件, 两个例子,都可以通过! 目前已测试 ie8 火狐,360
  • java-swing-事件监听-(动作事件监听器)

    千次阅读 多人点赞 2019-06-22 14:54:08
    动作事件监听器是 Swing 中比较常用的事件监听器,它的具体信息如下: 事件名称:ActionEvent。 事件监听接口: ActionListener。这个接口需要被 需要处理ActionEvent的类实现 事件相关方法:addActionListener...

    前面学习的只是如何布置使用 swing控件,但是对它们进行点击等动作时,相应控件没有任何反应。

    所以要给每个控件添加一个事件处理机制,当我们(用户)对 Swing组件 进行某些操作时,对应 Swing组件 会自动产生各种事件来响应用户行为。如当用户点击按钮时,Swing组件会产生一个 ActionEvent。

    Swing组件会产生许多事件,如:ActionEvents,ChangeEvents,ItemEvents等,来响应用户的鼠标点击等行为。

    动作事件监听器
    动作事件监听器是 Swing 中比较常用的事件监听器,它的具体信息如下:

    事件名称:ActionEvent。
    事件监听接口: ActionListener。这个接口需要被 需要处理ActionEvent的类实现
    事件相关方法:addActionListener() 添加监听,对于需要响应ActionEvent的控件(像需要响应点击的按钮等)要使用这个方法。removeActionListener() 删除监听等…

    以按钮的单击响应为例编写一个小程序,当鼠标单击按钮时,文本框显示总共单击的次数
    具体代码如下:
    要导入的类,之后不再赘述:

    import javax.swing.JPanel; //中间容器 (嵌板)最常用的面板
    import javax.swing.JButton;  //按钮
    import javax.swing.JFrame;   //顶层容器 (框架)
    import javax.swing.JTextField;  //文本框实现类
    import java.awt.event.ActionEvent;   //动作事件
    import java.awt.event.ActionListener;  //动作事件监听接口
    
    public class text_ ActionEvent
    {
    	static int clicks = 0;  //记录点击次数
    	public static void main(String[] args) 
    	{
    		JFrame jframe = new JFrame("动作监听");  //窗口
    		jframe.setSize(200, 100);   //设置窗口大小
    		JPanel jpanel1 = new JPanel();  //面板
    		JButton jbutton1 = new JButton("按钮1");  //按钮1
    		JTextField jtextfield1 = new JTextField("",15);  //用于显示的文本框,为15列
    		
    		//创建响应动作监听的类,它需要重写ActionListener接口的actionPerformed()方法
    		class jbutton1hander implements ActionListener
    	    {
    	        @Override
    	        public void actionPerformed(ActionEvent e)
    	        {
    	        	jtextfield1.setText("按钮1被单击 " + (++clicks) + " 次");
    	        	//当单击设置了动作响应的按钮的时候,会显示单击的总次数
    	        }
    	    }
    		
    		jbutton1.addActionListener(new jbutton1hander()); //这句话很关键,添加动作监听器
    		jpanel1.add(jtextfield1);  //文本框添加入面板
    		jpanel1.add(jbutton1);    //按钮1添加入面板
    		jframe.add(jpanel1);    //面板添加入窗口
    		
    		jframe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置关闭时操作
    		jframe.setVisible(true);   //设置可见
    	}
    }
    

    运行结果:
    没开始单击时界面
    在这里插入图片描述
    单击1次时界面
    在这里插入图片描述
    单击2次时界面
    在这里插入图片描述
    这是最简单的一种情况,只有一个按钮响应一个事件,但是在实际中,情况不是这么简单。

    1.由于同一个控件(事件源)上可能发生多种事件,因此,Java 采取了授权模型(Delegation Model),控件(事件源)可以把在其自身上所有可能发生的事件分别授权给不同的事件处理者(实现各个事件类的接口的类)来处理。eg:

    //假设有两个分别实现两个不同事件接口的监听类(伪码,有残缺,举例用)
    class ActionHander implements ActionListener{}
    class ChangeHander implements ChangeListener{}
    Jbutton jbutton; //一个按钮
    //按钮上会发生上面两个事件,就分别授权给不同事件处理者
    jbutton1.addActionListener(new ActionHander());  //授权Action事件
    jbutton1.addChangeListener(new ChangeHander());  //授权Change事件
    

    2.当多个控件需要响应一个事件的时候,这里有三种方法,以ActionEvent动作事件,和两个按钮为例。当鼠标单击某个按钮时,文本框显示这个按钮总共单击的次数。

    ActionEvent的三种实现方法
    <1>基于if-slse语句的实现

    public class text_ ActionEvent
    {
    	static int clicks1 = 0;  //用于保存按钮1单击次数
    	static int clicks2 = 0;  //用于保存按钮2单击次数
    	public static void main(String[] args) 
    	{
    		JFrame jframe = new JFrame("动作监听");  //窗口
    		jframe.setSize(200, 100);  //设置窗口大小
    		JPanel jpanel1 = new JPanel();  //面板
    		JButton jbutton1 = new JButton("按钮1");  //按钮1
    		JButton jbutton2 = new JButton("按钮2");  //按钮2
    		JTextField jtextfield1 = new JTextField("",15);  //用于显示的文本框,为15列
    		
    		//创建响应动作监听的类,它需要重写ActionListener接口的actionPerformed()方法
    		class jbutton1hander implements ActionListener
    	    {
    	        @Override
    	        public void actionPerformed(ActionEvent e)
    	        {
    	        //下面是重点
    	        	String name = e.getActionCommand();   //这个方法用于获取动作命令
    	            if(name.equals("按钮1"))
    	            {
    	            	jtextfield1.setText("按钮1被单击 " + (++clicks1) + " 次");
    	            }
    	            else
    	            {
    	            	jtextfield1.setText("按钮2被单击 " + (++clicks2) + " 次");
    	            }  
    	        }
    	    }
    		jbutton1.addActionListener(new jbutton1hander()); //这句话很关键,添加动作监听器
    		jbutton2.addActionListener(new jbutton1hander()); //两个按钮添加同一个动作监听器
    		
    		jpanel1.add(jtextfield1);  //文本框添加入面板
    		jpanel1.add(jbutton1);    //按钮1添加入面板
    		jpanel1.add(jbutton2);    //按钮2添加入面板
    		jframe.add(jpanel1);    //面板添加入窗口
    		
    		jframe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置关闭时操作
    		jframe.setVisible(true);   //设置可见
    	}
    }
    

    运行结果:
    没有开始单击时
    在这里插入图片描述
    第1次单击,单击按钮1
    在这里插入图片描述
    第2次单击,单击按钮1
    在这里插入图片描述
    第3次单击,单击按钮2
    在这里插入图片描述
    第4次单击,单击按钮1
    在这里插入图片描述
    第一种方法,在处理的事件比较少时比较方便,代码集中易于理解。

    但是它的缺点也很明显,因为只有一个监听器,当程序比较复杂时,需要大串的if-else语句来实现,程序代码就变得难阅读与维护。

    <2>使用匿名内部类的实现

    public class text_ ActionEvent
    {
    	static int clicks1 = 0;   //记录按钮1的点击次数
    	static int clicks2 = 0;   //记录按钮2的点击次数
    	public static void main(String[] args) 
    	{
    		JFrame jframe = new JFrame("动作监听");  //窗口
    		jframe.setSize(200, 100);   //设置窗口大小
    		JPanel jpanel1 = new JPanel();  //面板
    		JButton jbutton1 = new JButton("按钮1");  //按钮1
    		JButton jbutton2 = new JButton("按钮2");  //按钮1
    		JTextField jtextfield1 = new JTextField("",15);  //用于显示的文本框,为15列
    		//下面很关键
    		//使用匿名内部类添加监听器
    		jbutton1.addActionListener
    		(
    			new ActionListener()  //需要实现的接口
    			{
    				@Override        //必须重写ActionListener接口的actionPerformed方法
    				public void actionPerformed(ActionEvent e)
    				{
    					jtextfield1.setText("按钮1被单击 " + (++clicks1) + " 次");
    				}
    			}
    		);
    		
    		jbutton2.addActionListener
    		(
    			new ActionListener()  //需要实现的接口
    			{
    				@Override        //必须重写ActionListener接口的actionPerformed方法
    				public void actionPerformed(ActionEvent e)
    				{
    					jtextfield1.setText("按钮2被单击 " + (++clicks2) + " 次");
    				}
    			}
    		);
    		
    		jpanel1.add(jtextfield1);  //文本框添加入面板
    		jpanel1.add(jbutton1);    //按钮1添加入面板
    		jpanel1.add(jbutton2);    //按钮2添加入面板
    		jframe.add(jpanel1);    //面板添加入窗口
    		
    		jframe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置关闭时操作
    		jframe.setVisible(true);   //设置可见
    	}
    }
    

    运行结果同上不再赘述

    第二种方法也会出现一定的问题,现实中,因为整个程序中的组件不是全部定义在一起的,当组件变多,分散在程序中,也不便于阅读和修改。

    <3>使用一般的命名内部类的实现

    public class text_ ActionEvent
    {
    	static int clicks1 = 0;  //记录按钮1的单击次数
    	static int clicks2 = 0;  //记录按钮2的单击次数
    	public static void main(String[] args) 
    	{
    		JFrame jframe = new JFrame("动作监听");  //窗口
    		jframe.setSize(200, 100);   //设置窗口大小
    		JPanel jpanel1 = new JPanel();  //面板
    		JButton jbutton1 = new JButton("按钮1");  //按钮1
    		JButton jbutton2 = new JButton("按钮2");  //按钮1
    		JTextField jtextfield1 = new JTextField("",15);  //用于显示的文本框,为15列
    		
    		//下面很关键
    		//使用一般类创建动作监听者
    		class jbutton1Handler implements ActionListener
    		{
    			@Override        //必须重写ActionListener接口的actionPerformed方法
    			public void actionPerformed(ActionEvent e)
    			{
    				jtextfield1.setText("按钮1被单击 " + (++clicks1) + " 次");
    			}
    		}
    		
    		class jbutton2Handler implements ActionListener
    		{
    			@Override        //必须重写ActionListener接口的actionPerformed方法
    			public void actionPerformed(ActionEvent e)
    			{
    				jtextfield1.setText("按钮2被单击 " + (++clicks2) + " 次");
    			}
    		}
    		
    		//按钮分别添加不同动作监听者
    		jbutton1.addActionListener(new jbutton1Handler());
    		jbutton2.addActionListener(new jbutton2Handler());
    		
    		jpanel1.add(jtextfield1);  //文本框添加入面板
    		jpanel1.add(jbutton1);    //按钮1添加入面板
    		jpanel1.add(jbutton2);    //按钮2添加入面板
    		jframe.add(jpanel1);    //面板添加入窗口
    		
    		jframe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置关闭时操作
    		jframe.setVisible(true);   //设置可见
    	}
    }
    
    展开全文
  • Android 监听应用的安装和卸载

    热门讨论 2012-11-29 18:11:40
    如果想要监听获取应用的安装和卸载事件,只需要自定义一个BroadcastReceiver,来对系统广播进行监听和处理
  • Vue监听数组 watch监听

    千次阅读 2020-10-05 15:48:53
    Vue中监听数组解析 1,简单监听一个参数,demo如下 data() { return { msg: "test---test", } }, watch: { msg(newVal, oldVal) { console.log(newVal) console.log(oldVal) }, }, created() { thi

    Vue中监听数组解析

    1,简单监听一个参数,demo如下

    data() {
            return {
                msg: "test---test",
            }
        },
        watch: {
            msg(newVal, oldVal) {
                console.log(newVal)
                console.log(oldVal)
            },
        },
        created() {
            this.msg = "change"
        }
    

    这个就是对一个简单参数的监听

    2,对数组的监听,上代码

        data() {
            return {
                list: [1, 2, 3, 4, 6],  //需要被监听的数组
            }
        },
        watch: {
            list(newVal, oldVal) {  //对数组进行监听
                console.log(newVal)
                console.log(oldVal)
            },
        },
        created() {
            this.list[2] = "666"   //将数组对应下标值改变
        }
    

    以上方法watch并不会有任何监听结果,此时监听失败。那么这个问题的由来,可以参考这篇文章监听数组变化
    解决办法,
    方法一
    使用vuejs提供的变异方法,例如splice() push() 等

        created() {
            this.list.splice(1,1,666)  //用splice方法,将数组index=1的数值改成换成666
            // this.list.push("") // 增加空值  也能监听到
            // this.list.pop()
            // this.list.shift()
            //this.length = 10  //直接改变数组长度  无效
        }
    

    在这里插入图片描述
    以上方法就可以监听数组中某个值或属性改变,类似还有push,pop,等方法,这里不进行列举。补充一下,如果直接这样写 this.list.length = 7 或 增加深度监听(handler方法和immediate属性)这样都是无法监听到的。直接增加数组长度,而由于 JavaScript 的限制,Vue 不能检测以下变动的数组:

    //当你利用索引直接设置一个项时,例如:vm.items[indexOfItem] = newValue
    //当你修改数组的长度时,例如:vm.items.length = newLength

    方法二 Vue.set (简洁明了 推荐使用)
    Vue.set(vm.items, indexOfItem, newValue) (要改变的数组, 下标 , 新值)
    或者使用 this.$set(this.list,1,888) 以上例子输出结果,也可以检测到数组变化

    [1, 888, 3, 4, 6, ob: Observer]
    [1, 888, 3, 4, 6, ob: Observer]

    以上有个问题,那就是你会发现打印的新值和旧值是一样的。虽然它监听到改变,但是无法判断具体是哪个值发生了改变,官方给出了说明
    在这里插入图片描述

    解决办法

    可采用computed计算属性进行对源对象的深拷贝,完成新值更新。

    export default {
        name: 'App',
        data() {
            return {
                list: [1, 2, 3, 4, 6],
            }
        },
        computed: {
            newList(){    
                return JSON.parse(JSON.stringify(this.list))
            }
        },
        watch: {
            newList(newVal, oldVal) {
                console.log(newVal)
                console.log(oldVal)
            },
        },
        created() {
            this.$set(this.list,1,888)
        }
    }
    

    在这里插入图片描述
    到这里,就可以实现对数组多方位监听以及数值的变化了,希望可以帮到你。

    展开全文
  • JAVA监听

    万次阅读 多人点赞 2018-08-15 00:45:49
    作为JAVA开发人员,我们应对javaweb的三个技术要点之一的Listener进行学习,楼主查阅相关资料并学习相关视频,总结如下JAVA监听器内容,供大家参考学习。完整代码内容我已放到我的github中,请自行下载:...
  • 关于Selenium监听器不能监听浏览器实际发生的事件的研究 由于工作需要,因此进行了Selenium监听器方面的研究,发现一个问题: Selenium的监听器无法监听浏览器实际发生的事件。   由于本人用的是java+Selenium...
  • activity监听器使用

    千次阅读 2021-05-09 14:55:46
    监听器在java众多的中间件中都有着广泛的使用,比如大家熟知的MQ,在处理消息时很大程度上要依赖监听器,对activity ,也提供了监听器以及对监听器内的各种事件进行定义,方便开发者在使用的时候方便的进行选择使用 ...
  • watch监听中 立即监听和深度监听

    千次阅读 2019-11-21 10:42:42
    wacth通常用来监听数据的变化如下代码,默认是被监听数据变化时执行, 其中handler默认情况下不用写,下图是需要这个监听立即被执行,就是首次进来没变化的时候就执行设置属性, 不需要立即执行就不用添加...
  • android监听app安装与卸载

    千次阅读 2019-08-16 10:32:15
    许多时候,需要监听到程序是否安装或者卸载成功,在android系统中,安装和卸载都会发送广播,当应用安装完成后系统会发android.intent.action.PACKAGE_ADDED广播。可以通过intent.getDataString()获得所安装的包名。...
  • return {// 定义一个简单对象 **obj** obj: { txt: "oldMsg" ...watch: {//最原始写法 无仍和监听效果 obj(newVal, oldVal) { console.log(newVal) console.log(oldVal) }, }, created() { this.obj.txt = “n
  • 本章内容 监听器的概述以及使用场景 监听Servlet上下文对象的实现及作用 监听HTTP会话 Session对象的实现及作用 ...web 监听器是一种 Servlet 中特殊的类,它们能帮助开发者监听 web 中特定的事件,比如 Se...
  • deep的意思就是深入观察,监听器会一层层的往下遍历,给对象的所有属性都加上这个监听器,但是这样性能开销就会非常大了,任何修改obj里面任何一个属性都会触发这个监听器里的 handler。 但是在实际开发过程中,...
  • 在实际的开发项目中,监听 key 的过期事件,应用非常广泛,例如:订单超时未支付,优惠券过期等等 一、修改 Redis 配置文件 1、在 Redis 的安装目录 2、找到 redis.windows.conf 文件,搜索 “notify-keyspace-...
  • 通过WifiManager监听Wifi信号强弱

    热门讨论 2013-11-04 14:03:09
    通过WifiManager监听Wifi信号强弱,即获得一定的数值,通过数值范围来判断,并更换图片
  • 轻量级的binlog监听方案

    千次阅读 2019-09-15 20:46:25
    互联网体系架构具有可控性差、 数据量大、 架构复杂等特点,错综复杂的各业务模块需要...mysql已成为互联网项目存储的主力,围绕着它的各外围模块急需实时地获取它的数据,binlog监听是解决此实时同步问题的不二之选。
  • SpringBoot事件的发布和监听

    千次阅读 2020-01-27 20:14:04
    在Spring中通常是ApplicationContext本身担任监听器注册表的角色,在其子类AbstractApplicationContext中就聚合了事件广播器ApplicationEventMulticaster和事件监听器ApplicationListnener,并且提供注册监听器的...
  • 监听器之Session监听

    千次阅读 2019-08-16 17:52:07
    监听实际上指的是对整个Web中需要的位置上的操作进行的一种监听而已,当发生了某些操作之中会自动的执行一些处理功能。那么怎么进行监听呢? 在监听器里面实际上主要都是针对于属性的监听(request、session、...
  • VUE监听同时监听多个属性

    千次阅读 2020-02-08 22:10:17
    同时监听多个属性 多种监听方式:数组、对象、值 同时监听多个属性 重点 通过计算属性将两个对象组合起来,并通过watch属性监听 只可以是两个完整的属性,不可以是子属性。例如,就不能是const {student.name,...
  • Android监听屏幕是否锁屏

    千次下载 热门讨论 2012-06-13 10:37:23
    监听是否锁屏,详见博文:http://blog.csdn.net/m_changgong/article/details/7608911
  • 事件监听机制(一)Java事件监听

    千次阅读 2019-02-25 09:56:27
    事件监听机制(一)Java事件监听 事件监听实现流程 事件对象: 继承自java.util.EventObject对象,由开发者自行定义实现。 事件源: 就是触发事件的源头,不同的事件源会触发不同的事件类型。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,510,512
精华内容 604,204
关键字:

监听