======= 第一部分（整体架构 及 流程）===========
1、SpringMVC 运行流程图：
一、首先来讲解下springMVC的底层工作流程
1、首先我们重点放在前端控制器（DispatcherServlet）
其类图：
总结一下各个Servlet的作用：
1. HttpServletBean
主要做一些初始化的工作，将web.xml中配置的参数设置到Servlet中。比如servlet标签的子标签init-param标签中配置的参数。
2. FrameworkServlet
将Servlet与Spring容器上下文关联。其实也就是初始化FrameworkServlet的属性webApplicationContext，这个属性代表SpringMVC上下文，它有个父类上下文，既web.xml中配置的ContextLoaderListener监听器初始化的容器上下文。
3. DispatcherServlet
初始化各个功能的实现类。比如异常处理、视图处理、请求映射处理等。
因为从流程图看，用户的请求最先到达就是DispatcherServlet。它是springmvc的核心，也是中央出处理器。因此我们分析源码，先看看他是什么样的流程：通过源码可看到：他是继承FrameworkServlet，它也是springmvc提供的类，继续往下继承关系看，FrameworkServlet继承HttpServletBean，它依旧是spring提供的.最终直到它继承HttpServlet，如图：
而这个类它就是servlet。因此既然是Servlet类，那么它有一个最终的方法，就是service()方法，它是Servlet最核心的方法。
因此，我们在DispatcherServlet类中找service方法，发现没有，我们继续往上一层FrameworkServlet类中找，发现找到了，因此Spring实现该方法在这个类去实现的。
protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
if (httpMethod != HttpMethod.PATCH && httpMethod != null) {
super.service(request, response);
} else {
this.processRequest(request, response);
}
}这里职责主要是先拿到一个请求，然后又做了一个判断请求方式。发现不是PATCH方式就去调用父类（HttpServlet）中service()方法。它去调用父类中的service方法其实就是去调用该父类中doPost(),doGet()等doXXX()方法，而会去FrameworkServlet的对应的doPost(),doGet()等doXXX()方法中去执行唯一的processRequest(request, response)方法，而processRequest方法中调用了doService(request, response)方法，也就是去执行其子类DispatcherServlet的重写的其方法，其中执行doDispatch(request, response);处理不同的业务。比如以FrameworkServlet的service方式为例，调用其父类HttpServlet的service方法
调用
或者执行FrameworkServlet类中service方法中的processRequest方法
然后一直往下执行到子类DispatcherServlet的doService方法
其中最主要的方法doDispatch(request, response);
doDispatch方法功能简单描述一下：
首先根据请求的路径找到HandlerMethod(带有Method反射属性，也就是对应Controller中的方法)，然后匹配路径对应的拦截器，有了HandlerMethod和拦截器构造个HandlerExecutionChain对象。HandlerExecutionChain对象的获取是通过HandlerMapping接口提供的方法中得到。有了HandlerExecutionChain之后，通过HandlerAdapter对象进行处理得到ModelAndView对象，HandlerMethod内部handle的时候，使用各种HandlerMethodArgumentResolver实现类处理HandlerMethod的参数，使用各种HandlerMethodReturnValueHandler实现类处理返回值。 最终返回值被处理成ModelAndView对象，这期间发生的异常会被HandlerExceptionResolver接口实现类进行处理。
由源码可得：他首先主要是创建一个视图对象 ModelAndView mv = null;然后检查当前请求是否是二进制的请求processedRequest = this.checkMultipart(request);然后就是只要代码
mappedHandler = this.getHandler(processedRequest);
就是根据当前的请求去拿一个Handler.(在这个源码中springNVC都是使用的Handler,那么他到底是什么？这个Handler其实就是我们的控制器，包括我们写Controller)。
由流程图可知，发送清求到控制器，控制器第二个节点就是发送第二个请求就是去拿Handler，因此可知这里才是最核心代码。由图可知他取Handler最终要去找HandlerMapping,然后他再去拿一个Handler。那么为什么要去找HandlerMapping去要一个Handler呢？首先我们在配置控制器的时候有两种方式1.xml方式，2.注解的方式。因此spring源码他给我们不止一种控制器 。因为两种方式控制器 。因此spring并不知道我们使用的事哪一种控制器。因为两种控制器，spring去底层去找的控制的实现方式是不一样的。因此这就是为什么第二步他要去找Handler（控制器）的了。但是Handler怎么找的到呢?就是通过HandlerMapping这样一个处理器映射器。如代码可知他首先是判断当前this.handlerMappings是否为空
那么接下来他会怎么处理呢？由源码得知，Spring首先是遍历handlerMappings，怎么遍历呢？他会问当前数组中有没有我这控制器。也就是代码中的hm对应的是当前控制器；
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
if (this.handlerMappings != null) {
for (HandlerMapping hm : this.handlerMappings) {
if (logger.isTraceEnabled()) {
logger.trace(
"Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");
}
HandlerExecutionChain handler = hm.getHandler(request);
if (handler != null) {
return handler;
}
}
}
return null;
}
找到之后；他返回的是一个HandlerExecutionChain类型的Handler;这里面封装了一个我们自己的创建controlller和它里面还封装一个拦截器。
因此到这里我们就拿到了对应的也是最合适的Handler,然后返回中央处理器。
然后到第二个方法：
HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
获取控制器的适配器。也就是我们之前拿到了控制器，接下来要去执行控制器，也就是拿到控制器适配器中执行控制器。这里为什么要获取适配器呢？因为跟控制器映射器（也就是配置方式）一样。你就有不同的适配器。因此适配器也不是一个。跟我们上面Handler原理一样。
判断再往下执行的时候还要判断你有没有需要执行的拦截器。
接下来就是适配器去执行Handler
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
如果你有ModelAndView，就返回一个ModelAndView.然后返回给试图对象，然后把视图对象交给视图解析器，去渲染，最后响应给用户。
到这里：其控制器原理大致可以理解为：第一步是去找那个控制器，第二步是去执行控制器，然后返回给试图对象，然后把视图对象交给视图解析器，去渲染，最后响应给用户。
======= 第二部分（具体细节） ======
那么这里有个疑问？Spring MVC中的handlerMappings初始值是哪来的呢？以及自定义的Controller等等
Spring mvc 提供的控制器类型handlerMappings 是如何被初始化的，来引出SpringMVC初始化。那么先看HandlerMappings初始化源码可得：
其初始化是在DispatcherServlet类中的这个方法进行的，而这个初始化方法initHandlerMappings（）又是什么时候执行的呢？在该类中发现，是在下面方法中执行初始化的，同时发现好多组件都是在这个方法中执行，比如另一个重要的对象控制器适配器
那么归根究底，其SprinngMVC的初始化是在onRefresh（）这个方法中执行的。
因此下面首先通过时序图来探索springMVC的初始化流程：（图片来源于网络）
servlet初始化会调用 init 方法，换句话说就是springMVC进行初始化的时候首先会去执行HttpServletBean的init方法， 下面看看HttpServletBean的源码：
其中有一点值得注意，那就是 initServletBean() 这个方法是由其子类 FrameworkServlet 实现，因此， 接下来 FramworkServlet 会执行 initServletBean 这个方法，下面就继续看看 initServletBean 方法源码：
可以看到 initServletBean 方法中就调用了一个 initFrameworkServlet 方法和 initWebApplicationContext 方法，其中initFrameworkServlet方法是由子类实现，这个不多说，直接看 initWebApplicationContext 方法源码：
protected WebApplicationContext initWebApplicationContext() {
//此处的 rootContext 在你配置了ContextLoaderListener的时候注入的
//通过分析ContextLoaderListenr的源码，可以看到
//ContextLoaderListener通过ContextLoader根据ApplicationContext.xml的配置会创建一个xmlWebApplicationContext
//如果没有配置ContextLoaderListener,本处将为null,但不影响springMVC,为何？通过接下来的分析，就能看到原因
WebApplicationContext rootContext = WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());
WebApplicationContext wac = null;
//当webApplicationContext已经存在，那么就直接使用，使用之前会先设置rootContext,为其跟。
//配置完成之后refresh一次，refresh会涉及到IOC的内容，本处不做探讨。
if (this.webApplicationContext != null) {
wac = this.webApplicationContext;
if (wac instanceof ConfigurableWebApplicationContext) {
ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext)wac;
if (!cwac.isActive()) {
if (cwac.getParent() == null) {
cwac.setParent(rootContext);
}
this.configureAndRefreshWebApplicationContext(cwac);
}
}
}
//如果不存在webApplicationContext,那么先去ServletContext中查找
if (wac == null) {
wac = this.findWebApplicationContext();
}
//如果上述没有查到，那么就创建webApplicationContext
if (wac == null) {
wac = this.createWebApplicationContext(rootContext);
}
if (!this.refreshEventReceived) {
//此方法由DispatcherServlet调用 （非常重要！！！）
this.onRefresh(wac);
}
//将webApplicationContext保存在ServletContext
if (this.publishContext) {
//将上下文发布为servlet上下文属性。
String attrName = this.getServletContextAttributeName();
this.getServletContext().setAttribute(attrName, wac);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Published WebApplicationContext of servlet '" + this.getServletName() + "' as ServletContext attribute with name [" + attrName + "]");
}
}
return wac;
}上面代码调用了一次 createWebApplicationContext 方法， 下面就看看这个方法的源码：
protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {
Class<?> contextClass = getContextClass();
if (this.logger.isDebugEnabled()) {
this.logger.debug("Servlet with name '" + getServletName() +
"' will try to create custom WebApplicationContext context of class '" +
contextClass.getName() + "'" + ", using parent context [" + parent + "]");
}
if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
throw new ApplicationContextException(
"Fatal initialization error in servlet with name '" + getServletName() +
"': custom WebApplicationContext class [" + contextClass.getName() +
"] is not of type ConfigurableWebApplicationContext");
}
//此处利用反射创建
ConfigurableWebApplicationContext wac =
(ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
wac.setEnvironment(getEnvironment());
wac.setParent(parent);
String configLocation = getContextConfigLocation();
if (configLocation != null) {
wac.setConfigLocation(configLocation);
}
configureAndRefreshWebApplicationContext(wac);
return wac;
}还记得FrameworkServlet初始化的时候会调用onRefresh()方法吗，这个方法是留给其子类DispatcherServlet调用的， 最后就该看看DispatcherServlet里面的 onRefresh 方法了：
protected void onRefresh(ApplicationContext context) {
this.initStrategies(context);
}
//初始化此servlet使用的策略对象。
//可以在子类中重写以初始化其他策略对象
protected void initStrategies(ApplicationContext context) {
this.initMultipartResolver(context);
this.initLocaleResolver(context);
this.initThemeResolver(context);
this.initHandlerMappings(context);
this.initHandlerAdapters(context);
this.initHandlerExceptionResolvers(context);
this.initRequestToViewNameTranslator(context);
this.initViewResolvers(context);
this.initFlashMapManager(context);
}可以看到onRefresh方法就一句话，调用initStrategies方法， 上面给出了 initStrategies 源码， 很直观，就是在初始化SpringMVC 的一系列组件， 但是此处你要明白，SpringMVC的组件其实已经在webApplicationContext创建时就已经实例化了， 此处所谓的初始化只是在选择合适的组件（每一个组件都对应了几个不同的实现）。
到此，就可以很清楚知道，HandlerMappings和HandlerAdapter等是在什么时候初始化的。
===============第三部分（前台请求 到匹配对应的Controller 过程）===============
我们使用浏览器通过地址 http://ip:port/contextPath/path进行访问，SpringMVC是如何得知用户到底是访问哪个Controller中的方法，这期间到底发生了什么。
分析SpringMVC是如何处理请求与Controller之间的映射关系的，这个过程中到底发生了什么事情。
1.这个过程中重要的接口和类。
HandlerMethod类：
是一个封装了方法参数、方法注解，方法返回值等众多元素的类。
MethodParameter类：
HandlerMethod类中的parameters属性类型，是一个MethodParameter数组。MethodParameter是一个封装了方法参数具体信息的工具类，包括参数的的索引位置，类型，注解，参数名等信息。
HandlerMethod在实例化的时候，构造函数中会初始化这个数组，这时只初始化了部分数据，在HandlerAdapter对请求处理过程中会完善其他属性，之后交予合适的HandlerMethodArgumentResolver接口处理。
RequestMappingHandlerMapping类：
isHandler(Class<?> beanType)方法，判断若有@Controller和@RequestMapping注解 则证明是handler
例子：
当我们访问：http://ip：port/urlPath.....的时候。
会先根据 "/urlPath....." 找urlMap对应的RequestMappingInfo集合，找不到的话取handlerMethods集合中所有的key集合(也就是RequestMappingInfo集合)。
然后进行匹配，匹配根据RequestCondition的getMatchingCondition方法。
然后会使用比较器进行排序。
之前也分析过，比较器是有优先级的。
我们看到，RequestMappingInfo除了pattern，其他属性都是一样的。
我们看下PatternsRequestCondition比较的逻辑：
PatternsRequestCondition的compareTo（PatternsRequestCondition other, HttpServletRequest request）方法：
资源Bean定义解析器类ResourcesBeanDefinitionParser:
public BeanDefinition parse(Element element, ParserContext context) 方法：
@Override
public BeanDefinition parse(Element element, ParserContext context) {
Object source = context.extractSource(element);
registerUrlProvider(context, source);
RuntimeBeanReference pathMatcherRef = MvcNamespaceUtils.registerPathMatcher(null, context, source);
RuntimeBeanReference pathHelperRef = MvcNamespaceUtils.registerUrlPathHelper(null, context, source);
String resourceHandlerName = registerResourceHandler(context, element, pathHelperRef, source);
if (resourceHandlerName == null) {
return null;
}
Map<String, String> urlMap = new ManagedMap<>();
String resourceRequestPath = element.getAttribute("mapping");
if (!StringUtils.hasText(resourceRequestPath)) {
context.getReaderContext().error("The 'mapping' attribute is required.", context.extractSource(element));
return null;
}
urlMap.put(resourceRequestPath, resourceHandlerName);
RootBeanDefinition handlerMappingDef = new RootBeanDefinition(SimpleUrlHandlerMapping.class);
handlerMappingDef.setSource(source);
handlerMappingDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
handlerMappingDef.getPropertyValues().add("urlMap", urlMap);
handlerMappingDef.getPropertyValues().add("pathMatcher", pathMatcherRef).add("urlPathHelper", pathHelperRef);
String orderValue = element.getAttribute("order");
// Use a default of near-lowest precedence, still allowing for even lower precedence in other mappings
Object order = StringUtils.hasText(orderValue) ? orderValue : Ordered.LOWEST_PRECEDENCE - 1;
handlerMappingDef.getPropertyValues().add("order", order);
RuntimeBeanReference corsRef = MvcNamespaceUtils.registerCorsConfigurations(null, context, source);
handlerMappingDef.getPropertyValues().add("corsConfigurations", corsRef);
String beanName = context.getReaderContext().generateBeanName(handlerMappingDef);
context.getRegistry().registerBeanDefinition(beanName, handlerMappingDef);
context.registerComponent(new BeanComponentDefinition(handlerMappingDef, beanName));
// Ensure BeanNameUrlHandlerMapping (SPR-8289) and default HandlerAdapters are not "turned off"
// Register HttpRequestHandlerAdapter
MvcNamespaceUtils.registerDefaultComponents(context, source);
return null;
}====================第四部分 （SpringMVC实现数据类型的转换、参数数据的绑定）===========
例子：
Controller层的：
public String method(Integer num, Date birth) { ... }
Http请求传递的数据都是字符串String类型的，上面这个方法在Controller中定义，如果该方法对应的地址接收到到浏览器的请求的话，并且请求中含有num和birth参数，那么num会被自动转换成Integer对象；birth会被自动转为Date对象(Date转换需要配置属性编辑器)。
重要的接口和类：
1.PropertyEditorRegistry接口
封装方法来给JavaBean注册对应的属性编辑器。
2.PropertyEditorRegistrySupport：PropertyEditorRegistry接口的基础实现类
3、PropertyEditorRegistrySupport类有个createDefaultEditors方法，会创建默认的属性编辑器。
/**
* Actually register the default editors for this registry instance.
*/
private void createDefaultEditors() {
this.defaultEditors = new HashMap<>(64);
// Simple editors, without parameterization capabilities.
// The JDK does not contain a default editor for any of these target types.
this.defaultEditors.put(Charset.class, new CharsetEditor());
this.defaultEditors.put(Class.class, new ClassEditor());
this.defaultEditors.put(Class[].class, new ClassArrayEditor());
this.defaultEditors.put(Currency.class, new CurrencyEditor());
this.defaultEditors.put(File.class, new FileEditor());
this.defaultEditors.put(InputStream.class, new InputStreamEditor());
this.defaultEditors.put(InputSource.class, new InputSourceEditor());
this.defaultEditors.put(Locale.class, new LocaleEditor());
this.defaultEditors.put(Path.class, new PathEditor());
this.defaultEditors.put(Pattern.class, new PatternEditor());
this.defaultEditors.put(Properties.class, new PropertiesEditor());
this.defaultEditors.put(Reader.class, new ReaderEditor());
this.defaultEditors.put(Resource[].class, new ResourceArrayPropertyEditor());
this.defaultEditors.put(TimeZone.class, new TimeZoneEditor());
this.defaultEditors.put(URI.class, new URIEditor());
this.defaultEditors.put(URL.class, new URLEditor());
this.defaultEditors.put(UUID.class, new UUIDEditor());
this.defaultEditors.put(ZoneId.class, new ZoneIdEditor());
// Default instances of collection editors.
// Can be overridden by registering custom instances of those as custom editors.
this.defaultEditors.put(Collection.class, new CustomCollectionEditor(Collection.class));
this.defaultEditors.put(Set.class, new CustomCollectionEditor(Set.class));
this.defaultEditors.put(SortedSet.class, new CustomCollectionEditor(SortedSet.class));
this.defaultEditors.put(List.class, new CustomCollectionEditor(List.class));
this.defaultEditors.put(SortedMap.class, new CustomMapEditor(SortedMap.class));
// Default editors for primitive arrays.
this.defaultEditors.put(byte[].class, new ByteArrayPropertyEditor());
this.defaultEditors.put(char[].class, new CharArrayPropertyEditor());
// The JDK does not contain a default editor for char!
this.defaultEditors.put(char.class, new CharacterEditor(false));
this.defaultEditors.put(Character.class, new CharacterEditor(true));
// Spring's CustomBooleanEditor accepts more flag values than the JDK's default editor.
this.defaultEditors.put(boolean.class, new CustomBooleanEditor(false));
this.defaultEditors.put(Boolean.class, new CustomBooleanEditor(true));
// The JDK does not contain default editors for number wrapper types!
// Override JDK primitive number editors with our own CustomNumberEditor.
this.defaultEditors.put(byte.class, new CustomNumberEditor(Byte.class, false));
this.defaultEditors.put(Byte.class, new CustomNumberEditor(Byte.class, true));
this.defaultEditors.put(short.class, new CustomNumberEditor(Short.class, false));
this.defaultEditors.put(Short.class, new CustomNumberEditor(Short.class, true));
this.defaultEditors.put(int.class, new CustomNumberEditor(Integer.class, false));
this.defaultEditors.put(Integer.class, new CustomNumberEditor(Integer.class, true));
this.defaultEditors.put(long.class, new CustomNumberEditor(Long.class, false));
this.defaultEditors.put(Long.class, new CustomNumberEditor(Long.class, true));
this.defaultEditors.put(float.class, new CustomNumberEditor(Float.class, false));
this.defaultEditors.put(Float.class, new CustomNumberEditor(Float.class, true));
this.defaultEditors.put(double.class, new CustomNumberEditor(Double.class, false));
this.defaultEditors.put(Double.class, new CustomNumberEditor(Double.class, true));
this.defaultEditors.put(BigDecimal.class, new CustomNumberEditor(BigDecimal.class, true));
this.defaultEditors.put(BigInteger.class, new CustomNumberEditor(BigInteger.class, true));
// Only register config value editors if explicitly requested.
if (this.configValueEditorsActive) {
StringArrayPropertyEditor sae = new StringArrayPropertyEditor();
this.defaultEditors.put(String[].class, sae);
this.defaultEditors.put(short[].class, sae);
this.defaultEditors.put(int[].class, sae);
this.defaultEditors.put(long[].class, sae);
}
}
3.TypeConverter接口
类型转换接口。 通过该接口，可以将value转换为requiredType类型的对象。
4.TypeConverterSupport：TypeConverter基础实现类，并继承了PropertyEditorRegistrySupport
有个属性typeConverterDelegate，类型为TypeConverterDelegate，TypeConverterSupport将类型转换委托给typeConverterDelegate操作。
5.TypeConverterDelegate
类型转换委托类。具体的类型转换操作由此类完成。
6.SimpleTypeConverter
TypeConverterSupport的子类，使用了PropertyEditorRegistrySupport(父类TypeConverterSupport的父类PropertyEditorRegistrySupport)中定义的默认属性编辑器。
7.PropertyAccessor接口
对类中属性操作的接口。
8.BeanWrapper接口
继承ConfigurablePropertyAccessor(继承PropertyAccessor、PropertyEditorRegistry、TypeConverter接口)接口的操作Spring中JavaBean的核心接口。
9.BeanWrapperImpl类
BeanWrapper接口的默认实现类，TypeConverterSupport是它的父类，可以进行类型转换，可以进行属性设置。
10.DataBinder类
实现PropertyEditorRegistry、TypeConverter的类。支持类型转换，参数验证，数据绑定等功能。
有个属性SimpleTypeConverter，用来进行类型转换操作。
11.WebDataBinder
DataBinder的子类，主要是针对Web请求的数据绑定。
-----------
在分析RequestParamMethodArgumentResolver处理请求参数之前，我们简单回顾一下SpringMVC是如何对http请求进行处理的。
HandlerAdapter会对每个请求实例化一个ServletInvocableHandlerMethod对象进行处理，我们仅看下WebDataBinderFactory的构造过程。
WebDataBinderFactory接口是一个创建WebDataBinder的工厂接口。
boolean类型的参数会被RequestParamMethodArgumentResolver这个HandlerMethodArgumentResolver处理。
下面我们进入RequestParamMethodArgumentResolver看看是如何处理的。
RequestParamMethodArgumentResolver的resolveArgument方法是由它的父类AbstractNamedValueMethodArgumentResolver中定义的：
@Nullable
public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
AbstractNamedValueMethodArgumentResolver.NamedValueInfo namedValueInfo = this.getNamedValueInfo(parameter);
MethodParameter nestedParameter = parameter.nestedIfOptional();
Object resolvedName = this.resolveStringValue(namedValueInfo.name);
if(resolvedName == null) {
throw new IllegalArgumentException("Specified name must not resolve to null: [" + namedValueInfo.name + "]");
} else {
Object arg = this.resolveName(resolvedName.toString(), nestedParameter, webRequest);
if(arg == null) {
if(namedValueInfo.defaultValue != null) {
arg = this.resolveStringValue(namedValueInfo.defaultValue);
} else if(namedValueInfo.required && !nestedParameter.isOptional()) {
this.handleMissingValue(namedValueInfo.name, nestedParameter, webRequest);
}
arg = this.handleNullValue(namedValueInfo.name, arg, nestedParameter.getNestedParameterType());
} else if("".equals(arg) && namedValueInfo.defaultValue != null) {
arg = this.resolveStringValue(namedValueInfo.defaultValue);
}
if(binderFactory != null) {
WebDataBinder binder = binderFactory.createBinder(webRequest, (Object)null, namedValueInfo.name);
try {
arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);
} catch (ConversionNotSupportedException var11) {
throw new MethodArgumentConversionNotSupportedException(arg, var11.getRequiredType(), namedValueInfo.name, parameter, var11.getCause());
} catch (TypeMismatchException var12) {
throw new MethodArgumentTypeMismatchException(arg, var12.getRequiredType(), namedValueInfo.name, parameter, var12.getCause());
}
}
this.handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);
return arg;
}
}
ServletRequestDataBinderFactory创建ExtendedServletRequestDataBinder。
ExtendedServletRequestDataBinder属于DataBinder的子类。
我们在介绍重要接口的时候说过DataBinder进行类型转换的时候内部会使用SimpleTypeConverter进行数据转换。
boolean类型改成Boolean类型的话，不传参数的话b就是null，我们解释默认属性编辑器的时候Boolean类型的参数是允许空的。但是boolean类型不传参数的话，默认会是false，而不会抛出异常。 原因就是resolveArgument方法中handleNullValue处理null值，spring进行了特殊的处理，如果参数类型是boolean的话，取false。
编写自定义的属性编辑器
1、extends PropertyEditorSupport （继承 PropertyEditorSupport ）
public class CustomDeptEditor extends PropertyEditorSupport {
@Override
public void setAsText(String text) throws IllegalArgumentException {
if(text.indexOf(",") > 0) {
Dept dept = new Dept();
String[] arr = text.split(",");
dept.setId(Integer.parseInt(arr[0]));
dept.setName(arr[1]);
setValue(dept);
} else {
throw new IllegalArgumentException("dept param is error");
}
}
}SpringMVC中使用自定义的属性编辑器有3种方法：
1. Controller方法中添加@InitBinder注解的方法
@InitBinder
public void initBinder(WebDataBinder binder) {
binder.registerCustomEditor(Dept.class, new CustomDeptEditor());
}2. 实现WebBindingInitializer接口
public class MyWebBindingInitializer implements WebBindingInitializer {
@Override
public void initBinder(WebDataBinder binder, WebRequest request) {
binder.registerCustomEditor(Dept.class, new CustomDeptEditor());
}
}之前分析源码的时候，HandlerAdapter构造WebDataBinderFactory的时候，会传递HandlerAdapter的属性webBindingInitializer。
因此，我们在配置文件中构造RequestMappingHandlerAdapter的时候传入参数webBindingInitializer。
3. @ControllerAdvice注解
@ControllerAdvice
public class InitBinderControllerAdvice {
@InitBinder
public void initBinder(WebDataBinder binder) {
binder.registerCustomEditor(Dept.class, new CustomDeptEditor());
}
}加上ControllerAdvice别忘记配置文件component-scan需要扫描到这个类。
==============第五部分（SpringMVC 拦截器 设计）====
==========第六部分 （Order 接口）================
Spring中提供了一个Ordered接口。Ordered接口，顾名思义，就是用来排序的。
Spring是一个大量使用策略设计模式的框架，这意味着有很多相同接口的实现类，那么必定会有优先级的问题。
于是，Spring就提供了Ordered这个接口，来处理相同接口实现类的优先级问题。
=============第七部分（处理视图）============