SpringMVC源码浅析

SpringMVC源码浅析

核心组件：DispatcherServlet、HandlerMapping、HandlerAdapter、ModelAndView

DispatcherServlet负责请求的分发(doDispatch)。

// DispatcherServlet 继承层级关系 
DispatcherServlet (org.springframework.web.servlet) // doService -> doDispatch -> getHandler
    FrameworkServlet (org.springframework.web.servlet)// 重写了doGet等方法，调用processRequest -> doService
        ApplicationContextAware (org.springframework.context)
            Aware (org.springframework.beans.factory)
        HttpServletBean (org.springframework.web.servlet)
            EnvironmentAware (org.springframework.context)
                Aware (org.springframework.beans.factory)
            EnvironmentCapable (org.springframework.core.env)
            HttpServlet (javax.servlet.http)//定义了doGet、doPost等方法
                GenericServlet (javax.servlet)
                    Object (java.lang)
                    Serializable (java.io)
                    Servlet (javax.servlet)
                    ServletConfig (javax.servlet)

DispatchServlet中getHandler 方法浅析

// private List<HandlerMapping> handlerMappings; 
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    if (this.handlerMappings != null) {
        for (HandlerMapping mapping : this.handlerMappings) {
             //这个getHandler方法实现于：AbstractHandlerMapping，内部又调用了getHandlerInternal(抽象方法)
            // getHandlerInternal具体实现于：AbstractHandlerMethodMapping，这个方法主要返回了HandlerMathod对象
            HandlerExecutionChain handler = mapping.getHandler(request);
            if (handler != null) {
                return handler;
            }
		}
    }

    return null;
}

@Override
@Nullable
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
	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 = obtainApplicationContext().getBean(handlerName);
	}

	HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);

	if (logger.isTraceEnabled()) {
		logger.trace("Mapped to " + handler);
	}
	else if (logger.isDebugEnabled() && !request.getDispatcherType().equals(DispatcherType.ASYNC)) {
		logger.debug("Mapped to " + executionChain.getHandler());
	}

	if (hasCorsConfigurationSource(handler) || CorsUtils.isPreFlightRequest(request)) {
		CorsConfiguration config = getCorsConfiguration(handler, request);
		if (getCorsConfigurationSource() != null) {
			CorsConfiguration globalConfig = getCorsConfigurationSource().getCorsConfiguration(request);
			config = (globalConfig != null ? globalConfig.combine(config) : config);
		}
		if (config != null) {
			config.validateAllowCredentials();
		}
		executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
	}

	return executionChain;
}

@Override
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
	String lookupPath = initLookupPath(request);
	this.mappingRegistry.acquireReadLock();
	try {
		HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
		return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
	}
	finally {
		this.mappingRegistry.releaseReadLock();
	}
}

class MappingRegistry {

		private final Map<T, MappingRegistration<T>> registry = new HashMap<>();

		private final MultiValueMap<String, T> pathLookup = new LinkedMultiValueMap<>();

		private final Map<String, List<HandlerMethod>> nameLookup = new ConcurrentHashMap<>();

		private final Map<HandlerMethod, CorsConfiguration> corsLookup = new ConcurrentHashMap<>();

		private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
		
    	//其余方法省略....
}

static class MappingRegistration<T> {

		private final T mapping;

		private final HandlerMethod handlerMethod;

		private final Set<String> directPaths;

		@Nullable
		private final String mappingName;

		public MappingRegistration(T mapping, HandlerMethod handlerMethod,
				@Nullable Set<String> directPaths, @Nullable String mappingName) {

			Assert.notNull(mapping, "Mapping must not be null");
			Assert.notNull(handlerMethod, "HandlerMethod must not be null");
			this.mapping = mapping;
			this.handlerMethod = handlerMethod;
			this.directPaths = (directPaths != null ? directPaths : Collections.emptySet());
			this.mappingName = mappingName;
		}

		public T getMapping() {
			return this.mapping;
		}

		public HandlerMethod getHandlerMethod() {
			return this.handlerMethod;
		}

		public Set<String> getDirectPaths() {
			return this.directPaths;
		}

		@Nullable
		public String getMappingName() {
			return this.mappingName;
		}
	}

RequestMappingHandlerMapping 继承了AbstractHandlerMapping和AbstractHandlerMethodMapping，AbstractHandlerMethodMapping中包含一个private final MappingRegistry mappingRegistry = new MappingRegistry();对象，该对象又包含一个private final Map<T, MappingRegistration<T>> registry = new HashMap<>();，注意到这个hashmap的value类型是MappingRegistration，内有private final HandlerMethod handlerMethod;这个handlerMethod就是保存了到底哪个控制器、控制器的哪个方法用来处理请求这样的具体信息（在ioc容器初始化时就完成扫描和初始化）。DispatcherServlet通过getHandler方法得到一个具体的HandlerExecutionChain，该对象内包含:

private final Object handler;

private final List<HandlerInterceptor> interceptorList = new ArrayList<>();

通过debug之后发现，handler最终是HandlerMethod类型的；另外内还有一系列的拦截器组成的list。

通过getAdpater方法，将HandlerExecutionChain中的handler传入，返回HandlerAdapter，之后执行对应控制器中的具体方法(handle方法运用Java的 反射机制执行controller的具体方法）将返回结果包装在ModelAndView中。

HandlerAdapter的具体子类：

SimpleControllerHandlerAdapter
SimpleServletHandlerAdapter
RequestMappingHandlerAdapter // 用于处理被 @RequestMapping 标注的方法或handler对象
HttpRequestHandlerAdapter

HandlerMapping的作用：

找到能处理请求的handler（具体某个Controller中的方法，封装到HandlerMethod中）

HandlerAdapter的作用：

将与请求对应的handler封装到支持handler的adapter中，同时定义了如何处理请求的策略，通过请求url、请求Method和处理器的requestMapping定义，最终确定使用handler类的哪个方法来处理请求，并检查处理类相应处理方法的参数以及相关的Annotation配置，确定如何转换需要的参数传入调用方法，并最终利用反射的方式执行具体处理请求的方法，返回ModelAndView。

拦截器的执行时机：

Controller 和 RestController 区别