大家知道，Spring MVC 有一项非常实用的功能，叫参数绑定。其具体能实现的功能异常强大，这里不再赘述，网上有非常多的资料可供参考，仅举一例用以描述问题。
@RestController
public class FooController {
@GetMapping("/methodOne")
public Boolean methodOne(Integer filedOne, String fieldTwo) {
System.out.println(filedOne);
System.out.println(fieldTwo);
return Boolean.TRUE;
}
}
这是一种很常见的使用姿势 - GET请求，有两个参数，分别为filedOne(Integer)，fieldTwo(String)。
先前一直都知道Spring MVC 有参数绑定功能，也一直心安理得去使用，把结论当成必然去记，一直未曾探究其原理。其实，我好奇的并非Spring MVC完成参数绑定的过程，而是好奇，Spring如何获取到方法的形参名，并完成属性注入？
难道大家没有这样的疑问？在Java 8及之后，编译的时候可以通过-parameters 为反射生成元信息，可以获取到方法的参数名，但这个行为默认是关闭的，且更靠前的Java 6 Java 7呢，甚至没有这个参数，因此应该不是通过反射获取参数名。既然反射走不通，那Spring又是使用了哪种奇淫技巧来获取方法的参数名呢？带着这个问题一起来看源码。
注：下面的源码分析基于Spring 4.3.17
假设我们请求 GET http://localhost:8080/methodOne?fieldTwo=jack，
即请求methodOne，参数名为fieldTwo，参数值为jack，接下来就看看Spring MVC是怎么处理的。
一个Spring MVC的应用，当有一个Web请求的进来的时候，我们一般从org.springframework.web.servlet.DispatcherServlet#doDispatch开始分析
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
...（省略）
// Determine handler for the current request.
mappedHandler = getHandler(processedRequest);
...（省略）
// Determine handler adapter for the current request.
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
...（省略）
// Actually invoke the handler.
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
...（省略）
}
我们重点看mv = ha.handle(processedRequest, response, mappedHandler.getHandler());，调用HandlerAdapter的handle方法，实际上会进入到org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#handleInternal
@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);
}
...（省略）
}
synchronizeOnSession默认为false，不用管，因此会走到else的分支，即mav = invokeHandlerMethod(request, response, handlerMethod);
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);
...（省略）
invocableMethod.invokeAndHandle(webRequest, mavContainer);
...（省略）
}
将handlerMethod包装成ServletInvocableHandlerMethod，并设置argumentResolvers、returnValueHandlers、binderFactory、parameterNameDiscoverer。其中，argumentResolvers需要重点关注，因为它是用来做参数解析的。接下来看invocableMethod.invokeAndHandle(webRequest, mavContainer);
public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
Object... providedArgs) throws Exception {
Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
...（省略）
}
直接进入invokeForRequest方法
public Object invokeForRequest(NativeWebRequest request, ModelAndViewContainer mavContainer,
Object... providedArgs) throws Exception {
Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
...（省略）
}
即将进入重要方法getMethodArgumentValues
private Object[] getMethodArgumentValues(NativeWebRequest request, ModelAndViewContainer mavContainer,
Object... providedArgs) throws Exception {
MethodParameter[] parameters = getMethodParameters();//获取方法参数
Object[] args = new Object[parameters.length];
for (int i = 0; i < parameters.length; i++) {
MethodParameter parameter = parameters[i];
parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);//设置参数名发现者
args[i] = resolveProvidedArgument(parameter, providedArgs);
if (args[i] != null) {
continue;
}
if (this.argumentResolvers.supportsParameter(parameter)) {//从参数解析器列表里找到能够支持该参数解析的
try {
args[i] = this.argumentResolvers.resolveArgument(
parameter, mavContainer, request, this.dataBinderFactory);//进行参数解析
continue;
}
catch (Exception ex) {
if (logger.isDebugEnabled()) {
logger.debug(getArgumentResolutionErrorMessage("Failed to resolve", i), ex);
}
throw ex;
}
}
if (args[i] == null) {
throw new IllegalStateException("Could not resolve method parameter at index " +
parameter.getParameterIndex() + " in " + parameter.getMethod().toGenericString() +
": " + getArgumentResolutionErrorMessage("No suitable resolver for", i));
}
}
return args;
}
- 获取方法参数。
MethodParameter[] parameters = getMethodParameters();
这里的参数是指我们最上面定义的public Boolean methodOne(Integer filedOne, String fieldTwo)参数表示，因为我们定义了两个参数，所以这里parameters有两个元素。
我们看一下MethodParameter类的定义：
public class MethodParameter {
private static final Annotation[] EMPTY_ANNOTATION_ARRAY = new Annotation[0];
private static final Class<?> javaUtilOptionalClass;
private final Method method;
private final Constructor<?> constructor;
private final int parameterIndex;
private int nestingLevel = 1;
/** Map from Integer level to Integer type index */
Map<Integer, Integer> typeIndexesPerLevel;
private volatile Class<?> containingClass;
private volatile Class<?> parameterType;
private volatile Type genericParameterType;
private volatile Annotation[] parameterAnnotations;
private volatile ParameterNameDiscoverer parameterNameDiscoverer;
private volatile String parameterName;
private volatile MethodParameter nestedMethodParameter;
...（省略）
}
- method 记录参数属于哪个方法（在这里，
public java.lang.Boolean com.example.demo.controller.FooController.methodOne(java.lang.Integer,java.lang.String)） - parameterIndex 记录参数在所属方法的位置索引（在这里，filedOne的index = 0,fieldTwo的index = 1）
- containingClass记录了所属的Class（在这里，
com.example.demo.controller.FooController） - parameterType 记录参数的类型(在这里，filedOne的类型是
java.lang.Integer，fieldTwo的类型是java.lang.String) - parameterAnnotations 记录参数上有什么注解（在这里，无注解，因此为空）
- parameterNameDiscoverer 记录参数名解析器，非常重要，它能解答最开始提出的问题
- parameterName 记录参数名。我们就是要找到Spring MVC如何解析参数名，并给这个属性赋值。
第一次进入到getMethodArgumentValues方法的时候，调用getMethodParameters方法可以直接获取到parameters，因为应用启动的时候就解析好了，但是启动的时候并没有解析参数名，因此parameterName为空。
- 设置参数名解析器：
parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
其中，this.parameterNameDiscoverer是InvocableHandlerMethod类的一个成员变量，直接new了一个 DefaultParameterNameDiscoverer，是ParameterNameDiscoverer的默认实现。
public class InvocableHandlerMethod extends HandlerMethod {
private WebDataBinderFactory dataBinderFactory;
private HandlerMethodArgumentResolverComposite argumentResolvers = new HandlerMethodArgumentResolverComposite();
private ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
...（省略）
}
public class DefaultParameterNameDiscoverer extends PrioritizedParameterNameDiscoverer {
private static final boolean standardReflectionAvailable = ClassUtils.isPresent(
"java.lang.reflect.Executable", DefaultParameterNameDiscoverer.class.getClassLoader());
public DefaultParameterNameDiscoverer() {
if (standardReflectionAvailable) {
addDiscoverer(new StandardReflectionParameterNameDiscoverer());
}
addDiscoverer(new LocalVariableTableParameterNameDiscoverer());
}
}
我们看到，DefaultParameterNameDiscoverer继承自PrioritizedParameterNameDiscoverer（一个ParameterNameDiscoverer代理，里面维护了带优先级的参数名解析器集合，先添加的优先解析，如果某个解析器解析后返回null，则会使用下一个解析器进行解析，默认情况下使用Java 8的反射机制进行解析，解析失败就fall back到使用基于ASM的参数解析器去获取class文件里的debug信息），在构造DefaultParameterNameDiscoverer时就维护了解析器集合，如果类路径下存在java.lang.reflect.Executable，就添加一个StandardReflectionParameterNameDiscoverer(使用Java 8的反射机制)，再添加基于ASM的参数解析器LocalVariableTableParameterNameDiscoverer，用于fall back时的解析
- 从参数解析器列表里找到能够支持该参数解析的
if (this.argumentResolvers.supportsParameter(parameter))
private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
if (result == null) {
for (HandlerMethodArgumentResolver methodArgumentResolver : this.argumentResolvers) {
if (logger.isTraceEnabled()) {
logger.trace("Testing if argument resolver [" + methodArgumentResolver + "] supports [" +
parameter.getGenericParameterType() + "]");
}
if (methodArgumentResolver.supportsParameter(parameter)) {
result = methodArgumentResolver;
this.argumentResolverCache.put(parameter, result);
break;
}
}
}
return result;
}
这里，能够支持我们代码中参数解析的解析器为RequestParamMethodArgumentResolver，何以见得？我们看org.springframework.web.method.annotation.RequestParamMethodArgumentResolver#supportsParameter
public boolean supportsParameter(MethodParameter parameter) {
if (parameter.hasParameterAnnotation(RequestParam.class)) {//我们的两个参数都没有用RequestParam注解进行修饰，因此代码会走到else
if (Map.class.isAssignableFrom(parameter.nestedIfOptional().getNestedParameterType())) {
String paramName = parameter.getParameterAnnotation(RequestParam.class).name();
return StringUtils.hasText(paramName);
}
else {
return true;
}
}
else {
if (parameter.hasParameterAnnotation(RequestPart.class)) {
return false;
}
parameter = parameter.nestedIfOptional();
if (MultipartResolutionDelegate.isMultipartArgument(parameter)) {
return true;
}
else if (this.useDefaultResolution) {/true
return BeanUtils.isSimpleProperty(parameter.getNestedParameterType());//代码会走到这里
}
else {
return false;
}
}
}
public static boolean isSimpleProperty(Class<?> clazz) {
Assert.notNull(clazz, "Class must not be null");
return isSimpleValueType(clazz) || (clazz.isArray() && isSimpleValueType(clazz.getComponentType()));
}
public static boolean isSimpleValueType(Class<?> clazz) {
return (ClassUtils.isPrimitiveOrWrapper(clazz) ||
Enum.class.isAssignableFrom(clazz) ||
CharSequence.class.isAssignableFrom(clazz) ||
Number.class.isAssignableFrom(clazz) ||
Date.class.isAssignableFrom(clazz) ||
URI.class == clazz || URL.class == clazz ||
Locale.class == clazz || Class.class == clazz);
}
其实，Spring MVC在RequestMappingHandlerAdapter的afterPropertiesSet方法中初始化了参数解析器列表argumentResolvers，注册了四类一系列参数解析器：
- 基于注解的参数解析器
- RequestParamMethodArgumentResolver(@RequestParam，useDefaultResolution = false)
- RequestParamMapMethodArgumentResolver(@RequestParam)
- PathVariableMethodArgumentResolver(@PathVariable)、
- RequestHeaderMethodArgumentResolver(@RequestHeader)
- RequestResponseBodyMethodProcesso(r@RequestBody)
- ServletModelAttributeMethodProcessor(@ModelAttribute， annotationNotRequired = false)
- ...
- 基于类型的参数注解器
- ServletRequestMethodArgumentResolver(ServletRequest、InputStream)
- ServletResponseMethodArgumentResolver(ServletResponse、OutputStream)
- ModelMethodProcessor(Model)
- ...
- 自定义参数解析器
- 兜底参数解析器
- RequestParamMethodArgumentResolver(useDefaultResolution = true)
- ServletModelAttributeMethodProcessor(annotationNotRequired = true)
其中RequestParamMethodArgumentResolver被注册了两次，第一次useDefaultResolution = false，第二次useDefaultResolution = true。
useDefaultResolution的含义是：一个简单类型的方法参数，如果没有被诸如@RequestParam等注解修饰，要不要被当成一个请求参数去解析。
我们的两个请求参数filedOne、filedTwo，都没有被@RequestParam进行注解，且类型都是简单类型(Integer、String)。因此，我们的两个请求参数都将会被RequestParamMethodArgumentResolver进行解析
- 进行参数解析
args[i] = this.argumentResolvers.resolveArgument(
parameter, mavContainer, request, this.dataBinderFactory);
public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
if (resolver == null) {
throw new IllegalArgumentException("Unknown parameter type [" + parameter.getParameterType().getName() + "]");
}
return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
}
经过上面的分析，知道我们的resolver就是RequestParamMethodArgumentResolver，它并没有重写resolveArgument方法，因此这里调用的是父类AbstractNamedValueMethodArgumentResolver里的方法，我们接着看
public final Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);//获取参数信息，包含参数名，是否required，以及参数默认值
MethodParameter nestedParameter = parameter.nestedIfOptional();
Object resolvedName = resolveStringValue(namedValueInfo.name);//获取解析后的参数名
...（省略）
Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);//获取参数值
...（省略）
arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);//转型成实际的参数类型
...（省略）
handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);//勾子方法，处理解析之后的值
return arg;
}
进入getNamedValueInfo方法
private NamedValueInfo getNamedValueInfo(MethodParameter parameter) {
NamedValueInfo namedValueInfo = this.namedValueInfoCache.get(parameter);
if (namedValueInfo == null) {
namedValueInfo = createNamedValueInfo(parameter);
namedValueInfo = updateNamedValueInfo(parameter, namedValueInfo);
this.namedValueInfoCache.put(parameter, namedValueInfo);
}
return namedValueInfo;
}
第一次进来，无法从cache获取到NamedValueInfo信息，需要经过create、update步骤之后，再放回缓存。
createNamedValueInfo方法主要是根据@RequestParam获取name、required、defaultValue信息，但我们这里并没有用该注解修饰，所以会分别给给默认值""、false、ValueConstants.DEFAULT_NONE。
接下来是updateNamedValueInfo方法
private NamedValueInfo updateNamedValueInfo(MethodParameter parameter, NamedValueInfo info) {
String name = info.name;
if (info.name.isEmpty()) {
name = parameter.getParameterName();
...（省略）
}
我们知道在createNamedValueInfo中， info.name被赋值为""，因此直接进入name = parameter.getParameterName()
public String getParameterName() {
ParameterNameDiscoverer discoverer = this.parameterNameDiscoverer; // 这里是上面提到的DefaultParameterNameDiscoverer
if (discoverer != null) {
String[] parameterNames = (this.method != null ?
discoverer.getParameterNames(this.method) : discoverer.getParameterNames(this.constructor));
if (parameterNames != null) {
this.parameterName = parameterNames[this.parameterIndex];
}
this.parameterNameDiscoverer = null;
}
return this.parameterName;
}
discoverer为上文中提到的DefaultParameterNameDiscoverer，因此我们直接进入其getParameterNames方法，又因未重写该方法，因此实际上调用的是其父类PrioritizedParameterNameDiscoverer的相应方法。
@Override
public String[] getParameterNames(Method method) {
for (ParameterNameDiscoverer pnd : this.parameterNameDiscoverers) {
String[] result = pnd.getParameterNames(method);
if (result != null) {
return result;
}
}
return null;
}
正如我们上文提到的，PrioritizedParameterNameDiscoverer是一个解析器代理，其维护多个解析器。在解析的时候，使用其维护的解析器集合一一进行解析，如果解析成功，直接返回；如果解析失败，则使用集合中下一个解析器进行解析。
第一个解析器是StandardReflectionParameterNameDiscoverer，因为我们并未使用 -parameters进行编译，因此解析失败，返回null。
第二个解析器是LocalVariableTableParameterNameDiscoverer，其实现如下：
public String[] getParameterNames(Method method) {
Method originalMethod = BridgeMethodResolver.findBridgedMethod(method); //根据桥接方法寻找原始方法，在这里桥接方法跟原始方法是同一个
Class<?> declaringClass = originalMethod.getDeclaringClass();
Map<Member, String[]> map = this.parameterNamesCache.get(declaringClass);
if (map == null) {
map = inspectClass(declaringClass); //使用ASM获取类信息
this.parameterNamesCache.put(declaringClass, map);
}
if (map != NO_DEBUG_INFO_MAP) {
return map.get(originalMethod);
}
return null;
}
进入inspectClass方法
private Map<Member, String[]> inspectClass(Class<?> clazz) {
InputStream is = clazz.getResourceAsStream(ClassUtils.getClassFileName(clazz));
...（省略）
ClassReader classReader = new ClassReader(is);
Map<Member, String[]> map = new ConcurrentHashMap<Member, String[]>(32);
classReader.accept(new ParameterNameDiscoveringVisitor(clazz, map), 0);
return map;
...（省略）
}
先是读取class文件进流里，然后借助ClassVisitor，调用ClassReader的accept方法去解析Java类文件。而accept方法呈现的细节，正是对class文件解析。
class结构如下：
ClassFile {
u4 magic;
u2 minor_version;
u2 major_version;
u2 constant_pool_count;
cp_info constant_pool[constant_pool_count-1];
u2 access_flags;
u2 this_class;
u2 super_class;
u2 interfaces_count;
u2 interfaces[interfaces_count];
u2 fields_count;
field_info fields[fields_count];
u2 methods_count;
method_info methods[methods_count];
u2 attributes_count;
attribute_info attributes[attributes_count];
}
从上述结构中看到，class文件中存储有一项类型为method_info的methods属性，我们称之为方法表。再来看看method_info的结构：
method_info {
u2 access_flags;
u2 name_index;
u2 descriptor_index;
u2 attributes_count;
attribute_info attributes[attributes_count];
}
method_info中存储有一项类型为attribute_info的attributes属性，我们称之为属性表。再来看看attribute_info的结构：
attribute_info {
u2 attribute_name_index;
u4 attribute_length;
u1 info[attribute_length];
}
这是attribute_info的通用结构，它可以用在ClassFile、field_info、method_info、Code_attribute中。正是由于这个原因，上面的method_info才能包含attribute_info类型的属性attributes。而其中有一项属性叫Code，其结构为：
Code_attribute {
u2 attribute_name_index;
u4 attribute_length;
u2 max_stack;
u2 max_locals;
u4 code_length;
u1 code[code_length];
u2 exception_table_length;
{ u2 start_pc;
u2 end_pc;
u2 handler_pc;
u2 catch_type;
} exception_table[exception_table_length];
u2 attributes_count;
attribute_info attributes[attributes_count];
}
刚才我们说过，attribute_info还能用在Code_attribute中，所以上面的结构中，又包含了attribute_info类型的属性attributes。其中有一项属性叫LocalVariableTypeTable，我们看看其结构：
LocalVariableTable_attribute {
u2 attribute_name_index;
u4 attribute_length;
u2 local_variable_table_length;
{ u2 start_pc;
u2 length;
u2 name_index;
u2 descriptor_index;
u2 index;
} local_variable_table[local_variable_table_length];
}
里面有一个内嵌属性local_variable_table，其中的name_index指向了常量池中的某项CONSTANT_Utf8_info，其值就是我们所要找的参数名。
关于class文件的结构，更详细的内容可以查阅官方文档
至此，总算弄明白Spring MVC对于无注解的参数是如何获取参数名的：通过LocalVariableTableParameterNameDiscoverer进行解析，该解析器借助了ASM工具，读取class文件，根据class文件的结构，读取method_info->Code_attribute->LocalVariableTable_attribute->local_variable_table->name_index->CONSTANT_Utf8_info，最终找到方法的参数名
