接着上一小节，上面提到RequestResponseBodyMethodProcessor，这个参数解析器既实现了HandlerMethodArgumentResolver，也实现了HandlerMethodReturnValueHandler，所以它既能处理方法参数，也能处理方法返回值
public Object org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor.resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
//RequestResponseBodyMethodProcessor是一个用于处理http请求体的参数处理器，但是http请求体传递过来的参数有不同的表现形式，比如有json类型的，有xml数据流形式的，所以需要额外的http消息转换器进行处理，消息转换器是我们在创建HandlerAdapter的初始化方法中设置到RequestResponseBodyMethodProcessor中的
Object arg = readWithMessageConverters(webRequest, parameter, parameter.getGenericParameterType());
//获取参数名
String name = Conventions.getVariableNameForParameter(parameter);
//创建参数绑定，为什么要使用参数绑定？参数绑定提供了将我们解析后参数如何设置到方法参数上的能力
//我们自定义的参数转换器，属性编辑器都是通过它来进行维护，使用。
WebDataBinder binder = binderFactory.createBinder(webRequest, arg, name);
if (arg != null) {
//校验参数
validateIfApplicable(binder, parameter);
if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
//绑定出错时，抛出错误
throw new MethodArgumentNotValidException(parameter, binder.getBindingResult());
}
}
//记录参数绑定的结果
mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());
return arg;
}
挑选http消息解析器
protected <T> Object org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor.readWithMessageConverters(NativeWebRequest webRequest, MethodParameter methodParam,
Type paramType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {
//获取request
HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
//包装本地request，ServletServerHttpRequest提供更多的扩展方法，比如直接获取请求体数据流等
ServletServerHttpRequest inputMessage = new ServletServerHttpRequest(servletRequest);
Object arg = readWithMessageConverters(inputMessage, methodParam, paramType);
//无法解析，抛错
if (arg == null) {
if (methodParam.getParameterAnnotation(RequestBody.class).required()) {
throw new HttpMessageNotReadableException("Required request body is missing: " +
methodParam.getMethod().toGenericString());
}
}
return arg;
}
readWithMessageConverters
protected <T> Object org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodArgumentResolver.readWithMessageConverters(HttpInputMessage inputMessage, MethodParameter param,
Type targetType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {
MediaType contentType;
boolean noContentType = false;
try {
//从请求头中获取请求的媒体类型
contentType = inputMessage.getHeaders().getContentType();
}
catch (InvalidMediaTypeException ex) {
throw new HttpMediaTypeNotSupportedException(ex.getMessage());
}
if (contentType == null) {
//标记请求没有提供媒体类型
noContentType = true;
//设置默认的媒体类型为流
contentType = MediaType.APPLICATION_OCTET_STREAM;
}
//获取这个参数的包含类
Class<?> contextClass = (param != null ? param.getContainingClass() : null);
//获取参数类型
Class<T> targetClass = (targetType instanceof Class<?> ? (Class<T>) targetType : null);
if (targetClass == null) {
//解析参数类型
ResolvableType resolvableType = (param != null ?
ResolvableType.forMethodParameter(param) : ResolvableType.forType(targetType));
targetClass = (Class<T>) resolvableType.resolve();
}
//获取请求方法
HttpMethod httpMethod = ((HttpRequest) inputMessage).getMethod();
Object body = NO_VALUE;
try {
inputMessage = new EmptyBodyCheckingHttpInputMessage(inputMessage);
//寻找支持此参数的消息转换器
for (HttpMessageConverter<?> converter : this.messageConverters) {
Class<HttpMessageConverter<?>> converterType = (Class<HttpMessageConverter<?>>) converter.getClass();
//GenericHttpMessageConverter继承自HttpMessageConverter，它的read方法额外提供设置包含类的参数
//write方法额外提供了泛型类型参数
if (converter instanceof GenericHttpMessageConverter) {
GenericHttpMessageConverter<?> genericConverter = (GenericHttpMessageConverter<?>) converter;
//判断是否支持
if (genericConverter.canRead(targetType, contextClass, contentType)) {
if (logger.isDebugEnabled()) {
logger.debug("Read [" + targetType + "] as \"" + contentType + "\" with [" + converter + "]");
}
if (inputMessage.getBody() != null) {
//RequestAdvice前置拦截，RequestAdvice是在创建当前参数解析器时设置的
inputMessage = getAdvice().beforeBodyRead(inputMessage, param, targetType, converterType);
//解析参数值
body = genericConverter.read(targetType, contextClass, inputMessage);
//RequestAdvice后置拦截
body = getAdvice().afterBodyRead(body, inputMessage, param, targetType, converterType);
}
else {
body = null;
//处理空请求体，一般项目中很少使用实现了RequestAdvice接口的ControllerAdvice
body = getAdvice().handleEmptyBody(body, inputMessage, param, targetType, converterType);
}
break;
}
}
else if (targetClass != null) {
//差不多的处理方式，只是调用的方法参数不同罢了
if (converter.canRead(targetClass, contentType)) {
if (logger.isDebugEnabled()) {
logger.debug("Read [" + targetType + "] as \"" + contentType + "\" with [" + converter + "]");
}
if (inputMessage.getBody() != null) {
inputMessage = getAdvice().beforeBodyRead(inputMessage, param, targetType, converterType);
body = ((HttpMessageConverter<T>) converter).read(targetClass, inputMessage);
body = getAdvice().afterBodyRead(body, inputMessage, param, targetType, converterType);
}
else {
body = null;
body = getAdvice().handleEmptyBody(body, inputMessage, param, targetType, converterType);
}
break;
}
}
}
}
catch (IOException ex) {
throw new HttpMessageNotReadableException("Could not read document: " + ex.getMessage(), ex);
}
if (body == NO_VALUE) {
if (httpMethod == null || !SUPPORTED_METHODS.contains(httpMethod) ||
(noContentType && inputMessage.getBody() == null)) {
return null;
}
throw new HttpMediaTypeNotSupportedException(contentType, this.allSupportedMediaTypes);
}
return body;
}
我们挑选一个HttpMessageConverter进行分析，就拿MappingJackson2HttpMessageConverter进行分析吧
首先我们按照参数解析器筛选，调用消息转换器的顺序进行分析吧
public boolean org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter.canRead(Type type, Class<?> contextClass, MediaType mediaType) {
//判断是否是支持的媒体类型，消息转换器的默认媒体类型我们可以自定义设置
if (!canRead(mediaType)) {
return false;
}
//获取java类型，这个JavaType用于JackSon这个json框架判断是否能够进行序列化的类型
JavaType javaType = getJavaType(type, contextClass);
if (!jackson23Available || !logger.isWarnEnabled()) {
return this.objectMapper.canDeserialize(javaType);
}
AtomicReference<Throwable> causeRef = new AtomicReference<Throwable>();
//如果可以进行反序列化，直接返回true
if (this.objectMapper.canDeserialize(javaType, causeRef)) {
return true;
}
//如果有错误提示，那么打印日志
Throwable cause = causeRef.get();
if (cause != null) {
String msg = "Failed to evaluate Jackson deserialization for type " + javaType;
if (logger.isDebugEnabled()) {
logger.warn(msg, cause);
}
else {
logger.warn(msg + ": " + cause);
}
}
return false;
}
read
public Object org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter.read(Type type, Class<?> contextClass, HttpInputMessage inputMessage)
throws IOException, HttpMessageNotReadableException {
JavaType javaType = getJavaType(type, contextClass);
return readJavaType(javaType, inputMessage);
}
@SuppressWarnings("deprecation")
private Object org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter.readJavaType(JavaType javaType, HttpInputMessage inputMessage) {
try {
if (inputMessage instanceof MappingJacksonInputMessage) {
Class<?> deserializationView = ((MappingJacksonInputMessage) inputMessage).getDeserializationView();
if (deserializationView != null) {
return this.objectMapper.readerWithView(deserializationView).withType(javaType).
readValue(inputMessage.getBody());
}
}
//使用Jackson进行json反序列化
return this.objectMapper.readValue(inputMessage.getBody(), javaType);
}
catch (IOException ex) {
throw new HttpMessageNotReadableException("Could not read document: " + ex.getMessage(), ex);
}
}
顺便把写也说下，返回值处理的时候就不要不再赘述了
public boolean org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter.canWrite(Class<?> clazz, MediaType mediaType) {
//和read差不多的逻辑
if (!canWrite(mediaType)) {
return false;
}
if (!jackson23Available || !logger.isWarnEnabled()) {
return this.objectMapper.canSerialize(clazz);
}
AtomicReference<Throwable> causeRef = new AtomicReference<Throwable>();
if (this.objectMapper.canSerialize(clazz, causeRef)) {
return true;
}
Throwable cause = causeRef.get();
if (cause != null) {
String msg = "Failed to evaluate Jackson serialization for type [" + clazz + "]";
if (logger.isDebugEnabled()) {
logger.warn(msg, cause);
}
else {
logger.warn(msg + ": " + cause);
}
}
return false;
}
写
public final void org.springframework.http.converter.AbstractHttpMessageConverter.write(final T t, MediaType contentType, HttpOutputMessage outputMessage)
throws IOException, HttpMessageNotWritableException {
final HttpHeaders headers = outputMessage.getHeaders();
//设置默认的请求头，比如内容长度，返回的媒体雷星
addDefaultHeaders(headers, t, contentType);
if (outputMessage instanceof StreamingHttpOutputMessage) {
StreamingHttpOutputMessage streamingOutputMessage =
(StreamingHttpOutputMessage) outputMessage;
streamingOutputMessage.setBody(new StreamingHttpOutputMessage.Body() {
@Override
public void writeTo(final OutputStream outputStream) throws IOException {
//将值写到outputMessage的body中
writeInternal(t, new HttpOutputMessage() {
@Override
public OutputStream getBody() throws IOException {
return outputStream;
}
@Override
public HttpHeaders getHeaders() {
return headers;
}
});
}
});
}
else {
//(*1*)
writeInternal(t, outputMessage);
outputMessage.getBody().flush();
}
}
//(*1*)
protected void org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter.writeInternal(Object object, Type type, HttpOutputMessage outputMessage)
throws IOException, HttpMessageNotWritableException {
//从媒体类型的参数中获取编码，比如application/json;charset=utf-8,获取到utf-8
JsonEncoding encoding = getJsonEncoding(outputMessage.getHeaders().getContentType());
//创建Jackson的json生成器
JsonGenerator generator = this.objectMapper.getFactory().createGenerator(outputMessage.getBody(), encoding);
try {
//写入前缀，空方法
writePrefix(generator, object);
Class<?> serializationView = null;
FilterProvider filters = null;
Object value = object;
JavaType javaType = null;
。。。。。。省略部分代码，直接看到这个方法即可，将value值写到json生成器中，最后flush将所有数据都推到响应体中
objectWriter.writeValue(generator, value);
writeSuffix(generator, object);
generator.flush();
}
catch (JsonProcessingException ex) {
throw new HttpMessageNotWritableException("Could not write content: " + ex.getMessage(), ex);
}
}
好了，参数解析出来之后就要将参数绑定到方法上，那么我们的数据绑定将做什么呢？
//webRequest：维护中request和response，target：解析出来的参数值，objectName：参数名称
public final WebDataBinder org.springframework.web.bind.support.DefaultDataBinderFactory.createBinder(NativeWebRequest webRequest, Object target, String objectName)
throws Exception {
//创建数据绑定，这样一看每个方法参数都会创建一个属于他们的参数绑定对象
//new ExtendedServletRequestDataBinder(target, objectName);
WebDataBinder dataBinder = createBinderInstance(target, objectName, webRequest);
if (this.initializer != null) {
//初始化数据绑定
this.initializer.initBinder(dataBinder, webRequest);
}
//调用参数绑定方法，这时我们可以添加自己的属性编辑器
initBinder(dataBinder, webRequest);
return dataBinder;
}
初始化数据绑定实例
public void org.springframework.web.bind.support.ConfigurableWebBindingInitializer.initBinder(WebDataBinder binder, WebRequest request) {
//设置是否允许嵌入路径的自动创建，比如某个list字段，前端提交的表单是house.fruitBasket[1]=banner
//.fruitBasket[1]这个表示嵌入的路径，如果为false，那么就不会创建fruitBasket实例
binder.setAutoGrowNestedPaths(this.autoGrowNestedPaths);
//直接字段访问，默认为false，如果为true，将创建DirectFieldBindingResult，它获取的访问器是DirectFieldAccessor
//这个字段访问器将直接通过反射破坏字段的私有访问权限，直接调用Field#set方法设值
if (this.directFieldAccess) {
binder.initDirectFieldAccess();
}
//消息编码处理器，一般用于参数校验，解析错误编码，然后构建字段提示信息
if (this.messageCodesResolver != null) {
binder.setMessageCodesResolver(this.messageCodesResolver);
}
//设值绑定错误时的处理程序，将会使用上面设置的消息编码解析器来构建自己的错误信息
//然后设置到BindingResult中
if (this.bindingErrorProcessor != null) {
binder.setBindingErrorProcessor(this.bindingErrorProcessor);
}
//设置校验器
if (this.validator != null && binder.getTarget() != null &&
this.validator.supports(binder.getTarget().getClass())) {
binder.setValidator(this.validator);
}
//设置转换服务
if (this.conversionService != null) {
binder.setConversionService(this.conversionService);
}
//注册属性编辑器
if (this.propertyEditorRegistrars != null) {
for (PropertyEditorRegistrar propertyEditorRegistrar : this.propertyEditorRegistrars) {
propertyEditorRegistrar.registerCustomEditors(binder);
}
}
}
然后再看到调用参数绑定方法的实现
public void org.springframework.web.method.annotation.InitBinderDataBinderFactory.initBinder(WebDataBinder binder, NativeWebRequest request) throws Exception {
for (InvocableHandlerMethod binderMethod : this.binderMethods) {
//是否适用于当前参数
//(*1*)
if (isBinderMethodApplicable(binderMethod, binder)) {
//调用InvocableHandlerMethod，这个调用过程就不再赘述了
//这里SpringMVC提供了一个参数WebDataBinder，这样的话我们可以向它注册自定义的属性编辑器等
Object returnValue = binderMethod.invokeForRequest(request, null, binder);
//@InitBinder方法不允许有返回值，因为没有意义
if (returnValue != null) {
throw new IllegalStateException("@InitBinder methods should return void: " + binderMethod);
}
}
}
}
//(*1*)
protected boolean org.springframework.web.method.annotation.InitBinderDataBinderFactory.isBinderMethodApplicable(HandlerMethod initBinderMethod, WebDataBinder binder) {
//获取@InitBinder注解
InitBinder annot = initBinderMethod.getMethodAnnotation(InitBinder.class);
Collection<String> names = Arrays.asList(annot.value());
//如果没有指定参数名，或者指定的参数名是当前参数名，返回true
return (names.size() == 0 || names.contains(binder.getObjectName()));
}
校验参数值
protected void org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodArgumentResolver.validateIfApplicable(WebDataBinder binder, MethodParameter methodParam) {
//获取参数上的所有注解
Annotation[] annotations = methodParam.getParameterAnnotations();
for (Annotation ann : annotations) {
//如果存在@Validated元注解，那么会返回当前ann注解的代理注解，在spring中元注解就是当前注解的父类
Validated validatedAnn = AnnotationUtils.getAnnotation(ann, Validated.class);
//如果没有这个注解，那么查看当前注解是否是以Valid开头的
if (validatedAnn != null || ann.annotationType().getSimpleName().startsWith("Valid")) {
Object hints = (validatedAnn != null ? validatedAnn.value() : AnnotationUtils.getValue(ann));
Object[] validationHints = (hints instanceof Object[] ? (Object[]) hints : new Object[] {hints});
binder.validate(validationHints);
break;
}
}
}
我们上面的方法中似乎没有看到参数是如果进行绑定的，难道是SpringMVC漏操作了吗？肯定不是的，那是因为我们使用是RequestResponseBodyMethodProcessor
这个类只处理被@RequestBody标注的参数，意思就是将http请求体的内容进行json转化获取xml等其他形式的转换，得到的值不需要进行web参数绑定
所以为了研究参数的绑定我们选用另外一个参数解析器 -》 ModelAttributeMethodProcessor，这个类会处理被@ModelAttribute标注的参数
public final Object ModelAttributeMethodProcessor.resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
//获取参数名
String name = ModelFactory.getNameForParameter(parameter);
//mavContainer如果不存在这个值，那么会创建一个空的对象返回回来
Object attribute = (mavContainer.containsAttribute(name) ?
mavContainer.getModel().get(name) : createAttribute(name, parameter, binderFactory, webRequest));
//创建web数据绑定
WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);
if (binder.getTarget() != null) {
//这里就是参数绑定的逻辑，虽然创建参数对象，但是这个对象还是空白的，需要将请求参数的数据绑定上去
bindRequestParameters(binder, webRequest);
//校验
validateIfApplicable(binder, parameter);
if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
throw new BindException(binder.getBindingResult());
}
}
// Add resolved attribute and BindingResult at the end of the model
//将创建的@ModeAttribute注解参数设置以解析到的名字做key设置到map中并获取BindingResult对象
Map<String, Object> bindingResultModel = binder.getBindingResult().getModel();
//移除已经存在的属性
mavContainer.removeAttributes(bindingResultModel);
//添加到最后
mavContainer.addAllAttributes(bindingResultModel);
//进行参数转换
return binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);
}
参数绑定
protected void org.springframework.web.servlet.mvc.method.annotation.ServletModelAttributeMethodProcessor.bindRequestParameters(WebDataBinder binder, NativeWebRequest request) {
//获取本地（javax包下的那个request）request
ServletRequest servletRequest = request.getNativeRequest(ServletRequest.class);
ServletRequestDataBinder servletBinder = (ServletRequestDataBinder) binder;
//绑定
//(*1*)
servletBinder.bind(servletRequest);
}
//(*1*)
public void org.springframework.web.bind.ServletRequestDataBinder.bind(ServletRequest request) {
//构建参数，内部构造器会把request中请求参数封装成一个个PropertyValue
MutablePropertyValues mpvs = new ServletRequestParameterPropertyValues(request);
//检查这个请求是否为上传请求
MultipartRequest multipartRequest = WebUtils.getNativeRequest(request, MultipartRequest.class);
if (multipartRequest != null) {
//如果是的话，那么再构建封装MultiFile的PropertyValue
bindMultipart(multipartRequest.getMultiFileMap(), mpvs);
}
//把路径变量的值封装成PropertyValue
addBindValues(mpvs, request);
//(*2*)
doBind(mpvs);
}
//(*2*)
protected void org.springframework.web.bind.WebDataBinder.doBind(MutablePropertyValues mpvs) {
//检查并处理默认前缀，这个非常有用，如果我们的方法参数有两个对象，比如Person和Animal他们都一个共同的字段name
//当前前端提交参数的时候可定不是这样name=Amy&name=dog，SpringMVC不知道设置哪个
//那么就需要有前缀这东西，那么前端提交的时候就是person.name=Amy&animal.name=dog
//这样我们在SpringMVC中写两个@InitBinder方法，指定处理这两个参数的参数前缀
//(*3*)
checkFieldDefaults(mpvs);
//检查并处理标记前缀，和checkFieldDefaults类似，只不过被它标识的前缀属性值都被
//设置成空，比如Boolean就设置为false，数组就设置为空数组，其他的都设置为null
checkFieldMarkers(mpvs);
//(*4*)
super.doBind(mpvs);
}
//(*3*)
protected void org.springframework.web.bind.WebDataBinder.checkFieldDefaults(MutablePropertyValues mpvs) {
//前缀如果不为空
if (getFieldDefaultPrefix() != null) {
//获取前缀
String fieldDefaultPrefix = getFieldDefaultPrefix();
PropertyValue[] pvArray = mpvs.getPropertyValues();
for (PropertyValue pv : pvArray) {
//循环查找是否有以这个为前缀的参数名
if (pv.getName().startsWith(fieldDefaultPrefix)) {
//去掉前缀
String field = pv.getName().substring(fieldDefaultPrefix.length());
if (getPropertyAccessor().isWritableProperty(field) && !mpvs.contains(field)) {
//如果不包含这个参数，那么设置进去
mpvs.add(field, pv.getValue());
}
//并把原来的移除掉
mpvs.removePropertyValue(pv);
}
}
}
}
//(*4*)
protected void org.springframework.validation.DataBinder.doBind(MutablePropertyValues mpvs) {
//检查是否是允许的属性，如果不是将被移除，可以自定义，在@InitBinder方法中设置
checkAllowedFields(mpvs);
//检查是否缺少必须的属性，可以自定，在@InitBinder方法中设置
checkRequiredFields(mpvs);
//开始设置值，属性的设置，我们在spring源码分析中分析过，此处不再赘述
applyPropertyValues(mpvs);
}
好了，至此我们的参数就已经创建好了
现在我们回到HandlerMethod的调用
protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
ServletWebRequest webRequest = new ServletWebRequest(request, response);
//获取数据绑定工厂，实际它内部应用的每个InitBinder方法都维护一个默认的参数绑定工厂
WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
//创建model工厂
ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
//创建ServletInvocableHandlerMethod，并解析handlerMethod的@ResponseStatus
ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
//设置方法参数解析器
invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
//设置方法返回参数处理器
invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
//设置数据绑定工厂
invocableMethod.setDataBinderFactory(binderFactory);
//设置参数名解析器
invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
ModelAndViewContainer mavContainer = new ModelAndViewContainer();
//合并FlashMap中的内容，这个FlashMap是SpringMVC在DispatcherServlet的doService方法中筛选出的最佳闪存
mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
//初始化model，会将handler类型注解@SessionAttributes指定的属性从session中获取，然后进行合并
//接下来就是调用model方法，最后将返回的结构存储到mavContainer中
modelFactory.initModel(webRequest, mavContainer, invocableMethod);
//当重定向是否忽略调用默认的model中的数据，默认是false
mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);
创建异步请求包装类，持有request和response
AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
//设置异步请求超时时间，超过这个时间，异步请求被认为失败
asyncWebRequest.setTimeout(this.asyncRequestTimeout);
//获取异步管理器
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
//设置任务执行线程池，额。。。。。。怎么说呢，感觉它不想线程池，因为每提交一个任务就会创建一个线程然后执行他们
//而且还不会缓存这些线程对象
asyncManager.setTaskExecutor(this.taskExecutor);
//设置请求包装类asyncWebRequest
asyncManager.setAsyncWebRequest(asyncWebRequest);
//注册回调拦截器
asyncManager.registerCallableInterceptors(this.callableInterceptors);
//设置延迟回调拦截器
asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);
//是否已经处理完
if (asyncManager.hasConcurrentResult()) {
//获取处理后的结构
Object result = asyncManager.getConcurrentResult();
//获取ModelAndViewContainer
mavContainer = (ModelAndViewContainer) asyncManager.getConcurrentResultContext()[0];
//将值复位
asyncManager.clearConcurrentResult();
if (logger.isDebugEnabled()) {
logger.debug("Found concurrent result value [" + result + "]");
}
//将result的值进行一层包装，变成新的handler，当invocableMethod被调用的时候直接返回，然后通过一系列的
//返回值处理器进行处理
invocableMethod = invocableMethod.wrapConcurrentResult(result);
}
//调用方法
invocableMethod.invokeAndHandle(webRequest, mavContainer);
//如果异步已经启动，返回null
if (asyncManager.isConcurrentHandlingStarted()) {
return null;
}
//更新model的属性值，如果有重定向属性值的话，会存储outputFlashMap
//(*1*)
return getModelAndView(mavContainer, modelFactory, webRequest);
}
//(*1*)
private ModelAndView getModelAndView(ModelAndViewContainer mavContainer,
ModelFactory modelFactory, NativeWebRequest webRequest) throws Exception {
//更新model中的属性
modelFactory.updateModel(webRequest, mavContainer);
//如果已经标记为响应完成，那么直接返回null，将不会进行视图的解析
if (mavContainer.isRequestHandled()) {
return null;
}
ModelMap model = mavContainer.getModel();
ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model);
if (!mavContainer.isViewReference()) {
mav.setView((View) mavContainer.getView());
}
//设置重定向model
if (model instanceof RedirectAttributes) {
Map<String, ?> flashAttributes = ((RedirectAttributes) model).getFlashAttributes();
HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes);
}
return mav;
}
调用我们ServletInvocableHandlerMethod
public void org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletWebRequest webRequest,
ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
//调用方法，此处不再赘述
Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
//设置响应头状态码和消息，这个状态还记得是在创建ServletInvocableHandlerMethod时，它在构造器中解析handlerMethod上的@ResponseStatus中得到的
setResponseStatus(webRequest);
//如果返回值为null
if (returnValue == null) {
//如果请求未过期，或者已经设置了响应状态，或者已经处理完成（一般返回json的在handler中就已经处理完了）
if (isRequestNotModified(webRequest) || hasResponseStatus() || mavContainer.isRequestHandled()) {
//那么就设置请求处理已经完成，不需要再做处理了
mavContainer.setRequestHandled(true);
return;
}
}
//如果设置了响应缘由，那么也标识为完成
else if (StringUtils.hasText(this.responseReason)) {
mavContainer.setRequestHandled(true);
return;
}
//否则设置为false，表示还需进一步处理
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;
}
}
筛选HandlerMethodReturnValueHandler
public void org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite.handleReturnValue(Object returnValue, MethodParameter returnType,
ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
//筛选HandlerMethodReturnValueHandler
//(*1*)
HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);
if (handler == null) {
throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName());
}
//处理返回值
handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
}
//(*1*)
private HandlerMethodReturnValueHandler org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite.selectHandler(Object value, MethodParameter returnType) {
//判断是否是异步值，其处理的returnHandler是AsyncHandlerMethodReturnValueHandler类型
//并且可以用于判断这个返回值value是否是WebAsyncTask类型的
boolean isAsyncValue = isAsyncReturnValue(value, returnType);
for (HandlerMethodReturnValueHandler handler : this.returnValueHandlers) {
if (isAsyncValue && !(handler instanceof AsyncHandlerMethodReturnValueHandler)) {
continue;
}
//判断是否支持当前返回参数
if (handler.supportsReturnType(returnType)) {
return handler;
}
}
return null;
}
返回参数的处理器有很多，我们也挑选一个常用的，它和请求参数处理一样的类，它就是RequestResponseBodyMethodProcessor
首先来看到它支持什么样的返回值
public boolean org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor.supportsReturnType(MethodParameter returnType) {
//判断当前handler类上面是否存在@ResponseBody注解或者方法上是否有@ResponseBody注解
return (AnnotationUtils.findAnnotation(returnType.getContainingClass(), ResponseBody.class) != null ||
returnType.getMethodAnnotation(ResponseBody.class) != null);
}
好，已经知道它可以处理什么的类型了，那么接下来就来学习下这个返回值处理器是怎么处理返回值的
public void org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor.handleReturnValue(Object returnValue, MethodParameter returnType,
ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {
//直接设置为true，表示请求被处理完成
mavContainer.setRequestHandled(true);
// Try even with null return value. ResponseBodyAdvice could get involved.
//调用消息转换器处理参数
writeWithMessageConverters(returnValue, returnType, webRequest);
}
我们可以看到，SpringMVC在参数返回值处理时也使用了消息转换器
protected <T> void org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodProcessor.writeWithMessageConverters(T returnValue, MethodParameter returnType, NativeWebRequest webRequest)
throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {
//包装成ServletServerHttpRequest，提供了额外的能力，比如获取http请求体
ServletServerHttpRequest inputMessage = createInputMessage(webRequest);
//包装响应
ServletServerHttpResponse outputMessage = createOutputMessage(webRequest);
//(*1*)
writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage);
}
//(*1*)
//returnValue：调用方法的返回值，returnType：返回参数类型，inputMessage：请求消息，outputMessage：响应消息
protected <T> void org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodProcessor.writeWithMessageConverters(T returnValue, MethodParameter returnType,
ServletServerHttpRequest inputMessage, ServletServerHttpResponse outputMessage)
throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {
//获取返回值类型
Class<?> returnValueClass = getReturnValueType(returnValue, returnType);
//获取泛化的参数类型，如果是HttpEntity，将获取其指定的泛型类型
Type returnValueType = getGenericType(returnType);
//后去本地请求参数
HttpServletRequest servletRequest = inputMessage.getServletRequest();
//获取请求可接受的媒体类型
List<MediaType> requestedMediaTypes = getAcceptableMediaTypes(servletRequest);
//获取可返回的媒体类型
List<MediaType> producibleMediaTypes = getProducibleMediaTypes(servletRequest, returnValueClass, returnValueType);
//如果存在返回值，但是可返回的媒体类型没有，那没法玩，只能抛错了
if (returnValue != null && producibleMediaTypes.isEmpty()) {
throw new IllegalArgumentException("No converter found for return value of type: " + returnValueClass);
}
Set<MediaType> compatibleMediaTypes = new LinkedHashSet<MediaType>();
//获取可兼容的媒体类型
for (MediaType requestedType : requestedMediaTypes) {
for (MediaType producibleType : producibleMediaTypes) {
if (requestedType.isCompatibleWith(producibleType)) {
compatibleMediaTypes.add(getMostSpecificMediaType(requestedType, producibleType));
}
}
}
//如果没有找到，并且返回值又不为空的话，只能抛错错误
if (compatibleMediaTypes.isEmpty()) {
if (returnValue != null) {
throw new HttpMediaTypeNotAcceptableException(producibleMediaTypes);
}
return;
}
List<MediaType> mediaTypes = new ArrayList<MediaType>(compatibleMediaTypes);
//进行排序
MediaType.sortBySpecificityAndQuality(mediaTypes);
MediaType selectedMediaType = null;
for (MediaType mediaType : mediaTypes) {
//寻找具体的媒体类型
if (mediaType.isConcrete()) {
selectedMediaType = mediaType;
break;
}
//如果没有具体的媒体类型，那么只能设置一个默认的媒体类型了application/octet-stream
else if (mediaType.equals(MediaType.ALL) || mediaType.equals(MEDIA_TYPE_APPLICATION)) {
selectedMediaType = MediaType.APPLICATION_OCTET_STREAM;
break;
}
}
if (selectedMediaType != null) {
//移除掉媒体类型后面指定权重的值，比如text/html;q=0.9
//会把q去掉
selectedMediaType = selectedMediaType.removeQualityValue();
for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
if (messageConverter instanceof GenericHttpMessageConverter) {
//寻找能够处理此返回参数的消息转换器
if (((GenericHttpMessageConverter<T>) messageConverter).canWrite(returnValueType,
returnValueClass, selectedMediaType)) {
//ResponseAdvice前置处理
returnValue = (T) getAdvice().beforeBodyWrite(returnValue, returnType, selectedMediaType,
(Class<? extends HttpMessageConverter<?>>) messageConverter.getClass(),
inputMessage, outputMessage);
if (returnValue != null) {
addContentDispositionHeader(inputMessage, outputMessage);
((GenericHttpMessageConverter<T>) messageConverter).write(returnValue,
returnValueType, selectedMediaType, outputMessage);
if (logger.isDebugEnabled()) {
logger.debug("Written [" + returnValue + "] as \"" +
selectedMediaType + "\" using [" + messageConverter + "]");
}
}
return;
}
}
else if (messageConverter.canWrite(returnValueClass, selectedMediaType)) {
//ResponseAdvice前置处理
returnValue = (T) getAdvice().beforeBodyWrite(returnValue, returnType, selectedMediaType,
(Class<? extends HttpMessageConverter<?>>) messageConverter.getClass(),
inputMessage, outputMessage);
if (returnValue != null) {
//添加Content-Disposition响应头
addContentDispositionHeader(inputMessage, outputMessage);
//调用转换器
((HttpMessageConverter<T>) messageConverter).write(returnValue,
selectedMediaType, outputMessage);
if (logger.isDebugEnabled()) {
logger.debug("Written [" + returnValue + "] as \"" +
selectedMediaType + "\" using [" + messageConverter + "]");
}
}
return;
}
}
}
//如果能够到达这里，那么直接抛错
if (returnValue != null) {
throw new HttpMediaTypeNotAcceptableException(this.allSupportedMediaTypes);
}
}
假设我们使用到转换器是MappingJackson2HttpMessageConverter
public final void org.springframework.http.converter.AbstractGenericHttpMessageConverter.write(final T t, final Type type, MediaType contentType, HttpOutputMessage outputMessage)
throws IOException, HttpMessageNotWritableException {
//获取响应头
final HttpHeaders headers = outputMessage.getHeaders();
//添加返回媒体类型响应头
addDefaultHeaders(headers, t, contentType);
//将返回值设置到响应流中
if (outputMessage instanceof StreamingHttpOutputMessage) {
StreamingHttpOutputMessage streamingOutputMessage = (StreamingHttpOutputMessage) outputMessage;
streamingOutputMessage.setBody(new StreamingHttpOutputMessage.Body() {
@Override
public void writeTo(final OutputStream outputStream) throws IOException {
//这部分内容我们在分析参数解析的消息转换中已经分析过了
writeInternal(t, type, new HttpOutputMessage() {
@Override
public OutputStream getBody() throws IOException {
return outputStream;
}
@Override
public HttpHeaders getHeaders() {
return headers;
}
});
}
});
}
else {
//这部分内容我们在分析参数解析的消息转换中已经分析过了
writeInternal(t, type, outputMessage);
outputMessage.getBody().flush();
}
}
好了，AbstractHandlerMethodAdapter就到此为止了。
