Java架构直通车——DispatcherServlet详解

最新推荐文章于 2024-05-01 23:49:52 发布
最新推荐文章于 2024-05-01 23:49:52 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： Java架构直通车
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/No_Game_No_Life_/article/details/116657154
版权

文章目录


前文介绍了 Java架构直通车——理解Tomcat架构设计，我们知道Tomcat实际上就是Servlet容器，

引入

Spring MVC框架是围绕DispatcherServlet来设计的，这个Servlet会把请求分发给各个处理器，并支持可配置的处理器映射、视图渲染、本地化、时区与主题渲染和文件上传等功能。

Spring MVC框架是请求驱动的：所有设计都围绕着一个中央Servlet来展开，它负责把所有请求分发到控制器；同时提供其他Web应用开发所需要的功能。DispatcherServlet与Spring IoC容器做到了无缝集成，这意味着，Spring提供的任何特性在Spring MVC中你都可以使用。

DispatcherServlet处理流程

DispatcherServlet与WebApplicationContext

DispatcherServlet其实就是个Servlet（它继承自HttpServlet基类）。在Web MVC框架中，DispatcherServlet依赖于一个WebApplicationContext，这个context继承了WebApplicationContext的所有bean定义。继承的这些bean可以在每个servlet自己所属的域中被覆盖，覆盖的bean可以被设置成只有这个servlet实例自己才可以使用的属性。
在这里插入图片描述
WebApplicationContext是一个普通的ApplicationContext的扩展，它知道自己与哪个servlet相关联（通过ServletContext）。下面是WebApplicationContext所包含的bean：
在这里插入图片描述

处理流程

在请求到来的时候，会在请求中查找并绑定 WebApplicationContext，它可以作为参数被控制器中的方法使用。 默认绑定到 DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE 对应的值。

处理流程不做赘述，参考：
再临SpringBoot——理解Spring Web Mvc架构处理流程
SpringMvc in Action——构建Sprig Web应用程序

DispatcherServlet源码分析

DispatcherServlet本质上还是一个Servlet。Servlet的生命周期大致分为三个阶段：

  1. 初始化阶段 init方法
  2. 处理请求阶段 service方法
  3. 结束阶段 destroy方法
public interface Servlet {
    public void init(ServletConfig config) throws ServletException;
    public void service(ServletRequest req, ServletResponse res)
            throws ServletException, IOException;
    public void destroy();
    
    public ServletConfig getServletConfig();
    public String getServletInfo();
}

这里就重点关注DispatcherServlet在这三个阶段具体做了那些工作。

init()

DispatcherServlet的init()的实现在其父类HttpServletBean中。

    public final void init() throws ServletException {
        ...
        // Set bean properties from init parameters.
        try {
            PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
            BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
            ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
            bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));
            initBeanWrapper(bw);
            bw.setPropertyValues(pvs, true);
        }
        catch (BeansException ex) {
            logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);
            throw ex;
        }

        // Let subclasses do whatever initialization they like.
        initServletBean();

        ...
    }

以上部分源码描述的过程是通过读取的配置元素，读取到DispatcherServlet中，配置相关bean的配置。完成配置后调用initServletBean方法来创建Servlet WebApplicationContext。

initServletBean方法在FrameworkServlet类中重写了：

    protected final void initServletBean() throws ServletException {
        ...

        try {
            this.webApplicationContext = initWebApplicationContext();
            initFrameworkServlet();
        }
        ...
    }
    
    protected WebApplicationContext initWebApplicationContext() {
        WebApplicationContext rootContext =
                WebApplicationContextUtils.getWebApplicationContext(getServletContext());
        WebApplicationContext wac = null;

        if (this.webApplicationContext != null) {
            wac = this.webApplicationContext;
            if (wac instanceof ConfigurableWebApplicationContext) {
                ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
                if (!cwac.isActive()) {
                    if (cwac.getParent() == null) {
                        cwac.setParent(rootContext);
                    }
                    configureAndRefreshWebApplicationContext(cwac);
                }
            }
        }
        if (wac == null) {
            wac = findWebApplicationContext();
        }
        if (wac == null) {
            wac = createWebApplicationContext(rootContext);
        }

        if (!this.refreshEventReceived) {
            onRefresh(wac);
        }

        if (this.publishContext) {
            String attrName = getServletContextAttributeName();
            getServletContext().setAttribute(attrName, wac);
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Published WebApplicationContext of servlet '" + getServletName() +
                        "' as ServletContext attribute with name [" + attrName + "]");
            }
        }

        return wac;
    }

service()

纵观SpringMVC的源码，大量运用模板方法的设计模式。Servlet的service方法也不例外。FrameworkServlet类重写service方法：

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

        HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
        if (HttpMethod.PATCH == httpMethod || httpMethod == null) {
            processRequest(request, response);
        }
        else {
            super.service(request, response);
        }
    }

如果请求的方法是PATCH或者空，直接调用processRequest方法（后面会详细解释）；否则，将调用父类的service的方法，即HttpServlet的service方法, 而这里会根据请求方法，去调用相应的doGet、doPost、doPut…

而doXXX系列方法的实现并不是HttpServlet类中，而是在FrameworkServlet类中。在FrameworkServlet中doXXX系列实现中，都调用了上面提到的processRequest方法：

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

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

        LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
        LocaleContext localeContext = buildLocaleContext(request);

        RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);

        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
        asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());

        initContextHolders(request, localeContext, requestAttributes);

        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 {
            resetContextHolders(request, previousLocaleContext, previousAttributes);
            if (requestAttributes != null) {
                requestAttributes.requestCompleted();
            }

            if (logger.isDebugEnabled()) {
                if (failureCause != null) {
                    this.logger.debug("Could not complete request", failureCause);
                }
                else {
                    if (asyncManager.isConcurrentHandlingStarted()) {
                        logger.debug("Leaving response open for concurrent processing");
                    }
                    else {
                        this.logger.debug("Successfully completed request");
                    }
                }
            }

            publishRequestHandledEvent(request, response, startTime, failureCause);
        }
    }

为了避免子类重写它，该方法用final修饰。

  1. 首先调用initContextHolders方法,将获取到的localeContext、requestAttributes、request绑定到线程上。
  2. 然后调用doService方法，doService具体是由DispatcherServlet类实现的。
  3. doService执行完成后，调用resetContextHolders，解除localeContext等信息与线程的绑定。
  4. 最终调用publishRequestHandledEvent发布一个处理完成的事件。

DispatcherServlet类中的doService方法实现会调用doDispatch方法，这里请求分发处理的主要执行逻辑。

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
        boolean multipartRequestParsed = false;

        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

        try {
            ModelAndView mv = null;
            Exception dispatchException = null;

            try {
                processedRequest = checkMultipart(request);
                multipartRequestParsed = (processedRequest != request);

                // Determine handler for the current request.
                mappedHandler = getHandler(processedRequest);
                if (mappedHandler == null || mappedHandler.getHandler() == null) {
                    noHandlerFound(processedRequest, response);
                    return;
                }

                // Determine handler adapter for the current request.
                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

                // Process last-modified header, if supported by the handler.
                String method = request.getMethod();
                boolean isGet = "GET".equals(method);
                if (isGet || "HEAD".equals(method)) {
                    long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                    if (logger.isDebugEnabled()) {
                        logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
                    }
                    if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                        return;
                    }
                }

                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                    return;
                }

                // Actually invoke the handler.
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

                if (asyncManager.isConcurrentHandlingStarted()) {
                    return;
                }

                applyDefaultViewName(processedRequest, mv);
                mappedHandler.applyPostHandle(processedRequest, response, mv);
            }
            catch (Exception ex) {
                dispatchException = ex;
            }
            catch (Throwable err) {
                // As of 4.3, we're processing Errors thrown from handler methods as well,
                // making them available for @ExceptionHandler methods and other scenarios.
                dispatchException = new NestedServletException("Handler dispatch failed", err);
            }
            processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
        }
        catch (Exception ex) {
            triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
        }
        catch (Throwable err) {
            triggerAfterCompletion(processedRequest, response, mappedHandler,
                    new NestedServletException("Handler processing failed", err));
        }
        finally {
            if (asyncManager.isConcurrentHandlingStarted()) {
                // Instead of postHandle and afterCompletion
                if (mappedHandler != null) {
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
            }
            else {
                // Clean up any resources used by a multipart request.
                if (multipartRequestParsed) {
                    cleanupMultipart(processedRequest);
                }
            }
        }
    }

doDispatch主要流程是：

  1. 先判断是否Multipart类型的请求。如果是则通过multipartResolver解析request
  2. 通过getHandler方法找到从HandlerMapping 找到该请求对应的handler ,如果没有找到对应的handler则抛出异常。
  3. 通过getHandlerAdapter方法找到handler对应的HandlerAdapter
  4. 如果有拦截器，执行拦截器preHandler方法
  5. HandlerAdapter执行handle方法处理请求，返回ModelAndView。
  6. 如果有拦截器，执行拦截器postHandle方法
  7. 然后调用processDispatchResult方法处理请求结果，封装到response中。

destroy()

destroy方法也是在FrameworkServlet里实现的，

	@Override
	public void destroy() {
		getServletContext().log("Destroying Spring FrameworkServlet '" + getServletName() + "'");
		// Only call close() on WebApplicationContext if locally managed...
		if (this.webApplicationContext instanceof ConfigurableApplicationContext && !this.webApplicationContextInjected) {
			((ConfigurableApplicationContext) this.webApplicationContext).close();
		}
	}

主要做了这么一个事：

	protected void doClose() {
		// Check whether an actual close attempt is necessary...
		if (this.active.get() && this.closed.compareAndSet(false, true)) {
			if (logger.isDebugEnabled()) {
				logger.debug("Closing " + this);
			}

			LiveBeansView.unregisterApplicationContext(this);

			try {
				// Publish shutdown event.
				publishEvent(new ContextClosedEvent(this));
			}
			catch (Throwable ex) {
				logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);
			}

			// Stop all Lifecycle beans, to avoid delays during individual destruction.
			if (this.lifecycleProcessor != null) {
				try {
					this.lifecycleProcessor.onClose();
				}
				catch (Throwable ex) {
					logger.warn("Exception thrown from LifecycleProcessor on context close", ex);
				}
			}

			// Destroy all cached singletons in the context's BeanFactory.
			destroyBeans();

			// Close the state of this context itself.
			closeBeanFactory();

			// Let subclasses do some final clean-up if they wish...
			onClose();

			// Reset local application listeners to pre-refresh state.
			if (this.earlyApplicationListeners != null) {
				this.applicationListeners.clear();
				this.applicationListeners.addAll(this.earlyApplicationListeners);
			}

			// Switch to inactive.
			this.active.set(false);
		}
	}

可以看到publishEvent、销毁了bean和beanFactory。

No_Game_No_Life_
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第三章 DispatcherServlet详解 ——跟开涛学SpringMVC
jinnianshilongnian的专栏
07-21 3236
3.1、DispatcherServlet作用 DispatcherServlet是前端控制器设计模式的实现，提供Spring Web MVC的集中访问点，而且负责职责的分派，而且与Spring IoC容器无缝集成，从而可以获得Spring的所有好处。 具体请参考第二章的图2-1。   DispatcherServlet主要用作职责调度工作，本身主要用于控制流程，主要职责如下： 1...
java dispatcher详解_DispatcherServlet配置的实例方法详解
weixin_42531516的博客
03-04 1165
配置DispatcherServlet的方法介绍DispatcherServlet是Spring MVC的前端控制器，要想在程序中使用DispatcherServlet，我们需要在web.xml中配置一个DispatcherServlet。配置的方法是，在web.xml文件中，配置一个节点，它的子节点可以自定义一个名字，例如sample，指定为org.spring.springframework....
解决使用Tomcat10导致的DispatcherServlet不可调用firstController问题，springMVC入门程序，Tomcat10
最新发布
weixin_52632140的博客
05-01 753
解决使用Tomcat10导致的DispatcherServlet不可调用firstController问题，springMVC入门程序，Tomcat10,
SpringMVC源码分析(一）——————详解DispatcherServlet
Nuomizhende45
01-12 557
一、对照这流程的第一步发起请求到前端控制器DispatcherServlet,首先看看DispatcherServlet这个类，为什么所有的请求能发给这个类，看下这个类的结构图： 这里我们发现了这个DispatcherServlet通过继承FrameWorkServlet、HttpServletBean从而间接的继承了HttpServlet，所以说这个DispatcherServlet也是一...
Java配置文件放哪里_SpringMVC——DispatcherServlet配置文件究竟应该放在哪里？
weixin_39949673的博客
03-02 1297
DispatcherServlet是前置控制器，配置在web.xml文件中的。拦截匹配的请求，Servlet拦截匹配规则要自己定义，把拦截下来的请求，依据相应的规则分发到目标Controller来处理，是配置spring MVC的第一步。但是，我们在搭建SpringMVC框架时，往往总是把DispatcherServlet的配置文件放错位置。网上有的说：springDispatcherServle...
SpringMVC —— DispatcherServlet 配置
永远的北极光
08-27 4043
一、web.xml 中相关配置 dispatcherServlet org.springframework.web.servlet.DispatcherServlet 1 dispatcherServlet /service/* 二、dispatcherServlet.xml 配置 <beans xmlns="http://www.springframework.o
DispatcherServlet详解
热门推荐
weixin_44399827的博客
08-01 1万+
在介绍DispatcherServlet的时候，我们得先了解 ，servlet。那什么时候servlet勒。 servlet是基于http协议的，在服务端(如Tomcate)运行的，是按照servlet规范编写的一个Java类。做Java Web开发的应该都了解它。主要用于处理客户端的请求并将其结果发送至客户端。servlet的生命周期可分三个阶段：初始化、运行和销毁。 1.初始化阶段 (1) servlet容器加载servlet类，把servlet类的.class文件中的数据读至内存中。 (2) se
Servlet请求分派器——DispatcherServlet
石沉溪洞
04-14 2505
前提 在索引文章中我提到过，我会写一篇关于Servlet的进阶知识，这篇就是了。学习这篇文章之前，请先把前面整套帖子中的程序跑通，这篇文章是作为进阶补充的。 如果你是直接来到这篇文章，没见到我所谓的“索引文章”，那么请移步： https://blog.csdn.net/Mr_Megamind/article/details/71404618 先从Volley说起 一般情况下，我们...
SpringBoot之DispatcherServlet详解及源码解析
程序新视界
11-30 7834
在使用SpringBoot之后，我们表面上已经无法直接看到DispatcherServlet的使用了。本篇文章，带大家从最初DispatcherServlet的使用开始到SpringBoot源码中DispatcherServlet的自动配置进行详解。 DispatcherServlet简介 DispatcherServlet是前端控制器设计模式的实现，提供了Spring Web MVC的集中访问点...
Spring MVC —— 关于 DispatcherServlet
小水牛的博客
03-08 1468
DispatcherServlet
Spring MVC之DispatcherServlet详解_动力节点Java学院整理
10-19
DispatcherServlet的职责主要包括以下几个方面： 1. **文件上传解析**：当接收到multipart类型的请求时，DispatcherServlet会通过MultipartResolver解析文件上传，将上传的数据分离出来供后续处理。 2. **请求映射...
spring mvc DispatcherServlet之前端控制器架构详解
08-27
DispatcherServlet之前端控制器架构详解 DispatcherServlet是Spring MVC框架中的核心组件，作为前端控制器，负责拦截和分发请求到不同的控制器去处理。下面我们将详细介绍DispatcherServlet的架构和生命周期。 ...
Spring MVC之DispatcherServlet_动力节点Java学院整理
10-19
Spring MVC 是一个强大的Java web应用程序框架，用于构建可维护、模块化且松散耦合的Web应用程序。在Spring MVC中，DispatcherServlet起着至关重要的作用，它是整个框架的前端控制器。DispatcherServlet的主要职责是...
Java架构师之源码分析专题SpringBoot2.x、Spring5、SpringMVC、Mybatis源码分析
08-23
在Java开发领域，深入理解框架的源码是成为一名优秀架构师的重要步骤。本专题课程针对SpringBoot 2.x、Spring 5、SpringMVC和Mybatis这四个关键框架进行源码解析，旨在帮助开发者从底层原理出发，提升技术水平，更好...
Java架构直通车——为什么线程切换会导致用户态与内核态的切换？
No_Game_No_Life_的博客
05-13 5453
文章目录什么是上下文切换？上下文切换的时机？上下文切换的开销互斥锁与自旋锁为什么线程切换会导致用户态与内核台的切换？ 什么是上下文切换？上下文切换的时机？ CPU通过分配时间片来执行任务，当一个任务的时间片用完，就会切换到另一个任务。在切换之前会保存上一个任务的状态，当下次再切换到该任务，就会加载这个状态。 ——任务从保存到再加载的过程就是一次上下文切换。 按导致上下文切换的因素划分，可将上下文切换分为两点： 自发性上下文切换 非自发性上下文切换 自发性上下文切换指线程由于自身因素导致的切出。 通过调
Java架构直通车——Redis的PF实现原理：HyperLogLog
No_Game_No_Life_的博客
06-29 3941
文章目录引入什么是基数统计基数统计的常用方法HyperLogLog原理再近一步：分桶平均更近一步：真实的HyperLogLog 引入 之前的文章Java架构直通车——点赞功能用Mysql还是Redis?一文中，我们介绍了分别从mysql和redis实现点赞功能统计的可行性。 这里要介绍一个HyperLogLog算法，虽然应用场景不同，但是两者还是具有一定的相似之处的。 HyperLogLog 是最早由 Flajolet 及其同事在 2007 年提出的一种 估算基数的近似最优算法。但跟原版论文不同的是，好像很
Java架构直通车——ThreadLocal实现RabbitMQ消息的批量发送
No_Game_No_Life_的博客
02-29 1887
文章目录引入什么是ThreadLocal使用ThreadLocal 引入 之前，我们完成了单个消息的发送，以及单个消息发送的多线程池化。 这里，我们继续完成批量发送消息的封装。 因为rabbitMq本身是不支持批量发消息的，所以我们可以直接使用上文所创建的连接池来发送。 最简单的代码是这样的： # ProducerClient.class @Override public void se...
Java架构直通车——订单扣库存问题
No_Game_No_Life_的博客
02-01 1546
文章目录场景描述扣库存问题不推荐的方案：扣库存问题解决方案推荐：如何验证 场景描述 无论是日常工作中，还是面试问题中，并发扣库存都是一个很常见的场景，正好业务里有这样的场景，可以对这类问题做一下总结。 举例说明两个比较典型的扣库存场景： 产品1：线上招募人员的产品，招募是有人数限制的，每招募成功1人，扣减库存1，直到库存为0，自动停止招募。 产品2：用户秒杀产品，用户在同一个时间点，同时抢一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值