SpringMvc源码记录之请求执行流程

最新推荐文章于 2022-10-29 23:59:31 发布
置顶 最新推荐文章于 2022-10-29 23:59:31 发布
阅读量218 收藏
点赞数
分类专栏： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18634003/article/details/86670101
版权
java 同时被 2 个专栏收录
15 篇文章 0 订阅
订阅专栏
spring
2 篇文章 0 订阅
订阅专栏

在SpringMvc启动以及加载过程中以及讲到Spring启动加载过程，现在看下以及请求进来的过程以及数据流转过程，首先在看源码之前简单对SpringMvc请求过程有一个简单的大方向的了解：

 第一步就是获取，然后在Web Spring获取后根据request 中url来从HandlerMap查询Handler

第二步

  1. 请求数据经过DispatchServerlet
  2. 通过request 获取url查询Handler
  3. Handler调用相应的 Controller方法获取结果
  4. 组装成ModelAndView
  5. ModelAndView解析成view
  6. 返回给客户端

可以看到DispatchServlet是控制整过的控制者，以及逻辑分发者接下在再看下该类的UML图，可以看到这个类主要是Spring以及Servlet的一个桥梁既有实现接口Servlet相关的接口，也有Spring相关的接口，一开始主要这里主要涉及Servlet接口相关的。从UML图可以看到它是HttpServlet的子类，那么他有一个很重要的一个性质接受用户的请求，web配置的URL请求拦截的请求都会通过该类的

void service(HttpServletRequest req, HttpServletResponse resp)

方法处理。从代码上看，这个类的service方法主要通过父类FrameWorkServlet实现：

FrameWorkServlet.service:


	/**
	 * Override the parent class implementation in order to intercept PATCH requests.
	 */
	@Override
	protected void service(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
        //获取请求方法：POST  GET PUT 等
		HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
		if (HttpMethod.PATCH == httpMethod || httpMethod == null) {
			processRequest(request, response);
		}
		else {
            //调用HttpServlet service方法
			super.service(request, response);
		}
	}

再看下父类HTTPServlet的方法：

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

这块代码功能很简单就是获取请求的  方法类型，不同的请求类型走不同的逻辑，这些可以交给子类实现，这里用了模板模式，在FrameServlet重写了些 doGet  doPost方法：

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

		processRequest(request, response);
	}

每一个方法最后都会调用processRequest这个方法，而这个方法最核心的是调用了

protected abstract void doService(HttpServletRequest request, HttpServletResponse response)
      throws Exception;

这个方法被DispatchServlet实现了，也就是说：一个请求过来最终的公共逻辑会走到DispatchServlet#doService方法。

接下来就是真正的逻辑开始了。这个方法看代码其实最核心的调用

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception

所以我们直接从这个方法开始看：

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.
                //获取处理Handler(重点)
				mappedHandler = getHandler(processedRequest);
                //没有找到Handler  说明404啦
				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;
					}
				}
                //这里执行所有的和这个请求有关的拦截器，执行preHandle方法
				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}

				// Actually invoke the handler.
                //适配器调用Handler方法，处理请求以及Handler，获取modelAndView
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

				if (asyncManager.isConcurrentHandlingStarted()) {
					return;
				}
                //这里执行所有的和这个请求有关的拦截器，执行postHandle方法
				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);
				}
			}
		}
	}

这里我们重点关注一下几个过程：

  1. 获取MapHandler过程，以及这个对象包含的信息
  2. HandlerAdapter执行过程
  3. HandlerAdapter角色作用

接下来我看从这三个方面来看下，下面都是基于注解的方式来走的（@Controller @RequestMapping）

MapHandler的获取

	protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
		for (HandlerMapping hm : this.handlerMappings) {
			if (logger.isTraceEnabled()) {
				logger.trace(
						"Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");
			}
            //从HandlerMapping中获取Handler
			HandlerExecutionChain handler = hm.getHandler(request);
			if (handler != null) {
				return handler;
			}
		}
		return null;
	}

在this.handlerMappings代表配置不同的类型，我们直接看debug的截图：

可以看到有三个HandlerMapping，其中SimpleUrlHandlerMapping是配置加载的，BeanNameURLHandlerMapping是默认实现的，RequestMappingHandlerMapping是基于@Controller @RequestMapping实现的。所以我们只用了注解实现的，我们只关心这块逻辑就好。接下来看下Mapping的getHandler方法：

@Override
	public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        //获取一个Handler对象
		Object handler = getHandlerInternal(request);
		if (handler == null) {
			handler = getDefaultHandler();
		}
		if (handler == null) {
			return null;
		}
		// Bean name or resolved handler?
		if (handler instanceof String) {
			String handlerName = (String) handler;
			handler = getApplicationContext().getBean(handlerName);
		}
        //获取这个请求相关的拦截器，并且和Handler组装成一个对象
		HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
		if (CorsUtils.isCorsRequest(request)) {
			CorsConfiguration globalConfig = this.corsConfigSource.getCorsConfiguration(request);
			CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
			CorsConfiguration config = (globalConfig != null ? globalConfig.combine(handlerConfig) : handlerConfig);
			executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
		}
		return executionChain;
	}

以上代码只完成两个事情：获取一个请求相关的Handler  以及拦截器，看下这两个方法：

获取Handler

	@Override
	protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
        //获取请求URL
		String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
		if (logger.isDebugEnabled()) {
			logger.debug("Looking up handler method for path " + lookupPath);
		}
        //加一个共享锁
		this.mappingRegistry.acquireReadLock();
		try {
            //获取HandlerMethod
			HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
			if (logger.isDebugEnabled()) {
				if (handlerMethod != null) {
					logger.debug("Returning handler method [" + handlerMethod + "]");
				}
				else {
					logger.debug("Did not find handler method for [" + lookupPath + "]");
				}
			}
            //生成创建Handler
			return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
		}
		finally {
			this.mappingRegistry.releaseReadLock();
		}
	}



protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
		List<Match> matches = new ArrayList<Match>();
        //获取一个Match对象，在下面看下这个debug数据内容（标注1）
		List<T> directPathMatches = this.mappingRegistry.getMappingsByUrl(lookupPath);
		if (directPathMatches != null) {
            //把可以和这个匹配的Match对象加入一个List中（标注2）
			addMatchingMappings(directPathMatches, matches, request);
		}
		if (matches.isEmpty()) {
			// No choice but to go through all mappings...
			addMatchingMappings(this.mappingRegistry.getMappings().keySet(), matches, request);
		}

		if (!matches.isEmpty()) {
            //把刚刚的Matches排序（标注3）
			Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
			Collections.sort(matches, comparator);
			if (logger.isTraceEnabled()) {
				logger.trace("Found " + matches.size() + " matching mapping(s) for [" +
						lookupPath + "] : " + matches);
			}
            //获取最优的Match
			Match bestMatch = matches.get(0);
			if (matches.size() > 1) {
				if (CorsUtils.isPreFlightRequest(request)) {
					return PREFLIGHT_AMBIGUOUS_MATCH;
				}
				Match secondBestMatch = matches.get(1);
                //有两个一样Match，那么就会抛出异常
				if (comparator.compare(bestMatch, secondBestMatch) == 0) {
					Method m1 = bestMatch.handlerMethod.getMethod();
					Method m2 = secondBestMatch.handlerMethod.getMethod();
					throw new IllegalStateException("Ambiguous handler methods mapped for HTTP path '" +
							request.getRequestURL() + "': {" + m1 + ", " + m2 + "}");
				}
			}
			handleMatch(bestMatch.mapping, lookupPath, request);
            //返回Match的handlerMethod
			return bestMatch.handlerMethod;
		}
		else {
			return handleNoMatch(this.mappingRegistry.getMappings().keySet(), lookupPath, request);
		}
	}

private void addMatchingMappings(Collection<T> mappings, List<Match> matches, HttpServletRequest request) {
		for (T mapping : mappings) {
			T match = getMatchingMapping(mapping, request);
			if (match != null) {
                //将拿到的match和mapping包装成一个对象
				matches.add(new Match(match, this.mappingRegistry.getMappings().get(mapping)));
			}
		}
	}

上面两个方法主要获取Handler的过程：

  1. 首先获取T泛型集合（这个T是一个啥）
  2. 将Match集合排序获取最优的（是啥排序策略）
  3. 返回最优Match.Handler（这个又是一个啥）

上面我们知道了这个过程，但是对里面的数据却没有一个感性的认识，现在直接看debug数据就行。

首先看下标注1，获取一个List，其实是从this.urlLookup这个Map中获取的：

 这个数据结构内容是，key放的是我们的Url，value是一个list，list的每一个对象是怎么来的呢？其实这个数据来源就是注解@RequestMapping中各个转化的内容，也就是一个出现多个一样的的Url的处理方法（后面会有如何选其中的一个方法）。回答第一个问题，T是一个包含了注解信息的对象，包括 url Post/Get  等

然后就到了注解2，把我们刚刚拿到的所有的注解的信息会构造一个Match，拿着之前注解信息还会从this.mappingRegistry获取一个Handler。

我们可以看到获取的value是一个HandlerMethod对象，它是记录的主要是方法的信息，例如这个url对应的Controller bean  Method，以及方法的参数信息（第三个对象答案）。也就是一个Match对象有一个@RequestMapping注解信息以及方法的信息

接下来看下标注3，标注3主要对多个Match进行选取最优的Match，有两个最优的那么就会抛异常，我们从代码获取比较器一步步走进去我们可以看到最终是按照@RequestMapping信息对象（RequestMappingInfo）来排序的（上面第二个问题的答案），，这里就不详细看了，里面代码比较简单。

以上就是获取Handler的逻辑：

  1. 根据URL获取注解的信息对象
  2. 根据注解信息对象获取具体的方法信息对象
  3. 根据注解信息对象排序选出最优的哪一个方法信息Handler  返回，反之就会抛异常

         HandlerInterceptor获取

在获取完Handler后获取拦截器，组装成 HandlerExecutionChain

protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
		HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
				(HandlerExecutionChain) handler : new HandlerExecutionChain(handler));

		String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);
		for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
			if (interceptor instanceof MappedInterceptor) {
				MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
                   //拦截器可以匹配URL，就会加入到链表中
				if (mappedInterceptor.matches(lookupPath, this.pathMatcher)) {
					chain.addInterceptor(mappedInterceptor.getInterceptor());
				}
			}
			else {
				chain.addInterceptor(interceptor);
			}
		}
		return chain;
	}

 

HandlerAdapter

我们在上面一部已经获取了URL对应的Handler，里面主要的要的处理的方法信息，这个请求交给哪一个Controller的哪一个方法，现在HandlerAdapter其实起的是一个执行的过程，以及提供各种上下文的对象完成数据映射转换，并且调用方法完成业务逻辑。

/**
	 * Return the HandlerAdapter for this handler object.
	 * @param handler the handler object to find an adapter for
	 * @throws ServletException if no HandlerAdapter can be found for the handler. This is a fatal error.
	 */
	protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
		for (HandlerAdapter ha : this.handlerAdapters) {
			if (logger.isTraceEnabled()) {
				logger.trace("Testing handler adapter [" + ha + "]");
			}
            //获取可以支持的适配器，这个和controller配置有关系，注解实现的返回RequestMappingHandlerAdapter
			if (ha.supports(handler)) {
				return ha;
			}
		}
		throw new ServletException("No adapter for handler [" + handler +
				"]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
	}

这里按照注解实现那么就会返回RequestMappingHandlerAdapter，从主流程handle->handleInternal->invokeHandlerMethod方法：

protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

		ServletWebRequest webRequest = new ServletWebRequest(request, response);
		try {
			WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
			ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);

			ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);//构建执行器
			//设置请求参数到Controller转换对象
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);

			if (asyncManager.hasConcurrentResult()) {
				Object result = asyncManager.getConcurrentResult();
				mavContainer = (ModelAndViewContainer) asyncManager.getConcurrentResultContext()[0];
				asyncManager.clearConcurrentResult();
				if (logger.isDebugEnabled()) {
					logger.debug("Found concurrent result value [" + result + "]");
				}
				invocableMethod = invocableMethod.wrapConcurrentResult(result);
			}
            //执行方法
			invocableMethod.invokeAndHandle(webRequest, mavContainer);
			if (asyncManager.isConcurrentHandlingStarted()) {
				return null;
			}
            //生成modelAndView
			return getModelAndView(mavContainer, modelFactory, webRequest);
		}
		finally {
			webRequest.requestCompleted();
		}
	}

上面的流程就是通过Handler以及上下文一些工具对象（各种Convert类）构建一个新的执行类进行执行。

public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
			Object... providedArgs) throws Exception {
        //执行获取返回值
		Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
		setResponseStatus(webRequest);

		if (returnValue == null) {
			if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
				mavContainer.setRequestHandled(true);
				return;
			}
		}
		else if (StringUtils.hasText(getResponseStatusReason())) {
			mavContainer.setRequestHandled(true);
			return;
		}

		mavContainer.setRequestHandled(false);
		try {
            //对返回的参数进行转换写入到Response中
			this.returnValueHandlers.handleReturnValue(
					returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
		}
		catch (Exception ex) {
			if (logger.isTraceEnabled()) {
				logger.trace(getReturnValueHandlingErrorMessage("Error handling return value", returnValue), ex);
			}
			throw ex;
		}
	}
	public Object invokeForRequest(NativeWebRequest request, ModelAndViewContainer mavContainer,
			Object... providedArgs) throws Exception {
        //转化获取controller需要的值
		Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
		if (logger.isTraceEnabled()) {
			logger.trace("Invoking '" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) +
					"' with arguments " + Arrays.toString(args));
		}
        //通过反射调用bean的处理方法，拿到返回值
		Object returnValue = doInvoke(args);
		if (logger.isTraceEnabled()) {
			logger.trace("Method [" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) +
					"] returned [" + returnValue + "]");
		}
		return returnValue;
	}

上面的逻辑主要分为两步：

  1. 获取controller方法执行的参数
  2. 通过反射执行方法

接下来看下参数的获取过程：

	private Object[] getMethodArgumentValues(NativeWebRequest request, ModelAndViewContainer mavContainer,
			Object... providedArgs) throws Exception {
        //获取controller参数信息
		MethodParameter[] parameters = getMethodParameters();
		Object[] args = new Object[parameters.length];
		for (int i = 0; i < parameters.length; i++) {
			MethodParameter parameter = parameters[i];
			parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
			args[i] = resolveProvidedArgument(parameter, providedArgs);
			if (args[i] != null) {
				continue;
			}
            //查找该参数能支持的转化获取的类
			if (this.argumentResolvers.supportsParameter(parameter)) {
				try {//获取转化需要的值
					args[i] = this.argumentResolvers.resolveArgument(
							parameter, mavContainer, request, this.dataBinderFactory);
					continue;
				}
				catch (Exception ex) {
					if (logger.isDebugEnabled()) {
						logger.debug(getArgumentResolutionErrorMessage("Failed to resolve", i), ex);
					}
					throw ex;
				}
			}
			if (args[i] == null) {
				throw new IllegalStateException("Could not resolve method parameter at index " +
						parameter.getParameterIndex() + " in " + parameter.getMethod().toGenericString() +
						": " + getArgumentResolutionErrorMessage("No suitable resolver for", i));
			}
		}
		return args;
	}

这一步主要识别一些根据参数以及标记例如注解等来拿到 HandlerMethodArgumentResolver 对象，例如参数带了 @RequestJsonbody 会有一个专门的类RequestResponseBodyMethodProcessor 来获取参数，带了@RequestParam 会有RequestParamMethodArgumentResolver类来获取参数。

还要一部就是在拿到返回值对返回值也有一个类似的转化的流程在

invokeAndHandle->this.returnValueHandlers.handleReturnValue

中，会调用

@Override
	public void handleReturnValue(Object returnValue, MethodParameter returnType,
			ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {

		HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);
		if (handler == null) {
			throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName());
		}
		handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
	}



	private HandlerMethodReturnValueHandler selectHandler(Object value, MethodParameter returnType) {
		boolean isAsyncValue = isAsyncReturnValue(value, returnType);
		for (HandlerMethodReturnValueHandler handler : this.returnValueHandlers) {
			if (isAsyncValue && !(handler instanceof AsyncHandlerMethodReturnValueHandler)) {
				continue;
			}
			if (handler.supportsReturnType(returnType)) {
				return handler;
			}
		}
		return null;
	}

这里如果通过拿到返回值得信息，例如注解，类等信息，决定拿到哪一个

HandlerMethodReturnValueHandler

来处理返回值。

 

以上就是主要的流程，回顾一下：

  1. 获取Servlet请求
  2. 获取请求 Url获取具体符合的方法集合
  3. 选取最优的方法
  4. 获取转换的Controller方法的执行参数
  5. 反射执行
  6. 获取结果，并且转换设置到Response中
qq_18634003
关注
专栏目录
【SpringMVC笔记08】SpringMVC执行流程介绍
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 CSDN 记录学习心得和笔记内容。
07-09 203
目录一、SpringMVC核心组件1.1、DispatcherServlet1.2、HandlerMapping1.3、HandlerAdapter1.4、Handler1.5、ViewResolver1.6、View二、SpringMVC执行流程2.1、执行流程2.2、SpringMVC执行流程源码解读SpringMVC框架，本质上就是Servlet，只不过SpringMVC框架对Servlet进行了封装，形成了很多的组件类，通过这些组件类的协调合作，从而实现。下面介绍一下SpringMVC框架中的核心组
SpringMVC DispatcherServlet执行流程及源码分析
什么都不会的小菜鸟
10-09 1175
你要知道的SpringMVC DispatcherServlet执行流程及源码分析都在这里转载请注明出处 http://www.jianshu.com/p/0f981efdfbbd本系列文章主要根据源码讲解SpringMVC的启动过程，以及相关重要组件的源码分析。阅读此系列文章需要具备Spring以及SpringMVC相关知识。本文将分以下几篇文章进行讲解，读者可按需查阅。 SpringMVC 启动
spring mvc 一次请求过程跟踪(一)
dydm_13128的专栏
09-02 2644
spring mvc 一次请求过程跟踪项目背景Spring Boot 主方法 import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication public class UploadA
springmvc的原理？springmvc的工作流程?springmvc的源码你看过吗？
冰蛙
07-30 239
首先请求到达核心控制器dispatcherServlet,dispatcherServlet会判断请求后缀是否满足格式要求,如果满足格式要求,会查询handlerMapping,查找对应的handler,调用handlerAdapter进行参数绑定等适配工作,之后调用具体的handler进行业务逻辑处理,返回一个modelAndView对象给dispatcherServlet。dispatcherServlet调用viewResolver进行视图解析渲染,然后返回给客户端(回答这些就足够了) Dispatc
springmvc工作流程以及相关源码解析
cb_lcl的博客
06-23 1173
springmvc经典流程图：图一图二SpringMVC流程1、  用户发送请求至前端控制器DispatcherServlet。web.xml中配置DispatcherServlet，如图：2、  DispatcherServlet收到请求调用HandlerMapping处理器映射器。HandlerMapping定义请求和处理程序对象之间的映射。其中： RequestMappingHandlerM...
springMVC工作流程及源码剖析
http://itzones.cn
07-05 1010
一、首先了解springMVC的组件定义及用途    1.DisPatcherServlet：前端控制器（不需要程序员开发）       用户请求到达前端控制器，它相当于MVC模式中的C（Controller），DispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，DispatcherServlet的存       在降低了组件之间的耦合性。
SpringMVC工作流程源码剖析
代码宇宙
03-14 534
原文链接： https://juejin.im/post/5e6b0ee3e51d4526f65cdb50. 0x0 先看名词 DispactherServlet：SpringMVC 的心脏，所有的请求从这里进入，也从这里出去 HandlerAdapter：请求处理器 HandlerMapping:请求和处理对象间的映射关系，可以理解为 地址 /api 对应 @RequestMapping("/...
看透springMvc源代码分析与实践 源码
12-06
《看透Spring MVC源代码分析与实践》是深入理解Spring MVC框架的重要参考资料，它通过源码解析帮助开发者深入了解Spring MVC的工作原理，提升开发和优化应用的能力。Spring MVC是Spring框架的一部分，专门负责处理...
SpringMVC源码深度解析
最新发布
weixin_56644618的博客
10-29 3109
springmvc的源码解析，建议收藏，多看几遍！！！
springMVC源码详解
11-23
《看透SpringMVC源代码分析与实践》这...总的来说，深入学习SpringMVC源码能够提升我们的技术水平，使我们在面对复杂业务场景时更有信心。《看透SpringMVC源代码分析与实践》这本书无疑是实现这一目标的重要参考资料。
SpringMVC学习笔记——运行流程及源码解析
shen的博客
08-10 520
流程图 源码解析
SpringMVC执行流程源码跟踪
lds的博客
09-03 297
前面过程省略。。。直接进入dispacherservlet： Httpservlet中的service方法执行； frameworkServlet中执行父类HttpServletBean的service方法： 执行dopost方法，调用processRequest方法：   调用dispacherservlet的doDispacher方法： 获取处理器映射器： ...
ajax请求在springMvc里的执行顺序
成龙的博客
07-26 679
Filter start Interceptor preHandle RequestBodyAdvice supports RequestBodyAdvice beforeBodyRead RequestBodyAdvice supports RequestBodyAdvice afterBodyRead controller 方法上的自定义切面 执行 controller 方法执行 Respon...
spring-mvc
u014605300的博客
01-16 299
3.1、DispatcherServlet作用 DispatcherServlet是前端控制器设计模式的实现，提供Spring Web MVC的集中访问点，而且负责职责的分派，而且与Spring IoC容器无缝集成，从而可以获得Spring的所有好处。 具体请参考第二章的图2-1。 DispatcherServlet主要用作职责调度工作，本身主要用于控制流程，主要职责如下： ...
DispatchServlet
开心的哈士奇
12-01 5691
介绍 dispatchServlet 俗称前端控制器，springmvc处理一切前端请求的入口所在，包括两个部分 Servlet WebApplicationContext和Root WebApplicationContext 官方图片如下： DispatchServlet注解式配置 在servlet2.5 时，原有的配置是在web.xml中定义的，定义如下： &amp;amp;lt;web-app&amp;amp;gt; ...
Springmvc中的DispatcherServerlet粗略分析(springboot 1.4.0.RELEASE)
qq_19711059的博客
05-23 1444
一.根据DispatcherServlet中的注释说明这个servlet用来调用handlers/controllers,springmvc中指的就是Controller,首先这个类对象初始化的时候会加载servlet使用到的所有组件  /** * This implementation calls {@link #initStrategies}. */ @Override protec
DispatcherServerlet的作用
胃病的不良少彦
10-16 1368
DispatcherServlet是前置控制器，配置在web.xml文件中的。 拦截匹配的请求，Servlet拦截匹配规则要自已定义，把拦截下来的请求， 依据相应的规则分发到目标Controller来处理，是配置spring MVC的第一步。 springWebMVC处理Http请求的大致过程： 一旦Http请求到来，DispatcherSevlet将负责将请求分发。 Dispatcher...
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
spring MVC原理
yingxiongtnt的专栏
04-13 1016
Spring MVC工作流程图   图一   图二   Spring工作流程描述 1. 用户向服务器发送请求，请求被Spring 前端控制Servelt DispatcherServlet捕获； 2.DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI）。然后根据该URI，调用HandlerMapping获得该Handler配置的所有相关...
基于角色的权限控制在springMVC框架中的实现
weixin_34302798的博客
01-11 178
2019独角兽企业重金招聘Python工程师标准>>> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值