SpringBoot 之监听器、拦截器、过滤器

最新推荐文章于 2021-04-23 09:33:26 发布

yyangqqian

最新推荐文章于 2021-04-23 09:33:26 发布

阅读量220

点赞数

分类专栏： # SpringBoot

本文链接：https://blog.csdn.net/const_/article/details/93211076

版权

SpringBoot 专栏收录该内容

35 篇文章 4 订阅

订阅专栏

监听器

拦截器Interceptor

拦截器概念

拦截器，在AOP(Aspect-Oriented Programming)中用于在某个方法或字段被访问之前，进行拦截，然后在之前或之后加入某些操作。拦截是AOP的一种实现策略。使用动态代理来实现的。

拦截器作用

日志记录： 记录请求信息的日志，以便进行信息监控、信息统计、计算PV（Page View）等。
权限检查： 如登录检测，进入处理器检测检测是否登录。
性能监控： 通过拦截器在进入处理器之前记录开始时间，在处理完后记录结束时间，从而得到该请求的处理时间。
通用行为： 读取cookie得到用户信息并将用户对象放入请求，从而方便后续流程使用，只要是多个处理器都需要的即可使用拦截器实现。

拦截器接口

public interface HandlerInterceptor {

	default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		return true;
	}

	default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable ModelAndView modelAndView) throws Exception {
	}

	default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable Exception ex) throws Exception {
	}

}

preHandle：预处理回调方法，实现处理器的预处理（如登录检查），第三个参数为响应的处理器（Controller实现）；返回值：true，表示继续流程（如调用下一个拦截器或处理器）； false，表示流程中断（如登录检查失败），不会继续调用其他的拦截器或处理器，此时需要通过response来产生响应。
postHandler：在当前请求进行处理之后，也就是Controller方法调用之后执行，但是它会在DispatcherServlet进行视图返回渲染之前被调用，所以我们可以在这个方法中对Controller处理之后的ModelAndView对象进行操作。
afterCompletion：整个请求处理完毕回调方法，即在视图渲染完毕时回调，如性能监控中我们可以在此记录结束时间并输出消耗时间，还可以进行一些资源清理，但仅调用处理器执行链中preHandle返回true的拦截器的afterCompletion。

拦截器实现

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
public class TimeInterceptor implements HandlerInterceptor {
    private static final Logger LOG = LoggerFactory.getLogger(TimeInterceptor.class);
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        LOG.info("在请求处理之前进行调用（Controller方法调用之前）");
        request.setAttribute("startTime", System.currentTimeMillis());
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        LOG.info("controller object is {}", handlerMethod.getBean().getClass().getName());
        LOG.info("controller method is {}", handlerMethod.getMethod());
        // 需要返回true，否则请求不会被控制器处理
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        LOG.info("请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后），如果异常发生，则该方法不会被调用");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        LOG.info("在整个请求结束之后被调用，也就是在DispatcherServlet 渲染了对应的视图之后执行（主要是用于进行资源清理工作）");
        long startTime = (long) request.getAttribute("startTime");
        LOG.info("time consume is {}", System.currentTimeMillis() - startTime);
    }
}

拦截器注册

实现拦截器后还需要将拦截器注册到spring容器中，可以通过实现WebMvcConfigurer接口，覆盖其addInterceptors(InterceptorRegistry registry)方法。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebAppConfigurer implements WebMvcConfigurer {
    @Autowired
    private TimeInterceptor timeInterceptor;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        InterceptorRegistration registration = registry.addInterceptor(timeInterceptor);
        // 拦截所有请求
        registration.addPathPatterns("/**");
        // 添加不拦截路径
        registration.excludePathPatterns("/login", "/error", "/logout","/login.html");
    }
}

运行流程图

正常流程：
在这里插入图片描述
中断流程：中断流程中，比如是HandlerInterceptor2中断的流程（preHandle返回false），此处仅调用它之前拦截器的preHandle返回true的afterCompletion方法。

性能监控

@Slf4j
@Component
public class StopWatchHandlerInterceptor implements HandlerInterceptor {
    private NamedThreadLocal<Long> startTimeThreadLocal =
            new NamedThreadLocal<>("StopWatch-StartTime");

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
                             Object handler) throws Exception {
        long beginTime = System.currentTimeMillis();
        startTimeThreadLocal.set(beginTime);
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
                                Object handler, Exception ex) throws Exception {
        long endTime = System.currentTimeMillis();
        long beginTime = startTimeThreadLocal.get();
        long consumeTime = endTime - beginTime;
        if (consumeTime > 500) {//此处认为处理时间超过500毫秒的请求为慢请求
            //TODO 记录到日志文件
            log.info(String.format("%s consume %d millis", request.getRequestURI(), consumeTime));
        }
    }

}

NamedThreadLocal：Spring提供的一个命名的ThreadLocal实现。

过滤器Filter

过滤器概念

过滤器采用函数回调的方式进行，在请求进入容器后，还未进入Servlet之前进行预处理（比如编码设置），并且在请求结束返回给前端之前进行后期处理。

过滤器实现

自定义的过滤器都必须实现javax.Servlet.Filter接口，并重写接口中定义的三个方法。

void init(FilterConfig config)
用于完成Filter的初始化。
void destory()
用于Filter销毁前，完成某些资源的回收。
void doFilter(ServletRequest request,ServletResponse response,FilterChain chain)
实现过滤功能，即对每个请求及响应增加的额外的预处理和后处理。执行该方法之前，即对用户请求进行预处理；执行该方法之后，即对服务器响应进行后处理。
值得注意的是，chain.doFilter()方法执行之前为预处理阶段，该方法执行结束即代表用户的请求已经得到控制器处理。因此，如果在doFilter中忘记调用chain.doFilter()方法，则用户的请求将得不到处理。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@WebFilter(urlPatterns = "/*",filterName = "TimeFilter")
public class TimeFilter implements Filter {
    private static final Logger LOG = LoggerFactory.getLogger(TimeFilter.class);
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        LOG.info("初始化过滤器：{}", filterConfig.getFilterName());
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        LOG.info("start to doFilter");
        long startTime = System.currentTimeMillis();
        chain.doFilter(request, response);
        long endTime = System.currentTimeMillis();
        LOG.info("the request of {} consumes {}ms.", getUrlFrom(request), (endTime - startTime));
        LOG.info("end to doFilter");
    }

    @Override
    public void destroy() {
        LOG.info("销毁过滤器");
    }

    private String getUrlFrom(ServletRequest servletRequest) {
        if (servletRequest instanceof HttpServletRequest) {
            return ((HttpServletRequest) servletRequest).getRequestURL().toString();
        }
        return "";
    }
}

// 然后在启动类上添加注解@ServletComponentScan
// 该注解用于自动扫描指定包下（默认是与启动类同包下）的
// WebFilter、WebServlet、WebListener等特殊类。
@SpringBootApplication
@ServletComponentScan
public class SpringBootUleApplication {
	public static void main(String[] args) {
		SpringApplication.run(SpringBootUleApplication.class, args);
	}
}

chain.doFilter(request, response)；这个方法的调用作为分水岭。
事实上Servlet中的doService()方法是在chain.doFilter(request, response)；这个方法中进行的。

过滤器使用场景

统一所有请求中文字符编码
设置所有请求的请求头信息

总结

区别

拦截器是基于java的反射机制（JDK实现的动态代理）来实现的，而过滤器是基于函数回调来实现的。
拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。
拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。
在action的生命周期中，拦截器可以多次被调用，而过滤器只能在请求后时被调用一次。
Filter是Servlet（Web）容器支持的，Interceptor是Spring容器支持的。
（重点）拦截器可以获取IOC容器中的各个bean，而过滤器就不行，这点很重要，在拦截器里注入一个service，可以调用业务逻辑。
拦截器可以获取ioc中的service bean实现业务逻辑。
最大的区别：Filter拦截URL，HandlerInterceptor拦截Action中的方法。过滤器可以理解为“取你所想取”，过滤器关注的是Web请求；拦截器可以理解为“拒你所想拒”，拦截器关注的是方法的调用，比如拦截敏感词汇。

触发时机：

过滤器是在请求进入容器后，但请求进入servlet之前进行预处理的。请求结束返回也是，是在servlet处理完后，返回给前端之前；所以过滤器的入参是servletRequest。
chain.doFilter(request, response);这个方法的调用作为分水岭。事实上调用Servlet的doService()方法是在chain.doFilter(request, response);这个方法中进行的。
拦截器是基于spring容器的，拦截controller。
SpringMVC的机制是由同一个Servlet来分发请求给不同的Controller。

执行流程图：

在这里插入图片描述

切片Aspect

切片概述

相比过滤器，拦截器能够知道用户发出的请求最终被哪个控制器处理，但是拦截器还有一个明显的不足，即不能够获取request的参数以及控制器处理之后的response。所以就有了切片的用武之地了。

切片实现

切片的实现需要注意 @Aspect,@Component以及@Around 这三个注解的使用。
https://www.jianshu.com/p/efbc657e034c

https://mp.weixin.qq.com/s/vLO2ei3ffTM_XiTzwrsQDA
https://blog.51cto.com/3001448/1205771

yyangqqian

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot 之监听器、拦截器、过滤器

import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import javax.servlet.http.HttpSe...
复制链接

扫一扫