Servlet监听
8种监听器分别是：
8种监听器分别是：
1.监听器⽤来监听web程序中的事件，例如创建、修改、删除session、request、context等。
想要实现监听器的功能需要实现监听器的接⼝xxxLinetener,当Tomcat触发监听器的时候，会⾃动调⽤。
监听器可以分为四种类型：
1.监听对象的创建：
ServletContext:主要监听servletContext的创建，需要实现ServeltContextListener接⼝。
ServletRequest:主要监听request的创建，需要实现ServletRequestListener接⼝
HttpSession:主要监听session的创建，需要实现HttpSessionListener接⼝
2.监听属性的改变：
ServletContext:主要监听servletContext属性的更改、添加、删除，需要实现ServeltContextAttrbuteListener接⼝。
ServletRequest:主要监听request属性的更改、添加、删除，需要实现ServletRequestAttrbuteListener接⼝
HttpSession:主要监听session属性的更改、添加、删除，需要实现HttpSessionAttrbuteListener接⼝
3.监听session的活化与钝化：
httpSessionActivationListener主要监听了session的活化与钝化
4.监听session与对象的绑定：
httpSessionBindingListener监听了session与对象的绑定。
《Servlet组件》-第03章- 监听器与过滤器-题目
知识点01-监听器：011203001题目1：当Web应用程序被关闭时，Servlet容器会调用Servlet Context“监听器”的哪个方法？( B ) 易A contextInitialized()B contextDestroyed()C contextFinialized()D contextShutdown()题目2：监听事件和处理事件（A ）易A 都由Listener完成B 都由相应事件Listener处登记过的构件完成C 由Listener和构件分别完成D 由Listener和窗口分别完成题目3：察看下面这个类（ C ）易public class IfAttributsChanged implements ServletContextAttributeListener{public void attributeAdded(ServletContextAttributeEvent scab){System.out.println(“加入一个属性”);}public void attributeRemoved(ServletContextAttributeEvent scab){System.out.println(“删除一个属性”);}}关于IfAttributsChanged类的叙述，下列哪一个为真？A 此类可以成功编译B 此类无法成功编译，原因是缺少attributeChanged()方法。
C 此类无法成功编译，原因是缺少attributeReplaced()方法。
D 此类无法成功编译，原因是缺少attributeUpdated()方法。
题目4：实现下列哪一种接口的对象，并不需要在web.xml文件内进行额外的设定，Servlet 容器就能够回应该对象加入HTTP会话所发生的事件？（D ）易A ServletContextListenerB HttpSessionListenerC HttpSessionAttributeListenerD HttpSessionBindingListener题目5：上下文相关的监听器（B C）（选择两项）易A HttpSessionListenerB ServletContextListenerC ServletContextAttributeListenerD ServletRequestAttributeListener题目6：Servlet2.4 以后提供了哪几种对象的事件监听。
java总结
1、Servlet与JSP有什么区别？Servlet和JSP完成的功能是相同的，都可以接收用户的请求，可以对用户进行响应，可以调用业务方法。
不同点在于JSP是在html或者xml中嵌入了Java代码或者JSP的标记，在制作页面方面具有优势，可以使用网页编辑工具来制作网页，然后嵌入Java或者JSP的标记。
Servlet是纯Java代码，通常用于控制，不用于输出。
在MVC模式中，JSP通常充当视图，Servlet通常充当控制器。
另外，JSP 在运行的时候还要转换成类似于Servlet的Java代码。
2、Servelt通常有哪些方法init方法，完成初始化service方法，包括doGet和doPost，用于接收用户的请求，调用后台的JavaBean或者EJB，选择界面对用户响应。
destroy方法，用于释放资源3、谈谈Servlet的生命周期当接收到请求的时候，容器察看对应的Servlet对象是否存在，如果不存在，需要加载Servetl，实例化Servlet，调用init方法进行初始化。
如果已经存在，根据用户的请求创建request和response对象，把这两个对象作为参数调用Servlet对象的service方法，Servlet通过这个方法与用户进行交互，方法执行完之后，对请求的处理结束。
Servelt对象继续等待下一个请求。
当应用卸载的时候，调用destroy 方法释放资源。
多个请求共享Servelt对象。
4、Servlet API的两个主要包javax.servlet.*;javax.servlet.http.*;5、编写Servlet需要继承的类是什么？HttpServlet6、编写Servlet通常需要实现的两个方法是什么？doGet方法和doPost方法7、doGet方法和doPost方法中的两个参数是什么？HttpServletRequest和HttpServletResponse，前者封装了与请求相关的信息，后者封装了与响应相关的信息。
JSP应用与开发技术第12、13、14章 课后习题答案
第12章Servlet基础1.简述Servlet和JSP的关系。
答：Servlet是服务器端运行的一种Java应用程序。
当浏览器端有请求则将其结果传递给浏览器。
在JSP中使用到的所有对象都将被转换为Servlet或者非Servlet的Java对象，然后被执行，所以执行JSP实际上与执行Servlet是一样的。
2.简述Servlet的生命周期。
答：Servlet的生命周期可分为下面几个阶段：（1）装载Servlet。
（2）实例化一个Servlet实例对象。
（3）调用Servlet的init( )方法进行初始化。
（4）服务。
（5）卸载。
3.简述HttpSession接口的功能和使用方法。
答:.HttpSession接口是Servlet提供会话追踪解决方案。
HttpSession对象存放在服务器端，只是对cookie和url重写技术的封装应用。
使用HttpSession进行会话控制的过程：（1）获得一个HttpSession实例对象；（2）访问和设置与会话相关联信息，维护会话的状态；（3）废弃会话数据。
4.简述开发一个Servlet所需要的步骤。
答：第一步：编写Servlet实例第二步：在web.xml文件中配置该Servlet第三步：编写其它文件5.编写一个html页面和一个Servelt，实现利用Servelt的doPost方法读取html文件中Form表单内容。
答：参考12.6.26.写一个利用HttpSession接口的用户登录的Servlet，当用户已经登录时，返回欢迎信息；否则转向登录页面。
答：第一步：编写Servlet实例SessionServlet.java所示。
package com;import java.io.*;import java.util.*;import javax.servlet.*;import javax.servlet.http.*;/**** 使用HttpSession管理会话的登录Servlet*/public class LoginServlet extends HttpServlet {p rotected void doGet(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException { doPost(request, response);}p rotected void doPost(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html;charset=GB2312");PrintWriter out = response.getWriter();out.println("<html>");out.println("<body>");out.println("<head>");out.println("<title>使用HttpSession管理会话的登录页面</title>");out.println("</head>");out.println("<body>");// 获取会话对象HttpSession session = request.getSession();// 从会话对象中读取数据Boolean isLogin = (Boolean) session.getAttribute("isLogin");if (isLogin == null) {isLogin = Boolean.FALSE;}String user = request.getParameter("user");String password = request.getParameter("pass");if (isLogin.booleanValue()) {// 从会话对象中读取数据user = (String) session.getAttribute("user");Date loginTime = new Date(session.getCreationTime());out.println("<h2>欢迎您，" + user + "！</h2>");out.println("<h2>您的登录时间是：" + loginTime + "！</h2>");} else if ((user != null) && (password != null)) {// 在会话对象中保存数据session.setAttribute("user", user);session.setAttribute("isLogin", Boolean.TRUE);Date loginTime = new Date(session.getCreationTime());out.println("<h2>欢迎您，" + user + "！</h2>");out.println("<h2>您的登录时间是：" + loginTime + "！</h2>");} else {out.println("<h2>请在下面输入登录信息</h2>");out.println("<form method=\"post\" action=\"login\">");out.println("<table>");out.println("<tr>");out.println("<td>用户名：</td>");out.println("<td><input name=\"user\" type=\"text\"></td>");out.println("</tr>");out.println("<tr>");out.println("<td>密码：</td>");out.println("<td><input name=\"pass\" type=\"password\"></td>");out.println("</tr>");out.println("<tr>");out.println("<td></td>");out.println("<td><input name=\"ok\" type=\"submit\" value=\"确定\">");out.println("<input name=\"cancel\" type=\"reset\" value=\"重置\"></td>");out.println("</tr>");out.println("</table>");out.println("</form>");}out.println("</body>");out.println("</html>");}}第二步：在web.xml文件中配置该Servlet<web-app>……<!-- ServerInfoServlet definition --><servlet><description></description><display-name>getSession</display-name><servlet-name> getSession </servlet-name><servlet-class>com.SessionServlet</servlet-class></servlet><!-- SessionServlet definition --><servlet-mapping><servlet-name>getSession</servlet-name><url-pattern>/getSession</url-pattern></servlet-mapping>……</web-app>第13章使用Servlet过滤器和监听器1、什么是过滤器？什么是监听器？分别应用在哪些方面？答：对Web应用来说，过滤器就是驻留在服务器端，在源数据和目的数据间，对Web请求和Web响应的头属性(Header)和内容体(Body)进行操作的一种特殊Web组件。
Java三大器之拦截器（Interceptor）的实现原理及代码示例
Java三⼤器之拦截器（Interceptor）的实现原理及代码⽰例1，拦截器的概念java⾥的拦截器是动态拦截Action调⽤的对象，它提供了⼀种机制可以使开发者在⼀个Action执⾏的前后执⾏⼀段代码，也可以在⼀个Action执⾏前阻⽌其执⾏，同时也提供了⼀种可以提取Action中可重⽤部分代码的⽅式。
在AOP中，拦截器⽤于在某个⽅法或者字段被访问之前，进⾏拦截然后再之前或者之后加⼊某些操作。
⽬前，我们需要掌握的主要是Spring的拦截器，Struts2的拦截器不⽤深究，知道即可。
2，拦截器的原理⼤部分时候，拦截器⽅法都是通过代理的⽅式来调⽤的。
Struts2的拦截器实现相对简单。
当请求到达Struts2的ServletDispatcher时，Struts2会查找配置⽂件，并根据配置实例化相对的拦截器对象，然后串成⼀个列表（List），最后⼀个⼀个的调⽤列表中的拦截器。
Struts2的拦截器是可插拔的，拦截器是AOP的⼀个实现。
Struts2拦截器栈就是将拦截器按⼀定的顺序连接成⼀条链。
在访问被拦截的⽅法或者字段时，Struts2拦截器链中的拦截器就会按照之前定义的顺序进⾏调⽤。
3，⾃定义拦截器的步骤第⼀步：⾃定义⼀个实现了Interceptor接⼝的类，或者继承抽象类AbstractInterceptor。
第⼆步：在配置⽂件中注册定义的拦截器。
第三步：在需要使⽤Action中引⽤上述定义的拦截器，为了⽅便也可以将拦截器定义为默认的拦截器，这样在不加特殊说明的情况下，所有的Action都被这个拦截器拦截。
4，过滤器与拦截器的区别过滤器可以简单的理解为“取你所想取”，过滤器关注的是web请求；拦截器可以简单的理解为“拒你所想拒”，拦截器关注的是⽅法调⽤，⽐如拦截敏感词汇。
4.1，拦截器是基于java反射机制来实现的，⽽过滤器是基于函数回调来实现的。
（有⼈说，拦截器是基于动态代理来实现的）4.2，拦截器不依赖servlet容器，过滤器依赖于servlet容器。
listener、filter、servlet内存马原理
listener、filter、servlet内存马原理Listener、Filter、Servlet内存马原理引言随着Web应用程序的快速发展，保护Web应用程序的安全性变得越来越重要。
然而，Web应用程序中的安全漏洞却层出不穷，其中包括内存马（memshell）的攻击方式。
内存马指的是一种攻击技术，通过在服务器内存中注入恶意代码来获取对服务器的控制权。
本文将围绕Listener、Filter和Servlet这三个核心组件展开讨论，探究内存马攻击在这些组件中的原理及防御措施。
一、Listener的基本原理在Java Web应用程序中，Listener是一种用于监听Web应用程序中特定事件的组件。
它可以监听ServletContext（应用程序级别）、HttpSession（会话级别）和ServletRequest（请求级别）等不同级别的事件。
当某个事件发生时，Listener可以执行预定义的操作。
1.1 Listener的注册和触发在Web应用程序启动时，容器会根据部署描述文件（web.xml）中的配置自动注册Listener。
当发生事件时，容器会触发相应的事件监听器进行处理。
1.2 Listener内存马原理攻击者可以通过Listener注入恶意代码来执行恶意操作。
具体来说，攻击者将恶意代码编写到一个实现了特定监听器接口的类中，并将该类的实例注册到应用程序中。
当事件触发时，容器会调用相应的监听器方法。
如果存在恶意代码，它将被执行，并可能对服务器进行攻击，如获取敏感信息、操纵服务器配置等。
1.3 Listener的防御措施为了保护Web应用程序免受Listener注入攻击，我们可以采取以下措施：- 避免使用不必要的Listener：只注册需要的Listener，避免不必要的风险。
- 对注册的Listener进行严格审查：审查应用程序中注册的Listener代码，确保它们不包含任何可疑的操作。
- 限制Listener的执行权限：使用安全策略文件（security policy）对Listener的执行权限进行限制，仅允许它们执行必要的操作。
《JavaWeb课件：Servlet知识点详解》
Servlet的作用
通过Servlet，服务器可以根据 请求来生成响应结果进行返回， 从而实现服务器端的程序处理。
Java环境和Web容器
在使用Servlet之前，需要具备 基本的Java编程能力，并且需 要使用Web容器来提供Servlet 服务。
《Java Web课件：Servlet 知识点详解》
本课件详细讲解Java Web开发中的Servlet，包括基本概念、请求与响应、生 命周期、注解与配置、会话管理、过滤器与监听器及相关案例。
认识Servlet
Java Web课件
Java Web是使用Java技术进 行网络编程的一种方式。
Servlet是什么？
过滤器可以在HTTP请求到达目标资源之前，预先过滤一些请求，可以进行请求内 容的修改和重写。
2 过滤器的使用
在web.xml配置文件中，定义过滤器的名称、URL模式等，也可以使用注解等方 式进行配置和使用。
3 监听器的作用
监听器可以用于监视Servlet容器的一些状态和行为，如Session的创建和销毁等。
Servlet的生命周期
初始化过程
在Servlet被创建后，容器会自动调用init()方法，并传进一个ServletConfig对象。
服务处理过程
一旦容器调用了Servlet的init()方法，就可以接收请求并处理请求，此时Servlet实例会处于多个状态之 下。
销毁过程
Servlet实例会在某个时刻被销毁，此时容器会调用Servlet实例的destroy()方法。
Servlet的重定向和转发
Servlet中的Listener的应用
Servlet中的Listener的应用由于工作需要,最近在找一些解决方案,发现Listener是一个很好的东西,能够监听到session,application的create,destroy,可以监听到session,application属性绑定的变化,考虑了一下,可以应用在"在线人数统计","数据缓存"等各个方面,下面是整理的一些资料.Listener是Servlet的监听器，它可以监听客户端的请求、服务端的操作等。
通过监听器，可以自动激发一些操作，比如监听在线的用户的数量。
当增加一个HttpSession时，就激发sessionCreated(HttpSessionEvent se)方法，这样就可以给在线人数加1。
常用的监听接口有以下几个：ServletContextAttributeListener监听对ServletContext属性的操作，比如增加、删除、修改属性。
ServletContextListener监听ServletContext。
当创建 ServletContext时，激发contextInitialized(ServletContextEvent sce)方法；当销毁ServletContext时，激发contextDestroyed(ServletContextEvent sce)方法。
HttpSessionListener监听HttpSession的操作。
当创建一个Session时，激发session Created(HttpSessionEvent se)方法；当销毁一个Session时，激发sessionDestroyed (HttpSessionEvent se)方法。
HttpSessionAttributeListener监听HttpSession中的属性的操作。
当在Session增加一个属性时，激发 attributeAdded(HttpSessionBindingEvent se) 方法；当在Session删除一个属性时，激发attributeRemoved(HttpSessionBindingEvent se)方法；当在Session属性被重新设置时，激发attributeReplaced(HttpSessionBindingEvent se) 方法。
servlet监听器
Servlet监听器：1，什么是监听器？其主要的功能就是监听Web的各种操作，当相关的操作触发后将产生的事件，并对此事件进行处理；2，对application监听！对application监听，实际上就是对ServletContext（Servlet上下文）监听，主要使用ServletContextListener和ServletContextAttributeListener 两个接口；ServletContext状态监听：ServletContextListener接口；对Servlet上下文状态监听可以使用javax.servlet.ServletContextListener 接口，此接口的方法如下：No 方法类型描述1 public void contextInitialized(ServletContextEventsce)普通容器启动时触发2 public void contextDestoryed(ServletContextEventsce)普通容器销毁时触发在ServletContext监听操作中，一旦触发了ServletContextListener接口中定义的事件后，可以通过ServletContextEvent进行事件的处理，此事件定义的方法如下：No 方法类型描述1 public ServletContextgetServletContext()普通取得ServletContext对象可以通过getServletContext()方法取得一个ServletContext对象的实例，一个简单的ServletContextListenerDemo：Java代码1.package com.keith.listener;2.3.import javax.servlet.ServletContextEvent;4.import javax.servlet.ServletContextListener;5.6.public class ServletContextListenerDemo implements ServletContextListener {7.8. /**9. * context销毁时触发10. */11. public void contextDestroyed(ServletContextEvent event) {12. System.out.println("容器销毁时触发--->"+event.getServletContext().getContextPath());13. }14.15. /**16. * context加载的时候触发17. */18. public void contextInitialized(ServletContextEvent event){19. System.out.println("容器初始化---> "20. + event.getServletContext().getContextPath());21. }22.23.}在web.xml里这样配置：Xml代码1.<listener>2.<listener-class>com.keith.listener.ServletContextListenerDemo</listener-class>3.</listener>在web服务器关闭或者重启的时候会输出：容器初始化---> /jsp（jsp是我的工程名）；信息；ServletContext属性监听：ServletContextAttributeListener接口对Servlet上下文属性操作监听，可以使用javax.servlet.ServletContextAttributeListener接口，对此接口定义的方法：No 方法类描述型1 public void attributeAdded(ServletContextAttributeEvent scab)普通增加属性时触发2 public voidattributeRemoved(ServletContextAttribute Eventscab)普通删除属性时触发3 public voidattributeReplaced(ServletContextAttribute Eventscab)普通替换属性（重复设置）时触发在上下文属性监听中，一旦触发了SerlvetContextAttributeListener接口中定义的事件后，可以通过ServletContextAttributeEvent进行事件的处理，此事件定义的方法如下：No 方法类型描述1 public String getName() 普通取得设置的属性名称2 public Object getValue() 普通取得设置的属性内容对ServletContext属性的监听例子：ServletContextAttributeListenerDemo：Java代码1.package com.keith.listener;2.3.import javax.servlet.ServletContextAttributeEvent;4.import javax.servlet.ServletContextAttributeListener;5.6.public class ServletContextAttributeListenerDemo implements7. ServletContextAttributeListener {8.9. /**10. * 增加属性时触发11. */12. public void attributeAdded(ServletContextAttributeEvent event) {13. System.out.println("---增加属性时--》属性名称："+event.getName()+", 属性内容："+event.getValue());14. }15.16. /**17. * 移除属性时触发18. */19. public void attributeRemoved(ServletContextAttributeEventevent) {20. System.out.println("---移除属性时--》属性名称："+event.getName()+", 属性内容："+event.getValue());21. }22.23. /**24. * 替换属性时触发25. */26. public void attributeReplaced(ServletContextAttributeEvent event) {27. System.out.println("---替换属性时--》属性名称："+event.getName()+", 属性内容："+event.getValue());28. }29.30.}web.xml：Xml代码1.<listener>2.<listener-class>com.keith.listener.ServletContextAttributeListenerDemo</listener-class>3.</listener>在页面我们可以这样测试，观察控制台：Java代码1.<%2. this.getServletContext().setAttribute("time:","2011年");3. %>4.<%5. this.getServletContext().removeAttribute("time");6. %>3，对session监听在监听器中，针对于session的监听操作主要使用HttpSessionListener，HttpSessionAttributeListener和HttpSessionBindingListener接口：session状态监听：HttpSessionListener接口：当需要对创建或销毁session 的操作进行监听时，可以试想javax.servlet.http.HttpSessionListener 接口，此接口定义的方法如下： No 方法类型描述 1 public void sessionCreated(HttpSessionEvent se)普通 session 创建时调用 2public void sessionDestoryed(HttpSessionEvent se) 普通 session 销毁时调用当session 创建或销毁后，将产生HttpSessionEvent 事件，此事件定义的方法如下：No 方法类型 描述1 public HttpSession getSession() 普通 取得当前的sessionsession 状态监听： Java 代码1. package com.keith.listener;2.3. import javax.servlet.http.HttpSessionEvent;4. import javax.servlet.http.HttpSessionListener;5.6. public class HttpSessionListenerDemo implements HttpSessionLis tener {7.8. /**9. * session 创建时触发 10. */11. public void sessionCreated(HttpSessionEvent event) { 12. System.out.println("Session 创建，SESSION ID == "+event.getSession().getId()); 13. } 14.15. /**16. * session 销毁时触发 17. */18. public void sessionDestroyed(HttpSessionEvent event) { 19. System.out.println("session 销毁，SESSION ID == "+event.getSession().getId()); 20. } 21.22.}web.xml：Java代码1.<listener>2. <listener-class>com.keith.listener.HttpSessionListenerDemo</listener-class>3.</listener>当访问一个动态页面的时候，观察后台！、session的销毁操作：当一个新用户打开一个新的动态页面时，服务器会为新用户分配一个session，并且触发HttpSessionListener接口中的sessionCreated()事件，但是在session有2种销毁方法：1，调用HttpSession接口中的invalidate()方法，让一个session失效；2，配置session的时间，在web.xml中这样配置的session的有效时间：Java代码1.<session-config>2. <session-timeout>5</session-timeout>3.</session-config>session在5分钟后失效；默认的时间是30分钟；session属性监听：HttpSessionAttributeListener接口；在session监听中也可以对session的属性进行监听，这一点与监听servletContext属性的道理一样，要对session的属性操作监听，可以使用javax.servlet.http.HttpSessionAttribute Listener接口完成；此接口的定义方法如下：No 方法类型描述1 public void attributeAdded(HttpSessionBindingEventse)普通增加属性时触发2 public void attributeRemoved(HttpSessionBindingEventse)普通删除属性时触发3 public void 普替换属性时attributeReplaced(HttpSessionBindingEvent se) 通触发当进行属性操作时，将根据属性的操作触发HttpSessionAttributeListener接口中的方法，每个操作方法都将产生HttpSessionbindingEvent事件，此事件定义的方法如下：No 方法类型描述1 public HttpSession getSession() 普通取得session2 public String getName() 普通取得属性名称3 public Object getValue() 普通取得属性的内容对session的属性操作监听：HttpSessionAttributeListenerDemo：Java代码1.package com.keith.listener;2.3.import javax.servlet.http.HttpSessionAttributeListener;4.import javax.servlet.http.HttpSessionBindingEvent;5.6.public class HttpSessionAttributeListenerDemo implements HttpSessionAttributeListener{7.8. /**9. * 属性增加时触发10. */11. public void attributeAdded(HttpSessionBindingEvent event){12. System.out.println(event.getSession().getId()+",增加了属性---》属性名称："+event.getName()+",属性内容："+event.getValue());13. }14.15. /**16. * 属性移除时触发17. */18. public void attributeRemoved(HttpSessionBindingEvent event) {19. System.out.println(event.getSession().getId()+",移除了属性---》属性名称："+event.getName()+",属性内容："+event.getValue());20. }21.22. /**23. * 属性替换时触发24. */25. public void attributeReplaced(HttpSessionBindingEvent event) {26. System.out.println(event.getSession().getId()+",替换了属性---》属性名称："+event.getName()+",属性内容："+event.getValue());27. }28.29.}web.xml：Xml代码1.<listener>2.<listener-class>com.keith.listener.HttpSessionAttributeListenerDemo</listener-class>3.</listener>在页面中对session的setAttribute()/removeAttribute()进行测试；session属性监听：HttpSessionBindingListener接口，以上的session 监听接口都需要在web.xml文件中配置后才起作用，但是在Web中也提供了一个javax.servlet.http.HttpSessionBindingListener接口，通过此接口实现的监听程序可以不用配置直接使用，此接口定义的方法如下：No 方法类型描述1 public void valueBound(HttpSessionBindingEventevent)类型绑定对象到session时触发2 public voidvalueUnbound(httpSessionBindingEvent event)类型从session中移除对象时触发以上的2个方法都将产生HttpSessionBindingEvent事件，下面通过此接口实现一个用户登陆信息监听的操作：LoginUser：Java代码1.package com.keith.listener;2.3.import javax.servlet.http.HttpSessionBindingEvent;4.import javax.servlet.http.HttpSessionBindingListener;5.6.public class LoginUser implements HttpSessionBindingListener {7. private String name;8.9. public LoginUser() {10.11. }12.13. public LoginUser(String name) {14. this.setName(name);15. }16.17. /**18. * 在session中绑定19. */20. public void valueBound(HttpSessionBindingEvent event) {21. System.out.println("---在session中保存LoginUser对象(name = "+this.getName()+")，session id = "+event.getSession().getId());22. }23.24. /**25. * 在session中移除26. */27. public void valueUnbound(HttpSessionBindingEvent event) {28. System.out.println("---从session中移除LoginUser对象（name = "+this.getName()+"），session id = "+event.getSession().getId());29. }30.31. public String getName() {32. return name;33. }34.35. public void setName(String name) {36. = name;37. }38.39.}在session.jsp中：Java代码1.<%2. LoginUser user = new LoginUser("keith");3. session.setAttribute("info",user);4.%>访问session.jsp时，看控制台的输出（统一方法测试下移除session时控制台的输出）；4，对request监听对request操作监听，主要使用ServletRequestListener和ServletRequestAttributeListener两个接口；请求状态监听：ServletRequestListener接口：当需要对用户的每次请求进行监听时，可以使用javax.servlet.ServletRequestListener接口，此接口的定义方法如下：No 方法类型描述1 public void requestInitalized(ServletRequestEventsre)普通请求开始时调用2 public void requestDestroyed(ServletRequestEventsre)普通请求结束时调用ServletRequestListener接口一旦监听到事件后，将产生ServletRequestEvent 的事件处理对象，此事件定义的方法如下：No 方法类型描述1 public ServletRequestgetServletRequest()普通取得ServletRequest对象2 public ServletContextgetServletContext()普通取得ServletContext对象对用户的request进行监听：ServlteRequestListenerDemo：Java代码1.package com.keith.listener;2.3.import javax.servlet.ServletRequestEvent;4.import javax.servlet.ServletRequestListener;5.6.public class ServlteRequestListenerDemo implements ServletRequestListener{7.8. /**9. * request初始化时触发10. */11. public void requestDestroyed(ServletRequestEvent event) {12. System.out.println("request初始化。
《Java Web应用开发项目教程》第8章 使用监听器实现在线人数统计
计算机与软件学院
第8章 使用监听器实现在线人数统计
■本章要点：
Servlet监听器开发技术 在线人数统计功能模块设计与实现 Servlet监听器技术特性分析 Servlet监听器的典型应用
计算机与软件学院
8.1 使用Servlet监听器实现在线人数统计
■在线人数统计功能分析 在系统运行过程中，了解当前使用系统的用户，有多少人 在使用系统？具体又是哪些人在使用系统？
public void contextDestroyed(ServletContextEvent sce){ //应用程序卸载时启动}
public void sessionCreated(HttpSessionEvent se){ //当有用户访问时启动}
public void sessionDestroyed(HttpSessionEvent se){ //当有用户退出时启动}
计算机与软件学院
■Servlet监听器
8.2 servlet监听器知识总结
计算机与软件学院
8.2 servlet监听器知识总结
■Servlet上下文监听
1、ServletContextListener编程接口:“Web应用程序 的生命周期方法”。
• contextInitialized(ServletContextEvent event) 应用程序被加载及初始化时激发
计算机与软件学院
8.1.3 Servlet监听器技术特性分析
■监听域对象的创建、属性和改变和销毁
3.在ServletRequestListener接口: • public void requestInitialized(ServletRequestEvent
java 过滤器、监听器 拦截器 原理个人总结
过滤器创建一个Filter 只需两个步骤:(1)创建Filter 处理类:(2)在web.xml 文件中配置Filter 。
创建Filter 必须实现javax.servlet.Filter 接口，在该接口中定义了三个方法。
• void init(FilterConfig config): 用于完成Filter 的初始化。
• void destroy(): 用于Filter 销毁前，完成某些资源的回收。
• void doFilter(ServletRequest request, ServletResponse response,FilterChain chain): 实现过滤功能，该方法就是对每个请求及响应增加的额外处理。
过滤器Filter也具有生命周期：init()->doFilter()->destroy()，由部署文件中的filter元素驱动。
在servlet2.4中，过滤器同样可以用于请求分派器，但须在web.xml中声明，<dispatcher>INCLUDE或FORWARD或REQUEST或ERROR</dispatcher>该元素位于filter-mapping中。
一、理解Struts2拦截器1. Struts2拦截器是在访问某个Action或Action的某个方法，字段之前或之后实施拦截，并且Struts2拦截器是可插拔的，拦截器是ＡＯＰ的一种实现．2. 拦截器栈（Interceptor Stack）。
Struts2拦截器栈就是将拦截器按一定的顺序联结成一条链。
在访问被拦截的方法或字段时，Struts2拦截器链中的拦截器就会按其之前定义的顺序被调用。
二、实现Struts2拦截器原理Struts2拦截器的实现原理相对简单，当请求struts2的action时，Struts 2会查找配置文件，并根据其配置实例化相对的拦截器对象，然后串成一个列表，最后一个一个地调用列表中的拦截器三、定义Struts2拦截器。
使用AJAX和JAVA Servlet技术实现WEB系统用户监听功能
从 上 面两种方 式来 看 ， 户监 听功 能实现 的关 键点 在 于如何 获取用 户登 出系统 的信息 ． 两种 方式 用 在
中， 方式 １实现 起来 比较 容 易． 由于 页面 的整 体 刷新 非 常 消耗服 务 器 资源 ， 其 是 当页 面数 据 量很 大 但 尤 的时候 ， 每次 刷新 都需 要查 询数 据库 进行 对 比， 旦登 陆 用户过 多 ， 易造 成 服务 器资 源耗 尽 ； 且 一 极 方式 ２ 实现 起来 比较 困难． 然其 对服 务器 和数据 库基 本无 太大要 求 ， 实 际使用 中很 多 用户并 不 一定会通 过 虽 但
Ｓ ｒｅ ） ｅｖ ｒ 模式 向 Ｂ Ｓ Ｂ ｏ ｓｒ Ｓ ｒｅ ） ／ （ ｒ ｗ ｅ／ ｅｖ ｒ 模式 转 变 ． ｃ／ 与 ｓ模 式 相 比 ， ／ Ｂ Ｓ模 式 对 客户 机 系 统要 求 不 高 ， 只 要能 使用 浏 览器 即 可 ， 以极 大 减少 对 客户 机 系统 兼 容性 的要 求 和节 省 大 量 软件 维 护 方 面 的开 支． 可 但 Ｃ Ｓ模 式也存 在 着 明显 的弱 点 ， ／ 即客户 机和 服务 器之 间 的联 系是单 向的 ， 户 机必 须通 过 刷新 （ｅｏ ｄ 客 ｒｌａ ）
中， 由于 Ｂ Ｓ模 式 的“ 动 ” ／ 被 特性 ， 使得 服务 器无 法 获得 客户 端用 户 的状 态 ， 就没 有办 法 获取 用 户登 出 也
系统 的信 息． 因此 ， 如何 有 效实现 用户监 听功 能 就成为 ＷＥ Ｂ类 系统 中一个 比较 棘手 的问题．
１ 当前 Ｂ／ 计 方 式在 用 户 监 听 方 面 的劣 势 Ｓ设
才能从 服务 器获得 或 向其发 送数据 ， 务器无 法主 动和 客户机 进行 联系 ， 服 只能被 动接 收其请 求做 出相应
servlet 规范
servlet 规范Servlet规范是一套由Java社区制定的标准，用于开发Web应用程序。
它定义了一种在Web服务器上运行的Java程序，用于处理客户端请求并生成动态内容。
Servlet规范分为两个层面：API（Application Programming Interface）和执行环境。
API定义了开发人员使用的类和接口，用于处理HTTP请求和响应。
执行环境是指Web服务器，它负责加载和执行Servlet程序，并提供运行时环境。
Servlet规范的主要内容包括：1. Servlet类和接口：Servlet规范定义了一些类和接口，用于开发Servlet程序。
其中最重要的是javax.servlet.Servlet接口，通过实现这个接口可以创建一个Servlet程序。
另外，javax.servlet.http.HttpServlet类是一个抽象类，提供了处理HTTP请求和生成HTTP响应的方法。
2. 生命周期管理：Servlet规范定义了Servlet的生命周期方法，包括init()、service()和destroy()。
init()方法在Servlet被加载时调用，用于进行一些初始化操作；service()方法在每次接收到客户端请求时调用，用于处理请求和生成响应；destroy()方法在Servlet被卸载时调用，用于释放资源。
3. URL映射和请求处理：Servlet规范定义了如何将URL映射到Servlet程序，并且规定了Servlet如何处理HTTP请求。
通过在web.xml文件中配置URL模式和Servlet类，可以将HTTP请求路由到相应的Servlet程序进行处理。
4. 请求和响应对象：Servlet规范定义了javax.servlet.ServletRequest和javax.servlet.ServletResponse接口，用于表示HTTP请求和响应。
这些接口提供了访问请求参数、请求头和响应内容的方法。
Servlet中的过滤器(拦截器)Filter与监听器Listener的作用和区别
Servlet中的过滤器（拦截器）Filter与监听器Listener的作用和区别1. 过滤器（Filter）的作用和用途：过滤器用于截取请求和响应，可以在请求到达目标资源之前预处理请求，也可以在响应返回给客户端之前对响应进行处理。
过滤器可以对请求和响应进行统一的处理，例如验证用户的登录状态、设置字符编码、限制请求的访问等。
过滤器的主要特点：- 过滤器的配置和初始化是在web.xml文件中进行的。
-过滤器可以通过设置多个过滤器链来实现不同的目的。
-过滤器可以通过链式调用的方式实现多个过滤器的集成。
-过滤器可以修改请求的参数、头部信息或者重定向到其他资源。
2. 监听器（Listener）的作用和用途：监听器用于监听Servlet中发生的事件和动作，并作出相应的处理。
监听器可以监听到Web应用的生命周期事件（如应用的启动和关闭）、会话的创建和销毁事件、请求的到达和离开等。
通过监听Servlet的事件，可以在事件发生前、发生后或者发生中进行相关操作，用于处理这些事件。
监听器的主要特点：-监听器可以通过注解或者配置文件的方式进行配置和初始化。
-监听器可以监听多个事件，根据事件的类型进行不同的处理。
-监听器可以访问和修改请求和响应对象。
-监听器可以获取到应用的初始化参数、会话信息等。
区别：- 过滤器（Filter）主要用于拦截请求和响应，可以对其进行预处理和后处理，常用于权限验证、请求包装、字符编码设置和URL重定向等。
而监听器（Listener）主要用于监听特定的事件和动作，常用于记录日志、统计在线人数、初始化和销毁操作等。
- 过滤器是在Servlet调用之前进行处理，通过链式调用的方式实现多个过滤器的集成。
而监听器是在Servlet处理过程中监听特定事件的发生，对事件进行相应的处理。
-过滤器可以修改请求和响应对象，而监听器只能获取和监听这些对象。
-过滤器可以针对多个URL进行配置，而监听器是全局的，对整个应用进行监听。
tomcat reloadable原理(一)
tomcat reloadable原理(一)tomcat reloadable原理概述在使用tomcat进行java web应用开发时，我们常常需要对应用程序进行热部署。
而其中一个重要的特性就是reloadable（可重新加载）。
那么reloadable原理是怎么样的呢？基本概念在深入探讨reloadable原理之前，我们需要了解几个基本概念：1. ClassLoader（类加载器）ClassLoader是Java中的一个重要概念，它用于加载Class文件，并生成对应的Class对象。
在tomcat中，每个web应用程序都有自己的ClassLoader，用于加载该应用程序的类。
2. ServletContext（Servlet上下文）ServletContext是Java中的一个接口，它代表了一个web应用程序的环境信息。
每个web应用程序都有一个对应的ServletContext对象。
3. ContextLoaderListener（上下文加载监听器）ContextLoaderListener是一个Servlet监听器，它负责在web应用程序启动时加载ServletContext，并将其存储在一个全局可访问的位置。
4. WebappClassLoader（Web应用程序ClassLoader）WebappClassLoader是tomcat中的一个特殊ClassLoader，它负责加载web应用程序的类。
每个web应用程序都有一个对应的WebappClassLoader。
reloadable原理基于以上的基本概念，我们可以得出如下的reloadable原理：1.当tomcat启动时，会创建一个WebappClassLoader，并将其传递给ContextLoaderListener。
2.ContextLoaderListener将WebappClassLoader存储在ServletContext中，以供其他组件使用。
监听器(Listener)
监听器(Listener)监听器是针对整个WEB环境的监听，包括客户端的请求、服务端的操作等；主要有三类：-Interface ServletContextListener-Interface HttpSessionListener-Interface ServletRequestListener以上接口全部继承自接口：extendsjava.util.EventListener一、ServletContext监听1.Interface ServletContextListener对整个Servlet上下文监听(启动、销毁)方法：-void contextInitialized(ServletContextEvent sce) 上下文初始化，-void contextDestroyed(ServletContextEvent sce)上下文销毁，其中Class ServletContextEvent-public ServletContext getServletContext()取得一个ServletContext对象2.Interface ServletContextAttributeListener对Servlet上下文属性进行监听方法：-void attributeAdded(ServletContextAttributeEvent event)-void attributeRemoved(ServletContextAttributeEvent event)-void attributeReplaced(ServletContextAttributeEvent event)其中Class ServletContextAttributeEvent-public String getName()：取得属性名称-public Object getValue()：取得属性的值public class ServletContextDemo implements ServletContextListener,ServletContextAttributeListener{private ServletContext application=null;public void contextInitialized(ServletContextEvent arg0) {this.application=arg0.getServletContext();System.out.println("** 上下文初始化 ...") ;System.out.println("** 当前虚拟目录的绝对路径："+this.application.getRealPath("/")) ;}public void contextDestroyed(ServletContextEvent arg0) {System.out.println("** 上下文销毁 ...") ;}public void attributeAdded(ServletContextAttributeEvent scae) {System.out.println("** 增加属性："+scae.getName()+" --> "+scae.getValue()) ;}public void attributeRemoved(ServletContextAttributeEvent scae) {System.out.println("** 删除属性："+scae.getName()+" --> "+scae.getValue()) ;}public void attributeReplaced(ServletContextAttributeEvent scae) {System.out.println("** 替换属性："+scae.getName()+" --> "+scae.getValue()) ;}} 二、对Session监听对Session的创建、销毁、属性操作在javax.servlet.http 包下：1.Interface HttpSessionListener对Session整体状况的监听方法：-void sessionCreated(HttpSessionEvent se)-void sessionDestroyed(HttpSessionEvent se)其中Class HttpSessionEvent-public HttpSession getSession()2.Interface HttpSessionAttributeListener方法：-void attributeAdded(HttpSessionBindingEvent event-voidattributeRemoved(HttpSessionBindingEvent event)-voidattributeReplaced(HttpSessionBindingEventevent)其中Class HttpSessionBindingEvent-public HttpSession getSession()-public String getName()-public Object getValue()常用来统计当前在线人数。
监听器Listener
监听器Listenerservlet规范包括三个技术点：servlet listener filter1．什么是监听器？监听器就是监听某个对象的的状态变化的组件监听器的相关概念：事件源：被监听的对象 ----- 三个域对象 request session servletContext监听器：监听事件源对象事件源对象的状态的变化都会触发监听器 ---- 6+2注册监听器：将监听器与事件源进⾏绑定响应⾏为：监听器监听到事件源的状态变化时所涉及的功能代码 ---- 程序员编写代码2．监听器有哪些？第⼀维度：按照被监听的对象划分：ServletRequest域 HttpSession域 ServletContext域第⼆维度：监听的内容分：监听域对象的创建与销毁的监听域对象的属性变化的3．监听三⼤域对象的创建与销毁的监听器(1)监听ServletContext域的创建与销毁的监听器ServletContextListener 1）Servlet域的⽣命周期何时创建：服务器启动创建何时销毁：服务器关闭销毁2）监听器的编写步骤：a、编写⼀个监听器类去实现监听器接⼝b、覆盖监听器的⽅法c、需要在web.xml中进⾏配置---注册3）监听的⽅法：4）配置⽂件：5）ServletContextListener监听器的主要作⽤a、初始化的⼯作：初始化对象初始化数据 ---- 加载数据库驱动连接池的初始化b、加载⼀些初始化的配置⽂件 --- spring的配置⽂件c、任务调度----定时器----Timer/TimerTask任务调度：(2)监听Httpsession域的创建于销毁的监听器HttpSessionListener1）HttpSession对象的⽣命周期何时创建：第⼀次调⽤request.getSession时创建何时销毁：服务器关闭销毁 session过期⼿动销毁2）HttpSessionListener的⽅法(3)监听ServletRequest域创建与销毁的监听器ServletRequestListener 1）ServletRequest的⽣命周期创建：每⼀次请求都会创建request销毁：请求结束2）ServletRequestListener的⽅法4．监听三⼤域对象的属性变化的(1)域对象的通⽤的⽅法：setAttribute(name,value)--- 触发添加属性的监听器的⽅法--- 触发修改属性的监听器的⽅法getAttribute(name)removeAttribute(name)--- 触发删除属性的监听器的⽅法(2)ServletContextAttibuteListener监听器(3) HttpSessionAttributeListener监听器（同上）(4) ServletRequestAriibuteListenr监听器（同上）5．与session中的绑定的对象相关的监听器（对象感知监听器）(1)即将要被绑定到session中的对象有⼏种状态绑定状态：就⼀个对象被放到session域中解绑状态：就是这个对象从session域中移除了钝化状态：是将session内存中的对象持久化（序列化）到磁盘活化状态：就是将磁盘上的对象再次恢复到session内存中⾯试题：当⽤户很对时，怎样对服务器进⾏优化？(2)绑定与解绑的监听器HttpSessionBindingListener(3)钝化与活化的监听器HttpSessionActivationListener可以通过配置⽂件指定对象钝化时间 --- 对象多长时间不⽤被钝化在META-INF下创建⼀个context.xml<Context><!-- maxIdleSwap:session中的对象多长时间不使⽤就钝化 --><!-- directory:钝化后的对象的⽂件写到磁盘的哪个⽬录下配置钝化的对象⽂件在work/catalina/localhost/钝化⽂件 --><Manager className="org.apache.catalina.session.PersistentManager" maxIdleSwap="1"><Store className="org.apache.catalina.session.FileStore" directory="itcast205" /></Manager></Context>被钝化到work/catalina/localhost/的⽂件。
监听器有哪些作用和用法？
监听器有哪些作⽤和⽤法？
Java Web开发中的监听器（listener）就是application、session、request三个对象创建、销毁或者往其中添加修改删除属性时⾃动执⾏代码的功能组件，如下所⽰：
①ServletContextListener：对Servlet上下⽂的创建和销毁进⾏监听。
②ServletContextAttributeListener：监听Servlet上下⽂属性的添加、删除和替换。
③HttpSessionListener：对Session的创建和销毁进⾏监听。
补充：session的销毁有两种情况：1session超时（可以在web.xml中通过/标签配置超时时间）；2通过调⽤session对象的invalidate()⽅法使session失效。
④HttpSessionAttributeListener：对Session对象中属性的添加、删除和替换进⾏监听。
⑤ServletRequestListener：对请求对象的初始化和销毁进⾏监听。
⑥ServletRequestAttributeListener：对请求对象属性的添加、删除和替换进⾏监听。
什么是servlet？servlet的作用
什么是servlet？servlet的作⽤
看到这个问题以前我学习javaEE的时候开发步骤(这⾥是⼤致配置和流程)：
1.在web.xml中配置servlet和servletMapping
2.书写servlet标签⾥⾯配置的类，类需要继承HttpServlet，然后复写⾥⾯的doget，dopos⽅法（当然还有init，destory⽅法）
3.启动tomcat服务器，访问对应的路径就能访问到对应的doget，dopost⽅法
但是这个web.xml和对应的类以及tomcat到底有什么关系呢？在后⾯到底做了什么呢？
⾸先我们要理清⼀个逻辑：浏览器http请求------》tomcat服务器-------》到达servlet-----》执⾏doget，dopost⽅法----》返回数据从这个逻辑可以看出tomcat才是和客户端打交道的:
他监听了端⼝，请求过来后，根据url信息和web.xml配置⽂件匹配，确定要将请求交给哪个servlet去处理，servlet处理请求然后返回给tomcat，tomcat在把数据返回给⽤户。
在看servlet源代码：
在看httpServlet：
从名字我们就不难理解，HttpServlet是Servlet对http请求协议处理的实现
那我们就可以得出Servlet接⼝就是处理⽹络请求的⼀套规范，他负责连接web服务器（如tomcat服务器），交互式的⽣成动态的web 内容。
javaweb中监听器、过滤器、拦截器以及AOP的先后顺序和理解
javaweb中监听器、过滤器、拦截器以及AOP的先后顺序和理解java web三⼤器：过滤器、拦截器、监听器（spring框架）spring、springMVC与springBoot的关系详见：⼀、启动顺序监听器---》过滤器---》拦截器案例理解：接到上级命令，要求对电话进去监听，过滤出恐怖分⼦，然后，拦截他们的恐怖袭击⾏动。
配置位置：监听器、过滤器⼀般配置在web.xml中，拦截器⼀般配置在springmvc.xml配置⽂件中⼆、概念监听器：Servlet的监听器Listener，它是实现了javax.servlet.ServletContextListener接⼝的服务器端程序，它也是随web应⽤的启动⽽启动，只初始化⼀次，随web应⽤的停⽌⽽销毁。
主要作⽤是：做⼀些初始化的内容添加⼯作、设置⼀些基本的内容、⽐如⼀些参数或者是⼀些固定的对象等等Filter过滤器：过滤器拦截web访问url地址。
严格意义上讲，filter只是适⽤于web中，依赖于Servlet容器，利⽤Java的回调机制进⾏实现。
Filter过滤器：和框架⽆关，可以控制最初的http请求，但是更细⼀点的类和⽅法控制不了。
过滤器可以拦截到⽅法的请求和响应(ServletRequest request, ServletResponse response)，并对请求响应做出像响应的过滤操作，⽐如设置字符编码，鉴权操作等⽐如：（不是login.do的地址请求，如果⽤户没有登陆都过滤掉）,或者在传⼊servlet或者struts的action前统⼀设置字符集，或者去除掉⼀些⾮法字符。
主要为了减轻服务器负载，减少压⼒。
Interceptor拦截器：拦截器拦截以 .action结尾的url，拦截Action的访问。
Interfactor是基于Java的反射机制（APO思想）进⾏实现，不依赖Servlet容器。
拦截器可以在⽅法执⾏之前(preHandle)和⽅法执⾏之后(afterCompletion)进⾏操作，回调操作(postHandle)，可以获取执⾏的⽅法的名称，请求(HttpServletRequest)Interceptor：可以控制请求的控制器和⽅法，但控制不了请求⽅法⾥的参数(只能获取参数的名称，不能获取到参数的值)（⽤于处理页⾯提交的请求响应并进⾏处理，例如做国际化，做主题更换，过滤等）。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
北京传智播客教育
—高级软件人才实作培训专家! 高级软件人才实作培训专家! attributeReplaced 方法
当监听器的域对象中的某个属性被替换时，web容 器调用事件监听器的这个方法进行相应 各个域属性监听器中的完整语法定义为： public void attributeReplaced(ServletContextAttributeEvent scae) public void attributeReplaced (HttpSessionBindingEvent hsbe) public void attributeReplaced (ServletRequestAttributeEvent srae)
北京传智播客教育
—高级软件人才实作培训专家! 高级软件人才实作培训专家! attributeRemoved 方法
当删除被监听对象中的一个属性时，web 容器调用事件 监听器的这个方法进行相应 各个域属性监听器中的完整语法定义为：
public void attributeRemoved(ServletContextAttributeEvent scae) public void attributeRemoved (HttpSessionBindingEvent hsbe) public void attributeRemoved (ServletRequestAttributeEvent srae)
北京传智播客教育
—高级软件人才实作培训专家! 高级软件人才实作培训专家!
监听HttpRequest域对象创建和销毁
ServletRequestListener 接口用于监听ServletRequest 对象的创建和销 毁。 Request 对象被创建时，监听器的requestInitialized方法将会被调用。 Request对象被销毁时，监听器的requestDestroyed方法将会被调用。
(此处复习session对象，写多个servlet都去getSession，看session的创 建) Session域对象创建和销毁的时机创建：用户每一次访问时，服务器创 建session 销毁：如果用户的session 30分钟没有使用，服务器就会销毁 session，我们在web.xml里面也可以配置session失效时间
北京传智播客教育
Байду номын сангаас高级软件人才实作培训专家! 高级软件人才实作培训专家! HttpSessionBindingListener接口
实现了HttpSessionBindingListener接口的 JavaBean 对象可以感知自己被绑定到 Session 中 和从 Session 中删除的事件 当对象被绑定到 HttpSession 对象中时，web 服务 器调用该对象的 void valueBound(HttpSessionBindingEvent event) 方法 当对象从 HttpSession 对象中解除绑定时，web 服 务器调用该对象的 void valueUnbound(HttpSessionBindingEvent event)方法
北京传智播客教育
—高级软件人才实作培训专家! 高级软件人才实作培训专家! Servle监听器
在Servlet规范中定义了多种类型的监听器，它们用于 监听的事件源分别为 ServletContext, HttpSession 和 ServletRequest 这三个域对象。 Servlet规范针对这三个对象上的操作，又把这多种类 型的监听器划分为三种类型。
北京传智播客教育
—高级软件人才实作培训专家! 高级软件人才实作培训专家! 感知 Session 绑定的事件监听器
保存在 Session 域中的对象可以有多种状态：绑定到 Session 中；从 Session 域中解除绑定；随 Session 对象持久化到一个存储设备中；随 Session 对象从一 个存储设备中恢复 Servlet 规范中定义了两个特殊的监听器接口来帮助 帮助 JavaBean 对象了解自己在 Session 域中的这些状态 域中的这些状态： HttpSessionBindingListener接口和 HttpSessionActivationListener接口 ，实现这两个接 口的类不需要 web.xml 文件中进行注册 不需要
—高级软件人才实作培训专家! 高级软件人才实作培训专家!
JavaWEB开发-Servlet事件监听器 JavaWEB开发-Servlet事件监听器 开发
方立勋
北京传智播客教育
—高级软件人才实作培训专家! 高级软件人才实作培训专家! 监听器
监听器就是一个实现特定接口的普通java程序，这个 程序专门用于监听另一个java对象的方法调用或属性 改变，当被监听对象发生上述事件后，监听器某个方 法将立即被执行。
提问，servletContext域对象何时创建和销毁：
创建：服务器启动针对每一个web应用创建servletcontext 销毁：服务器关闭前先关闭代表每一个web应用的servletContext
北京传智播客教育
—高级软件人才实作培训专家! 高级软件人才实作培训专家! 编写 Servlet 监听器
ServletContextListener 接口用于监听 ServletContext 对象的创建和销 毁事件。 当 ServletContext 对象被创建时，激发contextInitialized (ServletContextEvent sce)方法 当 ServletContext 对象被销毁时，激发 contextDestroyed(ServletContextEvent sce)方法。
和编写其它事件监听器一样，编写servlet监听器也需 要实现一个特定的接口，并针对相应动作覆盖接口中 的相应方法。 和其它事件监听器略有不同的是，servlet监听器的注 册不是直接注册在事件源上，而是由WEB容器负责注 册，开发人员只需在web.xml文件中使用<listener>标 签配置好监听器，web容器就会自动把监听器注册到 事件源中。 一个 web.xml 文件中可以配置多个 Servlet 事件监听 器，web 服务器按照它们在 web.xml 文件中的注册顺 序来加载和注册这些 Serlvet 事件监听器。
北京传智播客教育
—高级软件人才实作培训专家! 高级软件人才实作培训专家! attributeAdded 方法
当向被监听器对象中增加一个属性时，web容器就调用 事件监听器的 attributeAdded 方法进行相应，这个方法 接受一个事件类型的参数，监听器可以通过这个参数来 获得正在增加属性的域对象和被保存到域中的属性对象 各个域属性监听器中的完整语法定义为：
被监听对象 （俗称 事件源）
事件对象
（封装事件源，及动作）
监听器对象 void doxx(Event e){ }
通过e对象可以得
操作事件源
调用监听器对象的某个方法
注册监听器（即在事件源上关联监听器对象）
到事件源。从而可 以可以根据需要对 事件源进行处理
监听器典型案例：监听window窗口的事件监听器
北京传智播客教育
—高级软件人才实作培训专家! 高级软件人才实作培训专家! Servlet监听器在开发中的应用案例：
统计当前在线人数 自定义session扫描器
北京传智播客教育
—高级软件人才实作培训专家! 高级软件人才实作培训专家! 监听三个域对象属性变化
北京传智播客教育
—高级软件人才实作培训专家! 高级软件人才实作培训专家!
监听HttpSession域对象创建和销毁
HttpSessionListener接口用于监听HttpSession的创建和销毁 创建一个Session时，sessionCreated(HttpSessionEvent se) 方 法将会被调用。 销毁一个Session时，sessionDestroyed (HttpSessionEvent se) 方法将会被调用。
<Context> <Manager className="org.apache.catalina.session.PersistentManager" maxIdleSwap="1"> <Store className="org.apache.catalina.session.FileStore" directory="it315"/> </Manager> </Context>
北京传智播客教育
—高级软件人才实作培训专家! 高级软件人才实作培训专家! 练习：
显示登陆用户列表，并实现踢人功能。
北京传智播客教育
北京传智播客教育
—高级软件人才实作培训专家! 高级软件人才实作培训专家!
HttpSessionActivationListener接口
实现了HttpSessionActivationListener接口的 JavaBean 对象可以 感知自己被活化和钝化的事件 当绑定到 HttpSession 对象中的对象将要随 HttpSession 对象被钝 化之前，web 服务器调用如下方法 sessionWillPassivate(HttpSessionBindingEvent event) 方法 当绑定到 HttpSession 对象中的对象将要随 HttpSession 对象被活 化之后，web 服务器调用该对象的 void sessionDidActive(HttpSessionBindingEvent event)方法
Servlet规范定义了监听 ServletContext, HttpSession, HttpServletRequest 这三个对象中的属性变更信息事 件的监听器。 这三个监听器接口分别是 ServletContextAttributeListener, HttpSessionAttributeListener ServletRequestAttributeListener 这三个接口中都定义了三个方法来处理被监听对象中 的属性的增加，删除和替换的事件，同一个事件在这 三个接口中对应的方法名称完全相同，只是接受的参 数类型不同。