Spring MVC参数解析之ParameterNameDiscoverer

大家知道,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;
}
  1. 获取方法参数。
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为空。

  1. 设置参数名解析器:
parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);

其中,this.parameterNameDiscovererInvocableHandlerMethod类的一个成员变量,直接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时的解析

  1. 从参数解析器列表里找到能够支持该参数解析的
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在RequestMappingHandlerAdapterafterPropertiesSet方法中初始化了参数解析器列表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进行解析

  1. 进行参数解析
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,调用ClassReaderaccept方法去解析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,最终找到方法的参数名

  • 7
    点赞
  • 10
    收藏
    觉得还不错? 一键收藏
  • 3
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值