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创建监听器的步骤：

创建一个类，实现指定的监听器接口
重写接口中的方法
在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 }

创建处理用户登录的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 }

posted @ 2019-04-27 16:40 武士黄阅读(333) 评论(0) 编辑收藏举报

刷新页面返回顶部