springmvc--DispatcherServlet

最新推荐文章于 2023-03-23 13:57:17 发布
最新推荐文章于 2023-03-23 13:57:17 发布
阅读量173 收藏
点赞数
分类专栏： spring源码解析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljz2016/article/details/86773743
版权

在这里插入图片描述在该servlet初始化时，会 this.webApplicationContext = this.initWebApplicationContext();创建beanFactory和相应的bean，

所以对于springmvc项目，下面的listener与servlet只需要配置一个就行了，对于web项目，只需要配置servlet。

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>


  <servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath*:dispatcher-servlet.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>

作为web应用的入口转发器，入口方法是

 protected final void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        long startTime = System.currentTimeMillis();
        Throwable failureCause = null;
        LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
        LocaleContext localeContext = this.buildLocaleContext(request);
        RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes requestAttributes = this.buildRequestAttributes(request, response, previousAttributes);
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
        asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new FrameworkServlet.RequestBindingInterceptor(null));
        this.initContextHolders(request, localeContext, requestAttributes);

        try {
            this.doService(request, response);
        } catch (ServletException var17) {
            failureCause = var17;
            throw var17;
        } catch (IOException var18) {
            failureCause = var18;
            throw var18;
        } catch (Throwable var19) {
            failureCause = var19;
            throw new NestedServletException("Request processing failed", var19);
        } finally {
            this.resetContextHolders(request, previousLocaleContext, previousAttributes);
            if(requestAttributes != null) {
                requestAttributes.requestCompleted();
            }

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

            this.publishRequestHandledEvent(request, response, startTime, (Throwable)failureCause);
        }

    }

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

        Map<String, Object> attributesSnapshot = null;
        if(WebUtils.isIncludeRequest(request)) {
            attributesSnapshot = new HashMap();
            Enumeration attrNames = request.getAttributeNames();

            label108:
            while(true) {
                String attrName;
                do {
                    if(!attrNames.hasMoreElements()) {
                        break label108;
                    }

                    attrName = (String)attrNames.nextElement();
                } while(!this.cleanupAfterInclude && !attrName.startsWith("org.springframework.web.servlet"));

                attributesSnapshot.put(attrName, request.getAttribute(attrName));
            }
        }

        request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.getWebApplicationContext());
        request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
        request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
        request.setAttribute(THEME_SOURCE_ATTRIBUTE, this.getThemeSource());
        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 {
            this.doDispatch(request, response);
        } finally {
            if(!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted() && attributesSnapshot != null) {
                this.restoreAttributesAfterInclude(request, attributesSnapshot);
            }

        }

    }

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

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

                try {
                    processedRequest = this.checkMultipart(request); //判断是不是post表单请求，根据content-type判断
                    multipartRequestParsed = processedRequest != request;
                    //找到HandlerExecutionChain，里面包含有拦截器（已经筛选过路径），包含有目标Bean，目标方法。
                
                    mappedHandler = this.getHandler(processedRequest);
                    if(mappedHandler == null || mappedHandler.getHandler() == null) {
                        this.noHandlerFound(processedRequest, response);
                        return;
                    }
                    
					//(mappedHandler.getHandler()就是controller的执行方法，一个Method对象
					//从handlerAdapters中找到一个支持这个handler的adapter
					//这里获得的一般是RequestMappingHandlerAdapter。
                    HandlerAdapter ha = this.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(this.logger.isDebugEnabled()) {
                            this.logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
                        }

                        if((new ServletWebRequest(request, response)).checkNotModified(lastModified) && isGet) {
                            return;
                        }
                    }

                    if(!mappedHandler.applyPreHandle(processedRequest, response)) {
                    //将org.springframework.web.servlet.resource.ResourceUrlProvider放到request中
                    //将org.springframework.core.convert.ConversionService放到request中
                        return;
                    }

                    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                    if(asyncManager.isConcurrentHandlingStarted()) {
                        return;
                    }

                    this.applyDefaultViewName(processedRequest, mv);
                    mappedHandler.applyPostHandle(processedRequest, response, mv);
                } catch (Exception var20) {
                    dispatchException = var20;
                } catch (Throwable var21) {
                    dispatchException = new NestedServletException("Handler dispatch failed", var21);
                }

                this.processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);
            } catch (Exception var22) {
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, var22);
            } catch (Throwable var23) {
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, new NestedServletException("Handler processing failed", var23));
            }

        } finally {
            if(asyncManager.isConcurrentHandlingStarted()) {
                if(mappedHandler != null) {
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
            } else if(multipartRequestParsed) {
                this.cleanupMultipart(processedRequest);
            }

        }
    }
handle方法

这个方法会调用controller层用户自定义的方法，然后返回modelAndView，所以主要流程都在这里。

protected ModelAndView handleInternal(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
        this.checkRequest(request);
        ModelAndView mav;
        if(this.synchronizeOnSession) {
            HttpSession session = request.getSession(false);
            if(session != null) {
                Object mutex = WebUtils.getSessionMutex(session);
                synchronized(mutex) {
                    mav = this.invokeHandlerMethod(request, response, handlerMethod);
                }
            } else {
                mav = this.invokeHandlerMethod(request, response, handlerMethod);
            }
        } else {
            mav = this.invokeHandlerMethod(request, response, handlerMethod);
        }

        if(!response.containsHeader("Cache-Control")) {
            if(this.getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
                this.applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
            } else {
                this.prepareResponse(response);
            }
        }

        return mav;
    }

protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
        ServletWebRequest webRequest = new ServletWebRequest(request, response);

        ModelAndView var15;
        try {
            WebDataBinderFactory binderFactory = this.getDataBinderFactory(handlerMethod);
            ModelFactory modelFactory = this.getModelFactory(handlerMethod, binderFactory);
            ServletInvocableHandlerMethod invocableMethod = this.createInvocableHandlerMethod(handlerMethod);
            //把handlerMethod的核心信息提取出来到新创建对象invocableMethod 
            invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
            invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
            invocableMethod.setDataBinderFactory(binderFactory);
            invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
            
            ModelAndViewContainer mavContainer = new ModelAndViewContainer();
            mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
            
            modelFactory.initModel(webRequest, mavContainer, invocableMethod);
            mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);
            AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
            asyncWebRequest.setTimeout(this.asyncRequestTimeout);
            WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
            asyncManager.setTaskExecutor(this.taskExecutor);
            asyncManager.setAsyncWebRequest(asyncWebRequest);
            asyncManager.registerCallableInterceptors(this.callableInterceptors);
            asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);
            Object result;
            if(asyncManager.hasConcurrentResult()) {
                result = asyncManager.getConcurrentResult();
                mavContainer = (ModelAndViewContainer)asyncManager.getConcurrentResultContext()[0];
                asyncManager.clearConcurrentResult();
                if(this.logger.isDebugEnabled()) {
                    this.logger.debug("Found concurrent result value [" + result + "]");
                }

                invocableMethod = invocableMethod.wrapConcurrentResult(result);
            }
//重点，这里将会调用用户自定义的controller层的方法，也是浏览器请求路径对应的执行方法
            invocableMethod.invokeAndHandle(webRequest, mavContainer, new Object[0]);
            if(asyncManager.isConcurrentHandlingStarted()) {
                result = null;
                return (ModelAndView)result;
            }
			//执行完目标方法后，结果保存在mavContainer中，下面处理后获得modelAndView
            var15 = this.getModelAndView(mavContainer, modelFactory, webRequest);
        } finally {
            webRequest.requestCompleted();
        }

        return var15;
    }


public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
        Object returnValue = this.invokeForRequest(webRequest, mavContainer, providedArgs);
        this.setResponseStatus(webRequest);
        if(returnValue == null) {
            if(this.isRequestNotModified(webRequest) || this.getResponseStatus() != null || mavContainer.isRequestHandled()) {
                mavContainer.setRequestHandled(true);
                return;
            }
        } else if(StringUtils.hasText(this.getResponseStatusReason())) {
            mavContainer.setRequestHandled(true);
            return;
        }

        mavContainer.setRequestHandled(false);

        try {//处理返回的结果
            this.returnValueHandlers.handleReturnValue(returnValue, this.getReturnValueType(returnValue), mavContainer, webRequest);
        } catch (Exception var6) {
            if(this.logger.isTraceEnabled()) {
                this.logger.trace(this.getReturnValueHandlingErrorMessage("Error handling return value", returnValue), var6);
            }

            throw var6;
        }
    }

public Object invokeForRequest(NativeWebRequest request, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
//获取目标方法的参数值
        Object[] args = this.getMethodArgumentValues(request, mavContainer, providedArgs);
        if(this.logger.isTraceEnabled()) {
            this.logger.trace("Invoking '" + ClassUtils.getQualifiedMethodName(this.getMethod(), this.getBeanType()) + "' with arguments " + Arrays.toString(args));
        }

        Object returnValue = this.doInvoke(args);
        if(this.logger.isTraceEnabled()) {
            this.logger.trace("Method [" + ClassUtils.getQualifiedMethodName(this.getMethod(), this.getBeanType()) + "] returned [" + returnValue + "]");
        }
//目标方法的返回值
        return returnValue;
    }

处理方法返回值的解析器
在这里插入图片描述
解析结果视图

private void processDispatchResult(HttpServletRequest request, HttpServletResponse response, HandlerExecutionChain mappedHandler, ModelAndView mv, Exception exception) throws Exception {
        boolean errorView = false;
        if(exception != null) {
            if(exception instanceof ModelAndViewDefiningException) {
                this.logger.debug("ModelAndViewDefiningException encountered", exception);
                mv = ((ModelAndViewDefiningException)exception).getModelAndView();
            } else {
                Object handler = mappedHandler != null?mappedHandler.getHandler():null;
                mv = this.processHandlerException(request, response, handler, exception);
                errorView = mv != null;
            }
        }

        if(mv != null && !mv.wasCleared()) {
            this.render(mv, request, response);// 这里解析结果视图
            if(errorView) {
                WebUtils.clearErrorRequestAttributes(request);
            }
        } else if(this.logger.isDebugEnabled()) {
            this.logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + this.getServletName() + "': assuming HandlerAdapter completed request handling");
        }

        if(!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
            if(mappedHandler != null) {
                mappedHandler.triggerAfterCompletion(request, response, (Exception)null);
            }

        }
    }

遍历所有的ViewResolver，知道找到一个能够解析的。

protected View resolveViewName(String viewName, Map<String, Object> model, Locale locale, HttpServletRequest request) throws Exception {
        Iterator var5 = this.viewResolvers.iterator();

        View view;
        do {
            if(!var5.hasNext()) {
                return null;
            }

            ViewResolver viewResolver = (ViewResolver)var5.next();
            view = viewResolver.resolveViewName(viewName, locale);
        } while(view == null);

        return view;
    }

HandlerMethodArgumentResolver
RequestParamMethodArgumentResolver解析方法的入口参数值

getLocal方法，获取浏览器支持的语言。

public Locale resolveLocale(HttpServletRequest request) {
        Locale defaultLocale = this.getDefaultLocale();
        if(defaultLocale != null && request.getHeader("Accept-Language") == null) {
            return defaultLocale;
        } else {
            Locale requestLocale = request.getLocale();
            if(this.isSupportedLocale(requestLocale)) {
                return requestLocale;
            } else {
                Locale supportedLocale = this.findSupportedLocale(request);
                return supportedLocale != null?supportedLocale:(defaultLocale != null?defaultLocale:requestLocale);
            }
        }
    }
getHandlerExecutionChain方法
protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
        HandlerExecutionChain chain = handler instanceof HandlerExecutionChain?(HandlerExecutionChain)handler:new HandlerExecutionChain(handler);
        String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);
        Iterator var5 = this.adaptedInterceptors.iterator();//adaptedInterceptors是HandlerInterceptor的集合

        while(var5.hasNext()) {
            HandlerInterceptor interceptor = (HandlerInterceptor)var5.next();
            if(interceptor instanceof MappedInterceptor) {
                MappedInterceptor mappedInterceptor = (MappedInterceptor)interceptor;
                if(mappedInterceptor.matches(lookupPath, this.pathMatcher)) {
                //筛选出符合当前请求的拦截器，交给handlerExecutionChain链，如果这个拦截器是MappedInterceptor的实例的话
                    chain.addInterceptor(mappedInterceptor.getInterceptor());
                }
            } else {
            //如果不是，则直接交给拦截链
                chain.addInterceptor(interceptor);
            }
        }

        return chain;
    }

默认有3个handlerAdapter,
handlerAdapters
默认的handlerInterceptor
在这里插入图片描述

getDataBinderFactory方法

InitBinder.class注解，用在方法上。
WebDataBinderFactory 中包含有initBinder注解的方法

private WebDataBinderFactory getDataBinderFactory(HandlerMethod handlerMethod) throws Exception {
        Class<?> handlerType = handlerMethod.getBeanType();
        Set<Method> methods = (Set)this.initBinderCache.get(handlerType);
        if(methods == null) {//methods保存的是类中具有InitBinder注解的方法，
            methods = MethodIntrospector.selectMethods(handlerType, INIT_BINDER_METHODS);
            this.initBinderCache.put(handlerType, methods);
        }

        List<InvocableHandlerMethod> initBinderMethods = new ArrayList();
        Iterator var5 = this.initBinderAdviceCache.entrySet().iterator();
//Map<ControllerAdviceBean, Set<Method>> initBinderAdviceCache = new LinkedHashMap()
        while(true) {
            Entry entry;
            Object bean;
            do {
                if(!var5.hasNext()) {//没有
                    var5 = methods.iterator();

                    while(var5.hasNext()) {
                        Method method = (Method)var5.next();
                        bean = handlerMethod.getBean();
                        initBinderMethods.add(this.createInitBinderMethod(bean, method));
                    }

                    return this.createDataBinderFactory(initBinderMethods);
                }

                entry = (Entry)var5.next();
            } while(!((ControllerAdviceBean)entry.getKey()).isApplicableToBeanType(handlerType));

            bean = ((ControllerAdviceBean)entry.getKey()).resolveBean();
            Iterator var8 = ((Set)entry.getValue()).iterator();

            while(var8.hasNext()) {
                Method method = (Method)var8.next();
                initBinderMethods.add(this.createInitBinderMethod(bean, method));
            }
        }
    }
ljz2016
关注
专栏目录
SpringMVC-Mybatis-Shiro-redis
02-23
它提供了模型与视图之间的解耦，通过DispatcherServlet进行请求分发，使得开发者能够轻松地实现业务逻辑和视图展示的分离。SpringMVC还支持注解驱动的开发，简化了配置，使得代码更加简洁和可维护。 Mybatis是一个...
SpringMVC-Mybatis-Shiro-redis-master
01-18
SpringMVC通过DispatcherServlet进行请求分发，并使用拦截器（Interceptor）对请求进行预处理和后处理，增强了系统的灵活性和可扩展性。 **MyBatis** 是一个持久层框架，它允许开发者用简单的XML或注解来定义SQL...
mvc-dispatcher-servlet.xml
Wanger_tt的博客
03-09 1801
核心front Controller —– DispatcherServlet 负责数据的分发 HandlerAdapter由DispatcherServlet调用HANDLERiNTERCEPTORHandlerMapping 由哪个handler来响应dispatcherHandlerExecutionChainModleAndView Modle+
SpringMvc-Dispatcher
张三的博客
09-14 1885
虽然知道springMvc处理请求的大致过程，但是具体实现在脑子里比较模糊，因此简单看下源码，只求看懂工作原理，并做下笔记。 几个关键类或接口的说明： HandlerMapping： 这是一个接口，该接口表示实现了这个接口的类是完成url和处理bean映射逻辑的。当SpringMvc启动就会根据选择的实现类去把Controller类型的bean和url绑定如果我们不在配置文件配置
【Spring】抽丝剥茧SpringMVC-DispatcherServlet
beFocused的博客
11-30 387
DispatcherServlet 使用SpringMVC框架的同学一定知道DispatcherServlet。SpringMVC处理Http请求就是从DispatcherServlet开始。SpringMC简化了Servlet规范的开发模式，定义了通用了Servlet(DispatcherServlet)与Servlet容器(jetty/tomcat)交互。开发者专注于业务逻辑的开发。下图是DispatcherServlet的类图 可以看出DispatcherServlet其实就是...
SpringMVC-DispatcherServlet 服务过程源码分析
beginnerdzz的博客
04-12 485
DispatcherServlet 服务过程源码分析 springMVC调用组件处理请求的整个过程
SpringMVC 教程 - DispatcherServlet
Andrew_Ma_shuai的专栏
04-22 234
原文链接：https://www.codemore.top/cates/Backend/post/2018-04-09/spring-mvc-dispatcher-servlet简介同许多其他的web框架一样，SpringMVC使用了前端控制器的设计模式，即一个以DispatcherServlet为核心的Servlet为处理请求提供了一个共享的算法，而实际的工作是由可配置的委托组件执行的。这个模式...
springmvc-webapi-demo:使用springmvc构建webapi项目，springmvc-integerceptor、alibaba-json
05-15
在具体实现上，Spring MVC的DispatcherServlet会接收HTTP请求，并通过HandlerMapping找到对应的Controller方法。Interceptor会在调用Controller之前进行预处理，例如，检查请求头中的口令，如果符合预期，则允许请求...
Spring-SpringMVC-Hibernate-Template:本项目为 Spring-SpringMVC-Hibernate 的空白模板
06-08
SpringMVC通过DispatcherServlet作为前端控制器，接收HTTP请求，然后调用处理器映射器找到对应的处理器方法，再由视图解析器将结果渲染成用户可见的页面。 **Hibernate**： Hibernate是一个强大的Java持久化框架，...
springmvc-base-input-02.rar
最新发布
01-24
在 "springmvc-base-input-02" 这个项目中，我们很可能会看到如何处理用户输入和请求的进阶知识。 在 Spring MVC 中，`pom.xml` 文件是 Maven 项目的配置文件，它定义了项目的依赖关系。在这个项目中，`pom.xml` ...
SpringMVC的Dispatcher
weixin_45066790的博客
02-01 817
1.Spring的web框架围绕DispatcherServlet设计。 以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。 借用B站狂神的流程图（其中实现全部是框架给我们做的，我们只需要补充虚线的流程就好。） SpringMVC是Spring中的模块，它实现了mvc设计模式的web框架，首先用户发出请求，请求到达SpringMVC的前端控制器（DispatcherServlet）,
springmvc ---DispatcherServlet详解
被世界遗弃的江的博客
11-15 723
DispatcherServlet作用 DispatcherServlet是前端控制器设计模式的实现，提供Spring Web MVC的集中访问点，而且负责职责的分派。 DispatcherServlet主要用作职责调度工作，本身主要用于控制流程： 1、文件上传解析，如果请求类型是multipart将通过MultipartResolver进行文件上传解析；
springMVC --DispatcherServlet详解
chidou1692的博客
09-08 207
DispatcherServlet作用 DispatcherServlet是前端控制器设计模式的实现，提供Spring Web MVC的集中访问点，而且负责职责的分派。 DispatcherServlet主要用作职责调度工作，本身...
SpringMVC中DispatcherServlet详解
技术人集结地
03-13 4371
DispatcherServlet是Spring MVC框架的核心组件之一，它负责请求的接收、处理和响应。DispatcherServlet在整个请求处理过程中扮演着调度者的角色，将请求分发到相应的处理器进行处理，并将处理结果返回给客户端
SpringMvc-DispatcherServlet 源码分析
weixin_43299321的博客
05-06 145
那接下来咱们简单看看源码。。 SpringMvc的入口是servlet 所以先简单聊聊servlet。 Servlet的生命周期方法 init()方法 在Servlet的生命周期中，仅执行一次init()方法，它是在服务器装入Servlet时执行的，可以配置服务器，以在启动服务器或客户机首次访问Servlet时装入Servlet。无论有多少客户机访问Servlet，都不会重复执行init()...
Spring mvc 核心 DispatcherServlet 详解
swadian2008的博客
03-23 1319
与许多其他的 web 框架一样，Spring MVC 也是围绕前端控制器模式设计的，核心的 Servlet DispatcherServlet 为请求处理提供了共享算法，但是实际工作由可配置的委托组件执行的。这种设计非常灵活，可以支持不同的工作流。// 核心Servlet，其他组件可配置DispatcherServlet 和其他 Servlet 一样，也需要通过一些配置去发现它的委托组件（请求映射、视图解析、异常处理等组件），这些配置可以是 Java 代码，也可以是 web.xml 文件。
手写springmvc-dispathcherServlet
weixin_33849215的博客
05-18 176
2019独角兽企业重金招聘Python工程师标准>>> ...
菜鸟之路——Spring MVC（三）DispatcherServlet详解
sjjsh2的博客
11-06 7899
前言：回顾一下Spring的启动过程： 1、首先，对于一个web应用，其部署在web容器中，web容器提供其一个全局的上下文环境，这个上下文就是ServletContext，其为后面的spring IoC容器提供宿主环境； 2、其次，在web.xml中会提供有contextLoaderListener。在web容器启动时，会触发容器初始化事件，此时contextLoaderListene...
springMVC前端控制器Dispatcher
pzzzzzp的博客
08-08 271
springMVC前端控制器Dispatcher 一、springMVC执行流程 首先在接收到请求时，首先获取HandlerMapping 然后根据HandlerMapping获取对应的HandlerExecutionChain，这个执行链内置了Handler(可以理解为Controller) HandlerExecutionChain除了内置Handler外，还有拦截器HandlerInterceptor，首先有一个默认的拦截器，就是ConversionServiceExposingIntercepto
springmvc-servlettomcat
05-18
在使用 SpringMVC 框架时，我们需要将 SpringMVC 的 DispatcherServlet 配置到 Tomcat 中，以便 Tomcat 能够正确地处理 SpringMVC 的请求。具体来说，我们需要在 web.xml 配置文件中添加以下内容： ``` <servlet-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值