博客围绕Spring和Java展开，涉及Spring相关技术，可能包含Spring Boot的应用等信息技术领域内容，助力开发者了解相关开发知识。
org.springframework.web.method.support.InvocableHandlerMethod#invokeForRequest(NativeWebRequest request,mavContainer,Object... providedArgs) {
// 解析参数
Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);{
// 获取当前HandlerMethod的方法参数的信息
MethodParameter[] parameters = getMethodParameters();
// 没有参数
if (ObjectUtils.isEmpty(parameters)) {
return EMPTY_ARGS;
}
// 定义参数数组
Object[] args = new Object[parameters.length];
for (int i = 0; i < parameters.length; i++) {
MethodParameter parameter = parameters[i];
// 设置参数名称解析器,获取用户写的参数名称
parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
// 先找在这之前是不是已经提供了执行参数,只有在异常处理的时候,会将异常信息参数传递过来
// 正常请求的这个HandlerMethod的逻辑这个参数是为空的providedArgs
// 还有@InitBinder注解中也会传递一个参数,叫WebDataBinder对象
// 如果提供了参数,当当前方法需要相同类型的参数,就会直接赋值
args[i] = findProvidedArgument(parameter, providedArgs);
if (args[i] != null) {
continue;
}
// 拿到所有的参数解析器,看一下有哪些可以支持解析这个参数
// 如果都解析不了,那么就抛出异常
if (!this.resolvers.supportsParameter(parameter){
return getArgumentResolver(parameter) != null;{
// 解析过当前参数就需要缓存一下,省的每次都去找参数解析器
HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
// 没有缓存就遍历所有的参数解析器,在初始化的时候就已经设置了默认的一些参数解析器
if (result == null) {
for (HandlerMethodArgumentResolver resolver : this.argumentResolvers) {
// 判断是否支持
if (resolver.supportsParameter(parameter)) {
// 如果支持,就缓存起来,返回结果
result = resolver;
this.argumentResolverCache.put(parameter, result);
break;
}
}
}
return result;
}
}) {
throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
}
try {
// 开始调用所有的参数解析器解析参数
args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);{
// 获取参数解析器,因为上面调用supportsParameter是否支持的时候已经调用了getArgumentResolver缓存过了,parameter作为key,value就是参数解析器
HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
// 没有找到就是没有调用supportsParameter方法
if (resolver == null) {
throw new IllegalArgumentException("supportsParameter should be called first.");
}
// 使用找到的参数解析器开始解析参数
// 不同参数解析的逻辑不一样
// 1. 讲解PathVariable
// PathVariableMethodArgumentResolver
return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);{
// 获取参数的名称信息,将PathVariable注解信息封装成NamedValueInfo,并进行缓存,防止每次解析都创建
NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);
// 获取参数类型,支持参数为Optional包裹的参数
MethodParameter nestedParameter = parameter.nestedIfOptional();
// 解析嵌入值和表达式,例如: ${aa.bb},#{aa.bb}},如果没有表达式,就会原样返回
Object resolvedName = resolveEmbeddedValuesAndExpressions(namedValueInfo.name);
// 根据参数名解析参数值
Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);{
// 在getHandler的时候,就已经对路径进行了解析,将路径变量保存到了request域中
Map<String, String> uriTemplateVars = (Map<String, String>) request.getAttribute(
HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestAttributes.SCOPE_REQUEST);
// 获取参数值
return (uriTemplateVars != null ? uriTemplateVars.get(name) : null);
}
// 如果没有解析到值
if (arg == null) {
// 使用默认值再来试一次
if (namedValueInfo.defaultValue != null) {
// 解析嵌入值和表达式,例如: ${aa.bb},#{aa.bb},如果没有表达式,就会原样返回
arg = resolveEmbeddedValuesAndExpressions(namedValueInfo.defaultValue);
}
// 如果参数值必须,并且也不是Optional包裹的,说明解析不到值
else if (namedValueInfo.required && !nestedParameter.isOptional()) {
// 值缺失处理,该抛异常抛异常,该赋空对象赋空对象,自己处理
handleMissingValue(namedValueInfo.name, nestedParameter, webRequest);
}
// 处理空值情况,布尔类型返回给false,基本类型抛异常,其他的原样返回
arg = handleNullValue(namedValueInfo.name, arg, nestedParameter.getNestedParameterType());
}
// 参数值为"",且有默认值,解析嵌入值和表达式,例如: ${aa.bb},#{aa.bb}},如果没有表达式,就会原样返回
else if ("".equals(arg) && namedValueInfo.defaultValue != null) {
arg = resolveEmbeddedValuesAndExpressions(namedValueInfo.defaultValue);
}
// 判断binderFactory是否为空,发起请求之前,都创建过这个对象,所以不为空
// 用于参数的绑定
if (binderFactory != null) {
// 创建WebBinder对象
WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);{
// 创建WebDataBinder实例
WebDataBinder dataBinder = createBinderInstance(target, objectName, webRequest);{
return new ExtendedServletRequestDataBinder(target, objectName);
}
// 当前工厂中的WebBindingInitializer是否为空
// 在创建binderFactory的时候,就已经将initializer设置进来了
// return new ServletRequestDataBinderFactory(binderMethods, getWebBindingInitializer());
// 而getWebBindingInitializer是在添加了@EnableMVC加入RequestMappingAdapter初始化的时候,设置进来的
// 如果是默认的RequestMappingAdapter就没有
// 类型为org.springframework.web.bind.support.ConfigurableWebBindingInitializer
if (this.initializer != null) {
this.initializer.initBinder(dataBinder, webRequest);{
// 初始化Binder,设置一些属性,参数校验器,类型转换起,异常绑定处理器,属性编辑器
binder.setAutoGrowNestedPaths(this.autoGrowNestedPaths);
if (this.directFieldAccess) {binder.initDirectFieldAccess();}
if (this.messageCodesResolver != null) {binder.setMessageCodesResolver(this.messageCodesResolver);}
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);
}
}
}
}
// 这是工厂自身提供的初始化方法
initBinder(dataBinder, webRequest);{
// 遍历所有的InitBinder方法,前面已经找出来了,是Controller自身的和@ControllerAdvice中全局的一起
for (InvocableHandlerMethod binderMethod : this.binderMethods) {
// 判断当前InitBinderMethod是否可用,除非在InitBinder设置了参数
if (isBinderMethodApplicable(binderMethod, dataBinder)) {
// 根据参数执行方法,上面已经详细讲过了
Object returnValue = binderMethod.invokeForRequest(request, null, dataBinder);
// 返回值必须是void
if (returnValue != null) {
throw new IllegalStateException("@InitBinder methods must not return a value (should be void): " + binderMethod);
}
}
}
}
return dataBinder;
}
// 创建好了WebDataBinder之后,对参数进行转换
// 对参数进行适配,利用Spring自身提供的类型转换机制来就参数进行类型转换
// 也可以@InitBinder获取的WebDataBinder对象,设置一个相关的转换器来处理Spring没有提供的默认的转换器
// 例如:将String->枚举,Spring可能就没有提供,自己就可以自定义转换器,设置到WebDataBinder binder中
// 这样就能就String转换为枚举类型
arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);
// 参数类型转换之后,还是没有获取到值的情况
if (arg == null && namedValueInfo.defaultValue == null && namedValueInfo.required && !nestedParameter.isOptional()) {
handleMissingValueAfterConversion(namedValueInfo.name, nestedParameter, webRequest);
}
}
// 处理结果后的参数值
handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);{
String key = View.PATH_VARIABLES;
int scope = RequestAttributes.SCOPE_REQUEST;
Map<String, Object> pathVars = (Map<String, Object>) request.getAttribute(key, scope);
if (pathVars == null) {
pathVars = new HashMap<>();
// 将数据保存到请求域中
request.setAttribute(key, pathVars, scope);
}
// 因为可能存在多个路径变量,所以需要使用map
pathVars.put(name, arg);
}
return arg;
}
// 2. 讲解ReqeustBody
// resolver = RequestResponseBodyMethodProcessor
return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);{
// 获取到请求参数对象,使用消息转换器读取消息
Object arg = readWithMessageConverters(webRequest, parameter, parameter.getNestedGenericParameterType());{
Object arg = readWithMessageConverters(inputMessage, parameter, paramType);{
boolean noContentType = false;
MediaType contentType = inputMessage.getHeaders().getContentType();
// 给默认的内容类型
if (contentType == null) {
noContentType = true;
contentType = MediaType.APPLICATION_OCTET_STREAM;
}
// 获取到参数对象所属的类
Class<?> contextClass = parameter.getContainingClass();
// 获取参数的类型,如果给定的参数类型不是Class,返回null
Class<T> targetClass = (targetType instanceof Class ? (Class<T>) targetType : null);
// 如果参数类型不是Class
if (targetClass == null) {
// 根据给的参数找到对应类的Class来
ResolvableType resolvableType = ResolvableType.forMethodParameter(parameter);
targetClass = (Class<T>) resolvableType.resolve();
}
// 判断输入消息的类型是不是HttpRequest,标注了@RequestBody的情况是ServletServerHttpRequest,符合条件
// 获取到请求类型 POST转HttpMethod对象
HttpMethod httpMethod = (inputMessage instanceof HttpRequest ? ((HttpRequest) inputMessage).getMethod() : null);
// 读取的值默认为空对象
Object body = NO_VALUE;
try {
// 根据传递过来的inputMessage消息提创建一个EmptyBodyCheckingHttpInputMessage,内部会自己处理请求体
//比如自己设置了inputMessage
EmptyBodyCheckingHttpInputMessage message = new EmptyBodyCheckingHttpInputMessage(inputMessage);{
this.headers = inputMessage.getHeaders();
// 获取body
InputStream inputStream = inputMessage.getBody();
// 默认就是为false,除非传递的inputMessage参数重写了markSupported为true
if (inputStream.markSupported()) {
inputStream.mark(1);
this.body = (inputStream.read() != -1 ? inputStream : null);
inputStream.reset();
}
else {
// 创建一个新的输入流
PushbackInputStream pushbackInputStream = new PushbackInputStream(inputStream);
// 将请求体的输入村进入
int b = pushbackInputStream.read();
if (b == -1) {
this.body = null;
}
else {
this.body = pushbackInputStream;
pushbackInputStream.unread(b);
}
}
}
// 遍历所有的消息类型转换器对消息进行类型转换
// 这里的消息转换器有三种情况,详见消息转换器HttpMessageConverter原理
for (HttpMessageConverter<?> converter : this.messageConverters) {
// 获取消息转换器的类型
Class<HttpMessageConverter<?>> converterType = (Class<HttpMessageConverter<?>>) converter.getClass();
// 判断消息转换器是否是GenericHttpMessageConverter,如果不是,返回null,是的话就强转为GenericHttpMessageConverter类型
GenericHttpMessageConverter<?> genericConverter = (converter instanceof GenericHttpMessageConverter ? (GenericHttpMessageConverter<?>) converter : null);
// 判断当前消息转换器是否可以读取请求数据
if (genericConverter != null ?
// 如果消息类型为GenericHttpMessageConverter,那么直接判断它是否可以读取
genericConverter.canRead(targetType, contextClass, contentType){
// 判断消息转换器是否支持媒体类型
if (!canRead(mediaType)) {
return false;
}
// 将参数类型包装成JavaType类型
JavaType javaType = getJavaType(type, contextClass);
// 获取到合适的ObjectMapper,这个ObjectMapper就是有来序列化的
ObjectMapper objectMapper = selectObjectMapper(javaType.getRawClass(), mediaType);{
// objectMapperRegistrations默认为空,除非自己设置的
if (targetMediaType == null || CollectionUtils.isEmpty(this.objectMapperRegistrations)) {
return this.defaultObjectMapper;
}
// 如果注册表不为空
// 遍历ObjectMapperRegistration注册表,根据媒体类型来获取对应的ObjectMapper
for (Map.Entry<Class<?>, Map<MediaType, ObjectMapper>> typeEntry : getObjectMapperRegistrations().entrySet()) {
if (typeEntry.getKey().isAssignableFrom(targetType)) {
for (Map.Entry<MediaType, ObjectMapper> objectMapperEntry : typeEntry.getValue().entrySet()) {
if (objectMapperEntry.getKey().includes(targetMediaType)) {
return objectMapperEntry.getValue();
}
}
return null;
}
}
// 都没找到,返回默认的
return this.defaultObjectMapper;
}
// 如果没有找到objectMapper,就没有办法序列化
if (objectMapper == null) {
return false;
}
// 判断objectMapper是否可以序列化javaType类型
AtomicReference<Throwable> causeRef = new AtomicReference<>();
if (objectMapper.canDeserialize(javaType, causeRef)) {
return true;
}
return false;
} :
// 否则还要判断参数类型不能为空,再判断它是否可以读取
(targetClass != null && converter.canRead(targetClass, contentType))) {
// 实现了RequestResponseBodyAdvice的执行链,在创建当前参数解析器的时候就已经将
// 在RequestMappingHandlerAdapter初始化的时候,给参数解析器设置的
// this.requestResponseBodyAdvice就是在RequestMappingHandlerAdapter初始化的时候,执行initControllerAdviceCache();方法
// 从@ControllerAdvice中,实现了requestResponseBodyAdvice的类缓存下来了
// resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice));
RequestResponseBodyAdviceChain advice = this.advice;
// 上面已经将请求体的数据存在EmptyBodyCheckingHttpInputMessage massage中了
if (message.hasBody()) {
// 找到真实要用的HttpInputMessage消息体
// 因为HttpInputMessage可以通过ControllerAdviceBean中实现RequestBodyAdvice来处理,返回新的HttpInputMessage
HttpInputMessage msgToUse = advice.beforeBodyRead(message, parameter, targetType, converterType);{
// 找到匹配的可用的RequestBodyAdvice,因为可能在@ControllerAdvice中设置条件,可能不满足当前Bean的方法
for (RequestBodyAdvice advice : getMatchingAdvice(parameter, RequestBodyAdvice.class)) {
// 判断当前RequestBodyAdvice的supports是否返回的true
if (advice.supports(parameter, targetType, converterType)) {
// 调用接口的beforeBodyRead,在这之前还没开始读取,所以可以改请求体内部的数据
request = advice.beforeBodyRead(request, parameter, targetType, converterType);{
// 我自定义的RequestBodyAdvice,获取body,改变数据,然后又存进去,可达到加密解密的
InputStream body = inputMessage.getBody();
Object object = JSON.parseObject(IoUtil.read(body, Charset.defaultCharset()), targetType);
if (object instanceof A) {
((A) object).setId(-1)
}
// 将数据返回出去
return new MappingJacksonInputMessage(new ByteArrayInputStream(JSON.toJSONString(object).getBytes(StandardCharsets.UTF_8)), inputMessage.getHeaders());
}
}
}
return request;
}
// 调用转换器的read方法
body = (genericConverter != null ? genericConverter.read(targetType, contextClass, msgToUse) :
((HttpMessageConverter<T>) converter).read(targetClass, msgToUse));{
// 将Bean和参数类型封装成JavaType
// 再使用ObjectMapper读取body
JavaType javaType = getJavaType(type, contextClass);
return readJavaType(javaType, inputMessage);
}
// 上面调用过RequestBodyAdvice的beforeRead方法,现在调用RequestBodyAdvice的advice.afterBodyRead
// 就是一些读取前后的切面
body = advice.afterBodyRead(body, msgToUse, parameter, targetType, converterType);
}
else {
// 如果没有请求体
// 上面调用过RequestBodyAdvice的beforeRead,afterRead方法,在这里调用RequestBodyAdvice的advice.handleEmptyBody
// 处理请求体为空的数据
body = advice.handleEmptyBody(null, message, parameter, targetType, converterType);
}
break;
}
}
}
catch (IOException ex) {
throw new HttpMessageNotReadableException("I/O error while reading input message", ex, inputMessage);
}
// 如果body为初始值NO_VALUE,表示没有消息处理器或者没有合适的消息处理器来处理当前参数
if (body == NO_VALUE) {
// 没有请求方法POST,或者请求方法不支持,或者没有请求体,这个时候没有内容是正常的,直接返回null
if (httpMethod == null || !SUPPORTED_METHODS.contains(httpMethod) || (noContentType && !message.hasBody())) {
return null;
}
// 否则还没解析出参数表示无法处理当前这个请求参数
throw new HttpMediaTypeNotSupportedException(contentType,getSupportedMediaTypes(targetClass != null ? targetClass : Object.class));
}
// 返回处理后的请求体
return body;
}
// 没有读取到参数,但是参数又是必须要的,设置了required=true
if (arg == null && checkRequired(parameter)) {
// 参数不可读的异常
throw new HttpMessageNotReadableException("Required request body is missing: " + parameter.getExecutable().toGenericString(), inputMessage);
}
// 返回解析之后的参数
return arg;
}
// 获取在方法参数写的名称
String name = Conventions.getVariableNameForParameter(parameter);
// 判断binderFactory是否为空,发起请求之前,都创建过这个对象,所以不为空
if (binderFactory != null) {
// 创建Binder实例,在讲解PathVariable的时候代码解释过了
WebDataBinder binder = binderFactory.createBinder(webRequest, arg, name);
if (arg != null) {
// 校验参数,如果有必要就是@NotEmpty等等这种参数
validateIfApplicable(binder, parameter);{
// 找到方法中所有的参数注解,来校验
Annotation[] annotations = parameter.getParameterAnnotations();
for (Annotation ann : annotations) {
// 调用校验工具类校验
Object[] validationHints = ValidationAnnotationUtils.determineValidationHints(ann);{
// 获取注解类型
Class<? extends Annotation> annotationType = ann.annotationType();
// 获取注解全类名称
String annotationName = annotationType.getName();
// 如果加了@javax.validation.Valid这个注解
if ("javax.validation.Valid".equals(annotationName)) {
// 直接返回固定数组
return EMPTY_OBJECT_ARRAY;
}
// 获取@Validated注解信息
Validated validatedAnn = AnnotationUtils.getAnnotation(ann, Validated.class);
if (validatedAnn != null) {
// 获取校验的分组信息
Object hints = validatedAnn.value();
// 转换成数组,因为可能填写的是一个class,要包装成数组形成
return convertValidationHints(hints);{
// 如果没有校验分组,直接返回固定数组
if (hints == null) {
return EMPTY_OBJECT_ARRAY;
}
// 返回指定的分组
return (hints instanceof Object[] ? (Object[]) hints : new Object[]{hints});
}
}
// 其他情况,如果注解为Valid开头,反射获取分组名
if (annotationType.getSimpleName().startsWith("Valid")) {
// 和Validated差不多
Object hints = AnnotationUtils.getValue(ann);
return convertValidationHints(hints);
}
// 如果都不是,和@Valid没关系,那就返回null
return null;
}
// 如果上面找校验分组找到了,那就
if (validationHints != null) {
// 按照分组,使用DataBinder开始校验
binder.validate(validationHints);{
// 获取要校验的目标对象
Object target = getTarget();
// 获取在binder中创建的BindingResult获取出来,用来存储校验失败的结果
BindingResult bindingResult = getBindingResult();
// private final List<Validator> validators = new ArrayList<>();
// 获取所有的校验器对参数一一校验
for (Validator validator : getValidators()) {
// 存在校验分组,并且为智能类型SmartValidator,调用SmartValidator的方法
if (!ObjectUtils.isEmpty(validationHints) && validator instanceof SmartValidator) {
((SmartValidator) validator).validate(target, bindingResult, validationHints);{
if (this.targetValidator != null) {
// 调用目标校验器对参数进行校验,返回Set<ConstraintViolation<Object>> violations
// ConstraintViolation一个描述单个约束失败的类，验证一个对象将会返回ConstraintViolation的集合
processConstraintViolations(this.targetValidator.validate(target), errors);{
// 遍历所有的错误消息
for (ConstraintViolation<Object> violation : violations) {
// 获取错误的字段
String field = determineField(violation);
// 获取字段的错误信息
FieldError fieldError = errors.getFieldError(field);
if (fieldError == null || !fieldError.isBindingFailure()) {
ConstraintDescriptor<?> cd = violation.getConstraintDescriptor();
String errorCode = determineErrorCode(cd);
Object[] errorArgs = getArgumentsForConstraint(errors.getObjectName(), field, cd);
// 判断错误类型是不是BindingResult,如果是,将错误结果放入BindingResult中
// 因为BindingResult也是一个Errors类型
if (errors instanceof BindingResult) {
BindingResult bindingResult = (BindingResult) errors;
String nestedField = bindingResult.getNestedPath() + field;
// 嵌套字段是否为空
if (nestedField.isEmpty()) {
String[] errorCodes = bindingResult.resolveMessageCodes(errorCode);
ObjectError error = new ViolationObjectError(errors.getObjectName(), errorCodes, errorArgs, violation, this);
bindingResult.addError(error);
}
// 非嵌套字段
else {
Object rejectedValue = getRejectedValue(field, violation, bindingResult);
String[] errorCodes = bindingResult.resolveMessageCodes(errorCode, field);
FieldError error = new ViolationFieldError(errors.getObjectName(), nestedField,rejectedValue, errorCodes, errorArgs, violation, this);
bindingResult.addError(error);
}
}
else {
// 将数据添加到errors中
errors.rejectValue(field, errorCode, errorArgs, violation.getMessage());
}
}
}
}
}
}
// 其他情况直接调用校验方法
else if (validator != null) {
validator.validate(target, bindingResult);
}
}
}
break;
}
}
}
// 上面校验的结果已经存在BindingResult中了,如果存在错误,
if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter){
// 获取参数的索引
int i = parameter.getParameterIndex();
// 获取参数类型
Class<?>[] paramTypes = parameter.getExecutable().getParameterTypes();
// 如果被校验的参数紧接着的下一个参数不是Errors(BindingResult)对象,
boolean hasBindingResult = (paramTypes.length > (i + 1) && Errors.class.isAssignableFrom(paramTypes[i + 1]));
// 上面条件为true表示下一个参数是BindingResult
// !hasBindingResult表示校验的参数之后紧挨的不是BindingResult
return !hasBindingResult;
}) {
// 表示校验出错,并且校验的参数紧挨着的对象没有用BindingResult接受错误信息,就抛出异常
throw new MethodArgumentNotValidException(parameter, binder.getBindingResult());
}
}
// 将BindingResult的数据存入mavContainer的属性中,哪怕是没有错误,也会根据这个固定的key存入
// String MODEL_KEY_PREFIX = BindingResult.class.getName() + ".";
if (mavContainer != null) {
mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());
}
}
// 看一下参数是否需要适配并返回
// 如果参数是Optional,我们处理参数之后,也要包装为Optional还给用户
// 如果不是,就原样返回
return adaptArgumentIfNecessary(arg, parameter);
}
// 3. 讲解RequestParam,和1. PathVariable逻辑一样,相同的父类,以下逻辑不同,是抽象的
// 不光会处理普通参数,还会处理文件类型参数
// RequestParamMethodArgumentResolver
return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);{
// 根据参数名解析参数值
Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);{
// 获取原生的HttpServletRequest对象
HttpServletRequest servletRequest = request.getNativeRequest(HttpServletRequest.class);
if (servletRequest != null) {
// 解析文件参数,先看一下是不是文件
Object mpArg = MultipartResolutionDelegate.resolveMultipartArgument(name, parameter, servletRequest);{
// 在请求的时候,如果是文件请求,这个对象已经被包装过了
MultipartHttpServletRequest multipartRequest = WebUtils.getNativeRequest(request, MultipartHttpServletRequest.class);
// 判断是否是文件请求的依据有两个,一个是之前校验的请求对象封装成了MultipartHttpServletRequest
// 另一个是根据contentType.toLowerCase().startsWith("multipart/"));
boolean isMultipart = (multipartRequest != null || isMultipartContent(request));
// 获取参数类型,List<MultipartFile>,MultipartFile[]逻辑一样,增加了类型判断,这里省去了重复代码
if (MultipartFile.class == parameter.getNestedParameterType()) {
// 如果你不是文件类型的请求,那么你用这个参数也没有用
if (!isMultipart) {
return null;
}
// 之前没有将HttpServletRequest包装过包装一下
if (multipartRequest == null) {
multipartRequest = new StandardMultipartHttpServletRequest(request);
}
// 通过封装的请求对象获取文件对象
// 根据不同的文件解析器创建文件对象的方式不一样
// 在请求进来的时候,文件已经被解析过程,multipartResolver解析之后,将文件给MultipartHttpServletRequest对象了
// 也就是multipartRequest对象
return multipartRequest.getFile(name);{
// 从请求对象中获取文件流数据
Collection<Part> parts = request.getParts();
this.multipartParameterNames = new LinkedHashSet<>(parts.size());
// 每一个文件就是一个Part
for (Part part : parts) {
// 解析请求头
String headerValue = part.getHeader(HttpHeaders.CONTENT_DISPOSITION);
ContentDisposition disposition = ContentDisposition.parse(headerValue);
// 获取文件名
String filename = disposition.getFilename();
if (filename != null) {
// 创建StandardMultipartFile对象
files.add(part.getName(), new StandardMultipartFile(part, filename));
}
}
// 保存解析到的所有文件对象
setMultipartFiles(files);
}
}
// 如果文件类型直接为Part,数组,集合
else if (Part.class == parameter.getNestedParameterType()) {
if (!isMultipart) {
return null;
}
// 直接从request对象中就能获取
// 如果是数组,或者集合,就要通过request.getParts();再进行遍历包装返回
return request.getPart(name);
}
// 没有解析到文件
else {
return UNRESOLVABLE;
}
}
// 没有解析到文件
if (mpArg != MultipartResolutionDelegate.UNRESOLVABLE) {
return mpArg;
}
}
Object arg = null;
MultipartRequest multipartRequest = request.getNativeRequest(MultipartRequest.class);
// 获取文件参数
if (multipartRequest != null) {
List<MultipartFile> files = multipartRequest.getFiles(name);
if (!files.isEmpty()) {
Object arg = (files.size() == 1 ? files.get(0) : files);
}
}
// 获取普通参数
if (arg == null) {
String[] paramValues = request.getParameterValues(name);
ifObject (paramValues != null) {
arg = (paramValues.length == 1 ? paramValues[0] : paramValues);
}
}
return arg;
}
}
// 4. 讲解没有注解
// 使用的实ServletModelAttributeMethodProcessor,它是在Apdate中添加的兜底的处理器
return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);{
// 获取参数名
String name = ModelFactory.getNameForParameter(parameter);
// 获取是否存在ModelAttribute注解
ModelAttribute ann = parameter.getParameterAnnotation(ModelAttribute.class);
// 如果不为空,保存注解的binding信息
if (ann != null) {
// 表示当前参数需要被绑定,需要存到model中
mavContainer.setBinding(name, ann.binding());
}
Object attribute = null;
BindingResult bindingResult = null;
// 如果mavContainer已经存在这个属性
if (mavContainer.containsAttribute(name)) {
// 直接从Model获取值
attribute = mavContainer.getModel().get(name);
}
else {
try {
// 创建参数实例对象,找默认的构造方法进行实例化参数对象
// 在创建对象的过程中也会去参数进行校验等等
attribute = createAttribute(name, parameter, binderFactory, webRequest);{
// 从请求中获取数据,request.getParam
String value = getRequestValueForAttribute(attributeName, request);
if (value != null) {
// 通过获取到的值进行类型转换成目标值
Object attribute = createAttributeFromRequestValue(value, attributeName, parameter, binderFactory, request);{
// 创建Binder实例
DataBinder binder = binderFactory.createBinder(request, null, attributeName);
// 创建类型转换类,Spring专门提供类型转换的类
ConversionService conversionService = binder.getConversionService();
if (conversionService != null) {
// 接收的数据类型(req获取的都是String)
TypeDescriptor source = TypeDescriptor.valueOf(String.class);
// 需要转换的目标类型(参数类型)
TypeDescriptor target = new TypeDescriptor(parameter);
// 判断是否可以进行转换
// 如果可以转换将数据类型以及目标类型封装成CacheKey,转换器作为值缓存起来,不需要每次都找
// 无参构造找不到对应的转换器,只有有参构造才能找到对应的Convert
// 对于无参构造,都是调用下面的super.createAttribute,来创建空参数的对象,所以无需进行转换
if (conversionService.canConvert(source, target)) {
// 调用binder的转换方法,上面已经讲过了
/ 对参数进行适配,利用Spring自身提供的类型转换机制来就参数进行类型转换
// 也可以@InitBinder获取的WebDataBinder对象,设置一个相关的转换器来处理Spring没有提供的默认的转换器
// 例如:将String->枚举,Spring可能就没有提供,自己就可以自定义转换器,设置到WebDataBinder binder中
// 这样就能就String转换为枚举类型
return binder.convertIfNecessary(sourceValue, parameter.getParameterType(), parameter);
}
}
return null;
}
// 如果转换成了目标对象,就直接返回
if (attribute != null) {
return attribute;
}
}
// 没有转换成功,也就是上面Spring没有提供对应的类型转换器,这里就对类型进行通用处理,来创建参数对象
return super.createAttribute(attributeName, parameter, binderFactory, request);{
// 获取参数类型
MethodParameter nestedParameter = parameter.nestedIfOptional();
Class<?> clazz = nestedParameter.getNestedParameterType();
// 获取参数类型的构造方法,如果有无参构造方法,优先选择无参构造
Constructor<?> ctor = BeanUtils.getResolvableConstructor(clazz);
// 通过构造方法创建对象
// 如果有默认构造方法,直接使用默认的构造方法
// 如果不是默认构造方法,从request获取对应的值来创建实例对象
Object attribute = constructAttribute(ctor, attributeName, parameter, binderFactory, webRequest);
if (parameter != nestedParameter) {
attribute = Optional.of(attribute);
}
return attribute;
}
}
}
// 发生异常
catch (BindException ex) {
// 如果发生BindException异常了,判断是否有BindingResult接收,如果没有,抛出异常
if (isBindExceptionRequired(parameter)) {
throw ex;
}
// 其他情况,存在BindingResult接收异常信息,该怎么返回怎么返回,错误结果已经绑定到BindingResult中了
if (parameter.getParameterType() == Optional.class) {
attribute = Optional.empty();
}
else {
attribute = ex.getTarget();
}
bindingResult = ex.getBindingResult();
}
}
// 如果没有异常,正常创建了参数对象
if (bindingResult == null) {
// 创建Binder实例,通过Binder来对参数进行校验
WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);
if (binder.getTarget() != null) {
// 如果ModelAttribute设置了binding=false(默认为true),表示当前ModelAttribute标注的参数不能被绑定数据
if (!mavContainer.isBindingDisabled(name)) {
// 将请求参数的值一一绑定到参数中
bindRequestParameters(binder, webRequest);
}
// 对参数进行校验,如果有异常,会绑定到BindingResult中
validateIfApplicable(binder, parameter);
if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
throw new BindException(binder.getBindingResult());
}
}
// 创建好了WebDataBinder之后,对参数进行转换,如果有必要的话
// 这个就是利用Spring自身提供的类型转换机制来就参数进行类型转换
if (!parameter.getParameterType().isInstance(attribute)) {
// 对参数进行适配,利用Spring自身提供的类型转换机制来就参数进行类型转换
// 也可以@InitBinder获取的WebDataBinder对象,设置一个相关的转换器来处理Spring没有提供的默认的转换器
// 例如:将String->枚举,Spring可能就没有提供,自己就可以自定义转换器,设置到WebDataBinder binder中
// 这样就能就String转换为枚举类型
attribute = binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);
}
// 获取BindingResult
bindingResult = binder.getBindingResult();
}
// 同步Model数据,将bindingResult的Model数据同步到mavContainer中
Map<String, Object> bindingResultModel = bindingResult.getModel();{
// 默认就将当前参数的实例对象和BindingResult存入到Model中了
Map<String, Object> model = new LinkedHashMap<>(2);
model.put(getObjectName(), getTarget());
model.put(MODEL_KEY_PREFIX + getObjectName(), this);
return model;
}
// 同步Model数据,将bindingResult的Model数据同步到mavContainer中
mavContainer.removeAttributes(bindingResultModel);
mavContainer.addAllAttributes(bindingResultModel);
// 返回处理好的参数
return attribute;
}
}
}
catch (Exception ex) {
throw ex;
}
}
return args;
}
// 反射执行
return doInvoke(args);
}
扫一扫
1472
评论
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
查看更多评论
添加红包
