• listener

    servlet中的监听器

    servlet中的监听器是用于监听web常见对象HttpServletRequest,HttpSession,ServletContext。主要有下面三个作用：
    1.监听web对象创建与销毁。
    2.监听web对象的属性变化，添加、删除、修改。
    3.监听session绑定javaBean操作，活化（从硬盘读取到内存）与钝化（从内存持久化到硬盘）操作。
    当监听器发现被监听的对象发生变化时，可以做一些操作。

    在servlet中一共有8个监听器，按照监听器的作用分类如下：

    • 监听web对象创建与销毁的监听器
      • ServletContextListener
      • HttpSessionListener
      • ServletRequestListener
    • 监听web对象属性变化的监听器
      • ServletContextAttributeListener
      • HttpSessionAttributeListener
      • ServletRequestAttributeListener
    • 监听session绑定javaBean操作的监听器
      • HttpSessionBindingListener
      • HttpSessionActivationListener

    监听器的创建和使用

    javaweb创建监听器的步骤：

    1. 创建一个类，实现指定的监听器接口
    2. 重写接口中的方法
    3. 在web.xml文件中配置监听器

    监听对象的创建和销毁
    下面演示监听HttpServletRequest对象的销毁和创建。

    1.创建一个类实现ServletRequestListener接口：

    1 package com.monkey1024.listener;
2 
3 import javax.servlet.ServletRequestEvent;
4 import javax.servlet.ServletRequestListener;
5 
6 public class MyRequestListener implements ServletRequestListener {
7 
8 }

    2.重写接口中的方法：

     1 package com.monkey1024.listener;
 2 
 3 import javax.servlet.ServletRequestEvent;
 4 import javax.servlet.ServletRequestListener;
 5 
 6 public class MyRequestListener implements ServletRequestListener {
 7 
 8     @Override
 9     public void requestDestroyed(ServletRequestEvent sre) {
10         System.out.println("request对象被销毁");
11     }
12 
13     @Override
14     public void requestInitialized(ServletRequestEvent sre) {
15         System.out.println("request被创建");
16     }
17 }

    3.在web.xml文件中配置监听器

    <listener>
      <listener-class>com.monkey1024.listener.MyRequestListener</listener-class>
</listener>

    当客户端发送请求时，就可以看见控制台打印出的”request对象被销毁”和”request被创建”。

    同理，在监听HttpSesssion对象的创建与销毁时，需要创建一个类实现HttpSessionListener接口并重写里面的方法。
    什么情况下会销毁session：

    • 默认超时 30分钟
    • 关闭服务器
    • invalidate()方法
    • setMaxInactiveInterval(int interval) 可以设置超时时间

    在监听ServletContext对象的创建与销毁时，创建一个类实现ServletContextListener接口并重写里面的方法即可。

    监听属性的变化
    以监听在HttpServletRequest对象中添加、修改、删除属性为例：

    1.创建一个类实现ServletRequestAttributeListener接口：

    1 package com.monkey1024.listener;
2 
3 import javax.servlet.ServletRequestAttributeListener;
4 
5 public class MyRequestAttributeListener implements ServletRequestAttributeListener {
6 
7 }

    2.重写接口中的方法：

     1 package com.monkey1024.listener;
 2 
 3 import javax.servlet.ServletRequestAttributeEvent;
 4 import javax.servlet.ServletRequestAttributeListener;
 5 
 6 public class MyRequestAttributeListener implements ServletRequestAttributeListener {
 7 
 8     @Override
 9     public void attributeAdded(ServletRequestAttributeEvent srae) {
10         System.out.println("向request中添加了一个属性");
11         System.out.println("属性名："+srae.getName());
12         System.out.println("属性值："+srae.getValue());
13     }
14 
15     @Override
16     public void attributeRemoved(ServletRequestAttributeEvent srae) {
17         System.out.println("从request中删除了一个属性");
18         System.out.println("属性名："+srae.getName());
19         System.out.println("属性值："+srae.getValue());
20     }
21 
22     @Override
23     public void attributeReplaced(ServletRequestAttributeEvent srae) {
24         System.out.println("修改了request中的一个属性");
25         System.out.println("属性名："+srae.getName());
26         System.out.println("属性值："+srae.getValue());
27     }
28 
29 
30 }

    3.在web.xml文件中注册监听器：

    1 <listener>
2       <listener-class>com.monkey1024.listener.MyRequestAttributeListener</listener-class>
3 </listener>

    4.创建index.jsp:

     1 <%@ page language="java" contentType="text/html; charset=UTF-8"
 2 pageEncoding="UTF-8"%>
 3 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 4 <html>
 5 <head>
 6 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 7 <title>Insert title here</title>
 8 </head>
 9 <body>
10     <%
11         request.setAttribute("name", "monkey1024");
12         request.setAttribute("name", "admin");
13         request.removeAttribute("name");
14     %>
15 </body>
16 </html>

    当客户端访问index.jsp时，在控制台可以看到下面内容：

    向request中添加了一个属性
属性名：name
属性值：monkey1024
修改了request中的一个属性
属性名：name
属性值：monkey1024
从request中删除了一个属性
属性名：name
属性值：admin

    监听ServletContext和HttpSession中的属性变化的操作同上。

    监听session绑定javabean
    HttpSessionBindingListener监听器可以使javaBean对象在被绑定到会话或从会话中取消对它的绑定时得到通知。该监听器是由实体类来实现，需要注意的是该监听器的实现类不需要在web.xml文件中进行配置。

    1.创建Student类实现HttpSessionBindingListener接口：

     1 package com.monkey1024.listener;
 2 
 3 import javax.servlet.http.HttpSessionBindingEvent;
 4 import javax.servlet.http.HttpSessionBindingListener;
 5 
 6 public class Student implements HttpSessionBindingListener {
 7 
 8     private String name;
 9     private int age;
10     public String getName() {
11         return name;
12     }
13     public void setName(String name) {
14         this.name = name;
15     }
16     public int getAge() {
17         return age;
18     }
19     public void setAge(int age) {
20         this.age = age;
21     }
22 }

    2.重写接口里面的方法：

     1 package com.monkey1024.listener;
 2 
 3 import javax.servlet.http.HttpSessionBindingEvent;
 4 import javax.servlet.http.HttpSessionBindingListener;
 5 
 6 public class Student implements HttpSessionBindingListener {
 7 
 8     private String name;
 9     private int age;
10     public String getName() {
11         return name;
12     }
13     public void setName(String name) {
14         this.name = name;
15     }
16     public int getAge() {
17         return age;
18     }
19     public void setAge(int age) {
20         this.age = age;
21     }
22     @Override
23     public void valueBound(HttpSessionBindingEvent event) {
24         System.out.println("Student对象被添加到session中");
25     }
26     @Override
27     public void valueUnbound(HttpSessionBindingEvent event) {
28         System.out.println("Student对象从session中被删除了");
29     }
30 
31 
32 }

    3.在index.jsp中添加下面代码：

    Student s = new Student();
session.setAttribute("student", s);
session.removeAttribute("student");

    当客户端访问index.jsp时，会在控制台中看到下面信息：

    Student对象被添加到session中
Student对象从session中被删除了

    监听在 Session 中存放的指定类型对象的钝化与活化
    HttpSessionActivationListener该监听器用于监听在 Session 中存放的指定类型对象的钝化与活化。
    钝化是指将内存中的数据写入到硬盘中，而活化是指将硬盘中的数据恢复到内存。当用
    户正在访问的应用或该应用所在的服务器由于种种原因被停掉，然后在短时间内又重启，此时用户在访问时 Session 中的数据是不能丢掉的，在应用关闭之前，需要将数据持久化到硬盘中，
    在重启后应可以立即重新恢复 Session 中的数据。这就称为 Session 的钝化与活化。
    那么 Session 中的哪些数据能够钝化呢？只有存放在 JVM 堆内存中的实现了 Serializable
    类的对象能够被钝化。也就是说，对于字符串常量、基本数据类型常量等存放在 JVM 方法
    区中常量池中的常量，是无法被钝化的。
    对于监听 Session 中对象数据的钝化与活化，需要注意以下几点：

    • 实体类除了要实现 HttpSessionActivationListener 接口外，还需要实现 Serializable 接口。
    • 钝化指的是 Session 中对象数据的钝化，并非是 Session 的钝化。所以 Session 中有几个可以钝化的对象，就会发生几次钝化。
    • HttpSessionActivationListener 监听器是不需要在 web.xml 中注册的。

    1.创建Person类实现HttpSessionActivationListener和Serializable接口：

     1 package com.monkey1024.listener;
 2 
 3 import java.io.Serializable;
 4 
 5 import javax.servlet.http.HttpSessionActivationListener;
 6 
 7 public class Person implements HttpSessionActivationListener, Serializable {
 8 
 9 
10     private String name;
11     private int age;
12 
13     public String getName() {
14         return name;
15     }
16     public void setName(String name) {
17         this.name = name;
18     }
19     public int getAge() {
20         return age;
21     }
22     public void setAge(int age) {
23         this.age = age;
24     }
25 }

    2.重写HttpSessionActivationListener接口中的方法：

     1 package com.monkey1024.listener;
 2 
 3 import java.io.Serializable;
 4 
 5 import javax.servlet.http.HttpSessionActivationListener;
 6 import javax.servlet.http.HttpSessionEvent;
 7 
 8 public class Person implements HttpSessionActivationListener, Serializable {
 9 
10 
11     private String name;
12     private int age;
13 
14     public String getName() {
15         return name;
16     }
17     public void setName(String name) {
18         this.name = name;
19     }
20     public int getAge() {
21         return age;
22     }
23     public void setAge(int age) {
24         this.age = age;
25     }
26 
27     @Override
28     public void sessionWillPassivate(HttpSessionEvent se) {
29         System.out.println("钝化"+se.getSession().getId());
30     }
31     @Override
32     public void sessionDidActivate(HttpSessionEvent se) {
33         System.out.println("活化"+se.getSession().getId());
34     }
35 
36 
37 
38 }

    3.在index.jsp中编写下面内容：

    <%
    Person p = new Person();
    session.setAttribute("person", p);
%>

    4.在项目中的META-INF目录下创建一个content.xml的文件，在里面写上下面内容：

    1 <?xml version="1.0" encoding="UTF-8"?>
2 <Context>
3     <Manager className="org.apache.catalina.session.PersistentManager" maxIdleSwap="1">
4     <Store className="org.apache.catalina.session.FileStore" directory="monkey1024"/>
5     </Manager>
6 </Context>

    通过上面的设置，可以将session钝化和活化。
    启动tomcat访问index.jsp文件，之后正常关闭tomcat后可以看见控制台输出”钝化”。再次启动tomcat，可以看到控制台输出”活化”。

    案例：统计当前在线用户数量

    使用监听器实现在线客户统计

    统计连接在应用上的客户端数量。客户端的唯一标识就是 IP，只需要对连接到服务器上
    的 IP 数量进行统计，就可统计出客户端的数量。网上很多这方面的文章都是只监听了session，即当session创建时，在线客户端的数量就+1，session销毁时，在线客户端的数量就-1，这种统计的方法不正确，用户在同一台机器上打开两个不同的浏览器访问系统时，系统会创建两个session对象，如果按照上面方式统计的话当前在线客户有两个，而实际上只有一个，因此需要通过客户端的ip地址来判断的方式更加准确。

    统计系统在线用户量分析

    1.创建ServletContext 监听器
    在 ServletContext 初始化时创建一个Map对象，该Map对象用于存放 IP 信息，并将创建好的 Map 存放到 ServletContext 域中。Map的key为客户端 IP，而 value 则为该客户端 IP 所发出的session对象组成的 List。

     1 package com.monkey1024.listener;
 2 
 3 import java.util.HashMap;
 4 import java.util.List;
 5 import java.util.Map;
 6 
 7 import javax.servlet.ServletContext;
 8 import javax.servlet.ServletContextEvent;
 9 import javax.servlet.ServletContextListener;
10 import javax.servlet.http.HttpSession;
11 
12 public class MyServletContextListener implements ServletContextListener {
13 
14     /*
15      * 监听ServletContext 初始化时创建一个Map对象
16      */
17     @Override
18     public void contextInitialized(ServletContextEvent sce) {
19 
20         //map的key存放ip，value存放该ip地址生成的session对象的List集合
21         Map<String,List<HttpSession>> ipMap = new HashMap<>();
22 
23         ServletContext sc = sce.getServletContext();
24         //将创建好的map对象放到ServletContext域中
25         sc.setAttribute("ipMap", ipMap);
26     }
27 }

    2.定义 Request 监听器
    在该监听器中主要实现下面功能：

    • 获取当前请求的客户端的 IP
    • 获取当前 IP 所对应的全局域中的 List。若这个 List 为空，则创建一个 List。
    • 将当前 IP 放入到 List 中，并将当前 IP 与 List 写入到 Map 中，然后再重新将 Map 写回ServletContext 中
    • 将当前 IP 存放到当前请求所对应的 Session 域中，以备在 Session 销毁时使用
     1 package com.monkey1024.listener;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 import java.util.Map;
 6 
 7 import javax.servlet.ServletContext;
 8 import javax.servlet.ServletRequestEvent;
 9 import javax.servlet.ServletRequestListener;
10 import javax.servlet.http.HttpServletRequest;
11 import javax.servlet.http.HttpSession;
12 
13 public class MyRequestListener implements ServletRequestListener {
14 
15 
16     @Override
17     public void requestInitialized(ServletRequestEvent sre) {
18         //获取请求对象
19         HttpServletRequest request = (HttpServletRequest) sre.getServletRequest();
20         //获取请求的ip
21         String ip = request.getRemoteAddr();
22         System.out.println(ip);
23         ServletContext sc = sre.getServletContext();
24         //从ServletContext中获取ipMap
25         Map<String,List<HttpSession>> ipMap = (Map<String, List<HttpSession>>) sc.getAttribute("ipMap");
26         //获取key为当前ip的list
27         List<HttpSession> list = ipMap.get(ip);
28         if(list == null){
29             list = new ArrayList<>();
30         }
31 
32         //获取当前请求所关联的session
33         HttpSession currentSession = request.getSession();
34 
35         //遍历该list，如果存在请求所关联的session对象，则说明这是同一个会话中的请求，无需处理。
36         for(HttpSession s : list){
37             if(s == currentSession){
38                 return;
39             }
40         }
41 
42         //当上面条件不满足时，说明是该ip创建的一个新的session对象，需要将该对象加入到list中
43         list.add(currentSession);
44         //将list添加到map中
45         ipMap.put(ip, list);
46         //将ipMap重新放到ServletContext域中
47         sc.setAttribute("ipMap", ipMap);
48 
49         //将ip放到session中
50         currentSession.setAttribute("ip", ip);
51     }
52 
53 
54 }
     3.定义 Session 监听器
    该监听器的功能主要是，当 Session 被销毁时， 将当前 Session 对象从 List 中删除。在从
    List 删除后，若 List 中没有了元素，则说明这个 IP 所发出的会话已全部关闭，则可以将该 IP
    所对应的 Entry 从 map 中删除了。若 List 中仍有元素，则将变化过的 List 重新再写入回 map。
     
     1 package com.monkey1024.listener;
 2 
 3 import java.util.List;
 4 import java.util.Map;
 5 
 6 import javax.servlet.ServletContext;
 7 import javax.servlet.http.HttpSession;
 8 import javax.servlet.http.HttpSessionEvent;
 9 import javax.servlet.http.HttpSessionListener;
10 
11 public class MySessionListener implements HttpSessionListener {
12 
13 
14     @Override
15     public void sessionDestroyed(HttpSessionEvent se) {
16         HttpSession currentSession = se.getSession();
17         ServletContext sc = currentSession.getServletContext();
18         //从ServletContext中获取ipMap
19         Map<String,List<HttpSession>> ipMap = (Map<String, List<HttpSession>>) sc.getAttribute("ipMap");
20         //从currentSession中获取之前存放的ip
21         String ip = (String) currentSession.getAttribute("ip");
22         //根据ip去map中找到相应的list
23         List<HttpSession> sessionList = ipMap.get(ip);
24 
25         //因为已经监听到currentSession被销毁，所以从sessionList中删除currentSession
26         sessionList.remove(currentSession);
27 
28         //如果list的长度是0，则说明该ip所发出的session对象全部失效，可以将该ip从map中删除了
29         //如果list的长度不是0，则说明该ip所发出的session对象还存在，将变化写到map中
30         if(sessionList.size() == 0){
31             ipMap.remove(ip);
32         }else{
33             ipMap.put(ip, sessionList);
34         }
35 
36         //将更新后的map放到ServletContext中
37         sc.setAttribute("ipMap", ipMap);
38     }
39 
40 
41 }

    4.在web.xml中注册监听器

    1 1 <listener>
2 2       <listener-class>com.monkey1024.listener.MySessionListener</listener-class>
3 3   </listener>
4 4   <listener>
5 5       <listener-class>com.monkey1024.listener.MyServletContextListener</listener-class>
6 6   </listener>
7 7    <listener>
8 8       <listener-class>com.monkey1024.listener.MyRequestListener</listener-class>
9 9   </listener>

    5.创建index.jsp

     1 <%@ page language="java" contentType="text/html; charset=UTF-8"
 2 pageEncoding="UTF-8" import="com.monkey1024.listener.*"%>
 3 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 4 <html>
 5 <head>
 6 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 7 <title>Insert title here</title>
 8 </head>
 9 <body>
10 
11 该系统平台目前共有在线用户${ipMap.size() }个。<br>
12 <a href="${pageContext.request.contextPath }/logout">安全退出</a><br>
13 
14 </body>
15 </html>

    6.创建LogoutServlet
    该servlet主要作用是销毁session对象

     1 package com.monkey1024.servlet;
 2 
 3 import java.io.IOException;
 4 import javax.servlet.ServletException;
 5 import javax.servlet.http.HttpServlet;
 6 import javax.servlet.http.HttpServletRequest;
 7 import javax.servlet.http.HttpServletResponse;
 8 
 9 /**
10  * 用户注销
11  */
12 public class LogoutServlet extends HttpServlet {
13     private static final long serialVersionUID = 1L;
14 
15     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
16         //使用sessions销毁
17         request.getSession().invalidate();
18     }
19 
20     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
21         doGet(request, response);
22     }
23 
24 }

    案例：使用监听器踢出在线用户

    使用监听器管理在线用户

    网站的管理员对于一些不守规矩的登录用户可以进行踢出，即使用户强制下线，这里要完成的就是这个功能。思路如下：
    当有用户登录时，将用户的信息放到session里面，之后将这个session放到一个map的value中，使用用户名作为key，一般网站在注册用户名时是不能重复的，所以这里可以保证用户名的唯一性，即key不会重复。这里使用HttpSessionBindingListener监听器，一旦User对象与session发生绑定时就将其放到map中，map存储在ServletContext中。如果要踢出用户时，只需要根据用户名去map中找到相应的session，将session失效即可。

    1.创建登录页面login.jsp

     1 <%@ page language="java" contentType="text/html; charset=UTF-8"
 2     pageEncoding="UTF-8" %>
 3 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 4 <html>
 5 <head>
 6 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 7 <title>Insert title here</title>
 8 </head>
 9 <body>
10 
11 <form action="${pageContext.request.contextPath }/login">
12     用户名：<input type="text" name="username">
13     <input type="submit" value="登录">
14 </form>
15 
16 </body>
17 </html>

    2.定义ServletContext监听器，在ServletContext创建时创建map对象，在web.xml文件中注册监听器：

     1 package com.monkey1024.listener;
 2 
 3 import java.util.HashMap;
 4 import java.util.List;
 5 import java.util.Map;
 6 
 7 import javax.servlet.ServletContext;
 8 import javax.servlet.ServletContextEvent;
 9 import javax.servlet.ServletContextListener;
10 import javax.servlet.http.HttpSession;
11 
12 public class MyServletContextListener implements ServletContextListener {
13 
14     /*
15      * 监听ServletContext 初始化时创建一个Map对象
16      */
17     @Override
18     public void contextInitialized(ServletContextEvent sce) {
19 
20         //map的key存放用户名，value存放该用户生成的session对象
21         Map<String,HttpSession> map = new HashMap<>();
22         ServletContext sc = sce.getServletContext();
23         //将创建好的map对象放到ServletContext域中
24         sc.setAttribute("map", map);
25     }
26 
27 
28 }

    3.创建javabean User并实现HttpSessionBindingListener重写里面的方法，当与session发生绑定时，将用户名和产生的session对象放到map中：

     1 package com.monkey1024.bean;
 2 
 3 import java.util.List;
 4 import java.util.Map;
 5 
 6 import javax.servlet.ServletContext;
 7 import javax.servlet.http.HttpSession;
 8 import javax.servlet.http.HttpSessionBindingEvent;
 9 import javax.servlet.http.HttpSessionBindingListener;
10 
11 /**
12  * 用户
13  *
14  */
15 public class User implements HttpSessionBindingListener{
16 
17     private String username;
18 
19     public String getUsername() {
20         return username;
21     }
22 
23     public void setUsername(String username) {
24         this.username = username;
25     }
26 
27     @Override
28     public void valueBound(HttpSessionBindingEvent event) {
29         ServletContext sc = event.getSession().getServletContext();
30         //获取ServletContext中的map
31         Map<String,HttpSession> map = (Map<String, HttpSession>) sc.getAttribute("map");
32         //将用户信息放到map中
33         map.put(username, event.getSession());
34     }
35 
36 
37 }
    1. 创建处理用户登录的LoginServlet用来接收客户端提交的数据并将User对象与session绑定。
     1 package com.monkey1024.servlet;
 2 
 3 import java.io.IOException;
 4 
 5 import javax.servlet.ServletException;
 6 import javax.servlet.http.HttpServlet;
 7 import javax.servlet.http.HttpServletRequest;
 8 import javax.servlet.http.HttpServletResponse;
 9 
10 import com.monkey1024.bean.User;
11 
12 /**
13  * 用户登录
14  */
15 public class LoginServlet extends HttpServlet {
16     private static final long serialVersionUID = 1L;
17 
18     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
19         request.setCharacterEncoding("UTF-8");
20         response.setContentType("text/html;charset=UTF-8");
21 
22         //将获取用户名并user信息放到session中
23         User u = new User();
24         u.setUsername(request.getParameter("username"));
25         request.getSession().setAttribute("user", u);
26 
27         //重定向到登录成功页面
28         response.sendRedirect(request.getContextPath() + "/login_success.jsp");
29     }
30 
31     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
32         doGet(request, response);
33     }
34 
35 }

    5.创建展示所有登录用户信息的jsp页面：

     1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
 2 <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
 3 <%
 4 String path = request.getContextPath();
 5 String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
 6 %>
 7 <!DOCTYPE html>
 8 <html>
 9 <head>
10 <meta charset="UTF-8">
11 <title></title>
12 </head>
13 <body>
14     <table border="1">
15         <tr>
16             <td>序号</td>
17             <td>用户</td>
18             <td>操作</td>
19         </tr>
20         <c:forEach items="${applicationScope.map }" var="m" varStatus="obj">
21             <tr style="background-color: ${obj.index % 2 == 0?'orange':'red'}">
22                 <td>${obj.count }</td>
23                 <td>${m.key }</td>
24                 <td><a href="${pageContext.request.contextPath }/deleteUser?username=${m.key}">删除</a></td>
25             </tr>
26         </c:forEach>
27     </table>
28 </body>
29 </html>

    6.创建servlet用来踢出在线用户

     1 package com.monkey1024.servlet;
 2 
 3 import java.io.IOException;
 4 import java.util.Map;
 5 
 6 import javax.servlet.ServletContext;
 7 import javax.servlet.ServletException;
 8 import javax.servlet.http.HttpServlet;
 9 import javax.servlet.http.HttpServletRequest;
10 import javax.servlet.http.HttpServletResponse;
11 import javax.servlet.http.HttpSession;
12 
13 /**
14  * 踢出在线用户
15  */
16 public class DeleteServlet extends HttpServlet {
17     private static final long serialVersionUID = 1L;
18 
19     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
20         request.setCharacterEncoding("UTF-8");
21         response.setContentType("text/html;charset=UTF-8");
22 
23         //获取浏览器提交的数据，即要被踢出的用户名
24         String username = request.getParameter("username");
25         HttpSession currentSession = request.getSession();
26         ServletContext sc = currentSession.getServletContext();
27         //从ServletContext获取map
28         Map<String,HttpSession> map = (Map<String,HttpSession>)sc.getAttribute("map");
29 
30         //获取要删除用户的session
31         HttpSession session = map.get(username);
32         //将该用户的session失效并从map中删除
33         if(session != null){
34             session.invalidate();
35             map.remove(username);
36         }
37 
38         response.sendRedirect(request.getContextPath() + "/userlist.jsp");
39     }
40 
41     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
42         doGet(request, response);
43     }
44 
45 }
     
     
  • 相关阅读:
    《文献管理与信息分析》速看提问
    《构建之法（第三版）》速读提问
    《深入理解计算机系统》速读提问
    2017-2018-1 20179205《Linux内核原理与设计》第八周作业
    《从问题到程序》第一、二章学习
    2017-2018-1 20179205 第三周测试 汇编混合编程
    2017-2018-1 20179205《Linux内核原理与设计》第七周作业
    第三周main参数传递-1 课堂测试
    2017-2018-1 20179205《Linux内核原理与设计》第六周作业
    2017-2018-1 20179203 《Linux内核原理与分析》第八周作业
  • 原文地址：https://www.cnblogs.com/samuraihuang/p/10779242.html
Copyright © 2020-2023  润新知