`

Spring2.5源码解读 之 基于annotation的Controller实现原理分析(1)

SpringServlet正则表达式BeanIOC 
阅读更多

Spring2.5源码解读 之 基于annotation的Controller实现原理分析(1)

网上已有许多关于Spring源码解读的文章，但对于SpringMVC中基于annotation的Controller这一块，目前还没发现有相关源码解读的文章，这几天，一直在研究SpringMVC，小有所获。这里，对Spring中基于annotation的Controller的实现原理作下简单分析，作为以后学习的参考资料，如果有人也对此感兴趣，也欢迎一起研究，交流心得。

快速开始SpringMVC

1、导入核心JAR，有两种导入方式
   * 导入全部JAR：spring.jar
   * 导入最小JAR：spring-core、spring-beans、spring-context、spring-web、spring-webmvc
   第三方依赖JAR：commons-logging.jar
2、配置核心servlet：

Java代码 复制代码
  1. <servlet>   
  2.     <servlet-name>SpringServlet</servlet-name>   
  3.     <servlet-class>   
  4.         org.springframework.web.servlet.DispatcherServlet   
  5.     </servlet-class>   
  6.     <load-on-startup>1</load-on-startup>   
  7. </servlet>   
  8. <servlet-mapping>   
  9.     <servlet-name>SpringServlet</servlet-name>   
  10.     <url-pattern>*.html</url-pattern>   
  11. </servlet-mapping>  
	<servlet>
		<servlet-name>SpringServlet</servlet-name>
		<servlet-class>
			org.springframework.web.servlet.DispatcherServlet
		</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>SpringServlet</servlet-name>
		<url-pattern>*.html</url-pattern>
	</servlet-mapping>



* 3、配置包扫描列表
  在[servlet-name]-servlet中配置：

Java代码 复制代码
  1. <context:component-scan base-package="com.spring.test" />  
<context:component-scan base-package="com.spring.test" />



将所有基于annotation的handler放在test包下即可。

  相当简洁的配置，体现出了的Sping的强大、灵活，不过估计不会有人这样用Spring，呵呵

源码分析之旅：

SpringMVC的核心是DispatcherServlet，网上已经有对该类的简单分析，见后面参考资料。对于handler扫描、初始化映射关系等，以后有时间再详细解读，这里只是稍微提一下：
DispatcherServlet的初始化：

Java代码 复制代码
  1. protected void initStrategies(ApplicationContext context) {   
  2.     //方法入参为ApplicationContext，可证明在DispatcherServlet初始化之前，IoC容器已经开始工作了   
  3.     initMultipartResolver(context);   
  4.     initLocaleResolver(context);   
  5.     initThemeResolver(context);   
  6.     initHandlerMappings(context);   
  7.     initHandlerAdapters(context);   
  8.     initHandlerExceptionResolvers(context);   
  9.     initRequestToViewNameTranslator(context);   
  10.     initViewResolvers(context);   
  11. }  
	protected void initStrategies(ApplicationContext context) {
		//方法入参为ApplicationContext，可证明在DispatcherServlet初始化之前，IoC容器已经开始工作了
		initMultipartResolver(context);
		initLocaleResolver(context);
		initThemeResolver(context);
		initHandlerMappings(context);
		initHandlerAdapters(context);
		initHandlerExceptionResolvers(context);
		initRequestToViewNameTranslator(context);
		initViewResolvers(context);
	}



该初始方法主要完成两件工作：
* 1、将容器中配置（在applicationContext.xml中定义）的HandlerMapping、LocaleResolver等等初始化
* 2、如果容器中未配置，则使用默认策略，该默认策略定义在DispatcherServlet.properties文件中

这其中有几个比较重要的组件（也称管道）需要初始化，包括HandlerMapping、HandlerAdapter、ViewResolver。
HandlerMapping

我们从DispatcherServlet的doService方法入手：

Java代码 复制代码
  1. protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {   
  2.     ...   
  3.     //将WebApplicationContext放在了request中   
  4.     request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());   
  5.     request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);   
  6.     request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);   
  7.     request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());   
  8.   
  9.     try {   
  10.         doDispatch(request, response);   
  11.     }   
  12.     ...   
  13. }  
	protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
		...
		//将WebApplicationContext放在了request中
		request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
		request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
		request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
		request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());

		try {
			doDispatch(request, response);
		}
		...
	}



可以看出，对于请求的处理实际上是由doDispatch()完成的，这里只对与annotation相关的部分进行分析：

Java代码 复制代码
  1. protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {   
  2.   
  3.     ...        
  4.     try {   
  5.         ModelAndView mv = null;   
  6.         try {   
  7.             //查找匹配的handler   
  8.             mappedHandler = getHandler(processedRequest, false);   
  9.             if (mappedHandler == null || mappedHandler.getHandler() == null) {   
  10.                 //如果没有，写入404错误   
  11.                 noHandlerFound(processedRequest, response);   
  12.                 return;   
  13.             }   
  14.   
  15.             //调用handler的方法   
  16.             HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());   
  17.             mv = ha.handle(processedRequest, response, mappedHandler.getHandler());   
  18.     ...   
  19.   
  20. }  
	protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
	
		...		
		try {
			ModelAndView mv = null;
			try {
				//查找匹配的handler
				mappedHandler = getHandler(processedRequest, false);
				if (mappedHandler == null || mappedHandler.getHandler() == null) {
					//如果没有，写入404错误
					noHandlerFound(processedRequest, response);
					return;
				}

				//调用handler的方法
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
		...

	}



再来看查找handler的过程：

Java代码 复制代码
  1. protected HandlerExecutionChain getHandler(HttpServletRequest request, boolean cache) throws Exception {   
  2.     ...   
  3.     //初始时handlerMappings中有两个：   
  4.     //1、BeanNameUrlHandlerMapping：根据bean的名字查找匹配的handler，意味我们可以在容器中将bean名以url定义，如"/order/*"   
  5.     //2、DefaultAnnotationHandlerMapping：根据annotation定义查找   
  6.     //每个handlerMapping中都维持有一个url-handler的HashMap，该列表在生成在初始化时完成   
  7.     Iterator it = this.handlerMappings.iterator();   
  8.     while (it.hasNext()) {   
  9.         HandlerMapping hm = (HandlerMapping) it.next();   
  10.         ...   
  11.         handler = hm.getHandler(request);//实际的匹配过程交由handlerMapping完成   
  12.         ...   
  13.     }   
  14.     return null;   
  15. }  
	protected HandlerExecutionChain getHandler(HttpServletRequest request, boolean cache) throws Exception {
		...
		//初始时handlerMappings中有两个：
		//1、BeanNameUrlHandlerMapping：根据bean的名字查找匹配的handler，意味我们可以在容器中将bean名以url定义，如"/order/*"
		//2、DefaultAnnotationHandlerMapping：根据annotation定义查找
		//每个handlerMapping中都维持有一个url-handler的HashMap，该列表在生成在初始化时完成
		Iterator it = this.handlerMappings.iterator();
		while (it.hasNext()) {
			HandlerMapping hm = (HandlerMapping) it.next();
			...
			handler = hm.getHandler(request);//实际的匹配过程交由handlerMapping完成
			...
		}
		return null;
	}



实际查找handler的过程由DefaultAnnotationHandlerMapping类完成。从它的继承层次可以看出，匹配的主要工作都由其父类完成了。在父类中定义了算法的骨架，具体的处理交由子类完成，这是Templet设计模式的典型应用。[[BR]]

先看父类AbstractHandlerMapping中定义的算法骨架：

Java代码 复制代码
  1. public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {   
  2.     Object handler = getHandlerInternal(request);//交由子类实现   
  3.     if (handler == null) {   
  4.         handler = getDefaultHandler();   
  5.     }   
  6.     if (handler == null) {   
  7.         return null;   
  8.     }   
  9.   
  10.     if (handler instanceof String) {    //如果handler是String，即完整类名，在容器中定义   
  11.         String handlerName = (String) handler;   
  12.         handler = getApplicationContext().getBean(handlerName);//从IoC中直接获取   
  13.     }   
  14.     return getHandlerExecutionChain(handler, request);   
  15. }  
	public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
		Object handler = getHandlerInternal(request);//交由子类实现
		if (handler == null) {
			handler = getDefaultHandler();
		}
		if (handler == null) {
			return null;
		}

		if (handler instanceof String) {	//如果handler是String，即完整类名，在容器中定义
			String handlerName = (String) handler;
			handler = getApplicationContext().getBean(handlerName);//从IoC中直接获取
		}
		return getHandlerExecutionChain(handler, request);
	}



AbstractHandlerMapping的子类AbstractUrlHandlerMapping中getHandlerInternal的定义：

Java代码 复制代码
  1. protected Object getHandlerInternal(HttpServletRequest request) throws Exception {   
  2.   
  3.     Object handler = lookupHandler(lookupPath, request);   
  4.     if (handler == null) {   
  5.         ...   
  6.     }   
  7.     return handler;   
  8. }   
  9.   
  10. protected Object lookupHandler(String urlPath, HttpServletRequest request) throws Exception {   
  11.     // 直接匹配：   
  12.     Object handler = this.handlerMap.get(urlPath);   
  13.     if (handler != null) {   
  14.         validateHandler(handler, request);//@RequestMapping的其它属性匹配交由子类完成，如method和param的匹配   
  15.         return buildPathExposingHandler(handler, urlPath);   
  16.     }   
  17.     // 正则表达式匹配：   
  18.     String bestPathMatch = null;   
  19.     for (Iterator it = this.handlerMap.keySet().iterator(); it.hasNext();) {   
  20.         String registeredPath = (String) it.next();   
  21.         if (getPathMatcher().match(registeredPath, urlPath) &&   
  22.                 (bestPathMatch == null || bestPathMatch.length() < registeredPath.length())) {   
  23.             bestPathMatch = registeredPath;//可以看出，匹配原则是按照url更长则更匹配   
  24.         }   
  25.     }   
  26.     if (bestPathMatch != null) {   
  27.         handler = this.handlerMap.get(bestPathMatch);   
  28.         validateHandler(handler, request);//@RequestMapping的其它属性匹配交由子类完成，如method和param的匹配   
  29.         String pathWithinMapping = getPathMatcher().extractPathWithinPattern(bestPathMatch, urlPath);   
  30.         return buildPathExposingHandler(handler, pathWithinMapping);   
  31.     }   
  32.     // No handler found...   
  33.     return null;   
  34. }  
	protected Object getHandlerInternal(HttpServletRequest request) throws Exception {

		Object handler = lookupHandler(lookupPath, request);
		if (handler == null) {
			...
		}
		return handler;
	}

	protected Object lookupHandler(String urlPath, HttpServletRequest request) throws Exception {
		// 直接匹配：
		Object handler = this.handlerMap.get(urlPath);
		if (handler != null) {
			validateHandler(handler, request);//@RequestMapping的其它属性匹配交由子类完成，如method和param的匹配
			return buildPathExposingHandler(handler, urlPath);
		}
		// 正则表达式匹配：
		String bestPathMatch = null;
		for (Iterator it = this.handlerMap.keySet().iterator(); it.hasNext();) {
			String registeredPath = (String) it.next();
			if (getPathMatcher().match(registeredPath, urlPath) &&
					(bestPathMatch == null || bestPathMatch.length() < registeredPath.length())) {
				bestPathMatch = registeredPath;//可以看出，匹配原则是按照url更长则更匹配
			}
		}
		if (bestPathMatch != null) {
			handler = this.handlerMap.get(bestPathMatch);
			validateHandler(handler, request);//@RequestMapping的其它属性匹配交由子类完成，如method和param的匹配
			String pathWithinMapping = getPathMatcher().extractPathWithinPattern(bestPathMatch, urlPath);
			return buildPathExposingHandler(handler, pathWithinMapping);
		}
		// No handler found...
		return null;
	}



子类DefaultAnnotationHandlerMapping中@RequestMapping的匹配过程：

Java代码 复制代码
  1. protected void validateHandler(Object handler, HttpServletRequest request) throws Exception {   
  2.     RequestMapping mapping = this.cachedMappings.get(handler.getClass());   
  3.     if (mapping == null) {   
  4.         mapping = AnnotationUtils.findAnnotation(handler.getClass(), RequestMapping.class);   
  5.     }   
  6.     if (mapping != null) {   
  7.         validateMapping(mapping, request);//具体的匹配在validateMapping中完成   
  8.     }   
  9. }   
  10.   
  11. protected void validateMapping(RequestMapping mapping, HttpServletRequest request) throws Exception {   
  12.     RequestMethod[] mappedMethods = mapping.method();   
  13.   
  14.     //请求方法是否匹配？   
  15.     if (!ServletAnnotationMappingUtils.checkRequestMethod(mappedMethods, request)) {   
  16.         String[] supportedMethods = new String[mappedMethods.length];   
  17.         for (int i = 0; i < mappedMethods.length; i++) {   
  18.             supportedMethods[i] = mappedMethods[i].name();   
  19.         }   
  20.         throw new HttpRequestMethodNotSupportedException(request.getMethod(), supportedMethods);//直接就抛异常了？似乎不妥，为什么不尝试下一个比较匹配的那个URL呢？也有可能是父类的算法定义有问题   
  21.     }   
  22.   
  23.     //请求参数是否匹配？   
  24.     String[] mappedParams = mapping.params();   
  25.     if (!ServletAnnotationMappingUtils.checkParameters(mappedParams, request)) {   
  26.         throw new ServletException("Parameter conditions {" +   
  27.                 StringUtils.arrayToDelimitedString(mappedParams, ", ") +   
  28.                 "} not met for request parameters: " + request.getParameterMap());   
  29.     }   
  30. }  
	protected void validateHandler(Object handler, HttpServletRequest request) throws Exception {
		RequestMapping mapping = this.cachedMappings.get(handler.getClass());
		if (mapping == null) {
			mapping = AnnotationUtils.findAnnotation(handler.getClass(), RequestMapping.class);
		}
		if (mapping != null) {
			validateMapping(mapping, request);//具体的匹配在validateMapping中完成
		}
	}

	protected void validateMapping(RequestMapping mapping, HttpServletRequest request) throws Exception {
		RequestMethod[] mappedMethods = mapping.method();

		//请求方法是否匹配？
		if (!ServletAnnotationMappingUtils.checkRequestMethod(mappedMethods, request)) {
			String[] supportedMethods = new String[mappedMethods.length];
			for (int i = 0; i < mappedMethods.length; i++) {
				supportedMethods[i] = mappedMethods[i].name();
			}
			throw new HttpRequestMethodNotSupportedException(request.getMethod(), supportedMethods);//直接就抛异常了？似乎不妥，为什么不尝试下一个比较匹配的那个URL呢？也有可能是父类的算法定义有问题
		}

		//请求参数是否匹配？
		String[] mappedParams = mapping.params();
		if (!ServletAnnotationMappingUtils.checkParameters(mappedParams, request)) {
			throw new ServletException("Parameter conditions {" +
					StringUtils.arrayToDelimitedString(mappedParams, ", ") +
					"} not met for request parameters: " + request.getParameterMap());
		}
	}




请求方法及参数的匹配过程由ServletAnnotationMappingUtils类的静态方法完成，逻辑比较简单：

Java代码 复制代码
  1. public static boolean checkRequestMethod(RequestMethod[] methods, HttpServletRequest request) {   
  2.     if (!ObjectUtils.isEmpty(methods)) {   
  3.         boolean match = false;   
  4.         for (RequestMethod method : methods) {   
  5.             if (method.name().equals(request.getMethod())) {   
  6.                 match = true;   
  7.             }   
  8.         }   
  9.         if (!match) {   
  10.             return false;   
  11.         }   
  12.     }   
  13.     return true;   
  14. }   
  15.   
  16. public static boolean checkParameters(String[] params, HttpServletRequest request) {   
  17.     if (!ObjectUtils.isEmpty(params)) {   
  18.         for (String param : params) {   
  19.             int separator = param.indexOf('=');   
  20.             if (separator == -1) {   
  21.                 if (param.startsWith("!")) {   
  22.                     if (WebUtils.hasSubmitParameter(request, param.substring(1))) {   
  23.                         return false;   
  24.                     }   
  25.                 }   
  26.                 else if (!WebUtils.hasSubmitParameter(request, param)) {   
  27.                     return false;   
  28.                 }   
  29.             }   
  30.             else {   
  31.                 String key = param.substring(0, separator);   
  32.                 String value = param.substring(separator + 1);   
  33.                 if (!value.equals(request.getParameter(key))) {   
  34.                     return false;   
  35.                 }   
  36.             }   
  37.         }   
  38.     }   
  39.     return true;   
  40. }  
	public static boolean checkRequestMethod(RequestMethod[] methods, HttpServletRequest request) {
		if (!ObjectUtils.isEmpty(methods)) {
			boolean match = false;
			for (RequestMethod method : methods) {
				if (method.name().equals(request.getMethod())) {
					match = true;
				}
			}
			if (!match) {
				return false;
			}
		}
		return true;
	}

	public static boolean checkParameters(String[] params, HttpServletRequest request) {
		if (!ObjectUtils.isEmpty(params)) {
			for (String param : params) {
				int separator = param.indexOf('=');
				if (separator == -1) {
					if (param.startsWith("!")) {
						if (WebUtils.hasSubmitParameter(request, param.substring(1))) {
							return false;
						}
					}
					else if (!WebUtils.hasSubmitParameter(request, param)) {
						return false;
					}
				}
				else {
					String key = param.substring(0, separator);
					String value = param.substring(separator + 1);
					if (!value.equals(request.getParameter(key))) {
						return false;
					}
				}
			}
		}
		return true;
	}




至此，handler的匹配过程结束，bean的实例作为匹配的handler返回。可以看出，匹配过程并未深入到方法一级，如果类级别和方法级别都定义了url，在这一层次会忽略方法级别的。其实，spring也不推荐在类级别和方法级别同时定义url。[[BR]]
再回到DispatcherServlet中，找到匹配handler后，下一步就要去调用handler，调用的方式有许多，spring抽像出了一个接口HandlerAdapter，接口的定义：

Java代码 复制代码
  1. public interface HandlerAdapter {   
  2.   
  3.     boolean supports(Object handler); //是否支持此种类型的handler   
  4.   
  5.     ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception; //具体的处理过程   
  6.   
  7.     long getLastModified(HttpServletRequest request, Object handler);   
  8. }  
public interface HandlerAdapter {

	boolean supports(Object handler); //是否支持此种类型的handler

	ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;	//具体的处理过程

	long getLastModified(HttpServletRequest request, Object handler);
}



DispatcherServlet中寻找合适的HandlerAdapter的过程：

Java代码 复制代码
  1. protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {   
  2.   
  3.     /*  
  4.     spring默认提供四个HandlerAdapter：  
  5.         HttpRequestHandlerAdapter：处理HttpRequestHandler接口的实例  
  6.         SimpleControllerHandlerAdapter：处理Controller接口的实例  
  7.         ThrowawayControllerHandlerAdapter：已经过时  
  8.         AnnotationMethodHandlerAdapter：处理annotation定义的实例  
  9.     */  
  10.     Iterator it = this.handlerAdapters.iterator();   
  11.     while (it.hasNext()) {   
  12.         HandlerAdapter ha = (HandlerAdapter) it.next();   
  13.         if (logger.isDebugEnabled()) {   
  14.             logger.debug("Testing handler adapter [" + ha + "]");   
  15.         }   
  16.         if (ha.supports(handler)) {   
  17.             return ha;   
  18.         }   
  19.     }   
  20.     ...   
  21. }  
	protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {

		/*
		spring默认提供四个HandlerAdapter：
			HttpRequestHandlerAdapter：处理HttpRequestHandler接口的实例
			SimpleControllerHandlerAdapter：处理Controller接口的实例
			ThrowawayControllerHandlerAdapter：已经过时
			AnnotationMethodHandlerAdapter：处理annotation定义的实例
		*/
		Iterator it = this.handlerAdapters.iterator();
		while (it.hasNext()) {
			HandlerAdapter ha = (HandlerAdapter) it.next();
			if (logger.isDebugEnabled()) {
				logger.debug("Testing handler adapter [" + ha + "]");
			}
			if (ha.supports(handler)) {
				return ha;
			}
		}
		...
	}



基于annotation的handler则是由AnnotationMethodHandlerAdapter进行处理，来看AnnotationMethodHandlerAdapter中相关处理代码：

Java代码 复制代码
  1. //是否支持此类型的handler？   
  2. public boolean supports(Object handler) {   
  3.     return getMethodResolver(handler).hasHandlerMethods();   
  4. }   
  5.   
  6. private ServletHandlerMethodResolver getMethodResolver(Object handler) {   
  7.     Class handlerClass = ClassUtils.getUserClass(handler);   
  8.     ServletHandlerMethodResolver resolver = this.methodResolverCache.get(handlerClass);   
  9.     if (resolver == null) {   
  10.         resolver = new ServletHandlerMethodResolver(handlerClass);//在父类的构造方法中完成handler的解析   
  11.         this.methodResolverCache.put(handlerClass, resolver);//缓存起来，方法调用时有用   
  12.     }   
  13.     return resolver;   
  14. }   
  15.   
  16. public final boolean hasHandlerMethods() {   
  17.     return !this.handlerMethods.isEmpty();//非常简单的判断，如果该类中的方法标记有@RequestMapping就返回true，也意味着它支持此种类型的handler   
  18. }  
	//是否支持此类型的handler？
	public boolean supports(Object handler) {
		return getMethodResolver(handler).hasHandlerMethods();
	}

	private ServletHandlerMethodResolver getMethodResolver(Object handler) {
		Class handlerClass = ClassUtils.getUserClass(handler);
		ServletHandlerMethodResolver resolver = this.methodResolverCache.get(handlerClass);
		if (resolver == null) {
			resolver = new ServletHandlerMethodResolver(handlerClass);//在父类的构造方法中完成handler的解析
			this.methodResolverCache.put(handlerClass, resolver);//缓存起来，方法调用时有用
		}
		return resolver;
	}

	public final boolean hasHandlerMethods() {
		return !this.handlerMethods.isEmpty();//非常简单的判断，如果该类中的方法标记有@RequestMapping就返回true，也意味着它支持此种类型的handler
	}



好了，到这里，handler已确定，由谁去处理handler也已确定，剩下的工作就是如何调用了。来看具体的调用代码：

Java代码 复制代码
  1. public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)   
  2.         throws Exception {   
  3.   
  4.     ...   
  5.     if (this.synchronizeOnSession) {   
  6.         HttpSession session = request.getSession(false);   
  7.         if (session != null) {   
  8.             Object mutex = WebUtils.getSessionMutex(session);   
  9.             synchronized (mutex) {   
  10.                 return invokeHandlerMethod(request, response, handler);   
  11.             }   
  12.         }   
  13.     }   
  14.     return invokeHandlerMethod(request, response, handler);   
  15. }   
  16.   
  17. protected ModelAndView invokeHandlerMethod(   
  18.         HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {   
  19.   
  20.     try {   
  21.         ServletHandlerMethodResolver methodResolver = getMethodResolver(handler);//缓存中已有   
  22.         Method handlerMethod = methodResolver.resolveHandlerMethod(request);//确定具体该调用哪个方法   
  23.         ServletHandlerMethodInvoker methodInvoker = new ServletHandlerMethodInvoker(methodResolver);   
  24.         ServletWebRequest webRequest = new ServletWebRequest(request, response);   
  25.         ExtendedModelMap implicitModel = new ExtendedModelMap();//方法入参ModelMap的原型   
  26.   
  27.         Object result = methodInvoker.invokeHandlerMethod(handlerMethod, handler, webRequest, implicitModel);//调用方法   
  28.         ModelAndView mav =   
  29.                 methodInvoker.getModelAndView(handlerMethod, handler.getClass(), result, implicitModel, webRequest);//构建ModelAndView   
  30.         methodInvoker.updateModelAttributes(   
  31.                 handler, (mav != null ? mav.getModel() : null), implicitModel, webRequest);//处理ModelMap中的值   
  32.         return mav;   
  33.     }   
  34.     catch (NoSuchRequestHandlingMethodException ex) {   
  35.         return handleNoSuchRequestHandlingMethod(ex, request, response);   
  36.     }   
  37. }  
	public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		...
		if (this.synchronizeOnSession) {
			HttpSession session = request.getSession(false);
			if (session != null) {
				Object mutex = WebUtils.getSessionMutex(session);
				synchronized (mutex) {
					return invokeHandlerMethod(request, response, handler);
				}
			}
		}
		return invokeHandlerMethod(request, response, handler);
	}

	protected ModelAndView invokeHandlerMethod(
			HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

		try {
			ServletHandlerMethodResolver methodResolver = getMethodResolver(handler);//缓存中已有
			Method handlerMethod = methodResolver.resolveHandlerMethod(request);//确定具体该调用哪个方法
			ServletHandlerMethodInvoker methodInvoker = new ServletHandlerMethodInvoker(methodResolver);
			ServletWebRequest webRequest = new ServletWebRequest(request, response);
			ExtendedModelMap implicitModel = new ExtendedModelMap();//方法入参ModelMap的原型

			Object result = methodInvoker.invokeHandlerMethod(handlerMethod, handler, webRequest, implicitModel);//调用方法
			ModelAndView mav =
					methodInvoker.getModelAndView(handlerMethod, handler.getClass(), result, implicitModel, webRequest);//构建ModelAndView
			methodInvoker.updateModelAttributes(
					handler, (mav != null ? mav.getModel() : null), implicitModel, webRequest);//处理ModelMap中的值
			return mav;
		}
		catch (NoSuchRequestHandlingMethodException ex) {
			return handleNoSuchRequestHandlingMethod(ex, request, response);
		}
	}



其中，确定具体调用哪个方法这个过程比较复杂，由ServletHandlerMethodResolver完成。

Java代码 复制代码
  1. public Method resolveHandlerMethod(HttpServletRequest request) throws ServletException {   
  2.     ...   
  3.     for (Method handlerMethod : getHandlerMethods()) {   
  4.         RequestMappingInfo mappingInfo = new RequestMappingInfo();   
  5.         RequestMapping mapping = AnnotationUtils.findAnnotation(handlerMethod, RequestMapping.class);   
  6.         mappingInfo.paths = mapping.value();   
  7.         //如果类级别没有定义@RequestMapping，则使用方法级别定义的   
  8.         if (!hasTypeLevelMapping() || !Arrays.equals(mapping.method(), getTypeLevelMapping().method())) {   
  9.             mappingInfo.methods = mapping.method();   
  10.         }   
  11.         if (!hasTypeLevelMapping() || !Arrays.equals(mapping.params(), getTypeLevelMapping().params())) {   
  12.             mappingInfo.params = mapping.params();   
  13.         }   
  14.         boolean match = false;   
  15.         if (mappingInfo.paths.length > 0) {//先检查url是否匹配   
  16.             for (String mappedPath : mappingInfo.paths) {   
  17.                 if (isPathMatch(mappedPath, lookupPath)) {   
  18.                     if (checkParameters(mappingInfo, request)) {   
  19.                         match = true;   
  20.                         targetPathMatches.put(mappingInfo, mappedPath);   
  21.                     }   
  22.                     else {   
  23.                         break;   
  24.                     }   
  25.                 }   
  26.             }   
  27.         }   
  28.         else {   
  29.             //如果没有定义url，则只需检查其它项是否匹配，如param、method
    分享到：
    | spring tool configure
    评论
    发表评论

    您还没有登录,请您登录后再发表评论

相关推荐

    spring2.5源码

    Spring 2.5是Spring框架的一个重要版本，它在...通过深入学习Spring 2.5的源码，开发者可以更好地理解Spring框架的设计思想和工作原理，从而提高开发效率和代码质量。同时，这也为理解后续版本的改进和发展奠定了基础。

    传智播客spring2.5源代码

    2. **注解驱动开发（Annotation-based Development）**：Spring 2.5开始大规模支持Java注解，比如`@Service`、`@Repository`和`@Controller`，它们分别用于标记业务层、数据访问层和控制层的组件。这使得XML配置文件...

    Struts2+Spring2.5+Hibernate3+annotation 整合程序

    这个"Struts2+Spring2.5+Hibernate3+annotation 整合程序"旨在展示如何将这三大框架与注解（Annotation）技术结合，以实现更高效、更简洁的代码编写。 Struts2是一个基于MVC设计模式的Web应用框架，它主要负责处理...

    struts1.3+spring2.5+hibernate3.3 组合开发 annotation实现

    Struts1.3、Spring2.5 和 Hibernate3.3 是经典的 Java Web 开发框架组合，它们在企业级应用中广泛使用。这个组合被称为“SSH”（Struts-Spring-Hibernate），它允许开发者构建可扩展且松耦合的后端系统。在本项目中...

    Spring2.5 IOC的简单实现

    以下将详细讲解 Spring 2.5 中的 IOC 实现原理以及如何创建简单的应用。 **1. IOC 简介** IOC 是一种设计模式，它将对象的创建和管理交给容器处理，使得代码更加松耦合。Spring 框架通过 XML 配置文件或注解方式来...

    基于Annotation的Struts2.0+Hibernate3.3+Spring2.5整合开发 (1)

    标题中的“基于Annotation的Struts2.0+Hibernate3.3+Spring2.5整合开发”指的是使用注解的方式将三个流行的Java企业级框架——Struts2、Hibernate和Spring进行集成开发。这样的集成有助于简化配置，提高代码的可读性...

    Spring2.5 自动扫描classpath

    1. **Spring_demo_04_aop_introduction** - 这个例子可能是对Spring的面向切面编程（AOP）的介绍，AOP允许我们在不修改原有代码的情况下，实现如日志记录、性能监控等功能。 2. **Spring_demo_07_dataSource** - ...

    spring源码

    在Spring2.5中，IoC容器通过使用注解（Annotation）进一步简化了配置，例如`@Component`、`@Service`、`@Repository`和`@Controller`，这些注解用于标记组件类，使得容器能自动发现并管理它们。此外，`@Autowired`...

    Spring注释 注入方式源码示例，Annotation

    花了些时间做了一个实验，彻底弄懂了spring Annotation注入的方式。凡带有@Component,@Controller,@Service,@Repository 标志的等于告诉Spring这类将自动产生对象，而@Resource则等于XML配置中的ref，告诉spring此处...

    Spring Annotation简介一

    1. **依赖注入（Dependency Injection, DI）**：Spring Annotation中最常用的注解之一是`@Autowired`，它实现了自动装配bean。当在类的字段或构造器上使用`@Autowired`时，Spring会自动寻找类型匹配的bean并注入。...

    spring源码雷神spring源码雷神

    1. **IoC（Inversion of Control）控制反转**：Spring的核心特性之一，它通过依赖注入（Dependency Injection，DI）来实现。IoC使得组件之间的依赖关系由容器管理，而不是由组件自身管理，从而降低了代码的耦合度。 ...

    SpringIOC_SpringMVC_SpringAnnotation_JPA

    标题 "SpringIOC_SpringMVC_SpringAnnotation_JPA" 涵盖了四个核心的Java开发框架技术，它们是Spring框架的重要组成部分。Spring框架是一个开源的应用框架，它为Java开发者提供了一个全面的基础设施，用于构建可扩展...

    spring源代码分析：annotation支持的实现

    这篇博客"spring源代码分析：annotation支持的实现"探讨了Spring如何通过注解处理来实现组件扫描和依赖注入。我们将深入探讨以下几个关键知识点： 1. **组件扫描（Component Scanning）**： - 组件扫描是Spring...

    spring源码spring-framework-4.2.5.RELEASE

    深入理解Spring源码需要对Java反射、动态代理、设计模式等有扎实的基础。建议从以下几个步骤入手： 1. 了解基本架构和模块划分。 2. 分析核心类如ApplicationContext、BeanFactory和DispatcherServlet的实现。 3. ...

    spring4.1.7源码

    通过研究这个版本的源码，开发者可以深入理解Spring的工作原理，从而更好地优化应用、排查问题以及学习先进的设计模式。 1. **IoC（控制反转）与DI（依赖注入）** Spring的核心功能之一是依赖注入，它允许对象之间...

    Spring MVC 学习笔记 七 controller中其他可用的annotation

    1. **@Controller**: 这个注解是定义一个类为Spring MVC的Controller。它标志着该类是一个处理HTTP请求的bean。通常，我们会在这个类中定义处理请求的方法，这些方法会使用其他的注解来指定请求映射。 2. **@...

Magicbox
Global site tag (gtag.js) - Google Analytics