拦截器、过滤器、监听器

无标签

发布日期: 2021-06-22

更新日期: 2021-07-28

文章字数: 5.8k

阅读时长: 23 分

阅读次数:

过滤器、拦截器、监听器

一、过滤器

1、定义

先来几张图明了一下
通过上面几张图大概明了了过滤器的作用以及使用地方，以及在SpringMVC里面的使用方式，下面也会谈及到在SpringBoot里面的配置和使用

Filter在英文中是过滤器的意思，当然在此处的使用也是完美的切合了它的意思，我们使用filter的主要目的就是完成一个过滤的作用。可以在一个请求到达servlet之前，将其截取进行逻辑判断，然后决定是否放行到请求的servlet。也可以在一个response到达客户端之前，截取结果进行逻辑判断，然后决定是否允许返回给客户端。所以filter有如下几个种类：

用户授权的filter：filter负责判断用户是否有权限请求该页面，给予过滤判断
日志filter：截取某个用户在本网站上的所有请求，记录轨迹
负责解码的filter：规定处理本次请求的解码方式
最后需要注意的是，一个filter过滤器可以加在多个servlet控制器上，当然多个filter过滤器也是可以加在一个servlet控制器上的。由此也是可以看出来，我们使用filter往往是对一些公共的操作进行处理，例如：判断用户权限，解码本次请求等，还比如，我们的web应用中某些页面是需要用户登录后才能访问的，以往我们都是在每个servlet页面加上判断控制，导致代码冗余，有了filter，我们可以定义一个实现了filter的过滤器，让需要判断是否登录的页面都加上这么一个过滤器，可以大大降低代码的冗余程度

2、功能

filter功能.它使用户可以改变一个request和修改一个 response. Filter 不是一个servlet,它不能产生一个response,它能够在一个request到达servlet之前预处理request,也可以在离开 servlet时处理response.换种说法,filter其实是一个”servlet chaining”(servlet 链).一个filter 包括:

在servlet被调用之前截获;
在servlet被调用之前检查servlet request;
根据需要修改request头和request数据;
根据需要修改response头和response数据;
在servlet被调用之后截获.

你能够配置一个filter 到一个或多个servlet;单个servlet或servlet组能够被多个filter 使用.几个实用的filter 包括:用户辨认filter,日志filter,审核filter,加密filter,符号filter,能改变xml内容的XSLT filter等.
一个filter必须实现javax.servlet.Filter接口并定义三个方法:

void setFilterConfig(FilterConfig config) //设置filter 的配置对象;
FilterConfig getFilterConfig() //返回filter的配置对象;
void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) //执行filter 的工作.

3、实现

通过注解实现，无需配置web.xml

/**
 * 使用注解标注过滤器
 * @WebFilter将一个实现了javax.servlet.Filte接口的类定义为过滤器
 * 属性filterName声明过滤器的名称,可选
 * 属性urlPatterns指定要过滤 的URL模式,也可使用属性value来声明.(指定要过滤的URL模式是必选属性)
 */
@WebFilter(filterName="Servlet3Filter",urlPatterns="/*")
public class Servlet3Filter implements Filter {

    @Override
    public void destroy() {
        System.out.println("过滤器销毁");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        System.out.println("执行过滤操作");
        chain.doFilter(request, response);
    }

    @Override
    public void init(FilterConfig config) throws ServletException {
        System.out.println("过滤器初始化");
    }
}

二、拦截器

1、定义

先看图
拦截器顾名思义起拦截作用，在中央处理器分配请求到指定控制层接口时，先通过拦截器验证，详解见下

2、概念

java里的拦截器是动态拦截Action调用的对象，它提供了一种机制可以使开发者在一个Action执行的前后执行一段代码，也可以在一个Action执行前阻止其执行，同时也提供了一种可以提取Action中可重用部分代码的方式。在AOP中，拦截器用于在某个方法或者字段被访问之前，进行拦截然后再之前或者之后加入某些操作。目前，我们需要掌握的主要是Spring的拦截器

3、原理

大部分时候，拦截器方法都是通过代理的方式来调用的。Struts2的拦截器实现相对简单。当请求到达Struts2的ServletDispatcher时，Struts会查找配置文件，并根据配置实例化相对的拦截器对象，然后串成一个列（List），最后一个一个的调用列表中的拦截器。Struts2的拦截器是可插拔的，拦截器是AOP的一个实现。Struts2拦截器栈就是将拦截器按一定的顺序连接成一条链。在访问被拦截的方法或者字段时，Struts2拦截器链中的拦截器就会按照之前定义的顺序进行调用

4、自定义拦截器

第一步：自定义一个实现了Interceptor接口的类，或者继承抽象类AbstractInterceptor。
第二步：在配置文件中注册定义的拦截器。
第三步：在需要使用Action中引用上述定义的拦截器，为了方便也可以将拦截器定义为默认的拦截器，这样在不加特殊说明的情况下，所有的Action都被这个拦截器拦截。

5、过滤器与拦截器的区别

过滤器可以简单的理解为“取你所想取”，过滤器关注的是web请求；拦截器可以简单的理解为“拒你所想拒”，拦截器关注的是方法调用，比如拦截敏感词汇；

拦截器是基于java反射机制来实现的，而过滤器是基于函数回调来实现的。（有人说，拦截器是基于动态代理来实现的）

拦截器不依赖servlet容器，过滤器依赖于servlet容器

拦截器只对Action起作用，过滤器可以对所有请求起作用

拦截器可以访问Action上下文和值栈中的对象，过滤器不能

在Action的生命周期中，拦截器可以多次调用，而过滤器只能在容器初始化时调用一次

6、Spring拦截器

我们如果在项目中使用了Spring框架，那么，我们可以直接继承HandlerInterceptorAdapter.java这个抽象类，来实现我们自己的拦截器（HandlerInterceptorAdapter继承了抽象接口HandlerInterceptor）

public abstract class HandlerInterceptorAdapter implements HandlerInterceptor{
    // 在业务处理器处理请求之前被调用
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception{
        return true;
    }
    // 在业务处理器处理请求完成之后，生成视图之前执行
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
      throws Exception{
    }
    // 在DispatcherServlet完全处理完请求之后被调用，可用于清理资源
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
      throws Exception{
    }
    
}

三、监听器

1、定义

先看图
监听器，字面上的理解就是监听观察某个事件（程序）的发生情况，当被监听的事件真的发生了的时候，事件发生者（事件源）就会给注册该事件的监听者（监听器）发送消息，告诉监听者某些信息，同时监听者也可以获得一份事件对象，根据这个对象可以获得相关属性和执行相关操作。换句话说_监听器是指专门用于对其他对象身上发生的事件或状态改变进行监听和相应处理的对象，当被监视的对象发生变化时，立即采取相应的行动。
另外，web监听器由servlet规范提供的，它可以监听客户端的请求，服务端的操作，监听的对象包括ServletContext,HttpSession,ServletRequest三个预对象(内置对象)，分别对应aplication，session，request。

2、三个对象

事件：用户对组件的一个操作，或者说程序执行某个方法，称之为一个事件，如机器人程序执行工作。
事件源：发生事件的组件就是事件源，也就是被监听的对象，如机器人可以工作，可以跳舞，那么就可以把机器人看做是一个事件源。
事件监听器（处理器）：监听并负责处理事件的方法，如监听机器人工作情况，在机器人工作前后做出相应的动作，或者获取机器人的状态信息。

三个对象的执行顺序：

1、给事件源注册监听器。
2、组件接受外部作用，也就是事件被触发。
3、组件产生一个相应的事件对象，并把此对象传递给与之关联的事件处理器。
4、事件处理器启动，并执行相关的代码来处理该事件。

3、监听器模式

监听器模式：事件源注册监听器之后，当事件源触发事件，监听器就可以回调事件对象的方法；更形象地说，监听者模式是基于：注册-回调的事件/消息通知处理模式，就是被监控者将消息通知给所有监控者。

1、注册监听器：事件源.setListener。
2、回调：事件源实现onListener。

4、概念

Servlet规范中定义的一种特殊类
用于监听ServletContext，HttpSession和ServletRequest等域对象的创建与销毁事件用于监听域对象的属性发生修改的事件可以在事件发生前，发生后做一些必要的处理

5、用途

1.统计在线人数和在线用户
2.系统启动时加载初始化信息
3.统计网站访问量
4.跟Spring结合

6、分类

1）按监听的对象划分

1)用于监听应用程序环境对象(ServletContext)的事件监听器
2)用于监听用户会话对象(HttpSession)的事件监听器
3)用于监听请求消息对象(ServletRequest)的事件监听器

2）按监听的事件划分

1、监听域对象自身的创建和销毁的事件监听器

ServletContext的创建与销毁

ServletContext实现了ServletContextListener用于监听它的创建与销毁事件，一个web项目可以定义多个ServletContextListener，但一个web项目只有一个ServletContext对象。
ServletContextListener有两个事件处理方法，这两个方法都会传入ServletContextEvent事件对象，可以获取ServletContext对象以及一些初始化参数。ServletContextListener主要用途：可以做定时器，加载全局属性对象，创建全局的数据库连接，加载一些缓存信息

public class FirstListener implements ServletContextListener {
    //ServletContext是上下文对象，当web应用启动时创建，web应用销毁时销毁
    @Override
    public void contextInitialized(ServletContextEvent sce) {
//项目启动时获取初始化参数
        String initParam = sce.getServletContext().getInitParameter("initParam");
        System.out.println("contextInitialized : initParam = " + initParam);
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
//销毁主要用于当数据库连接关闭时释放一些不必要的资源
        System.out.println("contextDestroyed");
    }
}

HttpSession的创建与销毁

与ServletContext类似，HttpSession实现了HttpSessionListener用于监听它的创建与销毁事件，一个web项目可以定义多个HttpSessionListener，但一个web项目只有一个HttpSession对象。HttpSessionEvent事件对象，可以获取当前被创建的HttpSession对象。HttpSessionListener主要用途：统计在线人数，记录访问日志。

Session创建：用户打开浏览器第一次访问我们应用时，这次会话web容器会分配一个session，可以在session中保存一些信息
Session销毁：1.手动点退出，关闭服务器；2.关闭浏览器一段时间直到session过期；3.不关闭浏览器，session超时

public class MyHttpSessionListener implements HttpSessionListener {
    @Override
    public void sessionCreated(HttpSessionEvent se) {
        System.out.println("sessionCreated");
    }

    @Override
    public void sessionDestroyed(HttpSessionEvent se) {
        System.out.println("sessionDestroyed");
    }
}

ServletRequest的创建与销毁

ServletRequest实现了ServletRequestListener用于监听它的创建与销毁事件，一个web项目可以定义多个ServletRequestListener，但一个web项目只有一个ServletRequest对象。ServletRequestListener主要用途：读取request里的参数，记录访问历史，路径。

public class MyServletRequestListener implements ServletRequestListener {
    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        //获取当前的请求参数
        String name = sre.getServletRequest().getParameter("name");
        System.out.println("requestInitialized");
    }

    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        System.out.println("requestDestroyed");
    }
}

2、监听域对象中的属性的增加和删除的事件监听器

在这里插入图片描述

public class MyServletContextAttributeListener implements ServletContextAttributeListener {
    @Override
    public void attributeAdded(ServletContextAttributeEvent scae) {
        System.out.println("ServletContext_attributeAdded:"+scae.getName());
    }

    @Override
    public void attributeRemoved(ServletContextAttributeEvent scae) {
        System.out.println("ServletContext_attributeRemoved:"+scae.getName());
    }

    @Override
    public void attributeReplaced(ServletContextAttributeEvent scae) {
        System.out.println("ServletContext_attributeReplaced:"+scae.getName());
    }
}
————————————————
public class MyHttpSessionAttributeListener implements HttpSessionAttributeListener {
    @Override
    public void attributeAdded(HttpSessionBindingEvent se) {
        System.out.println("HttpSession_attributeAdded:"+se.getName());
    }

    @Override
    public void attributeRemoved(HttpSessionBindingEvent se) {
        System.out.println("HttpSession_attributeRemoved:"+se.getName());
    }

    @Override
    public void attributeReplaced(HttpSessionBindingEvent se) {
        System.out.println("HttpSession_attributeReplaced:"+se.getName());
    }
}
—————————————
public class MyServletRequestAttributeListener implements ServletRequestAttributeListener {
    @Override
    public void attributeAdded(ServletRequestAttributeEvent srae) {
//可知是什么对象添加了什么属性，移除了什么属性       System.out.println("ServletRequest_attributeAdded:"+srae.getName());
    }

    @Override
    public void attributeRemoved(ServletRequestAttributeEvent srae) {
        System.out.println("ServletRequest_attributeRemoved:"+srae.getName());
    }

    @Override
    public void attributeReplaced(ServletRequestAttributeEvent srae) {
        System.out.println("ServletRequest_attributeReplaced:"+srae.getName());
    }
}

7、监听器类型

1.ServletContextListener -- 监听servletContext对象的创建以及销毁    
    1.1  contextInitialized(ServletContextEvent arg0)   -- 创建时执行    
    1.2  contextDestroyed(ServletContextEvent arg0)  -- 销毁时执行
2.HttpSessionListener  -- 监听session对象的创建以及销毁    
    2.2  sessionCreated(HttpSessionEvent se)   -- 创建时执行    
    
    2.2  sessionDestroyed(HttpSessionEvent se) -- 销毁时执行
3.ServletRequestListener -- 监听request对象的创建以及销毁    
    3.1  requestInitialized(ServletRequestEvent sre) -- 创建时执行    
    3.2  requestDestroyed(ServletRequestEvent sre) -- 销毁时执行
4.ServletContextAttributeListener  -- 监听servletContext对象中属性的改变    
    4.1  attributeAdded(ServletContextAttributeEvent event) -- 添加属性时执行    
    4.2  attributeReplaced(ServletContextAttributeEvent event) -- 修改属性时执行    
    4.3  attributeRemoved(ServletContextAttributeEvent event) -- 删除属性时执行
5.HttpSessionAttributeListener  --监听session对象中属性的改变    
    5.1  attributeAdded(HttpSessionBindingEvent event) -- 添加属性时执行    
    5.2  attributeReplaced(HttpSessionBindingEvent event) -- 修改属性时执行    
    5.3  attributeRemoved(HttpSessionBindingEvent event) -- 删除属性时执行
6.ServletRequestAttributeListener  --监听request对象中属性的改变    
    6.1  attributeAdded(ServletRequestAttributeEvent srae) -- 添加属性时执行    
    6.2  attributeReplaced(ServletRequestAttributeEvent srae) -- 修改属性时执行    
    6.3  attributeRemoved(ServletRequestAttributeEvent srae) -- 删除属性时执行

参考

SpringBoot整合

PS:原文链接https://www.cnblogs.com/haixiang/p/12000685.html，转载请注明出处

过滤器

过滤器简介

过滤器的英文名称为 Filter, 是 Servlet 技术中最实用的技术。如同它的名字一样，过滤器是处于客户端和服务器资源文件之间的一道过滤网，帮助我们过滤掉一些不符合要求的请求，通常用作 Session 校验，判断用户权限，如果不符合设定条件，则会被拦截到特殊的地址或者基于特殊的响应。

过滤器的使用

首先需要实现 Filter接口然后重写它的三个方法

init 方法：在容器中创建当前过滤器的时候自动调用
destory 方法：在容器中销毁当前过滤器的时候自动调用
doFilter 方法：过滤的具体操作

我们先引入 Maven 依赖，其中 lombok 是用来避免每个文件创建 Logger 来打印日志

Copy        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

我们首先实现接口，重写三个方法，对包含我们要求的四个请求予以放行，将其它请求拦截重定向至/online，只要在将MyFilter实例化后即可，我们在后面整合代码中一起给出。

Copyimport lombok.extern.log4j.Log4j2;
import org.springframework.stereotype.Component;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
import java.io.IOException;

@Log4j2
public class MyFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        log.info("初始化过滤器");
    }
  
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest)servletRequest;
        HttpServletResponseWrapper wrapper = new HttpServletResponseWrapper((HttpServletResponse) response);
        String requestUri = request.getRequestURI();
        log.info("请求地址是："+requestUri);
        if (requestUri.contains("/addSession")
            || requestUri.contains("/removeSession")
            || requestUri.contains("/online")
            || requestUri.contains("/favicon.ico")) {
            filterChain.doFilter(servletRequest, response);
        } else {
            wrapper.sendRedirect("/online");
        }
    }
  
    @Override
    public void destroy() {
        //在服务关闭时销毁
        log.info("销毁过滤器");
    }
}

拦截器

拦截器介绍

Java中的拦截器是动态拦截 action 调用的对象，然后提供了可以在 action 执行前后增加一些操作，也可以在 action 执行前停止操作，功能与过滤器类似，但是标准和实现方式不同。

登录认证：在一些应用中，可能会通过拦截器来验证用户的登录状态，如果没有登录或者登录失败，就会给用户一个友好的提示或者返回登录页面，当然大型项目中都不采用这种方式，都是调单点登录系统接口来验证用户。
记录系统日志：我们在常见应用中，通常要记录用户的请求信息，比如请求 ip，方法执行时间等，通过这些记录可以监控系统的状况，以便于对系统进行信息监控、信息统计、计算 PV、性能调优等。
通用处理：在应用程序中可能存在所有方法都要返回的信息，这是可以利用拦截器来实现，省去每个方法冗余重复的代码实现。

使用拦截器

我们需要实现 HandlerInterceptor 类，并且重写三个方法

preHandle：在 Controoler 处理请求之前被调用，返回值是 boolean类型，如果是true就进行下一步操作；若返回false，则证明不符合拦截条件，在失败的时候不会包含任何响应，此时需要调用对应的response返回对应响应。
postHandler：在 Controoler 处理请求执行完成后、生成视图前执行，可以通过ModelAndView对视图进行处理，当然ModelAndView也可以设置为 null。
afterCompletion：在 DispatcherServlet 完全处理请求后被调用，通常用于记录消耗时间，也可以对一些资源进行处理。

Copyimport lombok.extern.log4j.Log4j2;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

@Log4j2
@Component
public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        log.info("【MyInterceptor】调用了:{}", request.getRequestURI());
        request.setAttribute("requestTime", System.currentTimeMillis());
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response,
                           Object handler, ModelAndView modelAndView) throws Exception {
        if (!request.getRequestURI().contains("/online")) {
            HttpSession session = request.getSession();
            String sessionName = (String) session.getAttribute("name");
            if ("haixiang".equals(sessionName)) {
                log.info("【MyInterceptor】当前浏览器存在 session:{}",sessionName);
            }
        }
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
                                Object handler, Exception ex) throws Exception {
        long duration = (System.currentTimeMillis() - (Long)request.getAttribute("requestTime"));
        log.info("【MyInterceptor】[{}]调用耗时:{}ms",request.getRequestURI(), duration);
    }
}

监听器

监听器简介

监听器通常用于监听 Web 应用程序中对象的创建、销毁等动作的发送，同时对监听的情况作出相应的处理，最常用于统计网站的在线人数、访问量等。

监听器大概分为以下几种：

ServletContextListener：用来监听 ServletContext 属性的操作，比如新增、修改、删除。
HttpSessionListener：用来监听 Web 应用种的 Session 对象，通常用于统计在线情况。
ServletRequestListener：用来监听 Request 对象的属性操作。

监听器的使用

我们通过 HttpSessionListener来统计当前在线人数、ip等信息，为了避免并发问题我们使用原子int来计数。

ServletContext,是一个全局的储存信息的空间，它的生命周期与Servlet容器也就是服务器保持一致，服务器关闭才销毁。request，一个用户可有多个；session，一个用户一个；而servletContext，所有用户共用一个。所以，为了节省空间，提高效率，ServletContext中，要放必须的、重要的、所有用户需要共享的线程又是安全的一些信息。因此我们这里用ServletContext来存储在线人数sessionCount最为合适。

我们下面来统计当前在线人数

Copyimport lombok.extern.log4j.Log4j2;

import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
import java.util.concurrent.atomic.AtomicInteger;

@Log4j2
public class MyHttpSessionListener implements HttpSessionListener {

    public static AtomicInteger userCount = new AtomicInteger(0);

    @Override
    public synchronized void sessionCreated(HttpSessionEvent se) {
        userCount.getAndIncrement();
        se.getSession().getServletContext().setAttribute("sessionCount", userCount.get());
        log.info("【在线人数】人数增加为:{}",userCount.get());
      
        //此处可以在ServletContext域对象中为访问量计数，然后传入过滤器的销毁方法
        //在销毁方法中调用数据库入库，因为过滤器生命周期与容器一致
    }

    @Override
    public synchronized void sessionDestroyed(HttpSessionEvent se) {
        userCount.getAndDecrement();
        se.getSession().getServletContext().setAttribute("sessionCount", userCount.get());
        log.info("【在线人数】人数减少为:{}",userCount.get());
    }
}

过滤器、拦截器、监听器注册

实例化三器

Copyimport com.anqi.tool.sanqi.filter.MyFilter;
import com.anqi.tool.sanqi.interceptor.MyInterceptor;
import com.anqi.tool.sanqi.listener.MyHttpRequestListener;
import com.anqi.tool.sanqi.listener.MyHttpSessionListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletListenerRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    MyInterceptor myInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(myInterceptor);
    }

    /**
     * 注册过滤器
     * @return
     */
    @Bean
    public FilterRegistrationBean filterRegistrationBean(){
        FilterRegistrationBean filterRegistration = new FilterRegistrationBean();
        filterRegistration.setFilter(new MyFilter());
        filterRegistration.addUrlPatterns("/*");
        return filterRegistration;
    }

    /**
     * 注册监听器
     * @return
     */
    @Bean
    public ServletListenerRegistrationBean registrationBean(){
        ServletListenerRegistrationBean registrationBean = new ServletListenerRegistrationBean();
        registrationBean.setListener(new MyHttpRequestListener());
        registrationBean.setListener(new MyHttpSessionListener());
        return registrationBean;
    }
}

测试

Copyimport com.anqi.tool.sanqi.listener.MyHttpSessionListener;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

@RestController
public class TestController {

    @GetMapping("addSession")
    public String addSession(HttpServletRequest request) {
        HttpSession session = request.getSession();
        session.setAttribute("name", "haixiang");
        return "当前在线人数" + session.getServletContext().getAttribute("sessionCount") + "人";
    }

    @GetMapping("removeSession")
    public String removeSession(HttpServletRequest request) {
        HttpSession session = request.getSession();
        session.invalidate();
        return "当前在线人数" + session.getServletContext().getAttribute("sessionCount") + "人";
    }

    @GetMapping("online")
    public String online() {
        return "当前在线人数" + MyHttpSessionListener.userCount.get() + "人";
    }

}

以下是监听请求的监听器

Copyimport javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
import javax.servlet.http.HttpServletRequest;

public class MyHttpRequestListener implements ServletRequestListener {

    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        System.out.println("request 监听器被销毁");
    }

    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        HttpServletRequest req = (HttpServletRequest) sre.getServletRequest();
        String requestURI = req.getRequestURI();
        System.out.println(requestURI+"--"+"被调用");
    }
}

拦截器与过滤器的区别

1.参考标准

过滤器是 JavaEE 的标准，依赖于 Servlet 容器，生命周期也与容器一致，利用这一特性可以在销毁时释放资源或者数据入库。
拦截器是SpringMVC中的内容，依赖于web框架，通常用于验证用户权限或者记录日志，但是这些功能也可以利用 AOP 来代替。

2.实现方式

过滤器是基于回调函数实现，无法注入 ioc 容器中的 bean。
拦截器是基于反射来实现，因此拦截器中可以注入 ioc 容器中的 bean，例如注入 Redis 的业务层来验证用户是否已经登录

总结

SERVLET、过滤器、监听器、拦截器一个请求的执行过程：

context-param
–>listener
–>filter
–>DispatcherServlet
–>interceptor(拦截器)
–>Controller(控制器)
context-param：就是一些需要初始化的配置，放入context-param中，从而被监听器（这里特指org.springframework.web.context.ContextLoaderListener）监听，然后加载；
监听器(listener)：就是对项目起到监听的作用，它能感知到包括request(请求域)，session(会话域)和applicaiton(应用程序)的初始化和属性的变化；

过滤器(filter)：就是对请求起到过滤的作用，它在监听器之后，作用在servlet之前，对请求进行过滤；

servlet：就是对request和response进行处理的容器，它在filter之后执行，servlet其中的一部分就是controller层（标记为servlet_2），还包括渲染视图层(标记为servlet_3)和进入controller之前系统的一些处理部分(servlet_1)，另外我们把servlet开始的时刻标记为servlet_0，servlet结束的时刻标记为servlet_4。

拦截器(interceptor)：就是对请求和返回进行拦截，它作用在servlet的内部，控制器之间也会被拦截

LJH

https://ljh130168.github.io/2021/06/22/lan-jie-qi-guo-lu-qi-jian-ting-qi/

本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源 LJH !

无标签

redis之基础

2021-07-05 LJH

redis

lambda

2021-06-15 LJH

JAVA8新特性

拦截器、过滤器、监听器

过滤器、拦截器、监听器

一、过滤器

1、定义

2、功能

3、实现

二、拦截器

1、定义

2、概念

3、原理

4、自定义拦截器

5、过滤器与拦截器的区别

6、Spring拦截器

三、监听器

1、定义

2、三个对象

3、监听器模式

4、概念

5、用途

6、分类

1）按监听的对象划分

2）按监听的事件划分

1、监听域对象自身的创建和销毁的事件监听器

2、监听域对象中的属性的增加和删除的事件监听器

7、监听器类型

SpringBoot整合

过滤器

过滤器简介

过滤器的使用

拦截器

拦截器介绍

使用拦截器

监听器

监听器简介

监听器的使用

过滤器、拦截器、监听器注册

实例化三器

测试

拦截器与过滤器的区别

总结

你的赏识是我前进的动力