SpringMVC处理方法的具体逻辑

在讲解SpringMVC整体设计的时候，我们只分析了最顶层的核心接口，但是SpringMVC还有很多可以去探究的细节，还有很多我们可以扩展的接口，我们继续来深入学习SpringMVC。

在整体设计分析中，我们知道一个Web请求进来时依靠HandlerMapping来找到正确的Controller以及Controller下对应的@RequestMapping注解修饰的方法的。而具体的方法处理的逻辑是由HandlerAdapter实现类来完成的（一般都是RequestMappingHandlerAdapter）。

RequestMappingHandlerAdapter

必须要从顶层HandlerAdapter接口说起，SpringMVC在这块的设计我觉得非常好，我自己本人在项目开发中也借鉴了这种设计，我觉得看源码还是很有好处的，不仅让你了解原理，还能学习到很好的设计理念，话不多说，开始进行分析。

public interface HandlerAdapter {
    //实现类实现该方法来确定实现类处理哪种类型的数据
	boolean supports(Object handler);
    //实现类实现该方法来完成具体的处理逻辑
	ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
	long getLastModified(HttpServletRequest request, Object handler);

}

RequestMappingHandlerAdapter并不是直接实现了HandlerAdapter，而是继承了AbstractHandlerMethodAdapter这个抽象类，HandlerAdapter接口就是这个抽象类实现的。这里的设计就是典型的模板方法设计模式了。

public abstract class AbstractHandlerMethodAdapter extends WebContentGenerator implements HandlerAdapter, Ordered{
    @Override
	public final boolean supports(Object handler) {
        //必须要是HandlerMethod类型，但是其他的限制条件就让子类自由发挥。
		return (handler instanceof HandlerMethod && supportsInternal((HandlerMethod) handler));
	}
    	protected abstract boolean supportsInternal(HandlerMethod handlerMethod);
@Override
	public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		return handleInternal(request, response, (HandlerMethod) handler);
	}
	protected abstract ModelAndView handleInternal(HttpServletRequest request,
			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception;
}

标准的模板方法模式，supports方法和handle方法都使用了final来修饰，子类不能重写这两个方法。同时，定义了两个抽象方法，让实现类在符合我这个抽象类定义的规范下，可以对具体的逻辑进行自由发挥。

现在我们来看下RequestMappingHandlerAdapter

public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
		implements BeanFactoryAware, InitializingBean {
@Override
	protected boolean supportsInternal(HandlerMethod handlerMethod) {
		return true;
	}

	@Override
	protected ModelAndView handleInternal(HttpServletRequest request,
			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

		ModelAndView mav;
		checkRequest(request);

		// Execute invokeHandlerMethod in synchronized block if required.
		if (this.synchronizeOnSession) {
			HttpSession session = request.getSession(false);
			if (session != null) {
				Object mutex = WebUtils.getSessionMutex(session);
				synchronized (mutex) {
					mav = invokeHandlerMethod(request, response, handlerMethod);
				}
			}
			else {
				// No HttpSession available -> no mutex necessary
				mav = invokeHandlerMethod(request, response, handlerMethod);
			}
		}
		else {
			// No synchronization on session demanded at all...
			mav = invokeHandlerMethod(request, response, handlerMethod);
		}

		if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
			if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
				applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
			}
			else {
				prepareResponse(response);
			}
		}

		return mav;
	}
}

我们看到这个类实现了BeanFactoryAware, InitializingBean接口，立马就想到这个类在Spring环境中初始化的时候，是会做一些动作的，具体做什么，我们后续再细说。

我们先看对两个抽象方法的实现，主要看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);
			invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
			invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
			invocableMethod.setDataBinderFactory(binderFactory);
			invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);

			ModelAndViewContainer mavContainer = new ModelAndViewContainer();
	//省略大段代码
			invocableMethod.invokeAndHandle(webRequest, mavContainer);
			if (asyncManager.isConcurrentHandlingStarted()) {
				return null;
			}

			return getModelAndView(mavContainer, modelFactory, webRequest);
		}
		finally {
			webRequest.requestCompleted();
		}
	}

省略了大段代码，只留我们想要的部分：

1.构建一个ServletWebRequest对象。

2.创建一个ServletInvocableHandlerMethod对象，并且设置各种属性值。ServletInvocableHandlerMethod对象设置的很多属性，包括argumentResolvers(用来处理方法参数的工具类集合)和returnValueHandlers(用来处理返回值的工具类集合)

3.调用invocableMethod.invokeAndHandle(webRequest, mavContainer);方法，该方法将对Controller方法进行处理。

4.返回一个ModelAndView对象。

invokeAndHandle

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

1.调用invokeForRequest方法得到Controller中方法的返回值

2.使用returnValueHandlers中符合条件的HandlerMethodReturnValueHandler对返回值进行处理。

invokeForRequest方法中主要就是调用了getMethodArgumentValues()方法来获取到参数，然后再执行Controller中方法。

获取参数的方法最终是调用合适的HandlerMethodArgumentResolver实现类来处理参数。

this.argumentResolvers.resolveArgument(
							parameter, mavContainer, request, this.dataBinderFactory);
						

关于argumentResolvers和returnValueHandlers,上面有提过一下，我们来看下他到底是什么。

之前我们已经知道了RequestMappingHandlerAdapter实现了InitializingBean，所以在初始化的时候，会执行afterPropertiesSet()方法，来看下这个方法。

@Override
	public void afterPropertiesSet() {
		// Do this first, it may add ResponseBody advice beans
		initControllerAdviceCache();

		if (this.argumentResolvers == null) {
			List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
			this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
		}
		if (this.initBinderArgumentResolvers == null) {
			List<HandlerMethodArgumentResolver> resolvers = getDefaultInitBinderArgumentResolvers();
			this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
		}
		if (this.returnValueHandlers == null) {
			List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
			this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
		}
	}

1.首先初始化Spring环境中的所有ControllerAdviceBean，吧符合条件的Bean集合赋给requestResponseBodyAdviceBeans属性。这个在提消息转换器的时候会具体说。

2.接着对argumentResolvers属性赋值，一般情况下都是调用getDefaultArgumentResolvers()方法，获取到HandlerMethodArgumentResolver实现类集合，然后将集合放入到HandlerMethodArgumentResolverComposite类中，该类就是负责收集HandlerMethodArgumentResolver实现类以及完成筛选出合适的HandlerMethodArgumentResolver实现类来处理参数的工作，

3.对initBinderArgumentResolvers赋值，逻辑同上。

4.对returnValueHandlers赋值，逻辑同上。

分析到这里，我们知道了对Controller方法参数的处理是由HandlerMethodArgumentResolver实现类来完成的，对Controller方法返回值是通过HandlerMethodReturnValueHandler实现类来完成的。

public interface HandlerMethodArgumentResolver {


	
	boolean supportsParameter(MethodParameter parameter);


	Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception;

}

定义了两个方法，supportsParameter是让实现类定义支持处理的参数类型，resolveArgument是让实现类定义处理参数的具体逻辑。

常用的HandlerMethodArgumentResolver实现类可以通过RequestMappingHandlerAdapter#getDefaultArgumentResolvers()看到。这些实现类的源码大家有兴趣的话可以看看。 我们在Controller方法中经常会使用这几个注解：@RequestParam,@PathVariable,@RequestBody。

这些注解的意义就是让SpringMVC在处理方法的参数的时候找到合适的处理类来处理参数。

HandlerMethodReturnValueHandler接口与HandlerMethodArgumentResolver思路是一样的，SpringMVC中充满了这种设计，接口的设计都会提供两个方法，一个定义支持处理的数据类型，一个定义处理的具体逻辑。