Spring源码学习【八】SpringMVC之DispatcherServlet

最新推荐文章于 2024-06-26 16:49:32 发布
最新推荐文章于 2024-06-26 16:49:32 发布
阅读量457 收藏
点赞数 2
分类专栏： Spring源码 文章标签： SpringMVC源码 DispatcherServlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/greedystar/article/details/82771079
版权

目录

一、前言

二、源码学习

（一）初始化阶段 -> init()

（二）响应客户请求 -> service()

（二）销毁阶段 -> destroy()

三、总结

一、前言

Web环境是Spring框架的重要应用场景，而SpringMVC又是Web开发中一个常用的框架，因此我们有必要学习一下SpringMVC的实现原理。

回到Web项目的配置文件web.xml中，在使用SpringMVC时我们需要进行如下的配置：

<servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>WEB-INF/springMVC.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

熟悉Spring的同学对以上的配置肯定不陌生，这里配置了一个DispatcherServlet，这个Servlet是由Spring实现的，是SpringMVC最核心的部分，如上配置的这个Servlet会接收所有的请求，最终将请求分发至对应的Controller进行处理，下面我们就从DsipatcherServlet入手，学习SpringMVC的实现。

二、源码学习

首先，来看一看DsipatcherServlet的类继承关系（省略了部分接口）：

 

从上图中可以看到，DispatcherServlet间接继承了HttpServlet，可用于处理Http请求。

既然DispatcherServlet也是Servlet家族中的一员，那么它肯定要遵循Servlet的生命周期，即：

  • 初始化阶段，调用init()方法 
  • 响应客户请求阶段，调用service()方法 
  • 销毁阶段，调用destroy()方法

有了这些了解，我们就可以顺着DispatcherServlet的生命周期来学习SpringMVC的实现了。

（一）初始化阶段 -> init()

首先，定位到初始化阶段，在这个阶段会调用init()方法，这个方法定义在Serlvet接口中，我们可以发现这个方法的最终实现在DispatcherServlet的父类HttpServletBean中，这个方法被定义为final方法，不可被子类覆盖，代码如下：

public abstract class HttpServletBean extends HttpServlet implements EnvironmentCapable, EnvironmentAware {

    @Override
    public final void init() throws ServletException {
        if (logger.isDebugEnabled()) {
            logger.debug("Initializing servlet '" + getServletName() + "'");
        }
        // 获取配置的 init parameters，设置Bean的属性
        PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
        if (!pvs.isEmpty()) {
            try {
                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) {
                if (logger.isErrorEnabled()) {
                    logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);
                }
                throw ex;
            }
        }
        // 这个方法是一个模板方法，默认实现为空，交由其子类FrameworkServlet实现
        initServletBean();
        if (logger.isDebugEnabled()) {
            logger.debug("Servlet '" + getServletName() + "' configured successfully");
        }
    }

}

在上面的代码中，首先获取了init parameters，也就是web.xml中的<init-param/>节点，并将init parameters设置为这个Servlet Bean的属性，然后调用了子类FrameworkServlet的initServletBean()方法，进行额外的初始化处理，FrameworkServlet代码如下：

public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {

    @Override
    protected final void initServletBean() throws ServletException {
        getServletContext().log("Initializing Spring FrameworkServlet '" + getServletName() + "'");
        if (this.logger.isInfoEnabled()) {
            this.logger.info("FrameworkServlet '" + getServletName() + "': initialization started");
        }
        long startTime = System.currentTimeMillis();
        try {
            // 初始化应用上下文
            this.webApplicationContext = initWebApplicationContext();
            initFrameworkServlet();
        }
        catch (ServletException | RuntimeException ex) {
            this.logger.error("Context initialization failed", ex);
            throw ex;
        }

        if (this.logger.isInfoEnabled()) {
            long elapsedTime = System.currentTimeMillis() - startTime;
            this.logger.info("FrameworkServlet '" + getServletName() + "': initialization completed in " + elapsedTime + " ms");
        }
    }

    protected WebApplicationContext initWebApplicationContext() {
        // 首先从ServletContext中取得根应用上下文，也就是上一篇中在ContextLoader中创建的IOC容器
        WebApplicationContext rootContext = WebApplicationContextUtils.getWebApplicationContext(getServletContext());
        WebApplicationContext wac = null;
        if (this.webApplicationContext != null) {
            // 若在构造Servlet时已经注入应用上下文，则直接使用
            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) {
            // 构造Servlet时未注入应用上下文，则到ServletContext中获取
            wac = findWebApplicationContext();
        }
        if (wac == null) {
            // ServletContext中未获取到，则创建一个应用上下文
            // 这里创建应用上下文的处理与上一篇中的处理类似，不同之处在于创建完成后即进行了应用上下文的配置和刷新
            wac = createWebApplicationContext(rootContext);
        }

        if (!this.refreshEventReceived) {
            // 触发初始化刷新，这里指的不是应用上下文的刷新
            // 这个方法是一个模板方法，默认实现为空，交由子类DisispatcherServlet实现
            onRefresh(wac);
        }

        if (this.publishContext) {
            // 将当前的应用上下文发布到ServletContext中，key为：FrameworkServlet.class.getName() + ".CONTEXT." + servletName
            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;
    }

}

上面的代码中，取得了一个应用上下文，作为了根IOC容器的子容器，这样，DispatcherServlet中的IOC容器就建立起来了，细心的同学会发现，在返回应用上下文之前调用了onRefresh(wac)方法，这个方法由其子类DispatcherServlet实现，用于初始化Web层需要的策略，下面让我们一起来看一看这部分的源码：

public class DispatcherServlet extends FrameworkServlet {

    @Override
    protected void onRefresh(ApplicationContext context) {
        initStrategies(context);
    }

    protected void initStrategies(ApplicationContext context) {
        initMultipartResolver(context);
        initLocaleResolver(context);
        initThemeResolver(context);
        initHandlerMappings(context);
        initHandlerAdapters(context);
        initHandlerExceptionResolvers(context);
        initRequestToViewNameTranslator(context);
        initViewResolvers(context);
        initFlashMapManager(context);
    }

}

从上面的代码中可以看到，在获取应用上下文的过程中初始化了DispatcherServlet中需要的各种解析器，其中包括文件解析器、区域解析器、主题解析器等。

解析器的初始化过程大体相同，都是从应用上下文中取得相应的Bean，若不存在则使用默认解析器策略。

具体关于各解析器的介绍大家可以参考一篇博客：SpringMVC解析器

到这里，DispatcherServlet的初始化阶段就完成了，在这个过程中，一方面创建了DispatcherServlet的IOC容器，并将这个IOC容器作为根IOC容器的子容器，另一方面，初始化了DispatcherServlet需要的各种解析策略，接下来，DispatcherServlet将会在处理HTTP请求时发挥重要的作用。

（二）响应客户请求 -> service()

我们知道Servlet在接收到客户请求后会调用service()方法，根据请求类型执行doGet、doPost等一系列方法，在DispatcherServlet的继承体系中，由DispatcherServlet的父类FrameworkServlet重写了HttpServlet中的service()方法以及doGet()、doPost() 等一系列方法，下面以常用的HTTP请求方法来看一看FrameworkServlet的主要实现代码：

  • public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
        // 这里添加了对patch请求的支持
        if (httpMethod == HttpMethod.PATCH || httpMethod == null) {
            processRequest(request, response);
        }
        else {
            // 这里调用HttpServlet的service方法，根据请求类型调用该类中重写的doGet、doPost等方法 
            super.service(request, response);
        }
    }

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

    @Override
    protected final void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        processRequest(request, response);
    }

    @Override
    protected final void doPut(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        processRequest(request, response);
    }

    @Override
    protected final void doDelete(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        processRequest(request, response);
    }

}

从上面的代码中可以看到， DispatcherServlet接收到用户请求后，会调用父类FrameworkServlet中的service()方法，最终根据请求类型调用FrameworkServlet中重写的doGet、doPost等方法，这些方法都调用了processRequest()方法，下面让我们看一下processRequest()的具体实现：

public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {

    protected final void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        long startTime = System.currentTimeMillis();
        Throwable failureCause = null;
        // 获取LocaleContext(语言环境), 用作备份
        LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
        // 根据当前request创建LocaleContext
        LocaleContext localeContext = buildLocaleContext(request);
        // 获取RequestAttributes，用作备份
        RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
        // 根据当前request、response创建ServletRequestAttributes
        ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);
        // 为当前请求注册一个拦截器，用于在请求执行前后异步初始化和重置FrameworkServlet的LocaleContextHolder和RequestContextHolder
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
        asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());
        // 根据当前request初始化ContextHolders
        initContextHolders(request, localeContext, requestAttributes);
        try {
            // 具体处理请求，是一个模板方法，由子类DispatcherServlet实现
            doService(request, response);
        }
        catch (ServletException | IOException ex) {
            failureCause = ex;
            throw ex;
        }
        catch (Throwable ex) {
            failureCause = ex;
            throw new NestedServletException("Request processing failed", ex);
        }
        finally {
            // 使用备份重置ContextHolders
            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");
                    }
                }
            }
            // 向该应用注册的所有监听器发布RequestHandledEvent事件
            // 监听器可以通过实现ApplicationListener接口来实现
            publishRequestHandledEvent(request, response, startTime, failureCause);
        }
    }

}

在上面的代码中我们可以看到一个用于处理请求的核心方法：doService(request, response)，这个方法是一个模板方法，由其子类DispatcherServlet实现，代码如下：

public class DispatcherServlet extends FrameworkServlet {

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

        // 对于include请求，首先保存request属性快照，用于请求后恢复属性
        Map<String, Object> attributesSnapshot = null;
        if (WebUtils.isIncludeRequest(request)) {
            attributesSnapshot = new HashMap<>();
            Enumeration<?> attrNames = request.getAttributeNames();
            while (attrNames.hasMoreElements()) {
                String attrName = (String) attrNames.nextElement();
                if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
                    attributesSnapshot.put(attrName, request.getAttribute(attrName));
                }
            }
        }

        // 为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()); // 主题源，默认将应用上下文作为主题源

        if (this.flashMapManager != null) {
            FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
            if (inputFlashMap != null) {
                request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
            }
            request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
            request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
        }

        try {
            // 分发请求
            doDispatch(request, response);
        }
        finally {
            if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
                // Restore the original attribute snapshot, in case of an include.
                if (attributesSnapshot != null) {
                    // 恢复include请求属性
                    restoreAttributesAfterInclude(request, attributesSnapshot);
                }
            }
        }
    }

}

doService方法比较简单，主要是为request设置一些必要的属性，接下来调用了doDispatch方法进行请求的分发，这是SpringMVC中的核心功能，doDispatch方法中主要进行了如下的处理：

  • 处理拦截
  • 处理请求
  • 解析View

代码如下：

public class DispatcherServlet extends FrameworkServlet {

    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 {
                // 判断是否为文件上传请求，这里会尝试将request转换为文件上传请求
                processedRequest = checkMultipart(request);
                multipartRequestParsed = (processedRequest != request);

                // 通过HandlerMapping获取请求匹配的处理器：一个HandlerExecutionChain类的实例
                // 这个处理器中包含一个请求处理器和多个拦截器
                mappedHandler = getHandler(processedRequest);
                if (mappedHandler == null) {
                    // 未找到匹配的处理器，返回404错误
                    noHandlerFound(processedRequest, response);
                    return;
                }

                // 根据匹配的请求处理器获取支持该处理器的适配器
                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

                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);
                    }
                    // 对于get请求，如果从上次修改后未进行修改则不再对请求进行处理
                    if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                        return;
                    }
                }
                // 执行拦截器 -> preHandle
                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                    return;
                }

                // 执行处理器处理请求，返回ModelAndView对象
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

                if (asyncManager.isConcurrentHandlingStarted()) {
                    return;
                }
                // 若ModelAndView无视图名，则为其设置默认视图名
                applyDefaultViewName(processedRequest, mv);
                // 执行拦截器 -> postHandle
                mappedHandler.applyPostHandle(processedRequest, response, mv);
            }
            catch (Exception ex) {
                dispatchException = ex;
            }
            catch (Throwable err) {
                dispatchException = new NestedServletException("Handler dispatch failed", err);
            }
            // 处理异常，解析View
            processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
        }
        catch (Exception ex) {
            // 触发拦截器的afterCompletion方法
            triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
        }
        catch (Throwable err) {
            // 触发拦截器的afterCompletion方法
            triggerAfterCompletion(processedRequest, response, mappedHandler, new NestedServletException("Handler processing failed", err));
        }
        finally {
            if (asyncManager.isConcurrentHandlingStarted()) {
                if (mappedHandler != null) {
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
            }
            else {
                // 清除文件上传请求使用的资源
                if (multipartRequestParsed) {
                    cleanupMultipart(processedRequest);
                }
            }
        }
    }

}

到这里，客户的请求就相应完成了。在这个过程中，首先处理匹配的处理器中的拦截器，然后通过处理器处理客户的请求，最后通过视图解析器解析和渲染视图，这里还有许多细节未深入分析，我们将在后续继续学习。

（二）销毁阶段 -> destroy()

Servlet的销毁阶段会调用destroy()方法，这个方法的实现在FrameworkServlet中，实现比较简单，就是将Servlet中的IOC容器关闭，代码如下：

public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {

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

三、总结

本篇中，顺着Servlet的生命周期大致分析了SpringMVC的核心类DispatcherServlet的实现，对SpringMVC的请求控制有了一定的了解，但在DispatcherServlet处理客户请求的部分有许多内容未深入分析，需要进一步学习。

一颗贪婪的星
关注
专栏目录
Spring MVC DispatcherServlet
dream_heheda的博客
04-22 288
1.前端控制器 在Web应用程序模式中，前端控制器 将请求委托给应用程序的其他组件 来执行实际的处理。Spring MVC中，DispatcherServlet就是前端控制器。DispatcherServelt是 Spring MVC的核心，在这里 请求第一次 接触到框架，它主要负责 把请求 路由到 其他组件中。把请求 借助HandlerMapping 路由到控制器中。把控制器处理过的请求 借助...
SpringMVC 解析（二）DispatcherServlet
myqq_374327792的博客
02-09 1071
在我的关于Tomcat容器介绍的文章中，介绍了Tomcat容器的工作原理，我们知道Tomcat容器在收到请求之后，会把请求处理为Request/Response对象，交给Servlet实例处理。对于Spring的Web应用，得到Tomcat容器的请求之后会交给DispatcherServlet去处理。DispatcherServlet是Spring Web应用处理请求的核心组件，本文会介绍DispatcherServlet的工作原理及关键源码，本文主要参考了Spring的官方文档。 Servlet简介
springmvc之DispatcherServlet
weixin_34347651的博客
11-06 65
前言 　　最近打算利用闲暇的时间从零写个springmvc项目，工作中的项目框架都是搭好的，写业务逻辑多些，所以开始就一路磕磕碰碰。快半个月了项目还没搭起来。对底层和框架了解的太少了，趁此机会把遇到的问题都好好研究一下并记录下来，供以后学习用。希望文中有不对的或是不严谨的地方还请不吝赐教，感谢！！！ 正文 　　1.什么DispatcherServlet 　　与许多其...
springboot访问报错：Initializing Spring DispatcherServlet ‘dispatcherServlet‘
最新发布
baidu_38322633的博客
06-26 694
springboot报错:Initializing Spring DispatcherServlet 'dispatcherServlet'
Initializing Spring DispatcherServlet
m0_54866636的博客
03-21 1969
新建项目启动成功后 ，controller接口无法调通，且检查url参数等正确，调接口时控制台报： 是由于DispatcherServlet未初始化 解决方法(取其一即可)： 1、在application.properties文件添加： spring.mvc.servlet.load-on-startup=100 在spring boot load-on-startup默认值是-1，项目启动时，默认不会初始化DispatcherServlet，也就是不会调用Servlet接口的init()方法 可以通过
Spring MVC的DispatcherServlet – Java开发人员应该知道的10件事
最佳 Java 编程
06-06 191
如果您使用过Spring MVC，那么您应该知道什么是DispatcherServlet？ 它实际上是Spring MVC的心脏，确切地说是MVC设计模式或控制器的C语言。 应该由Spring MVC处理的每个Web请求都通过DispatcherServlet处理。 通常，它是Front Controller Pattern的实现，可在您的应用程序中提供单个入口点。 它处理所有传入的请求。 ...
Spring源码学习九：DispatcherServlet初始化源码分析1
08-04
Spring源码学习九：DispatcherServlet初始化源码分析1 DispatcherServlet是SpringMVC的核心分发器，它实现了请求分发，是处理请求的入口，本篇将深入源码分析它的初始化过程。 首先，从DispatcherServlet的名称上...
spring源码、springMVC源码、springboot源码资料，轻松应对金三银四Java面试 99% Spring面试题
04-19
在Java开发领域，Spring框架是不可或缺的核心技术之一，它极大地简化了企业级应用的开发工作。SpringMVC作为Spring框架的一部分，专门处理Web应用程序的请求和响应，而Spring Boot则是为了快速构建基于Spring的应用...
spring及springmvc源码
06-05
在源码学习过程中，你可能会遇到以下关键类和接口：`RequestMappingHandlerMapping`, `RequestMappingHandlerAdapter`, `SimpleControllerHandlerAdapter`, `ModelAndView`, `DefaultListableBeanFactory`, `Bean...
spring-mvc:springmvc源码学习-mvc source code
03-24
在这个“spring-mvc:springmvc源码学习”的项目中，我们将深入探讨Spring MVC的内部工作原理和设计思想。 首先，我们从`spring-mvc-master`这个目录名来看，这可能是一个Spring MVC项目的源代码仓库，包含了该项目...
【Spring】抽丝剥茧SpringMVC-DispatcherServlet
beFocused的博客
11-30 386
DispatcherServlet 使用SpringMVC框架的同学一定知道DispatcherServlet。SpringMVC处理Http请求就是从DispatcherServlet开始。SpringMC简化了Servlet规范的开发模式，定义了通用了Servlet(DispatcherServlet)与Servlet容器(jetty/tomcat)交互。开发者专注于业务逻辑的开发。下图是DispatcherServlet的类图 可以看出DispatcherServlet其实就是...
游戏思路借鉴三——贪吃蛇他来了！（一）
小杜爱吃肉
12-06 273
如果学计算机不是为了开心，那还有什么意义。结束了vb的全部课程，闲来无事也可以做一做小游戏来放松一下，下面就是我利用空闲时间制作的一款贪吃蛇小游戏，我将会还原整个制作过程，再一次体会小蛇所体现出来的计算机思想 效果视频，没有录屏软件，只能手机拍了 最开始我们要完成以下基础工作： 1使用绘画line画蛇 2绘画史一节一节的画出来 3确定每一节????身的位置 4切丁每一节蛇身的长度 我们利用line函数来画出蛇来，大家都知道line可以画矩形，所所以一届一届的蛇身我们就用line来画就好了，这时候，我们还需要
SpringMVC一（DispatcherServlet）
我的博客
08-18 143
SpringMVC—DispatcherServlet 一.概述 在Spring MVC(模型-视图-控制器）框架中，DispatcherServlet扮演调度器角色，所有HTTP请求和响应都围绕着DispatcherServlet。DispatcherServlet的请求处理工作流程如下： 1.服务器收到HTTP请求后，DispatcherServlet会查询HandlerMappin...
Spring MVC里的DispatchServlet（结合Spring官网翻译）
qq_44717657的博客
09-15 933
结合Spring官网翻译，通俗易懂地分析了中央调度器（dispatcherServlet）的组成部分以及工作流程
SpringMVC源码分析（一） ———DispatcherServlet
qq_53836264的博客
04-02 558
SpringMVC源码分析（一） ———DispatcherServlet
Spring MVC —— 关于 DispatcherServlet
小水牛的博客
03-08 1617
DispatcherServlet
spring mvc
weixin_34242509的博客
03-13 69
来自官网的图： web.xml加上： <web-app> <servlet> <servlet-name>example</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet&...
SpringMvc之DispatcherServlet详解
Mr.Cheng先生
12-01 1330
运行特性DispatcherServlet本质：他是一个Servlet Servlet原则：Servlet可以根据其特性进行运行主线的划分 根据Servlet的核心方法可以知道DispatcherServlet的主线： Init Service 初始化主线 —— 负责对SpringMVC的运行要素进行初始化 Http请求处理主线 —— 负责对SpringMVC中的组件进行逻辑调度完成对H
SpringMVC源码解析：DispatcherServlet的调度机制
SpringMVC作为一个MVC框架，虽然在应用层面上与Servlet容器如Tomcat、Undertow、Jetty紧密关联，但其设计思想和工作流程有着独特之处。在初学者阶段，我们通常会在`web.xml`中配置`DispatcherServlet`，并将其拦截的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值