JavaWeb三大组件（Servlet、Filter、Listener）

最新推荐文章于 2023-12-26 19:25:54 发布
最新推荐文章于 2023-12-26 19:25:54 发布
阅读量6.5k 收藏 39
点赞数 14

Servlet接口

public interface Servlet {  
  
    public void init(ServletConfig config) throws ServletException;  
  
    public ServletConfig getServletConfig();  
  
    public void service(ServletRequest req, ServletResponse res)  
    throws ServletException, IOException;  
  
    public String getServletInfo();  
  
    public void destroy();  
}

Servlet是用来处理客户端请求的动态资源，也就是当我们在浏览器中键入一个地址回车跳转后，请求就会被发送到对应的Servlet上进行处理。 
Servlet的任务有：

  1. 接收请求数据：我们都知道客户端请求会被封装成HttpServletRequest对象，里面包含了请求头、参数等各种信息。
  2. 处理请求：通常我们会在service、doPost或者doGet方法进行接收参数，并且调用业务层（service）的方法来处理请求。
  3. 完成响应：处理完请求后，我们一般会转发（forward）或者重定向（redirect）到某个页面，转发是HttpServletRequest中的方法，重定向是HttpServletResponse中的方法，两者是有很大区别的。

Servlet的创建：Servlet可以在第一次接收请求时被创建，也可以在在服务器启动时就被创建，这需要在web.xml的< servlet>中添加一条配置信息 < load-on-startup>5< /load-on-startup>，当值为0或者大于0时，表示容器在应用启动时就加载这个servlet，当是一个负数时或者没有指定时，则指示容器在该servlet被请求时才加载。 
Servlet的生命周期方法：

Init()

在Servlet实例化之后，Servlet容器会调用init()方法，来初始化该对象，主要是为了让Servlet对象在处理客户端请求前可以完成一些初始化的工作，例如：建立数据库连接、获取配置信息等。对于每一个Servlet实例，init()方法只能被调用一次。init()方法有一个类型为ServletConfig的参数，Servlet容器通过这个参数向Servlet传递配置信息。Servlet使用Servlet对象从Web应用程序的配置信息中获取以名-值对形式提供的初始化参数。另外，在Servlet中，还可以通过ServletConfig对行啊获取描述Servlet运行环境的ServletContext对象，使用该对象，Servlet可以和它的Servlet容器进行通信。

service()

容器调用service()方法来处理客户端请求。要注意，在Servlet方法被容器调用之前，必须确保init()方法正确完成。容器会构造一个表示客户端请求信息的请求对象（类型为ServletRequest）和一个用于对客户端进行响应的响应对象（类型为ServletResponse）作为参数传递给service()方法。在service方法中，Servlet对象通过ServletRequest对象得到客户端的相关信息和请求信息，在对请求进行处理后，调用ServletResponse对象的方法设置响应信息。

destory()

当容器检测到一个Servlet对象应该从服务中被移除的时候，容器会调用该对象的destory()方法，以便让Servlet对象可以释放它所使用的资源，同时保存数据到持久存储设备中，例如将内存中的数据保存到数据库中，关闭数据库连接等。当需要释放内存或者容器关闭时，容器就会调用Servlet对象的destory()方法。在Servlet容器调用destory()方法之前，如果还有其他线程正在service()方法中执行，容器将会等待这些线程执行完毕或等待服务器设定的超时时间到达。一旦Servlet对象的destory()方法被调用，容器不会再把其他的请求发送给该对象。如果需要该Servlet再次为客户端服务，容器将会重新产生一个Servlet对象来处理客户端请求。在destory()方法调用之后，容器会释放这个Servlet对象，在随后的时间内，该对象会被Java垃圾收集器所回收。

Servlet的配置：

  <servlet>
    <servlet-name>LoginServlet</servlet-name>
    <servlet-class>com.briup.estore.web.servlet.LoginServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>LoginServlet</servlet-name>
    <url-pattern>/login</url-pattern>
  </servlet-mapping>

getServletConfig()

该方法返回容器调用init()方法时传递给Servlet对象的ServletConfig对象，ServletConfig对象包含了Servlet的初始化参数。

getServletInfo()

返回一个String类型的字符串，其中包括了关于Servlet的信息，例如，作者、版本和版权。

ServletConfig接口

public interface ServletConfig {  
  
    public String getServletName();//返回Servlet实例的名字  
  
    public ServletContext getServletContext();//返回Servlet上下文对象  
      
    public String getInitParameter(String name);//返回名称为name的初始化参数的值  
  
    public Enumeration getInitParameterNames();//返回Servlet所有初始化参数的名字和枚举集合

GenericServlet抽象类

public abstract class GenericServlet   
    implements Servlet, ServletConfig, java.io.Serializable  
{//GenericServlet抽象类定义了一个通用的、不依赖于具体协议的Servlet，简化子类的实现。  
  
    private transient ServletConfig config;//config为transient，不参与序列化  
  
    public GenericServlet() { }  
      
    public void destroy() {  
    }  
      
    public String getInitParameter(String name) {  
    return getServletConfig().getInitParameter(name);  
    }  
      
    public Enumeration getInitParameterNames() {  
    return getServletConfig().getInitParameterNames();  
    }     
      
    public ServletConfig getServletConfig() {  
    return config;  
    }  
      
    public ServletContext getServletContext() {  
    return getServletConfig().getServletContext();  
    }  
  
    public String getServletInfo() {  
    return "";  
    }  
    //对Servlet接口中init()方法的实现。其中调用了不带参数的的init()方法。  
    public void init(ServletConfig config) throws ServletException {  
    this.config = config;  
    this.init();  
    }  
    //不带参数的init()方法。通常我们在编写继承自GenericServlet的Servlet类时，只需重写该方法。  
  
    public void init() throws ServletException {  
  
    }  
    public void log(String msg) {  
    getServletContext().log(getServletName() + ": "+ msg);  
    }  
    public void log(String message, Throwable t) {  
    getServletContext().log(getServletName() + ": " + message, t);  
    }  
      
    public abstract void service(ServletRequest req, ServletResponse res)  
    throws ServletException, IOException;  
  
  
    public String getServletName() {  
        return config.getServletName();  
    }  
}

HTTPServlet抽象类

public abstract class HttpServlet extends GenericServlet  
    implements java.io.Serializable  
{  
//绝大多数的网络应用中，都是客户端（浏览器）通过HTTP协议去访问服务器端的资源。  
//而我们所编写的Servle也主要是应用于HTTP协议的请求和响应。该抽象类简化了开发应用于HTTP协议的Servlet。  
......  
        //对GenericServlet类中service()方法的实现。  
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {  
        HttpServletRequest request;  
        HttpServletResponse response;  
                //首先进行显示类型转换  
        try {  
            request = (HttpServletRequest) req;  
            response = (HttpServletResponse) res;  
        } catch (ClassCastException e) {  
            throw new ServletException("non-HTTP request or response");  
        }  
        service(request, response);//调用下一个service方法  
    }  
        //在编写HTTPServlet子类时，通常不需要覆盖该方法，而只需要重写相应的doXXX()方法。  
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {  
        String method = req.getMethod();//获取HTTP请求方法的类型  
                //HTTP1.1中定义了7种请求方法：Get、Post、Head、Put、Delete、Trace和Options  
                //然后根据请求方法的类型，调用相应的doXXX()方法  
  
        if (method.equals(METHOD_GET)) {  
            long lastModified = getLastModified(req);  
            if (lastModified == -1) {  
                // servlet doesn't support if-modified-since, no reason  
                // to go through further expensive logic  
                doGet(req, resp);  
            } else {  
                long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);  
                if (ifModifiedSince < (lastModified / 1000 * 1000)) {  
                    // If the servlet mod time is later, call doGet()  
                    // Round down to the nearest second for a proper compare  
                    // A ifModifiedSince of -1 will always be less  
                    maybeSetLastModified(resp, lastModified);  
                    doGet(req, resp);  
                } else {  
                    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);  
                }  
            }  
  
        } else if (method.equals(METHOD_HEAD)) {  
            long lastModified = getLastModified(req);  
            maybeSetLastModified(resp, lastModified);  
            doHead(req, resp);  
  
        } else if (method.equals(METHOD_POST)) {  
            doPost(req, resp);  
  
        } else if (method.equals(METHOD_PUT)) {  
            doPut(req, resp);  
  
        } else if (method.equals(METHOD_DELETE)) {  
            doDelete(req, resp);  
  
        } else if (method.equals(METHOD_OPTIONS)) {  
            doOptions(req, resp);  
  
        } else if (method.equals(METHOD_TRACE)) {  
            doTrace(req, resp);  
  
        } else {  
            //不支持的请求方法，提示错误  
            // Note that this means NO servlet supports whatever  
            // method was requested, anywhere on this server.  
            String errMsg = lStrings.getString("http.method_not_implemented");  
            Object[] errArgs = new Object[1];  
            errArgs[0] = method;  
            errMsg = MessageFormat.format(errMsg, errArgs);  
  
            resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);  
        }  
    }  
  
......}

Servlet生命周期

Servlet运行在Servlet容器中，其生命周期由容器来管理。Servlet的生命周期通过Servlet接口中的init()、service()和destory()方法来表示。

注：如果需要让Servlet容器在启动时自动加载Servlet，可以在web.xml文件中配置。

单实例多线程的Servlet模型

Servlet规范中定义，默认情况下（Servlet不是在分布式的环境中部署），Servlet容器对声明的每一个Servlet，只创建一个实例。如果有多个客户端请求同时访问这个Servlet，Servlet容器如何处理多个请求呢？答案是采用多线程，Servlet容器维护一个线程池来服务请求。当容器接收到一个访问Servlet的请求，调度者线程从线程池中选取一个工作线程，将请求传递给该线程，然后由这个线程执行Servlet的service()方法。

线程安全的Servlet

变量的线程安全

因为Servlet是单实例多线程模型，多个线程共享一个Servlet实例，因此对于实例变量的访问是非线程安全的。

建议：在Servlet中尽可能的使用局部变量，应该只使用只读的实例变量和静态变量。如果非得使用共享的实例变量或静态变量，在修改共享变量时应该注意线程同步。

属性的线程安全

在Servlet中，可以访问保存在ServletContext、HttpSession和ServletRequest对象中的属性。那么这三种不同范围的对象，属性访问是否是线程安全的呢？

ServletContext：该对象被Web应用程序的所有Servlet共享，多线程环境下肯定是非线程安全的。

HttpSession：HttpSession对象只能在同属于一个Session的请求线程中共享。对于同一个Session，我们可能会认为在同一时刻只有一个用户请求，因此，Session对象的属性访问是线程安全的。但是，如果用户打开多个同属于一个进程的浏览器窗口，在这些窗口中的访问请求同属于一个Session，对于多个线程的并发修改显然不是线程安全的。

ServletRequest：因为Servlet容器对它所接收到的每一个请求，都创建一个新的ServletRequest对象，所以ServletRequest对象只在一个线程中被访问，因此对ServletRequest的属性访问是线程安全的。但是，如果在Servlet中创建了自己的线程，那么对ServletRequest的属性访问的线程安全性就得自己去保证。此外，如果作死的将当前请求的Servlet通过HttpSession或者ServletContext共享，那当然也是非线程安全的。

相关问题

1、重定向和转发的区别

JSP

JSP是一种建立在Servlet规范提供的功能之上的动态网页技术，它通过在网页文件中嵌入脚本代码，用于产生动态内容。

JSP文件在用户第一次请求时，会被编译成Servlet，然后由这个Servlet处理用户请求，所以JSP也可以看成是运行时的Servlet。

 

相关问题

JSP和Servlet的区别与联系？

 

JSP在本质上就是SERVLET,但是两者的创建方式不一样.Servlet完全是JAVA程序代码构成，擅长于流程控制和事务处理，通过Servlet来生成动态网页很不直观.JSP由HTML代码和JSP标签构成，可以方便地编写动态网页.因此在实际应用中采用Servlet来控制业务流程，而采用JSP来生成动态网页.在struts框架中，JSP位于MVC设计模式的视图层，而Servlet位于控制层.JSP是Servlet技术的扩展，本质上就是Servlet的简易方式。JSP编译后是“类servlet”。Servlet和JSP最主要的不同点在于，Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。而JSP是Java和HTML组合成一个扩展名为.jsp的文件。JSP侧重于视图，Servlet主要用于控制逻辑。

 

Filter

Filter接口

public interface Filter {  
        //用于完成Filter的初始化  
    public void init(FilterConfig filterConfig) throws ServletException;  
    //实现过滤功能  
        public void doFilter ( ServletRequest request, ServletResponse response,   
FilterChain chain ) throws IOException, ServletException;  
        //用于销毁Filter前，完成某些资源的回收  
    public void destroy();  
}

Filter生命周期

web.xml 中声明的每个 filter 在每个虚拟机中仅仅只有一个实例。
        (1) 加载和实例化
        Web 容器启动时，即会根据 web.xml 中声明的 filter 顺序依次实例化这些 filter。
        (2) 初始化
        Web 容器调用 init(FilterConfig) 来初始化过滤器。容器在调用该方法时，向过滤器传递 FilterConfig 对象，FilterConfig 的用法和 ServletConfig 类似。利用 FilterConfig 对象可以得到 ServletContext 对象，以及在 web.xml 中配置的过滤器的初始化参数。在这个方法中，可以抛出 ServletException 异常，通知容器该过滤器不能正常工作。此时的 Web 容器启动失败，整个应用程序不能够被访问。实例化和初始化的操作只会在容器启动时执行，而且只会执行一次。
        (3) doFilter
        doFilter 方法类似于 Servlet 接口的 service 方法。当客户端请求目标资源的时候，容器会筛选出符合 filter-mapping 中的 url-pattern 的 filter，并按照声明 filter-mapping 的顺序依次调用这些 filter 的 doFilter 方法。在这个链式调用过程中，可以调用 chain.doFilter(ServletRequest, ServletResponse) 将请求传给下一个过滤器(或目标资源)，也可以直接向客户端返回响应信息，或者利用 RequestDispatcher 的 forward 和 include 方法，以及 HttpServletResponse 的 sendRedirect 方法将请求转向到其它资源。需要注意的是，这个方法的请求和响应参数的类型是 ServletRequest  和 ServletResponse，也就是说，过滤器的使用并不依赖于具体的协议。
        (4) 销毁
        Web 容器调用 destroy 方法指示过滤器的生命周期结束。在这个方法中，可以释放过滤器使用的资源。
        

filter四种拦截方式

  • REQUEST：直接访问目标资源时执行过滤器。包括：在地址栏中直接访问、表单提交、超链接、重定向，只要在地址栏中可以看到目标资源的路径，就是REQUEST；
  • FORWARD：转发访问执行过滤器。包括RequestDispatcher#forward()方法、< jsp:forward>标签都是转发访问；
  • INCLUDE：包含访问执行过滤器。包括RequestDispatcher#include()方法、< jsp:include>标签都是包含访问；
  • ERROR：当目标资源在web.xml中配置为< error-page>中时，并且真的出现了异常，转发到目标资源时，会执行过滤器。

url-mapping的写法 
匹配规则有三种：

  • 精确匹配 —— 如/foo.htm，只会匹配foo.htm这个URL
  • 路径匹配 —— 如/foo/*，会匹配以foo为前缀的URL
  • 后缀匹配 —— 如*.htm，会匹配所有以.htm为后缀的URL
  • < url-pattern>的其他写法，如/foo/ ，/.htm ，/foo 都是不对的。

如果想要以不同的方式拦截，我们需要在<Filter-mapping>中添加<Dispacher>forward</Dispachaer>（这个字段会把之前的request
的值进行覆盖。并且会拦截需要转发的请求）
include 的用法和dispacher 的用法相似，不在进行介绍。
error的用法是用来来接错误信息页面，我们可以在web.xml的页面中配置错误页面的信息，具体配置如下（在Mapping之外配置）：
<error-page>
 <error-code>500</error-code>//此处应该写的数错误状态码
 <location>/index.jsp</location>//此处应该写的是拦截的具体路径
</error-page>、
错误页面的信息配置完成之后，我们就可以像之前的request拦截一样，在<Filter-mapping>中进行配置<Dispacher>error</Dispachaer>
这时候，当我们要访问的页面出错误时，过滤器便会自动进行拦截，同时我们可以使用request.sendError(500,"错误信息")；
来让页面产生错误。
注意：error的拦截只试用与错误页面，所谓的错误页面是在web.xml中配置的。

 

Filter运行原理

Filter应用场景

1、统一POST请求中文字符编码的过滤器 
2、控制浏览器缓存页面中的静态资源的过滤器
有些动态页面中引用了一些图片或css文件以修饰页面效果，这些图片和css文件经常是不变化的，所以为减轻服务器的压力，可以使用filter控制浏览器缓存这些文件，以提升服务器的性能。

3、使用Filter实现URL级别的权限认证
在实际开发中我们经常把一些执行敏感操作的servlet映射到一些特殊目录中，并用filter把这些特殊目录保护起来，限制只能拥有相应访问权限的用户才能访问这些目录下的资源。从而在我们系统中实现一种URL级别的权限功能。

4、实现用户自动登陆
首先，在用户登陆成功后，发送一个名称为user的cookie给客户端，cookie的值为用户名和md5加密后的密码。编写一个AutoLoginFilter，这个filter检查用户是否带有名称为user的cookie，如果有，则调用dao查询cookie的用户名和密码是否和数据库匹配，匹配则向session中存入user对象（即用户登陆标记），以实现程序完成自动登陆。

Filter应用实例

与开发 Servlet 不同的是，Filter 接口并没有相应的实现类可供继承，要开发过滤器，只能直接实现 Filer 接口。

 

此过滤器用来解决全站中文乱码问题：设置统一的字符编码集

public class CharacterEncodingFilter implements Filter {  
   
     private FilterConfig filterConfig = null;  
     //设置默认的字符编码  
     private String defaultCharset = "UTF-";  
   
     public void doFilter(ServletRequest req, ServletResponse resp,  
             FilterChain chain) throws IOException, ServletException {  
           
         HttpServletRequest request = (HttpServletRequest) req;  
         HttpServletResponse response = (HttpServletResponse) resp;  
         String charset = filterConfig.getInitParameter("charset");  
         if(charset==null){  
             charset = defaultCharset;  
         }  
         request.setCharacterEncoding(charset);  
         response.setCharacterEncoding(charset);  
         response.setContentType("text/html;charset="+charset);  
           
         MyCharacterEncodingRequest requestWrapper = new MyCharacterEncodingRequest(request);  
         chain.doFilter(requestWrapper, response);  
     }  
   
     public void init(FilterConfig filterConfig) throws ServletException {  
         //得到过滤器的初始化配置信息  
         this.filterConfig = filterConfig;  
     }  
       
     public void destroy() {  
   
     }  
 }

Listener

当Web应用在Web容器中运行时，Web应用内部会不断地发生各种事件：如Web应用的启动和停止、用户Session的开始和结束等，通常这些Web事件对开发者是透明的。Listener(监听器)是观察者模式的应用，通过方法回调来实现。

Listener生命周期

Listener在当web容器启动的时候，去读取每个web应用的web.xml配置文件，当配置文件中配有filter和listener时，web容器实例化listener，listener是当某个事件发生时，调用它特定方法，如HttpSessionListener,当创建一个session时会调用它的sessionCreated()方法，当servlet容器关闭或者重新加载web应用时lister对象被销毁。

Listener分类

不同功能的Listener 需要实现不同的 Listener  接口，一个Listener也可以实现多个接口，这样就可以多种功能的监听器一起工作。常用监听器：

1）监听 Session、request、ServletContext 的创建于销毁，分别为  

HttpSessionLister、ServletContextListener、ServletRequestListener

void contextInitialized(ServletContextEvent sce)：创建Servletcontext时

void contextDestroyed(ServletContextEvent sce)：销毁Servletcontext时

2）监听对象属性变化，分别为：

HttpSessionAttributeLister、ServletContextAttributeListener、ServletRequestAttributeListener

void attributeAdded(ServletContextAttributeEvent event)：添加属性时；

void attributeReplaced(ServletContextAttributeEvent event)：替换属性时；

void attributeRemoved(ServletContextAttributeEvent event)：移除属性时；

3）与session中的绑定的对象相关的监听器（对象感知监听器）
1：HttpSessionBindingListener监听 
⑴在需要监听的实体类实现HttpSessionBindingListener接口 
⑵重写valueBound()方法，这方法是在当该实体类被放到Session中时，触发该方法 
⑶重写valueUnbound()方法，这方法是在当该实体类从Session中被移除时，触发该方法 
2：HttpSessionActivationListener监听 
⑴在需要监听的实体类实现HttpSessionActivationListener接口 
⑵重写sessionWillPassivate()方法，这方法是在当该实体类被序列化时，触发该方法 
⑶重写sessionDidActivate()方法，这方法是在当该实体类被反序列化时，触发该方法

Listener应用

1、利用HttpSessionLister，统计当前在线人数。

public class OnLineCountListener implements HttpSessionListener {  
  
    @Override  
    public void sessionCreated(HttpSessionEvent se) {  
        ServletContext context = se.getSession().getServletContext();  
        Integer onLineCount = (Integer) context.getAttribute("onLineCount");  
        if (onLineCount == null) {  
            context.setAttribute("onLineCount", 1);  
        } else {  
            onLineCount++;  
            context.setAttribute("onLineCount", onLineCount);  
        }  
    }  
  
    @Override  
    public void sessionDestroyed(HttpSessionEvent se) {  
        ServletContext context = se.getSession().getServletContext();  
        Integer onLineCount = (Integer) context.getAttribute("onLineCount");  
        if (onLineCount == null) {  
            context.setAttribute("onLineCount", 1);  
        } else {  
            onLineCount--;  
            context.setAttribute("onLineCount", onLineCount);  
        }  
    }  
}

2、自定义Session扫描器

当一个Web应用创建的Session很多时，为了避免Session占用太多的内存，我们可以选择手动将这些内存中的session销毁，那么此时也可以借助监听器技术来实现。

package me.gacl.web.listener;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Timer;
import java.util.TimerTask;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

/**
* @ClassName: SessionScanerListener
* @Description: 自定义session扫描器
* @author: 孤傲苍狼
* @date: 2014-9-10 下午10:16:42
* 
*/ 
public class SessionScanerListener implements HttpSessionListener,ServletContextListener {

    /**
    * @Field: list
    *          定义一个集合存储服务器创建的HttpSession
    *        LinkedList不是一个线程安全的集合
    */ 
    /**
     * private List<HttpSession> list = new LinkedList<HttpSession>();
     * 这样写涉及到线程安全问题,SessionScanerListener对象在内存中只有一个
     * sessionCreated可能会被多个人同时调用，
     * 当有多个人并发访问站点时，服务器同时为这些并发访问的人创建session
     * 那么sessionCreated方法在某一时刻内会被几个线程同时调用，几个线程并发调用sessionCreated方法
     * sessionCreated方法的内部处理是往一个集合中添加创建好的session，那么在加session的时候就会
     * 涉及到几个Session同时抢夺集合中一个位置的情况，所以往集合中添加session时，一定要保证集合是线程安全的才行
     * 如何把一个集合做成线程安全的集合呢？
     * 可以使用使用 Collections.synchronizedList(List<T> list)方法将不是线程安全的list集合包装线程安全的list集合
     */
    //使用 Collections.synchronizedList(List<T> list)方法将LinkedList包装成一个线程安全的集合
    private List<HttpSession> list = Collections.synchronizedList(new LinkedList<HttpSession>());
    //定义一个对象，让这个对象充当一把锁，用这把锁来保证往list集合添加的新的session和遍历list集合中的session这两个操作达到同步
    private Object lock = new Object();
            
    @Override
    public void sessionCreated(HttpSessionEvent se) {
        System.out.println("session被创建了!!");
        HttpSession session = se.getSession();
        
        synchronized (lock){
            /**
             *将该操作加锁进行锁定，当有一个thread-1(线程1)在调用这段代码时，会先拿到lock这把锁，然后往集合中添加session，
             *在添加session的这个过程中假设有另外一个thread-2(线程2)来访问了，thread-2可能是执行定时器任务的，
             *当thread-2要调用run方法遍历list集合中的session时，结果发现遍历list集合中的session的那段代码被锁住了，
             *而这把锁正在被往集合中添加session的那个thread-1占用着，因此thread-2只能等待thread-1操作完成之后才能够进行操作
             *当thread-1添加完session之后，就把lock放开了，此时thread-2拿到lock，就可以执行遍历list集合中的session的那段代码了
             *通过这把锁就保证了往集合中添加session和变量集合中的session这两步操作不能同时进行，必须按照先来后到的顺序来进行。
             */
            list.add(session);
        }
    }

    @Override
    public void sessionDestroyed(HttpSessionEvent se) {
        System.out.println("session被销毁了了!!");
    }

    /* Web应用启动时触发这个事件
     * @see javax.servlet.ServletContextListener#contextInitialized(javax.servlet.ServletContextEvent)
     */
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("web应用初始化");
        //创建定时器
        Timer timer = new Timer();
        //每隔30秒就定时执行任务
        timer.schedule(new MyTask(list,lock), 0, 1000*30);
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("web应用关闭");
    }
}

/**
* @ClassName: MyTask
* @Description:定时器要定时执行的任务
* @author: 孤傲苍狼
* @date: 2014-9-11 上午12:02:36
*
*/ 
class MyTask extends TimerTask {
        
    //存储HttpSession的list集合
    private List<HttpSession> list;
    //存储传递过来的锁
    private Object lock;
    public MyTask(List<HttpSession> list,Object lock){
        this.list = list;
        this.lock = lock;
    }
    /* run方法指明了任务要做的事情
     * @see java.util.TimerTask#run()
     */
    @Override
    public void run() {
            //将该操作加锁进行锁定
        synchronized (lock) {
            System.out.println("定时器执行！！");
            ListIterator<HttpSession> it = list.listIterator();
            /**
             * 迭代list集合中的session，在迭代list集合中的session的过程中可能有别的用户来访问，
             * 用户一访问，服务器就会为该用户创建一个session,此时就会调用sessionCreated往list集合中添加新的session，
             * 然而定时器在定时执行扫描遍历list集合中的session时是无法知道正在遍历的list集合又添加的新的session进来了，
             * 这样就导致了往list集合添加的新的session和遍历list集合中的session这两个操作无法达到同步
             * 那么解决的办法就是把"list.add(session)和while(it.hasNext()){//迭代list集合}"这两段代码做成同步，
             * 保证当有一个线程在访问"list.add(session)"这段代码时，另一个线程就不能访问"while(it.hasNext()){//迭代list集合}"这段代码
             * 为了能够将这两段不相干的代码做成同步，只能定义一把锁(Object lock)，然后给这两步操作加上同一把锁，
             * 用这把锁来保证往list集合添加的新的session和遍历list集合中的session这两个操作达到同步
             * 当在执行往list集合添加的新的session操作时，就必须等添加完成之后才能够对list集合进行迭代操作，
             * 当在执行对list集合进行迭代操作时，那么必须等到迭代操作结束之后才能够往往list集合添加的新的session
             */
            while(it.hasNext()){
                HttpSession session = (HttpSession) it.next();
                /**
                 * 如果当前时间-session的最后访问时间>1000*15(15秒)
                 * session.getLastAccessedTime()获取session的最后访问时间
                 */
                if(System.currentTimeMillis()-session.getLastAccessedTime()>1000*30){
                    //手动销毁session
                    session.invalidate();
                    //移除集合中已经被销毁的session
                    it.remove();
                }
            }
        }
    }
}

 

qq_37211608
关注
  • 14
    点赞
  • 踩
  • 39
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JavaWeb两大组件FILTER&LISTENER
06-30
在JavaWeb开发中，"FILTER（过滤器）"和"LISTENER（监听器）"是两个重要的组件，它们极大地增强了应用程序的功能和灵活性。本案例将深入探讨这两个组件的原理、用法及其在实际项目中的应用。 一、FILTER（过滤器） ...
javaweb 项目中三种组件实例
05-30
在Java Web开发中，Filter、Listener和Interceptor是三个至关重要的组件，它们各自承担着不同的职责，共同构建了一个灵活且强大的应用程序架构。以下是对这三种组件的详细解释： 1. **Filter（过滤器）**： 过滤器...
Servlet、Filter、Listener、Interceptor
xiaomin1991222的专栏
09-06 205
首先，JSP/Servlet规范中定义了Servlet、Filter、Listener这三 种角色，并没有定义Interceptor这个角色，Interceptor是某些MVC框架中的角色，比如Struts2中，Interceptor是 用来拦截Action中的方法的调用，在被拦截的Action方法被执行前，先执行响应的拦截器中的方法。 servlet、filter、listener是配置到...
JavaWeb的三大组件详细总结
一个爱运动的程序员的博客
03-09 3173
文章目录一、Servlet（Server Applet） 一、Servlet（Server Applet） Servlet是Java Servlet的简称，称为小服务程序或服务连接器，用Java编写的服务器端程序，主要功能在于交互式地浏览和修改数据，生成动态Web内容。 狭义的Servlet是指Java语言实现的一个接口，广义的Servlet是指任何实现了这个Servlet接口的类，一般情况下，人...
JavaWeb三大件之Servlet
鸡翘少女不会受伤的博客
04-26 1090
JavaWeb三大件之Servlet 一丶主要内容 ①servlet是运行在服务端的程序，本质上是类 ②servlet是接口，和实现类 ③servlet接口的抽象方法及功能读解 ④servlet应用程序的体系结构 二丶Servlet基础 1.概念 servlet是独立于操作系统平台和网络传输协议的服务端的Java应用程序 它是一种JavaEE的组件技术 2.功能 扩展服务器的功能 生成响应 3.动作 接受请求 给出响应 4.开发流程 编写一个java类，继承HttpServlet类 重写HttpServl
Servlet技术之Listener监听器
最新发布
liubopro666的博客
12-26 1162
在 Java Web 开发中，Servlet 技术是一种非常重要的技术。它用于创建动态的 Web 页面，处理用户请求和生成响应。而 Listener 监听器则是 Servlet 技术中的一个重要组成部分，它允许开发者在特定的事件发生时执行自定义的代码。通过使用 Listener 监听器，开发者可以在 Servlet 生命周期的不同阶段执行自定义的代码，例如在初始化阶段、请求处理阶段和销毁阶段。这为开发者提供了更多的灵活性和控制力，使他们能够更好地管理和监控 Servlet 的行为。
Filter & Listener——概述、应用、Filter的使用 & 细节
Guizy
02-16 1867
目录 Filter概述 Filter的作用 Filter的应用 Filter的开发和使用 Filter的细节 Filter概述 过滤器:一个拥有过滤/拦截功能的东西,过滤掉一些不想要的,不和谐的东西. 生活中的过滤器:香烟过滤嘴,滤纸,净水器,空气净化器,丈母娘,土匪等. 大多数都是单向过滤器. Web中的过滤器(Filter):Web中的一个组件/程序,就好比Servlet,过滤器就是一...
Servlet开发JavaWeb工程示例详解
08-18
Servlet是JavaWeb的三大组件之一（Servlet、Filter、Listener），它属于动态资源。Servlet的作用是处理请求，服务器会把接收到的请求交给Servlet来处理，在Servlet中通常需要：接收请求数据；处理请求；完成响应。 ...
（重温）JavaWeb–Filter 过滤器（JavaWeb 的三大组件之一）
12-21
JavaWeb 技术中，Filter（过滤器）是三大核心组件之一，与Servlet程序和Listener监听器并列。Filter 是 JavaEE 规范的一部分，它定义了一个接口，允许开发者在请求被处理之前或之后进行拦截，对请求或响应进行预处理...
快速学习JavaWeb中监听器(Listener)的使用方法
09-01
- **组件监听器**（ComponentListener）：用于监听Web组件（如Servlet、Filter、JSP）的初始化、销毁等生命周期事件。 - **用户会话监听器**（HttpSessionActivationListener）：监听会话的激活和钝化。 - **属性...
servlet三大组件
glenshappy的专栏
02-04 1588
servlet大致可以分为三个：``简单servlet、过滤servlet、监听servlet` servlet： servlet的创建 创建一个类并实现Servlet接口。 重写service方法。 在服务器中注册Servlet 协议 一定是双方或多方签订的。 浏览器和服务器之间的通信是基于请求(request)和响应(reponse)的。 HTTP协议就是规定浏览器和服务器之间的通信报文格式。(报文首部分为首行和头，统称为首部。) get、post请求 1). get请求：请求参数在地
Java Web 14 — Filter&Listener（过滤器、监听器）
文泽路小男孩的博客
08-24 251
文章目录一、Filter：过滤器1.1 概念1.2 快速入门1.3 过滤器细节1.3.1 web.xml配置1.3.2 过滤器执行流程1.3.3 过滤器生命周期方法1.3.4 过滤器配置详解1.3.5 过滤器链（配置多个过滤器）二、Listener：监听器2.1 概念2.2 ServletContextListener 一、Filter：过滤器 1.1 概念 web中的过滤器：当访问服务器的资源...
MVC入门
xiaodanjava的专栏
06-19 1038
前面已经创建完项目了，那么下面一个步骤就是逐一新建在MVC框架中负责V（视图）、C（控制器）、M（模型）的对应文件。第一步：创建项目（已完成）第二步：新建负责V（视图）的JSP文件 在文件夹Web-Root下新建名为MyJsp.jsp的JSP文件，代码如下： 复制代码 1 2 <% 3 String path = request.getContextPath(); 4 String base
Servlet与Filter与LIstener基本功能介绍
unuan的博客
04-02 146
Servlet与Filter与LIstener Servlet用于处理请求响应业务 我们一般创建一个类继承HTTPServlet来实现请求响应处理业务 重写doGet，用于实现get方法请求 重写doPost，用于实现post方法请求 一般情况下会在doGet或者doPost方法里面进行联合，换句话说浏览器不管是get请求还是post请求，我们都可以处理 Filter用于过滤Serv...
Servlet--Filter&Listener
ZUIHENderen46的博客
10-14 453
过滤器 Filter (1)过滤器是什么? servlet规范当中定义的一种特殊的组件,用来拦截servlet容器的调用过程. 注:当servlet容器收到请求之后,如果有过滤器,会先调用过滤器.    (2)如何写过滤器? step1: 写一个java类,实现Filter接口. import java.io.IOException; import javax....
JavaWeb三大组件【Servlet、Filter、Listener】
乔巴俊儿~~的博客
04-22 2450
目录 引言 Filter Listener 引言 JavaWeb三大组件指的是：Servlet、Filter、Listener，这三个组件在JavaWeb开发中分别提供不同的功能。Servlet 是 JavaWeb 的三大组件之一,它属于动态资源，前面文章有写到（请参考）：web阶段~Servlet学习_乔巴菌儿的博客-CSDN博客 今天，我们将进行Filter（过滤器）与Listener（监听器）的学习。 Filter 【概念】 web中的过滤器：当访问服务器的资源时，过滤器可以将.
servlet,filter,listener,inteceptor区别
pigemajia的博客
08-05 284
慢慢来吧，需要补课的地方还有很多很多呀。初学的时候都不知道他们存在呢。呵呵。 下面从几个方面阐述一下题目中四个概念的区别与联系： 1、概念 2、生命周期 3、职责 4、执行过程 一、概念： 1...
Filter&Listener
Good_omen的博客
07-02 228
Filter：过滤器 1. 概念： web中的过滤器：当访问服务器的资源时，过滤器可以将请求拦截下来，完成一些特殊的功能。 过滤器的作用：一般用于完成通用的操作。如：登录验证、统一编码处理、敏感字符过滤… 2. 快速入门： 步骤： 1. 定义一个类，实现接口Filter 2. 复写方法 3. 配置拦截路径 web.xml 注解 代码： @WebFilter("/*")//访问所有资源之前，都会执行该过滤器 public class FilterDemo1 implements Filter { @Ov
listener filter servlet_Servlet工作机制解析
weixin_39611037的博客
11-28 65
Servlet是java Web技术的基础，也是学习Web 框架原理绕不过去的部分。本章我们来学习学习。1. Servlet和Servlet容器什么是servlet?从概念上来说是这样的：Servlet是用java编写，遵守java servlet API的一些类，原则上这些类可以响应任何类型的请求，我们一般用它来响应web方面的请求。说的通俗一点就是，servlet就是专门处理请求的一...
javaWeb三大组件的Listener有什么用
06-02
常见的三大组件（Servlet、Filter、Listener）中，Listener是最为特殊的一个，它与Servlet和Filter的作用不同，主要用于监听Web应用中的事件，例如： 1. ServletContextListener：用于监听Servlet上下文的创建和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值