SpringMVC源码分析-HandlerAdapter(7)-ServletInvocableHandlerMethod组件分析

BraveWang
367 阅读6分钟

###ServletInvocableHandlerMethod继承结构

ServletInvocableHandlerMethod

如图:ServletInvocableHandlerMethod也是一种HandlerMethod
相比HandlerMethod增加了参数解析,返回值处理等功能,最重要的是新增了方法的执行功能

下面依次分析这三个组件

###HandlerMethod

HandlerMapping组件中用到了HandlerMethod	
HandlerMethod用于封装Handler和处理请求的Method

HandlerMethod的属性:

// Handler
private final Object bean;
// 传入的Handler为String类型时,需要使用beanFactory获取bean
private final BeanFactory beanFactory;
// bean类型
private final Class<?> beanType;
// method
private final Method method;
// 当method是bridge method时设置为原有方法,否则设置为method
private final Method bridgedMethod;
// 处理请求的方法的参数
private final MethodParameter[] parameters;

private final HandlerMethod resolvedFromHandlerMethod;

需要注意的是:
HandlerMethod所有属性都是final类型.创建后不可修改
如果Handler为String类型,需要从容器查找bean
将bean属性变为容器中的bean是使用createWithResolvedBean方法完成的
其实是使用容器中找到的bean和HandlerMethod原来的属性新建了一个HandlerMethod

createWithResolvedBean源码:

public HandlerMethod createWithResolvedBean() {
	Object handler = this.bean;
	// handler为String类型,从容器获取Bean
	if (this.bean instanceof String) {
		String beanName = (String) this.bean;
		handler = this.beanFactory.getBean(beanName);
	}
	// 使用当前HandlerMethod和handler新建一个HandlerMethod
	return new HandlerMethod(this, handler);
}

private HandlerMethod(HandlerMethod handlerMethod, Object handler) {
	Assert.notNull(handlerMethod, "HandlerMethod is required");
	Assert.notNull(handler, "Handler object is required");
	this.bean = handler;
	this.beanFactory = handlerMethod.beanFactory;
	this.beanType = handlerMethod.beanType;
	this.method = handlerMethod.method;
	this.bridgedMethod = handlerMethod.bridgedMethod;
	this.parameters = handlerMethod.parameters;
	this.resolvedFromHandlerMethod = handlerMethod;
}

这里,parameters的类型是MethodParameter[],来看看这个类型

###MethodParameter

MethodParameter

// 参数所在方法
private final Method method;
// 参数的构成方法
private final Constructor<?> constructor;
// 参数的需要,从0开始
private final int parameterIndex;
// 嵌套级别
private int nestingLevel = 1;
// 保存每层嵌套参数的序号
Map<Integer, Integer> typeIndexesPerLevel;
// 容器类型,参数所属方法所在的类
private volatile Class<?> containingClass;
// 参数类型
private volatile Class<?> parameterType;
// Type型的参数类型
private volatile Type genericParameterType;
// 参数的注解
private volatile Annotation[] parameterAnnotations;
// 参数名称查找器
private volatile ParameterNameDiscoverer parameterNameDiscoverer;
// 参数名称
private volatile String parameterName;

private volatile MethodParameter nestedMethodParameter;

其中最重要的两个属性是:method和parameterIndex
因为有了这两个参数,参数类型,注释等都可以获取到

parameterNameDiscoverer参数名查找组件,可以查找出参数的名称

HandlerMothod定义了两个内部类来封装参数:
	HandlerMethodParameter封装方法调用的参数
	ReturnValueMethodParameter封装方法返回的参数
	ReturnValueMethodParameter继承自HandlerMethodParameter
	他们主要是用method和parameterIndex创建MethodParameter
	他们使用的method都是bridgedMethod,返回值使用的parameterIndex为-1

HandlerMethodParameter源码:

protected class HandlerMethodParameter extends SynthesizingMethodParameter {

	public HandlerMethodParameter(int index) {
		super(HandlerMethod.this.bridgedMethod, index);
	}

	protected HandlerMethodParameter(HandlerMethodParameter original) {
		super(original);
	}

	@Override
	public Class<?> getContainingClass() {
		return HandlerMethod.this.getBeanType();
	}

	@Override
	public <T extends Annotation> T getMethodAnnotation(Class<T> annotationType) {
		return HandlerMethod.this.getMethodAnnotation(annotationType);
	}

	@Override
	public <T extends Annotation> boolean hasMethodAnnotation(Class<T> annotationType) {
		return HandlerMethod.this.hasMethodAnnotation(annotationType);
	}

	@Override
	public HandlerMethodParameter clone() {
		return new HandlerMethodParameter(this);
	}
}

ReturnValueMethodParameter源码:

private class ReturnValueMethodParameter extends HandlerMethodParameter {

	private final Object returnValue;

	public ReturnValueMethodParameter(Object returnValue) {
		super(-1);
		this.returnValue = returnValue;
	}

	protected ReturnValueMethodParameter(ReturnValueMethodParameter original) {
		super(original);
		this.returnValue = original.returnValue;
	}

	@Override
	public Class<?> getParameterType() {
		return (this.returnValue != null ? this.returnValue.getClass() : super.getParameterType());
	}

	@Override
	public ReturnValueMethodParameter clone() {
		return new ReturnValueMethodParameter(this);
	}
}

###InvocableHandlerMethod

InvocableHandlerMethod继承自HandlerMethod
InvocableHandlerMethod可以直接调用内部属性method对应的方法

InvocableHandlerMethod中增加了三个属性

private WebDataBinderFactory dataBinderFactory;
private HandlerMethodArgumentResolverComposite argumentResolvers = new HandlerMethodArgumentResolverComposite();
private ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();

dataBinderFactory
	WebDataBinderFactory类型,可以创建WebDataBinder
	用于参数解析器ArgumentSolver中
	
argumentResolvers
	HandlerMethodArgumentResolverComposite类型
	用于解析参数
	
parameterNameDiscoverer
	ParameterNameDiscoverer类型
	用来获取参数名,用于MethodParameter中

InvocableHandlerMethod中Method的调用方法是invokeForRequest

invokeForRequest源码:

public Object invokeForRequest(NativeWebRequest request, ModelAndViewContainer mavContainer,
		Object... providedArgs) throws Exception {
	
	// 获取方法参数
	Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
	if (logger.isTraceEnabled()) {
		logger.trace("Invoking '" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) +
				"' with arguments " + Arrays.toString(args));
	}
	// 调用Method
	Object returnValue = doInvoke(args);
	if (logger.isTraceEnabled()) {
		logger.trace("Method [" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) +
				"] returned [" + returnValue + "]");
	}
	return returnValue;
}

可以看到doInvoke方法是实际执行请求的方法
doInvoke是整个HandlerMethod系列处理器中最核心的方法

doInvoke源码:

protected Object doInvoke(Object... args) throws Exception {
	// 强制方法可调用
	ReflectionUtils.makeAccessible(getBridgedMethod());
	try {
		// 执行
		return getBridgedMethod().invoke(getBean(), args);
	}
	catch (IllegalArgumentException ex) {
		assertTargetBean(getBridgedMethod(), getBean(), args);
		String text = (ex.getMessage() != null ? ex.getMessage() : "Illegal argument");
		throw new IllegalStateException(getInvocationErrorMessage(text, args), ex);
	}
	catch (InvocationTargetException ex) {
		// Unwrap for HandlerExceptionResolvers ...
		Throwable targetException = ex.getTargetException();
		if (targetException instanceof RuntimeException) {
			throw (RuntimeException) targetException;
		}
		else if (targetException instanceof Error) {
			throw (Error) targetException;
		}
		else if (targetException instanceof Exception) {
			throw (Exception) targetException;
		}
		else {
			String text = getInvocationErrorMessage("Failed to invoke handler method", args);
			throw new IllegalStateException(text, targetException);
		}
	}
}

除去异常处理,最核心的一句是getBridgedMethod().invoke(getBean(), args);
真正执行的方法就是直接调用bridgedMethod的invoke方法

调用前使用ReflectionUtils.makeAccessible强制方法变为可调用方法
及时订单的处理器方法是private也可以在这里被调用

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设置参数名解析器parameterNameDiscoverer
		parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
		// 如果响应类型的参数已经在providedArgs中提供了,则直接设置到parameter
		args[i] = resolveProvidedArgument(parameter, providedArgs);
		if (args[i] != null) {
			continue;
		}
		// 使用argumentResolvers解析参数
		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,调用父类getMethodParameters方法获取Method所有参数
2,定义一个Object类型的数组args用于保存解析出来的参数值
3,遍历每个参数进行解析,两种解析方法:
	1)在providedArgs中找
	2)使用argumentResolvers解析
	注:在RequestMappingHandlerAdapter中的调用并没有提供providedArgs
	所以只能用argumentResolvers来进行解析
4,为参数设置parameterNameDiscoverer用于获取参数名
	parameterNameDiscoverer可以在RequestMappingHandlerAdapter定义时配置
	默认使用DefaultParameterNameDiscoverer

InvocableHandlerMethod就是在HandlerMetod基础上添加了方法的调用功能
方法调用需要解析参数,所以也提供了解析参数的功能

注解了@InitBinder和@ModeAttribute的方法就是封装成InvocableHandlerMethod对象
,然后直接执行的

###ServletInvocableHandlerMethod

ServletInvocableHandlerMethod继承自InvocableHandlerMethod
在父类的基础上添加了三个功能:
1,对@ResponseStatus注解的支出
2,对返回值的处理
3,对异步处理结果的处理

@ResponseStatus注解

@ResponseStatus注解用于处理器方法或返回值上
作用是对返回Response的Status进行设置
有两个参数:value(HttpStatus类型)和reason(String类型,默认为空串)错误原因

当一个方法注释了@ResponseStatus后,返回的Status会使用注释中的Status
如果处理器返回值为空或reason不为空,将中断处理直接返回(不再渲染页面)

返回值处理

对返回值的处理是使用returnValueHandlers属性完成的,
returnValueHandlers是HandlerMethodReturnValueHandler类型

异步处理暂时不做了解

###invokeAndHandle

ServletInvocableHandlerMethod处理请求使用的是invokeAndHandle方法
(注意,不是invokeAndHandler,没有r)

invokeAndHandle源码:

public void invokeAndHandle(ServletWebRequest webRequest,
		ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {

	// 调用父类invokeForRequest执行请求
	Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
	// 处理@ResponseStatus注解
	setResponseStatus(webRequest);
	// 处理返回值
	if (returnValue == null) {//判断返回值是不是null
		// Request的NotModified为真
		// 有@ResponseStatus
		// RequestHandled=true      
		// 三个条件有一个成立,则设置请求处理完成并返回
		if (isRequestNotModified(webRequest) || hasResponseStatus() || mavContainer.isRequestHandled()) {
			mavContainer.setRequestHandled(true);
			return;
		}
	}
	// 返回值不为null,@ResponseStatus存在reason
	// 设置请求处理完成并返回
	else if (StringUtils.hasText(this.responseReason)) {
		mavContainer.setRequestHandled(true);
		return;
	}

	// 前边都不成立,则设置RequestHandled=false即请求未完成
	// 使用returnValueHandlers处理返回值
	mavContainer.setRequestHandled(false);
	try {
		this.returnValueHandlers.handleReturnValue(
				returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
	}
	catch (Exception ex) {
		if (logger.isTraceEnabled()) {
			logger.trace(getReturnValueHandlingErrorMessage("Error handling return value", returnValue), ex);
		}
		throw ex;
	}
}

setResponseStatus:

private void setResponseStatus(ServletWebRequest webRequest) throws IOException {

	if (this.responseStatus == null) {
		return;
	}
	if (StringUtils.hasText(this.responseReason)) {
		webRequest.getResponse().sendError(this.responseStatus.value(), this.responseReason);
	}
	else {
		webRequest.getResponse().setStatus(this.responseStatus.value());
	}
	// 设置到request的属性,为了在redirect中使用
	webRequest.getRequest().setAttribute(View.RESPONSE_STATUS_ATTRIBUTE, this.responseStatus);
}
avatar
文章
阅读
粉丝