0. 写在前面
一次偶然写代码的时候想到这个问题，通过反射我们是无法得到方法参数的名称的，那么spring mvc是如何通过参数名称完成请求参数绑定的呢？带着这个疑问进行了一番调查。
1. 参数绑定的方式
参数绑定的核心在于如何确定请求参数与方法参数之间如何对应，大致上，spring mvc实现请求参数和方法参数的绑定有三种方式，一种是通过注解实现，包括使用@PathVariable和@RequestParam。一个简单的实例如下，方法参数将同请求中参数名为注解中指定的名称进行绑定。
@GetMapping("annotation")
public void testAnnotation(
@RequestParam("f1") int f1, @RequestParam("f2")int f2, @RequestParam("f3")int f3
, @RequestParam("f4")int f4, @RequestParam("f5")int f5, @RequestParam("f6")int f6
, @RequestParam("f7")int f7, @RequestParam("f8")int f8, @RequestParam("f9")int f9
, @RequestParam("f10")int f10, @RequestParam("f11")int f11, @RequestParam("f12")int f12
, @RequestParam("f13")int f13, @RequestParam("f14")int f14, @RequestParam("f15")int f15
, @RequestParam("f16")int f16) {
System.out.println("annotation:" + System.currentTimeMillis());
}
第二种方式是不使用注解，直接通过参数名称与请求参数名称绑定
@GetMapping("name")
public void testByName(int f1, int f2, int f3, int f4, int f5
, int f6, int f7, int f8, int f9, int f10
, int f11, int f12, int f13, int f14, int f15, int f16) {
System.out.println("name:" + System.currentTimeMillis());
}
第三种方式是参数对象的属性与请求参数实现绑定
@GetMapping("domain")
public void testByDomain(TestDomain domain){
System.out.println("domain:" + System.currentTimeMillis());
}
2. 参数解析的方式
spring mvc使用了多个参数解析器用于针对各类参数的解析，这些解析器都实现了HandlerMethodArgumentResolver这个接口，spring mvc使用策略模式轮询每一种参数解析器来寻找适合参数的解析器，找到过后将放入缓存之中，下一次请求同一个方法时将直接从缓存中拿到解析器。源代码如下
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;
}
解析@RequestParam注解的参数解析器是RequestParamMethodArgumentResolver，初次解析时将通过反射获取注解中指定的参数名称
@Override
protected NamedValueInfo createNamedValueInfo(MethodParameter parameter) {
RequestParam ann = parameter.getParameterAnnotation(RequestParam.class);
return (ann != null ? new RequestParamNamedValueInfo(ann) : new RequestParamNamedValueInfo());
}
--------------
public RequestParamNamedValueInfo(RequestParam annotation) {
super(annotation.name(), annotation.required(), annotation.defaultValue());
}
--------------
public NamedValueInfo(String name, boolean required, String defaultValue) {
this.name = name;
this.required = required;
this.defaultValue = defaultValue;
}
再次进行解析时，则通过缓存直接得到RequestParamNamedValueInfo，缓存是ConcurrentHashMap，并发读无限制，代码中并发写线程安全
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;
}
不使用注解直接通过方法参数名绑定时对应的解析器仍然是RequestParamMethodArgumentResolver，在spring mvc提供的参数解析器之中包含两个该实例，能对方法参数名解析的实例中useDefaultResolution为true，也就是说作为默认解析了。该实例顺序在倒数第二，也就是说此前的策略都无法解析的情况下，使用该策略
else if (this.useDefaultResolution) {
return BeanUtils.isSimpleProperty(parameter.getNestedParameterType());
}
我们知道通过反射是无法获取方法参数名的，那么spring mvc是如何做到的呢？
spring mvc在java1.8之前使用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);
this.parameterNamesCache.put(declaringClass, map);
}
if (map != NO_DEBUG_INFO_MAP) {
return map.get(originalMethod);
}
return null;
}
缓存无法获取参数名信息的情况下，spring mvc将调用inspectClass方法区获取参数名信息，如果仍然无法获取，即map == NO_DEBUG_INFO_MAP则代表在类编译阶段没有生成调试信息，根本不可能获取到参数名信息。
这里有两个关键点，一个是inspectClass如何解析参数名信息，第二个是什么事参数名信息。先来看第一个，继续往下看代码，实质上获取参数名信息是通过spring自己实现的asm对类文件进行解析，asm也是cglib底层使用的工具，相关内容可以百度哈。这里也就是说spring mvc获取参数名信息是通过asm解析类文件拿到调试信息，而调试信息里面有参数名信息。
private Map<Member, String[]> inspectClass(Class<?> clazz) {
InputStream is = clazz.getResourceAsStream(ClassUtils.getClassFileName(clazz));
if (is == null) {
// We couldn't load the class file, which is not fatal as it
// simply means this method of discovering parameter names won't work.
if (logger.isDebugEnabled()) {
logger.debug("Cannot find '.class' file for class [" + clazz +
"] - unable to determine constructor/method parameter names");
}
return NO_DEBUG_INFO_MAP;
}
try {
ClassReader classReader = new ClassReader(is);
Map<Member, String[]> map = new ConcurrentHashMap<Member, String[]>(32);
classReader.accept(new ParameterNameDiscoveringVisitor(clazz, map), 0);
return map;
}
catch (IOException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Exception thrown while reading '.class' file for class [" + clazz +
"] - unable to determine constructor/method parameter names", ex);
}
}
catch (IllegalArgumentException ex) {
if (logger.isDebugEnabled()) {
logger.debug("ASM ClassReader failed to parse class file [" + clazz +
"], probably due to a new Java class file version that isn't supported yet " +
"- unable to determine constructor/method parameter names", ex);
}
}
finally {
try {
is.close();
}
catch (IOException ex) {
// ignore
}
}
return NO_DEBUG_INFO_MAP;
}
那么调试信息是如何生成的呢？这实际是在编译器决定的，对于java1.8之前，我们可以使用-g来生成调试信息，-g的具体使用可自行百度，我们直接看效果
D:\java\mushroomplay\pmp\pmp-core\project\src\main\java\com\jd\pmp\project\dao>javac Main.java
D:\java\mushroomplay\pmp\pmp-core\project\src\main\java\com\jd\pmp\project\dao>javap -l Main.class
Compiled from "Main.java"
public class Main {
public Main();
LineNumberTable:
line 8: 0
public void f1(java.lang.String, int);
LineNumberTable:
line 13: 0
public java.lang.String f2(java.util.Map);
LineNumberTable:
line 16: 0
}
D:\java\mushroomplay\pmp\pmp-core\project\src\main\java\com\jd\pmp\project\dao>javac -g Main.java
D:\java\mushroomplay\pmp\pmp-core\project\src\main\java\com\jd\pmp\project\dao>javap -l Main.class
Compiled from "Main.java"
public class Main {
public Main();
LineNumberTable:
line 8: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this LMain;
public void f1(java.lang.String, int);
LineNumberTable:
line 13: 0
LocalVariableTable:
Start Length Slot Name Signature
0 1 0 this LMain;
0 1 1 name Ljava/lang/String;
0 1 2 age I
public java.lang.String f2(java.util.Map);
LineNumberTable:
line 16: 0
LocalVariableTable:
Start Length Slot Name Signature
0 2 0 this LMain;
0 2 1 map Ljava/util/Map;
}
可以看出当编译时使用-g时我们可以看到生成了LocalVariableTable，里面保存了该类中所有方法的参数名信息。-g默认是不打开的，不过maven编译时默认是打开的，也就是说如果我们不特别指定，maven会自动生成调试信息，asm也就能够解析出参数名信息供spring mvc进行参数绑定。这是maven官方对应的文档：http://maven.apache.org/plugins/maven-compiler-plugin/compile-mojo.html
针对java1.8，我们可以在编译期使用-parameter参数，这样我们可以通过反射获取参数名信息，1.8jdk在反射包增加了
Parameter这个类，该类可以在使用了-paramter的情况下得到参数名信息。针对这个情况，spring mvc提供了如下这个类获取参数名信息
@UsesJava8
public class StandardReflectionParameterNameDiscoverer implements ParameterNameDiscoverer
最后是通过对象实现绑定，这种方式使用ServletModelAttributeMethodProcessor进行绑定，就不多说了
3. 不同解析方式的性能
通过简单的测试发现，如果是启动后第一次访问三种方式的速度都会比再次访问更慢，可以很容易的理解这是有缓存的缘故。三种方式对比则没有明显的性能差异。
