Spring之Interceptor执行过程分析

最新推荐文章于 2025-02-08 21:04:36 发布
最新推荐文章于 2025-02-08 21:04:36 发布
阅读量505 收藏
点赞数
分类专栏： SpringMVC 文章标签： SpringMVC Interceptor
原文链接：https://zhuanlan.zhihu.com/p/23626598
版权

HttpServlet

Service层处理HTTP请求的入口是service()方法（更深层次的需要看Tomcat的原理），分别处理HTTP不同的方法，这里我们看GET方法的逻辑。

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);
}

protected void service(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {
    String method = req.getMethod();

    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);
    }
}

FrameworkServlet

进入到Spring的框架逻辑中，调用doService，然后发布一个事件，这里重点看处理请求的doService方法，FrameworkServlet中该方法为abstract，具体在DispatcherServlet中实现。

@Override
protected final void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {

    processRequest(request, response);
}

protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {

    long startTime = System.currentTimeMillis();
    Throwable failureCause = null;

    // Expose current LocaleResolver and request as LocaleContext.
    LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
    LocaleContextHolder.setLocaleContext(buildLocaleContext(request), this.threadContextInheritable);

    // Expose current RequestAttributes to current thread.
    RequestAttributes previousRequestAttributes = RequestContextHolder.getRequestAttributes();
    ServletRequestAttributes requestAttributes = null;
    if (previousRequestAttributes == null || previousRequestAttributes.getClass().equals(ServletRequestAttributes.class)) {
        requestAttributes = new ServletRequestAttributes(request);
        RequestContextHolder.setRequestAttributes(requestAttributes, this.threadContextInheritable);
    }

    if (logger.isTraceEnabled()) {
        logger.trace("Bound request context to thread: " + request);
    }

    try {
        doService(request, response);
    } catch (ServletException ex) {
        failureCause = ex;
        throw ex;
    } catch (IOException ex) {
        failureCause = ex;
        throw ex;
    } catch (Throwable ex) {
        failureCause = ex;
        throw new NestedServletException("Request processing failed", ex);
    } finally {
        // Clear request attributes and reset thread-bound context.
        LocaleContextHolder.setLocaleContext(previousLocaleContext, this.threadContextInheritable);
        if (requestAttributes != null) {
            RequestContextHolder.setRequestAttributes(previousRequestAttributes, this.threadContextInheritable);
            requestAttributes.requestCompleted();
        }
        if (logger.isTraceEnabled()) {
            logger.trace("Cleared thread-bound request context: " + request);
        }

        if (failureCause != null) {
            this.logger.debug("Could not complete request", failureCause);
        } else {
            this.logger.debug("Successfully completed request");
        }
        if (this.publishEvents) {
            // Whether or not we succeeded, publish an event.
            long processingTime = System.currentTimeMillis() - startTime;
            this.webApplicationContext.publishEvent(
                    new ServletRequestHandledEvent(this,
                            request.getRequestURI(), request.getRemoteAddr(),
                            request.getMethod(), getServletConfig().getServletName(),
                            WebUtils.getSessionId(request), getUsernameForRequest(request),
                            processingTime, failureCause));
        }
    }
}

DispatcherServlet

doDispatch中具体处理每个请求，包括Interceptor的拦截逻辑和Controller handler的业务逻辑。

@Override
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
    if (logger.isDebugEnabled()) {
        String requestUri = urlPathHelper.getRequestUri(request);
        logger.debug("DispatcherServlet with name '" + getServletName() + "' processing " + request.getMethod() +
                " request for [" + requestUri + "]");
    }

    /**
     * Make framework objects available to handlers and view objects.
     * 为了处理器对象，视图对象可以访问某些某些全局的对象，设置到HTTP request的属性中
     * */
    request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
    request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
    request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
    request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());

    try {
        doDispatch(request, response);
    } finally {
    }
}

/**
 * 具体分发请求到handler
 * <p>The handler will be obtained by applying the servlet's HandlerMappings in order.
 * The HandlerAdapter will be obtained by querying the servlet's installed HandlerAdapters
 * to find the first that supports the handler class.
 * <p>All HTTP methods are handled by this method. It's up to HandlerAdapters or handlers
 * themselves to decide which methods are acceptable.
 *
 * @param request  current HTTP request
 * @param response current HTTP response
 * @throws Exception in case of any kind of processing failure
 */
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpServletRequest processedRequest = request;
    HandlerExecutionChain mappedHandler = null;
    int interceptorIndex = -1;

    try {
        ModelAndView mv;
        boolean errorView = false;

        try {
            processedRequest = checkMultipart(request);

            /**
             * 获取该请求对应的 handler和interceptor（定位到了某个类）
             * Determine handler for the current request.
             * */
            mappedHandler = getHandler(processedRequest, false);
            if (mappedHandler == null || mappedHandler.getHandler() == null) {
                noHandlerFound(processedRequest, response);
                return;
            }

            /**
             * 获得该请求对应的更具体的handler（适配器模式，包含更多的策略和配置），如AnnotationMethodHandlerAdapter
             * Determine handler adapter for the current request.
             * */
            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

            /**
             * 依次执行我们的Interceptor
             * Apply preHandle methods of registered interceptors.
             * */
            HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();
            if (interceptors != null) {
                for (int i = 0; i < interceptors.length; i++) {
                    HandlerInterceptor interceptor = interceptors[i];
                    if (!interceptor.preHandle(processedRequest, response, mappedHandler.getHandler())) {
                        /**
                         * 如果该preHandle方法返回了false，那么就倒序依次执行前面的Interceptor的 afterCompletion 方法，然后返回
                         * 所以不会执行后面的 Controller的handler方法，以及Interceptor的postHandle方法
                         * */
                        triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);
                        return;
                    }
                    interceptorIndex = i;
                }
            }

            /**
             * 真正进入 Controller handler 进行请求处理
             * Actually invoke the handler.
             * */
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

            // Do we need view name translation?
            if (mv != null && !mv.hasView()) {
                mv.setViewName(getDefaultViewName(request));
            }

            //
            /**
             * 然后逆序依次执行我们的Interceptor的 postHandle 方法
             * Apply postHandle methods of registered interceptors.
             * */
            if (interceptors != null) {
                for (int i = interceptors.length - 1; i >= 0; i--) {
                    HandlerInterceptor interceptor = interceptors[i];
                    interceptor.postHandle(processedRequest, response, mappedHandler.getHandler(), mv);
                }
            }
        } catch (ModelAndViewDefiningException ex) {
            logger.debug("ModelAndViewDefiningException encountered", ex);
            mv = ex.getModelAndView();
        } catch (Exception ex) {
            Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
            mv = processHandlerException(processedRequest, response, handler, ex);
            errorView = (mv != null);
        }

        // Did the handler return a view to render?
        if (mv != null && !mv.wasCleared()) {
            render(mv, processedRequest, response);
            if (errorView) {
                WebUtils.clearErrorRequestAttributes(request);
            }
        } else {
            if (logger.isDebugEnabled()) {
                logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() +
                        "': assuming HandlerAdapter completed request handling");
            }
        }

        /** 此时所有的Interceptor都顺利完成了（preHandle -> handler -> postHandle），
         * 此时倒序依次执行所有的Interceptor的 afterCompletion方法
         * Trigger after-completion for successful outcome.
         * */
        triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);
    } catch (Exception ex) {
        // Trigger after-completion for thrown exception.
        triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);
        throw ex;
    } catch (Error err) {
        ServletException ex = new NestedServletException("Handler processing failed", err);
        // Trigger after-completion for thrown exception.
        triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);
        throw ex;
    } finally {
        // Clean up any resources used by a multipart request.
        if (processedRequest != request) {
            cleanupMultipart(processedRequest);
        }
    }
}

private void triggerAfterCompletion(HandlerExecutionChain mappedHandler,
                                    int interceptorIndex,
                                    HttpServletRequest request,
                                    HttpServletResponse response,
                                    Exception ex) throws Exception {

    // Apply afterCompletion methods of registered interceptors.
    if (mappedHandler != null) {
        HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();
        if (interceptors != null) {
            for (int i = interceptorIndex; i >= 0; i--) {
                HandlerInterceptor interceptor = interceptors[i];
                try {
                    interceptor.afterCompletion(request, response, mappedHandler.getHandler(), ex);
                } catch (Throwable ex2) {
                    logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
                }
            }
        }
    }
}

总结

在这里插入图片描述
转载:https://zhuanlan.zhihu.com/p/23626598

正确解决org.springframework.web.HttpSessionRequiredException异常的有效解决方法
wbajsjhhhhh的博客
05-08 1773
正确解决org.springframework.web.HttpSessionRequiredException异常的有效解决方法
Spring Boot拦截器(Interceptor)详解
m0_54850786的博客
12-31 732
拦截到这次请求之后，它会先执行放行前的逻辑，然后再执行放行操作。在拦截器当中，我们通常也是做一些通用性的操作，比如：我们可以通过拦截器来拦截前端发起的请求，将登录校验的逻辑全部编写在拦截器当中。方法，这个方法执行完成后需要返回一个布尔类型的值，如果返回true，就表示放行本次操作，才会继续访问controller中的方法；首先我们先来看拦截器的拦截路径的配置，在注册配置拦截器的时候，我们要指定拦截器的拦截路径，通过。能匹配/depts，/depts/1，/depts/1/2，不能匹配/emps/1。
Spring MVC interceptor 使用
chengfangang的专栏
11-23 918
SpringMVC 中的Interceptor 拦截器也是相当重要和相当有用的，它的主要作用是拦截用户的请求并进行相应的处理。比如通过它来进行权限验证，或者是来判断用户是否登陆，或者是像12306 那样子判断当前时间是否是购票时间。    一、定义Interceptor实现类    SpringMVC 中的Interceptor 拦截请求是通过HandlerInterceptor 来实现的。在
拦截器（Interceptor）
2301_76161469的博客
06-05 1565
拦截器（Interceptor）是Spring框架提供的核心功能之一，主要用于拦截用户请求，在指定方法前后，根据业务需求执行预先设定的代码拦截器允许开发人员提前预定义一些逻辑，在用户的请求响应前后执行，也可以在用户请求前阻止其执行，在拦截器当中，开发人员可以在应用程序中做一些通用性的操作例如，可以通过拦截器拦截前端发来的请求，判断Session中是否有登录用户的信息，若有，则放行；若没有，则进行拦截在了解了什么是拦截器之后，我们来学习如何实现拦截器。
spring中自定义Event事件的使用和浅析
程序员涂小哥的技术博客
12-14 1万+
在我目前接触的项目中，用到了许多spring相关的技术，框架层面的spring、spring mvc就不说了，细节上的功能也用了不少，如schedule定时任务、Filter过滤器、 interceptor拦截器等等，而这一篇我要说的是spring Event自定义事件，目前的项目中似乎没怎么用，但是这一项技术貌似还蛮重要，所以也不能不掌握。 对于事件驱动模型的解释和理解，我觉得有一篇博客里说的非
org.apache.ibatis.binding.BindingException: Invalid bound statement (not found): .AdminUserService.
公众号-老炮说Java
08-31 970
2018-08-31 13:57:44.190 INFO 11664 — [nio-8888-exec-2] o.apache.tomcat.util.http.parser.Cookie : A cookie header was received [sysAdmin.company1=SST,sysAdmin.sysType1=Hub; Idea-1c2d522=fbcffa79-2c2a...
Spring MVC Interceptor 实现性能监控的功能代码
08-29
在Spring MVC中，Interceptor（拦截器）扮演着关键角色，它允许我们在请求处理之前、处理过程中以及处理之后执行自定义逻辑。在本场景中，我们使用Interceptor来实现性能监控功能，以追踪每个URL的执行时间。 `...
农银一面：Filter、Interceptor、Spring AOP 的执行顺序
最新发布
02-08 938
Filter是 JavaServlet规范的一部分，定义在包中，Filter可以对Servlet容器的所有 HTTP 请求（）和响应（）进行预处理或后处理操作。例如，在请求到达目标资源之前执行身份验证或设置字符编码，或者在响应返回给客户端前修改其响应内容格式。是 Spring MVC 框架的一部分，是位于包中的接口，用于在请求处理之前或之后执行特定逻辑。与Filter不同的是，不依赖于Servlet容器，它是 Spring 框架独有的。
【Spring】Spring AOP 源码分析-拦截器链的执行过程(四)
AloneYue优快云
12-13 857
文章目录1.简介2.背景知识3.源码分析3.1 JDK 动态代理逻辑分析3.2 获取所有的拦截器3.3 启动拦截器链3.3.1 执行拦截器链3.3.2 执行目标方法4.总结 1.简介 原文链接 本篇文章是 AOP 源码分析系列文章的最后一篇文章，在前面的两篇文章中，我分别介绍了 Spring AOP 是如何为目标 bean 筛选合适的通知器，以及如何创建代理对象的过程。现在我们的得到了 bean 的代理对象，且通知也以合适的方式插在了目标方法的前后。接下来要做的事情，就是执行通知逻辑了。通知可能在目标方法前
tomcat假死导致项目无法访问
独乐乐不如众乐乐
05-21 2608
问题 21-May-2019 15:49:55.773 严重 [http-nio-8088-Acceptor-0] org.apache.tomcat.util.net.NioEndpoint$Acceptor.run Socket accept failed java.io.IOException: 打开的文件过多 at sun.nio.ch.ServerSocketChannelIm...
问题记录：HttpServletRequestWrapper导致跨域失败的问题
热门推荐
何忆清风
01-10 5万+
spring filter跨域问题
【springMVC核心】第二弹
Flying_Heaven的博客
07-29 458
拦截器的执行原理及拦截器与过滤器的区别
Cleared thread-bound request context: org.apache.catalina.connector.RequestFacade问题和原因
qq_39008613的博客
05-19 6433
前端调后台接口没有返回数据 一直在等待导致浏览器奔溃 后台提示 以下错误 之前一直以为是查询慢和数据的原因 问题解决： 最终的问题是前端echarts图 应为数据多设置高度加载问题 导致浏览器奔溃 前端修改echarts图就好了 ...
SpringMVC 异常处理
Zystem
07-08 1820
1、拦截器 类似于Servlet开发中的过滤器Filter，用于对处理器（controller）进行预处理和后处理。用户可以自己定义一些拦截器来实现特定的功能。
No thread-bound request found错误（转）
wakata随记
04-11 1万+
该报错的解决办法参考自：http://javeye.iteye.com/blog/238559   使用spring+struts+hibernate时，如果action没有使用session、request、response时，正常。 但使用了上述3个域，报了如下错误 HTTP Status 500 - Unable to instantiate Action, com.ssh.ac
springmvc中获得HttpServletRequest request方法(org.springframework.web.context.request.RequestContextList)
marila4720的专栏
01-06 9789
在Spring2.0中除了以前的Singleton和Prototype外又加入了三个新的web作用域，分别为request、session和global session，它们的含义和用法请大家参考Spring官方手册的相关章节。如果你想让你的容器里的某个bean拥有其中某种新的web作用域，除了在bean级上配置相应的scope属性，还必须在容器级做一个额外的初始化配置。即在web应用的XML
[Java][web]利用Spring随时随地获得Request和Session
王德封-逐浪
07-22 2万+
利用Spring随时随地获得Request和Session 一、准备工作： 在web.xml中添加                               org.springframework.web.context.request.RequestContextListener                  二、使用方法： 1、方法一：通过代码实现 Ht
SpringMVC Interceptor 解析，加载源码流程
qq_33221085的博客
10-17 1509
SpringMVC Interceptor 解析，加载源码流程本文说什么xml配置解析阶段加载interceptor总结 本文说什么 interceptor从哪里来,怎么创建，怎么加载，在哪里被使用，以xml的配置形式为例 xml配置解析阶段 直接打开spring-webmvc的源码包找到spring.handlers,这个是spring对于组件xml解析模块。 打开后一看说明，mvc这个标签是...
Spring MVC 快速入门与深入分析
5. **配置文件**：`mvc.xml`是Spring MVC的核心配置文件，包含HandlerMapping、ViewResolver、Interceptor等组件的配置，以及相关Bean的定义。 6. **访问静态资源**：Spring MVC默认不会处理静态资源请求，但可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值