精华内容
下载资源
问答
  • Java实现时间监听

    2017-12-19 21:03:25
    Java实现时间监听Java实现时间监听Java实现时间监听Java实现时间监听Java实现时间监听Java实现时间监听
  •  2.1Java时间监听机制涉及到三个组件:事件源、事件监听器、事件对象  2.2当事件源上发生操作时,它会调用事件监听器的一个方法,并且调用这个方法时,会传递事件对象过来  2.3事件监听器是由开
  • java事件监听器原理

    千次阅读 2017-10-06 12:51:25
    java事件监听器分为三部分:事件,事件源,监听器。事件—事件状态对象,也就是发生了什么事件。用于listener的相应的方法之中,作为参数,一般存在与listerner的方法之中。(伴随着事件的发生,相应的状态通常都封装...

    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中也可以放在同一个类中,可以根据事件的状态,进行不同的处理。这样做的可以随时根据当前状态判断发生的是什么事件。

    展开全文
  • 本文中主要陈述一种实时监听文件夹中是否有文件增加的功能,可用于实际文件上传功能的开发。本文通过实例代码给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友参考下吧
  • 主要介绍了Java设计模式之监听器模式,结合实例形式较为详细的分析了java设计模式中监听器模式的概念、原理及相关实现与使用技巧,需要的朋友可以参考下
  • 运行后可以在后台进行监听键盘时间。后台支持打印记录,现在可以打出键盘编号,不用设置焦点就能监听键盘所有操作。
  • Java 中的事件监听机制

    千次阅读 2015-07-23 17:21:10
    java事件机制包括三个部分:事件、事件监听器、事件源。 1.事件:继承自java.util.EventObject类,开发者自定义。 package com.shuyan.javatest.EventTest; import java.util.EventObject; public class DnsEvent...

    看项目代码时遇到了好多事件监听机制相关的代码,现学习一下:

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

    1.事件:继承自java.util.EventObject类,开发者自定义。

    package com.shuyan.javatest.EventTest;
    
    import java.util.EventObject;
    
    public class DnsEvent extends EventObject {
    
    
        private String userData;
    
        private long parseTime;
    
        public DnsEvent(Object source) {
            super(source);
        }
    
        public DnsEvent(Object source, String userData, long parseTime) {
            super(source);
            this.userData = userData;
            this.parseTime = parseTime;
        }
    
        public String getUserData() {
            return userData;
        }
    
        public void setUserData(String userData) {
            this.userData = userData;
        }
    
        public long getParseTime() {
            return parseTime;
        }
    
        public void setParseTime(long parseTime) {
            this.parseTime = parseTime;
        }
    
    }

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

    package com.shuyan.javatest.EventTest;
    
    import java.util.EventListener;
    
    public interface DnsEventListener extends EventListener {
    
        public void processDnsEvent(DnsEvent dnsEvent);
    
    }
    监听器的具体实现类

    public class DnsEventaListenerImpl implements DnsEventListener {
    
        @Override
        public void processDnsEvent(DnsEvent dnsEvent) {
    
            String userdata = dnsEvent.getUserData();
            System.out.println("userdata-->" + userdata);
    
        }
    }

    3.事件源:事件发生的地方,由于事件源的某项属性或状态发生了改变导致某项事件发生。由于事件监听器要注册在事件源上,所以事件源类中应该要有盛装监听器的容器(List,Set等)。

    public class ManagerListener {
    
    
        private List<DnsEventListener> listeners = null;
    
        private static class Singleton {
            static ManagerListener managerListener = new ManagerListener();
        }
    
        public static ManagerListener getInstance() {
            return Singleton.managerListener;
        }
    
        private ManagerListener() {
            listeners = new ArrayList<>();
        }
    
        public void addDnsEventListener(DnsEventListener listener) {
            this.listeners.add(listener);
        }
    
        public void removeDnsEventListener(DnsEventListener listener) {
            this.listeners.remove(listener);
        }
    
        public void fireDnsEventListener(DnsEvent event) {
            for (DnsEventListener listener : listeners) {
                listener.processDnsEvent(event);
            }
        }
    
    
    }
    测试如下:


    public class DnsEventTest {
        public static void main(String[] args) {
            ManagerListener managerListener = ManagerListener.getInstance();
            DnsEvent dnsEvent = new DnsEvent(managerListener, "data", 1000L);
            DnsEventaListenerImpl listener = new DnsEventaListenerImpl();
    
            managerListener.addDnsEventListener(listener);
            managerListener.fireDnsEventListener(dnsEvent);
        }
    }



    参考:http://blog.csdn.net/longlong3050/article/details/6854456



    展开全文
  • 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

    展开全文
  • Java监听

    2020-12-09 20:26:20
    编写java类实现监听器的接口,并且实现其接口方法 在web.xml文件中对实现的监听器类进行注册 监听器的实现过程: 1.编写java类实现监听器的接口,并且实现其接口方法 不同接口的实现描述 ...

    定义

    • 是Servlet规范定义的一种特殊类
    • 用于监听ServletContext,HttpSession,ServletRequest等域对象的创建,销毁及其属性修改发生变化的事件
    • 在时间发生前后进行一些必要的操作

    实现步骤

    1. 编写java类实现监听器的接口,并且实现其接口方法
    2. 在web.xml文件中对实现的监听器类进行注册

    监听器的实现过程:

    1.编写java类实现监听器的接口,并且实现其接口方法 

    不同接口的实现描述

    • ServletContextListener:监听ServletContext对象应用程序的创建和销毁,ServletContext生命周期的监听
    • HttpSessionListener:对会话对象的创建和销毁的监听
    • ServletRequestListener:对请求对象的创建和销毁的监听
    • ServletContextAttributeListener:对Servlet属性做监听
    • HttpSessionAttributeListener:对会话属性的变化事件进行监听
    • ServletRequestAttributeListener:对请求对象的属性进行监听
    • HttpSessionBindingListener:绑定到session中的某个对象的状态事件监听器(不需要在web.xml中进行绑定)

    该接口有两个方法:

    • contextInitialized():完成对象初始化的监听,web程序启动时
    • contextDestroyed():对web程序的移除销毁,清理工作,防止资源的浪费

    2.在web.xml文件中对实现的监听器类进行注册

    运行看一看:可以看到web应用程序的创建和销毁过程


    HttpSessionListener:对会话对象的创建和销毁的监听

    先创建会话,然后会在1分钟后销毁创建id 

    监听器案例

    通过监听器实现web应用重复登陆,保证在同一个时间只有一个用户在进行登陆

    • 通过过滤器实现登陆控制,未登陆用户不能访问系统首页
    • 用户登录,将登录名存储到session中
    • 登录监听器监听session属性中登录属性的变化
    • 若登录用户用户名已经登录系统,清楚前次的登录信息

    登录页面的设置

    首先在login.jsp页面获取我们的用户值

    然后将这个用户值显示到main.jsp页面中

     

    运行看一看效果! 

    登录权限过滤(由过滤器来实现)

    • 首先创造一个过滤器,并且进行实现

    • 记得需要在web.xml中进行映射的配置

    •  最后在index.jsp页面中,完成弹窗的响应

    • 运行看一看,当我们直接访问main.jsp页面时,会跳出弹窗,并且点击确定后,会自动重定向到登录页面 

    用户信息存储实现(单例模式)

    数据缓存,来存储用户的登录信息,进行登录信息的判断,查看是否有同样的数据进行了登录。

    • 首先,创建一个类,并将它修改为单例模式

    HttpSession对象在创建后,都会有一个唯一的ID用于与其他的session做标志区别

                                                                    

    功能类的总的实现代码:

    package com.kilig.cache;
    
    import java.util.HashMap;
    import java.util.Map;
    
    import javax.servlet.http.HttpSession;
    
    public class LoginCache {
    	//首先将类修改为单例模式的类
    	//1.构造器的私有化
    	//2.定义静态变量
    	private static LoginCache instance =new LoginCache();
    	//定义集合存储缓存信息,首先将用户登录名和SessionID进行关联
    	private Map<String, String> loginUserSession =new HashMap<String, String>();
    	//在存储SessionID和session会话本身映射集合
    	private Map<String, HttpSession> loginSession =new HashMap<String, HttpSession>();
    	private LoginCache() {
    
    	}
    	//3.定义静态方法获取对象的实例
    	public static LoginCache getInstance() {
    		return instance;
    	}
    	//封装方法,操纵集合
    	public String getSessionIdByUsername(String username) {
    		return loginUserSession.get(username);//通过用户名获取集合中对应的NID
    	}
    	public HttpSession getSessionBySessionId(String sessionId) {
    		return loginSession.get(sessionId);//通过SessionId获得Session对象
    	}
    	//存储功能处理
    	public void setSessionIdByUsername(String username, String sessionId) {
    		loginUserSession.put(username, sessionId);//存储username,sessionId到会话缓存中
    	}
    	public void setSessionBySessionId(String sessionId, HttpSession session) {
    		loginSession.put(sessionId, session);//存储sessionId,session到会话缓存中
    	}
    }
    

    监听功能实现

    当session属性创建后,就是用户第一次访问web应用。用户可能只访问了登录界面,而并没有进行登录操作,此时监听到了会话的创建,但是对登录操作来说是没有任何意义的。

    因此我们采用的是属性的监听器。此时我们监听的就是loginUser,当user被创建时,此时就表示我们的用户进行了登录。因此就使用HttpSessionAttributeListener。

    记得在web.xml中进行注册哦 

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • Java端口监听

    千次阅读 2020-05-06 22:16:04
    import java.io.*; import java.net.ServerSocket; import java.net.Socket; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.SQLException; imp....
  • JAVA监听

    万次阅读 多人点赞 2018-08-15 00:45:49
    作为JAVA开发人员,我们应对javaweb的三个技术要点之一的Listener进行学习,楼主查阅相关资料并学习相关视频,总结如下JAVA监听器内容,供大家参考学习。完整代码内容我已放到我的github中,请自行下载:...
  • 主要介绍了Java Swing中JList选择事件监听器ListSelectionListener用法,结合具体实例形式分析了中JList选择事件监听器ListSelectionListener的功能、使用方法及相关注意事项,需要的朋友可以参考下
  • Java监听器的四种实现方法

    千次阅读 2020-10-21 11:04:04
    监听器的三种实现方法(OnlickListener) android监听有4种实现方法,匿名内部类实现,内部类实现,实现事件接口,覆写方法实现,控件onClick属性实现事件,下面我将一一举例。 欢迎使用Markdown编辑器 你好! 这是你...
  • 业务场景: 新上线一个线上运行版本,测试运行一段时间验证是否可用。测试运行版本要保证与之前服务的数据一致,故做了个日志转发,把发送到现运行版本的请求全部转发给测试版本一份。程序完全基于jvm自有jar包实现...
  • java监听器之定时器

    2018-05-22 10:13:14
    监听器之定时器,写一个定时器的监听器,这个监听器每十秒向控制台输出一次时间信息 博客地址:https://blog.csdn.net/qq_36631076/article/details/80401609
  • 由于玩某网游需要在出副本时等一分钟,而修改系统时间+1分钟可以提前出副本,避免麻烦写了个java后台监听键盘触发修改系统时间的脚本,当按下设置好的键盘组合即调用修改函数。   修改时间的函数代码如下(调用CMD...
  • Java实现监听文件变化的监听

    万次阅读 2019-01-05 16:52:09
    2、每次运行时,都会先调用事件监听处理类的 onStart 方法,然后检查是否有变动,并调用对应事件的方法,如 onChange 文件内容改变,检查完后,再调用 onStop 方法,释放当前线程占用的CPU资源,等待下次间隔时间到...
  • 自定义Java监听

    千次阅读 2019-04-28 12:04:31
    当范围对象的状态发生变化的时候,服务器自动调用监听器对象中的方法。 例如:创建一个“人”类Class Person 人拥有吃的方法public void eat(){},我们的目的就是,在这个人吃之前要提醒他洗手,所以我们就要监听这个...
  • Java常用事件监听器与实例分析

    千次阅读 多人点赞 2020-07-30 08:32:34
    动作时间监听器 焦点事件监听器 Hello!大家好哇,我是灰小猿! 今天来和大家总结一下有关在进行Java的GUI编程时常用的事件监听函数的基本作用和功能。 我们知道在Java窗体中的组件,本身是不具备任何功能的,...
  • 定义一个变量int a,在每次循环的过程中将某个集合的长度赋值给a,目的是能够判断当这个集合的长度不在改变。 想做一个监听机制,设置时间为4秒,在循环的过程中监听4秒内这个变量是否有变动
  • 主要介绍了java开发gui教程中jframe监听窗体大小变化事件和jframe创建窗体的示例,需要的朋友可以参考下
  • java Netty监听指定端口获取数据

    千次阅读 2020-08-31 19:46:13
    public class ServerHandler extends SimpleChannelInboundHandler<Object> { // private static final Logger logger = LoggerFactory.getLogger(NioServerHandler.class); /** *读取客户端发来的数据 ...
  • Java Swing 键盘事件监听

    千次阅读 2019-09-16 10:30:30
    Java Swing 键盘事件监听 开发工具与关键技术:java、 elipse2019、jdk1.8 作者:Amewin 撰写时间:2019年9月16日 键盘事件的事件源一般丐组件相关,当一个组件处于激活状态时,按下、释放或敲击键盘上的某个键时...
  • Java - 监听器有哪些作用和用法?

    万次阅读 2019-03-19 15:26:22
    Java Web开发中的监听器(listener)就是application、session、request三个对象创建、销毁或者往其中添加、修改、删除属性时自动执行代码的功能组件,如下所示: ①ServletContextListener:对S...
  • Java Swing 常用事件和监听器接口

    热门讨论 2009-11-24 22:33:46
    是笔者学习java swing事件、监听器、接口方法的总结,希望对初学java者有所帮助,是word格式,希望有人进一步总结。
  • java监听者模式

    2018-12-07 14:44:19
    Java时间监听机制涉及到三个组件:事件源、事件监听器、事件对象 当事件源上发生操作时,它会调用事件监听器的一个方法,并且调用这个方法时,会传递事件对象过来 事件监听器是由开发人员编写,开发人员在事件...
  • java实现监听进程

    千次阅读 2015-01-09 15:59:42
    但是,问题来了,长时间开挂的话腾讯有验证码,超过10分钟不输入外挂就自动关闭了。所以我就想搞一个程序挂在服务器上监听我的农场外挂,如果外挂自动退出了,我就给自己发一封邮件。 想来想去我决定用Runtime来实现...
  • java监听、读取串口数据

    万次阅读 多人点赞 2017-11-17 15:29:00
    一但说要监听一个串口的数据,我们一般都会是会想到C#,但是就是不想用C#来开发。其实java也是可以的。 第一:需要下载一个额外的支持Java串口通信操作的jar包,Rxtx这个jar包(32位/64位均支持)。下载地址(里面...
  • 我们通常会遇到这样的需求,修改配置文件后不需要重启项目即可生效,此时我们需要去监听配置文件是否有被修改,如果发现被修改,那么我们即可重新加载配置文件。 public class Doctor { private static final ...
  • java 监听器和监听器模式

    千次阅读 2017-01-09 14:25:37
    监听器是观察者模式的一种实现,监听器模式也就是观察者模式的一种。  监听器模式是对某种共有操作的监控。当此操作执行时对此操作作相应处理。 包含的元素:  1. 要监控的事件定义Event  2. 监控该...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 229,862
精华内容 91,944
关键字:

java时间监听

java 订阅