handleMapping handlerMapping和Handler Adatper

目录

• HandlerMapping
• HandlerExecutionChain
• handler
• HandlerAdapter
• DispatcherServlet和HandlerAdaptor的关系
• 深入了解Handler

• HandlerMapping负责查找相应的Handler以处理Web请求

• 深入理解HandlerAdapter

• SimpleServletHandlerAdapter
• SimpleControllerHandlerAdapter
• HttpRequestHandlerAdapter
• AbstractHandlerMethodAdapter

• 源码总结加载HandlerAdaptor

• 初始化HandlerMapping
• 总结加载HandlerAdapter

• 总结

HandlerMapping

处理器映射。看下官方文档中的解释：

由定义请求和处理程序对象之间的映射的对象实现的接口。
这个类可以由应用程序开发人员实现，尽管这不是必需的，因为 org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping 和 org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping 都包含在框架中。如果在应用程序上下文中没有注册 HandlerMapping bean，则前者是默认值。
HandlerMapping 实现可以支持映射拦截器，但不是必须的。处理程序将始终包装在 HandlerExecutionChain 实例中，可选地伴随一些 HandlerInterceptor 实例。 DispatcherServlet 将首先按给定顺序调用每个 HandlerInterceptor 的 preHandle 方法，如果所有 preHandle 方法都返回 true，则最后调用处理程序本身。
参数化这个映射的能力是这个 MVC 框架的一个强大而不同寻常的能力。例如，可以根据会话状态、cookie 状态或许多其他变量编写自定义映射。似乎没有其他 MVC 框架具有同样的灵活性。
注意：实现可以实现 org.springframework.core.Ordered 接口，以便能够指定排序顺序，从而指定 DispatcherServlet 应用的优先级。无序实例被视为最低优先级。

作用：

• 1、让HandlerMapping找到处理当前请求的对象，这个对象叫做handler；
• 2、HandlerMapping是可以有顺序的进行选择（实现Ordered接口）

在当期接口中，有一个重要方法：

public interface HandlerMapping {
  // 根据当前请求找到能够处理的HandlerExecutionChain
  HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;
}

HandlerExecutionChain

而在HandlerExecutionChain类中，可以看到当前类中的重点：

public class HandlerExecutionChain {
	..........
      
	private final Object handler;

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

HandlerExecutionChain是由handler（处理器）和interceptorList（拦截器集合）。

handler

在Spring MVC中，任何可以用于Web请求处理的处理对象统称为Handler。Controller是Handler的一种特殊类型。

HandlerMapping通过HandlerExecutionChain所返回的是一个Object类型的Handler对象，而并没限定说只能是Controller类型。

所以，一般意义上讲，任何类型的Handler都可以在Spring MVC中使用，比如Struts的Action和WebWork的Action等，只要它们是用于处理Web请求的处理对象就行。

不过，对于DispatcherServlet来说，这就有点儿问题了，它如何来判断我们到底使用的是什么类型的Handler,又如何决定调用Handler对象的哪个方法来处理Web请求呢？

显然，在DispatcherServlet直接硬编码if-else来枚举每一种可能的Handler类型是不具任何扩展性的。

为了能够以统一的方式调用各种类型的Handler,DispatcherServlet将不同Handler的调用职责转交给了一个称为HandlerAdaptor的角色。

HandlerAdapter

public interface HandlerAdapter {
	boolean supports(Object handler);
	
	@Nullable
	ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
	
	@Deprecated
	long getLastModified(HttpServletRequest request, Object handler);
}

HandlerAdaptor将作为一个适配器，屏蔽不同Handler类型给DispatcherServlet)所造成的“困扰”**。这也是适配器模式存在的意义。

HandlerAdapter得以成为DispatcherServlet和不同Handler的“中间人”，要归功于它的两个主要方法，即supports(…)和handle(…)。

至于getLastModified(…)方法，它的主要目的只是为返回给客户端的Last-Modified这个HTTP头提供相应的时间值。如果我们不想支持该功能，直接返间-1即可。

DispatcherServlet从HandlerMapping获得一个Handler之后，将询问HandlerAdaptor的supports(…)方法，以便了解当前HandlerAdaptor是否支持HandlerMapping刚刚返回的Handler类型的调用

....
                // 获取得到handler
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null) {
					noHandlerFound(processedRequest, response);
					return;
				}
                ....
				//寻找上面返回的handler对应的HandlerAdapter 
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

如果supports(…)返回true,DispatcherServlet则调用HandlerAdaptor的Handle方法，同时将刚才的Handler作为参数传入。

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
  if (this.handlerAdapters != null) {
    for (HandlerAdapter adapter : this.handlerAdapters) {
      if (adapter.supports(handler)) {
        return adapter;
      }
    }
  }
  throw new ServletException("No adapter for handler [" + handler +
                             "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
}

方法执行后将返回ModelAndview,之后的工作就由ViewResolver接手了。

// 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 = HttpMethod.GET.matches(method);
				if (isGet || HttpMethod.HEAD.matches(method)) {
					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
						return;
					}
				}

				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}

				//通过HandlerAdapter的handle方法返回一个ModelAndView
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

DispatcherServlet和HandlerAdaptor的关系

DispatcherServlet只需要面对HandlerAdaptor提供的统一接口，而不需要面对纷繁复杂的Handler类型。支持新的Handler类型，意味着只需要为DispatcherServlet提供新的HandlerAdaptor实现即可。

DispatcherServlet借助多个HandlerAdaptor,调用当前HandlerMapping所返回的Handler:来处理Web请求的逻辑。

所以无论我们想在Spring MVC中使用什么类型的Handler,只要同时为DispatcherServlet:提供对应该Handler的HandlerAdaptor实现就行，DispatcherServlet无须任何变动。

我想，HandlerAdaptor存在的原因我们已经搞清楚了，但还有一些问题不明，比如：

• 1、如果Controller只是一种特殊类型的Handler,那么Spring MVC是否还提供了其他可用的Handler类型呢？如果要提供我们自己的Handler类型又需要考虑哪些事情呢？
• 2、如何实现一个具体的HandlerAdaptor? Spring MVC有提供现成的实现吗？
• 3、如果想使用自定义的Handler,并且提供了对应的HandlerAdaptor实现，要通过什么方式告知DispatcherServlet来使用它们？

我想只有解开以上问题的答案才能帮助我们更深刻地理解Handler与HandlerAdaptor之间的关系。

深入了解Handler

到目前为止，我们使用最多的Handler就是Controller。不过，如果Controller不合我们的口味的话，我们也可以使用Spring MVC提供的其他类型的Handler,甚至于自定义Handler类型。

可以说，自定义Handler对于Handler类型来说并没任何限制，任何我们喜欢的形式都可以。如果不喜欢Controller,那么可以定义自己的MyHandler,甚至不需要强制Handler实现任何接口，仅是一个简单的POJO对象，只要能有办法知道该类就是用于Web请求处理的Handler类就行，比如用注解标注一下，然后通过反射机制就能获知哪些对象是用于Web请求处理的Handler,如下所示：

@Handler
public class AnyType{}

虽说对Handler自身没有任何限制，但是要让我们的Handler登上“历史舞台”发挥它的作用，却需要有能够给予帮助的“左膀右臂”，为我们的Handler提供必要的HandlerMapping和HandlerAdaptor,这才是真正让Handler自身没有任何限制的原因所在。

HandlerMapping负责查找相应的Handler以处理Web请求

protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
		if (this.handlerMappings != null) {
			for (HandlerMapping mapping : this.handlerMappings) {
				HandlerExecutionChain handler = mapping.getHandler(request);
				if (handler != null) {
					return handler;
				}
			}
		}
		return null;
	}

可以看到每种HandlerMapping得到的handler是不同的。

看下org.springframework.web.servlet.handler.AbstractHandlerMapping#getHandler中的实现过程：

这里就是为了满足各种各样的handlermapping映射的handler的。

要想使用Handler,首先需要提供一个能够识别该Handler的HandlerMapping实现。比如，无论是BeanNameUrlHandlerMapping还是SimpleUrlHandlerMapping,它们都可以获取并返回Controller类型的Handler.。

如果可以通过BeanNameUrlHandlerMapping或者SimpleUrlHandlerMapping告知DispatcherServlet我们的Handler存在的话，那还好。否则，我们就不得不提供一个能够识别我们自己Handler类型的HandlerMapping。

现在HandlerMapping返回了我们自定义的Handler,但DispatcherServlet本身显然是不管我们的Handlerl到底是何方人物的。为了让我们的Handler得以被DispatcherServlet所“青睐”，我们不得不提供一个HandlerAdaptor。实际上，并非只有我们的自定义Handler要“受此礼遇”，所有SpringMVC框架内的Handler都提供有相对应的HandlerAdaptor实现，如下所述：

• Controller 将 org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter作为其HandlerAdaptor。
• Spring2.5新添加的基于注解的Handler由org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter作为其HandlerAdaptor。

深入理解HandlerAdapter

可以直接去看下当前spring版本中的HandlerAdapter中的实现类

即可进去看一下根据HandlerAdapter找到的handler是如何来进行处理的。

主要工作只是调用这个HandlerAdaptor“认识”的Handler的Web请求处理方法，然后将处理结果转换为DispatcherServlet统一使用的ModelAndview就行。

SimpleServletHandlerAdapter

直接利用service来进行处理

public class SimpleServletHandlerAdapter implements HandlerAdapter {
	
	@Override
	public boolean supports(Object handler) {
		return (handler instanceof Servlet);
	}

	@Override
	@Nullable
	public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		((Servlet) handler).service(request, response);
		return null;
	}

	@Override
	public long getLastModified(HttpServletRequest request, Object handler) {
		return -1;
	}

}

SimpleControllerHandlerAdapter

实现了controller接口的类来进行处理

public class SimpleControllerHandlerAdapter implements HandlerAdapter {

	@Override
	public boolean supports(Object handler) {
		return (handler instanceof Controller);
	}

	@Override
	@Nullable
	public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		return ((Controller) handler).handleRequest(request, response);
	}

	@Override
	public long getLastModified(HttpServletRequest request, Object handler) {
		if (handler instanceof LastModified) {
			return ((LastModified) handler).getLastModified(request);
		}
		return -1L;
	}

}

HttpRequestHandlerAdapter

public class HttpRequestHandlerAdapter implements HandlerAdapter {

	@Override
	public boolean supports(Object handler) {
		return (handler instanceof HttpRequestHandler);
	}

	@Override
	@Nullable
	public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		((HttpRequestHandler) handler).handleRequest(request, response);
		return null;
	}

	@Override
	public long getLastModified(HttpServletRequest request, Object handler) {
		if (handler instanceof LastModified) {
			return ((LastModified) handler).getLastModified(request);
		}
		return -1L;
	}

}

AbstractHandlerMethodAdapter

处理的handler是HandlerMethod类型的

public abstract class AbstractHandlerMethodAdapter extends WebContentGenerator implements HandlerAdapter, Ordered {

	private int order = Ordered.LOWEST_PRECEDENCE;


	public AbstractHandlerMethodAdapter() {
		// no restriction of HTTP methods by default
		super(false);
	}

	public void setOrder(int order) {
		this.order = order;
	}

	@Override
	public int getOrder() {
		return this.order;
	}

	@Override
	public final boolean supports(Object handler) {
		return (handler instanceof HandlerMethod && supportsInternal((HandlerMethod) handler));
	}

	/**
	 * Given a handler method, return whether or not this adapter can support it.
	 * @param handlerMethod the handler method to check
	 * @return whether or not this adapter can adapt the given method
	 */
	protected abstract boolean supportsInternal(HandlerMethod handlerMethod);

	/**
	 * This implementation expects the handler to be an {@link HandlerMethod}.
	 */
	@Override
	@Nullable
	public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		return handleInternal(request, response, (HandlerMethod) handler);
	}

	/**
	 * Use the given handler method to handle the request.
	 * @param request current HTTP request
	 * @param response current HTTP response
	 * @param handlerMethod handler method to use. This object must have previously been passed to the
	 * {@link #supportsInternal(HandlerMethod)} this interface, which must have returned {@code true}.
	 * @return a ModelAndView object with the name of the view and the required model data,
	 * or {@code null} if the request has been handled directly
	 * @throws Exception in case of errors
	 */
	@Nullable
	protected abstract ModelAndView handleInternal(HttpServletRequest request,
			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception;

	/**
	 * This implementation expects the handler to be an {@link HandlerMethod}.
	 */
	@Override
	public final long getLastModified(HttpServletRequest request, Object handler) {
		return getLastModifiedInternal(request, (HandlerMethod) handler);
	}

	/**
	 * Same contract as for {@link javax.servlet.http.HttpServlet#getLastModified(HttpServletRequest)}.
	 * @param request current HTTP request
	 * @param handlerMethod handler method to use
	 * @return the lastModified value for the given handler
	 */
	protected abstract long getLastModifiedInternal(HttpServletRequest request, HandlerMethod handlerMethod);

}

源码总结加载HandlerAdaptor

首先来到org.springframework.web.servlet.HttpServletBean#init，因为HttpServletBean实现了HttpServlet接口，所以在Tomcat服务器在启动的时候执行这个方法

// Let subclasses do whatever initialization they like.
		initServletBean();

在org.springframework.web.servlet.FrameworkServlet#initServletBean方法中会调用：

this.webApplicationContext = initWebApplicationContext();

来进行处理初始化容器之外，还会调用org.springframework.web.servlet.FrameworkServlet#onRefresh

看一下实现：

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

具体的实现过程：

/**
	 * Initialize the strategy objects that this servlet uses.
	 * <p>May be overridden in subclasses in order to initialize further strategy objects.
	 */
	protected void initStrategies(ApplicationContext context) {
        // 初始化文件解析器
		initMultipartResolver(context);
		initLocaleResolver(context);
        //解析器
		initThemeResolver(context);
        // 初始化重点HandlerMapping和HandlerAdapter
		initHandlerMappings(context);
		initHandlerAdapters(context);
        // 初始化异常解析器
		initHandlerExceptionResolvers(context);
		initRequestToViewNameTranslator(context);
        // 初始化视图解析器
		initViewResolvers(context);
		initFlashMapManager(context);
	}

初始化HandlerMapping

// 如果没有找到HandlerMapping类型的bean，这里默认使用BeanNameUrlHandlerMapping
	/**
	 * Initialize the HandlerMappings used by this class.
	 * <p>If no HandlerMapping beans are defined in the BeanFactory for this namespace,
	 * we default to BeanNameUrlHandlerMapping.
	 */
private void initHandlerMappings(ApplicationContext context) {
  this.handlerMappings = null;

  // 默认为true，表示检查所有HandlerMapping的bean
  if (this.detectAllHandlerMappings) {
    // Find all HandlerMappings in the ApplicationContext, including ancestor contexts.
    Map<String, HandlerMapping> matchingBeans =
      BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
    if (!matchingBeans.isEmpty()) {
      this.handlerMappings = new ArrayList<>(matchingBeans.values());
      // 开始根据sort接口来进行排序
      // We keep HandlerMappings in sorted order.
      AnnotationAwareOrderComparator.sort(this.handlerMappings);
    }
  }
  else {
    try {
      HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
      this.handlerMappings = Collections.singletonList(hm);
    }
    catch (NoSuchBeanDefinitionException ex) {
      // Ignore, we'll add a default HandlerMapping later.
    }
  }
  // 如果为空，那么就根据默认策略是寻找springmvc自带的
  // Ensure we have at least one HandlerMapping, by registering
  // a default HandlerMapping if no other mappings are found.
  if (this.handlerMappings == null) {
    this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
    if (logger.isTraceEnabled()) {
      logger.trace("No HandlerMappings declared for servlet '" + getServletName() +
                   "': using default strategies from DispatcherServlet.properties");
    }
  }

  for (HandlerMapping mapping : this.handlerMappings) {
    if (mapping.usesPathPatterns()) {
      this.parseRequestPath = true;
      break;
    }
  }
}

看下具体的实施措施：

这里传进来的参数是HandlerMapping类型的

protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
		if (defaultStrategies == null) {
			try {
				// Load default strategy implementations from properties file.
				// This is currently strictly internal and not meant to be customized
				// by application developers.
				ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
				defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
			}
			catch (IOException ex) {
				throw new IllegalStateException("Could not load '" + DEFAULT_STRATEGIES_PATH + "': " + ex.getMessage());
			}
		}

		String key = strategyInterface.getName();
		String value = defaultStrategies.getProperty(key);
		if (value != null) {
            // 又遇到了，按照,进行分割
			String[] classNames = StringUtils.commaDelimitedListToStringArray(value);
			List<T> strategies = new ArrayList<>(classNames.length);
			for (String className : classNames) {
				try {
					Class<?> clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());
					Object strategy = createDefaultStrategy(context, clazz);
					strategies.add((T) strategy);
				}
				catch (ClassNotFoundException ex) {
					throw new BeanInitializationException(
							"Could not find DispatcherServlet's default strategy class [" + className +
							"] for interface [" + key + "]", ex);
				}
				catch (LinkageError err) {
					throw new BeanInitializationException(
							"Unresolvable class definition for DispatcherServlet's default strategy class [" +
							className + "] for interface [" + key + "]", err);
				}
			}
			return strategies;
		}
		else {
			return Collections.emptyList();
		}
	}

对应的在springmvc依赖下面的

所以默认会有三种来进行加载进来。

也就是说，如果使用的Handler是现有Handler类型，那么无须在DispatcherServlet的WebApplicationContext中做任何配置，默认的HandlerAdaptor已经足够了。不过，如果需要添加这些HandlerAdaptor类型之外的HandlerAdaptor实现，并且我们依然希望同时使用这些默认HandlerAdaptor所支持的Handler的话，那就需要在添加我们的自定义HandlerAdaptor的基础上，同时添加以上几种默认的HandlerAdaptor实现。

总结加载HandlerAdapter

和上面是一样的套路。

总结

1、首先加载得到HandlerMapping和HandlerAdapter类型的bean；

2、当请求来临的时候，调用HandlerMapping找到对应的handler；

3、通过HandlerAdapter调用对应的handler返回响应结果值；