SpringMVC参数解析器源码分析（二）--HandlerMethodArgumentResolver

最新推荐文章于 2024-03-30 16:37:34 发布
最新推荐文章于 2024-03-30 16:37:34 发布
阅读量586 收藏 1
点赞数
分类专栏： Spring源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lili429/article/details/79850635
版权

HandlerMethodArgumentResolverComposite

简介

HandlerMethodArgumentResolverComposite组装了所有的参数解析器的链表，保存了springMVC提供的所有的参数解析器以及自定义的参数解析器，采用职责链的模式来完成参数解析器的查找，并完成参数解析生成目标对象。

源码分析

public class HandlerMethodArgumentResolverComposite implements HandlerMethodArgumentResolver {

protected final Log logger = LogFactory.getLog(getClass());

//参数解析器列表
private final List<HandlerMethodArgumentResolver> argumentResolvers =
        new LinkedList<HandlerMethodArgumentResolver>();

//缓存已经查找过的参数解析器 
private final Map<MethodParameter, HandlerMethodArgumentResolver> argumentResolverCache =
        new ConcurrentHashMap<MethodParameter, HandlerMethodArgumentResolver>(256);


public HandlerMethodArgumentResolverComposite addResolver(HandlerMethodArgumentResolver resolver) {
    this.argumentResolvers.add(resolver);
    return this;
}


public HandlerMethodArgumentResolverComposite addResolvers(HandlerMethodArgumentResolver... resolvers) {
    if (resolvers != null) {
        for (HandlerMethodArgumentResolver resolver : resolvers) {
            this.argumentResolvers.add(resolver);
        }
    }
    return this;
}


public HandlerMethodArgumentResolverComposite addResolvers(List<? extends HandlerMethodArgumentResolver> resolvers) {
    if (resolvers != null) {
        for (HandlerMethodArgumentResolver resolver : resolvers) {
            this.argumentResolvers.add(resolver);
        }
    }
    return this;
}

//获取参数解析器列表
public List<HandlerMethodArgumentResolver> getResolvers() {
    return Collections.unmodifiableList(this.argumentResolvers);
}


public void clear() {
    this.argumentResolvers.clear();
}


//判断参数解析器是否支持参数解析
@Override
public boolean supportsParameter(MethodParameter parameter) {
    return (getArgumentResolver(parameter) != null);
}

//参数解析器解析parameter，具体解析过程要在不同的解析器中详细描述
@Override
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);
}

/**
 * 获取支持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;
}

}

HandlerMethodArgumentResolver

简述

下面来我们来看看常用的HandlerMethodArgumentResolver实现类：

  1. RequestParamMethodArgumentResolver支持有@RequestParam注解的参数或带有MultipartFile类型的参数

  2. RequestParamMapMethodArgumentResolver支持有@RequestParam注解的参数并且参数类型是实现Map接口的属性

  3. PathVariableMethodArgumentResolver支持有@PathVariable注解的参数

  4. RequestResponseBodyMethodProcessor 支持有@RequestBody注解的参数

  5. ServletRequestMethodArgumentResolver参数类型是实现或继承或是WebRequest、ServletRequest、MultipartRequest、HttpSession、Principal、Locale、TimeZone、InputStream、Reader、HttpMethod这些类。（这就是为何我们在Controller中的方法里添加一个HttpServletRequest参数，Spring会为我们自动获得HttpServletRequest对象的原因）

  6. ModelAttributeMethodProcessor 支持@ModelAttribute注解参数

RequestParamMethodArgumentResolver

RequestParamMethodArgumentResolver支持两种参数解析，一种是含@RequestParam注解的参数，另一种就是简单类型，如Integer、String、Date、URI, URL,Locale等。

使用场景
public String getUser(@RequestParameter("id") Long id) {
    return userService.get(id);
}


public String getUser(Long id) {
    return userService.get(id);
}
supportsParameter 判断是否支持当前parameter类型
public boolean supportsParameter(MethodParameter parameter) {
    //方法的参数中是否有RequestParam注解
    if (parameter.hasParameterAnnotation(RequestParam.class)) {
        //参数是否是Map  
        if (Map.class.isAssignableFrom(parameter.nestedIfOptional().getNestedParameterType())) {
            String paramName = parameter.getParameterAnnotation(RequestParam.class).name();
            return StringUtils.hasText(paramName);
        }
        else {
            return true;
        }
    }
    else {
        //如果参数上有RequestPart注解，直接返回faslse  
        if (parameter.hasParameterAnnotation(RequestPart.class)) {
            return false;
        }
        parameter = parameter.nestedIfOptional();
        //是否是文件上传
        if (MultipartResolutionDelegate.isMultipartArgument(parameter)) {
            return true;
        }
        //useDefaultResolution为true的bean是用来处理简单类型的bean的
        else if (this.useDefaultResolution) {
            return BeanUtils.isSimpleProperty(parameter.getNestedParameterType());
        }
        else {
            return false;
        }
    }
}

argumentResolvers中有两个RequestParamMethodArgumentResolver bean，一个useDefaultResolution为false，
一个useDefaultResolution为true。下面看一下哪些是简单的类型：

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) || clazz.isEnum() ||
            CharSequence.class.isAssignableFrom(clazz) ||
            Number.class.isAssignableFrom(clazz) ||
            Date.class.isAssignableFrom(clazz) ||
            URI.class == clazz || URL.class == clazz ||
            Locale.class == clazz || Class.class == clazz);
}

也就是我们的请求的参数类型为：枚举类型、String类型、Long、Integer、Float、Byte、Short、Double、Date、URI、URL、Locale、Class、文件上传对象或者参数是数组，数组类型为上面列出的类型时，则参数解析器为：RequestParamMethodArgumentResolver。

解析参数
resolveArgument

在RequestParamMethodArgumentResolver类中没有找到对应的resolveArgument方法，但是我们在他的父类AbstractNamedValueMethodArgumentResolver中找到了resolveArgument这个方法，源码如下：

public final Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
            NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        //获取入参的名称信息
        NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);
        MethodParameter nestedParameter = parameter.nestedIfOptional();

        Object resolvedName = resolveStringValue(namedValueInfo.name);
        if (resolvedName == null) {
            throw new IllegalArgumentException(
                    "Specified name must not resolve to null: [" + namedValueInfo.name + "]");
        }
        //解析参数值  
        Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);
        if (arg == null) {//request请求参数值为null
            //判断是否存在默认值
            if (namedValueInfo.defaultValue != null) {
                arg = resolveStringValue(namedValueInfo.defaultValue);
            }
            //判断添加@RequestParam的参数字段是否必须传值，默认必传
            else if (namedValueInfo.required && !nestedParameter.isOptional()) {
                //参数缺失处理，抛出相应类型异常
                handleMissingValue(namedValueInfo.name, nestedParameter, webRequest);
            }
            //null值处理
            arg = handleNullValue(namedValueInfo.name, arg, nestedParameter.getNestedParameterType());
        }
        else if ("".equals(arg) && namedValueInfo.defaultValue != null) {
            arg = resolveStringValue(namedValueInfo.defaultValue);
        }

        //参数类型转换
        if (binderFactory != null) {
            WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);
            try {
                arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);
            }
            catch (ConversionNotSupportedException ex) {
                throw new MethodArgumentConversionNotSupportedException(arg, ex.getRequiredType(),
                        namedValueInfo.name, parameter, ex.getCause());
            }
            catch (TypeMismatchException ex) {
                throw new MethodArgumentTypeMismatchException(arg, ex.getRequiredType(),
                        namedValueInfo.name, parameter, ex.getCause());

            }
        }

        handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);

        return arg;
    }
获取NamedValueInfo对象
private NamedValueInfo getNamedValueInfo(MethodParameter parameter) {
    NamedValueInfo namedValueInfo = this.namedValueInfoCache.get(parameter);
    if (namedValueInfo == null) {//缓存中不存在
        ////创建NamedValueInfo对象  
        namedValueInfo = createNamedValueInfo(parameter);
        //更新NamedValueInfo对象 
        namedValueInfo = updateNamedValueInfo(parameter, namedValueInfo);
        //缓存
        this.namedValueInfoCache.put(parameter, namedValueInfo);
    }
    return namedValueInfo;
}

RequestParamMethodArgumentResolver中的createNamedValueInfo方法以及RequestParamNamedValueInfo类：

通过RequestParamNamedValueInfo的两个构造函数可知，当@RequestParam存在的时候，使用注解的值，否则取默认的值。

protected NamedValueInfo createNamedValueInfo(MethodParameter parameter) {
    RequestParam ann = parameter.getParameterAnnotation(RequestParam.class);
    return (ann != null ? new RequestParamNamedValueInfo(ann) : new RequestParamNamedValueInfo());
}

private static class RequestParamNamedValueInfo extends NamedValueInfo {

    public RequestParamNamedValueInfo() {
        super("", false, ValueConstants.DEFAULT_NONE);
    }

    public RequestParamNamedValueInfo(RequestParam annotation) {
        super(annotation.name(), annotation.required(), annotation.defaultValue());
    }
}

updateNamedValueInfo方法可以看到，如果参数没有注解@RequestParam的话，则从MethodParameter中解析出参数的名字 

private NamedValueInfo updateNamedValueInfo(MethodParameter parameter, NamedValueInfo info) {
    String name = info.name;
    if (info.name.length() == 0) {
        //从MethodParameter中解析出参数的名字 
        name = parameter.getParameterName();
        if (name == null) {
            throw new IllegalArgumentException(
                    "Name for argument type [" + parameter.getNestedParameterType().getName() +
                    "] not available, and parameter name information not found in class file either.");
        }
    }
    //转换默认值
    String defaultValue = (ValueConstants.DEFAULT_NONE.equals(info.defaultValue) ? null : info.defaultValue);
    return new NamedValueInfo(name, info.required, defaultValue);
}
解析参数值

protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest request) throws Exception {

    //获取HttpServletRequest  
    HttpServletRequest servletRequest = request.getNativeRequest(HttpServletRequest.class);
    //判断是不是文件上传的请求 
    MultipartHttpServletRequest multipartRequest =
            WebUtils.getNativeRequest(servletRequest, MultipartHttpServletRequest.class);
    //获取上传文件对象
    Object mpArg = MultipartResolutionDelegate.resolveMultipartArgument(name, parameter, servletRequest);
    if (mpArg != MultipartResolutionDelegate.UNRESOLVABLE) {
        return mpArg;
    }

    Object arg = null;
    //判断是否是文件上传的请求
    if (multipartRequest != null) {
        //获取上传的文件列表
        List<MultipartFile> files = multipartRequest.getFiles(name);
        if (!files.isEmpty()) {
            arg = (files.size() == 1 ? files.get(0) : files);
        }
    }
    //其他请求都没返回，则是最简单的请求
    if (arg == null) {
        //获取参数值
        String[] paramValues = request.getParameterValues(name);
        if (paramValues != null) {
            arg = (paramValues.length == 1 ? paramValues[0] : paramValues);
        }
    }
    return arg;
}

PathVariableMethodArgumentResolver

简单示例
public User getUser(@PathVariable Long id) {
    return userService.get(id);
}

通过类名便可知道是路径变量做参数的解析器，这个类与RequestParamMethodArgumentResolver一样是AbstractNamedValueMethodArgumentResolver的子类，因此主要不同的地方在supportsParameter与resolveName方法，下面简单看一下：

supportsParameter
public boolean supportsParameter(MethodParameter parameter) {
    //没有@PathVariable注解直接返回false
    if (!parameter.hasParameterAnnotation(PathVariable.class)) {
        return false;
    }
    //判断是否是Map参数
    if (Map.class.isAssignableFrom(parameter.getParameterType())) {
        String paramName = parameter.getParameterAnnotation(PathVariable.class).value();
        return StringUtils.hasText(paramName);
    }
    return true;
}
resolveName
protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest request) throws Exception {
    Map<String, String> uriTemplateVars =
        (Map<String, String>) request.getAttribute(
                HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestAttributes.SCOPE_REQUEST);
    return (uriTemplateVars != null) ? uriTemplateVars.get(name) : null;
}

ModelAttributeMethodProcessor

简单示例

public String addB(@ModelAttribute User user)throws Exception {
    userService.addA(user.getUser_name(),user.getAge());
    return "success";
}
supportsParameter

支持有@ModelAttribute注解或者不需要注解但是入参不是简单类型的情况下，支持ModelAttributeMethodProcessor参数解析器

public boolean supportsParameter(MethodParameter parameter) {
    return (parameter.hasParameterAnnotation(ModelAttribute.class) ||
            (this.annotationNotRequired && !BeanUtils.isSimpleProperty(parameter.getParameterType())));
}
resolveArgument

这里参数以键值对的形式传入，从request取出后组成ProperValue列表，然后与参数对象的field对应赋值。具体绑定过程需要研究一下属性编辑器、数据绑定机制。

public final Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
        NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

    String name = ModelFactory.getNameForParameter(parameter);
    Object attribute = (mavContainer.containsAttribute(name) ? mavContainer.getModel().get(name) :
            createAttribute(name, parameter, binderFactory, webRequest));

    if (!mavContainer.isBindingDisabled(name)) {
        ModelAttribute ann = parameter.getParameterAnnotation(ModelAttribute.class);
        if (ann != null && !ann.binding()) {
            mavContainer.setBindingDisabled(name);
        }
    }

    WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);
    //参数绑定
    if (binder.getTarget() != null) {
        if (!mavContainer.isBindingDisabled(name)) {
            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
    Map<String, Object> bindingResultModel = binder.getBindingResult().getModel();
    mavContainer.removeAttributes(bindingResultModel);
    mavContainer.addAllAttributes(bindingResultModel);

    return binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);
}

RequestResponseBodyMethodProcessor

RequestResponseBodyMethodProcessor这个类其实同时实现了HandlerMethodReturnValueHandler和HandlerMethodArgumentResolver这两个接口。我们在当前文章中只介绍参数解析的部分。

supportsParameter
@Override
public boolean supportsParameter(MethodParameter parameter) {
    return parameter.hasParameterAnnotation(RequestBody.class);
}
resolveArgument

这里不在详细介绍，具体的转换可以看消息转换器的源码。

public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
        NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

    parameter = parameter.nestedIfOptional();
    //具体处理是使用消息转换器
    Object arg = readWithMessageConverters(webRequest, parameter, parameter.getNestedGenericParameterType());
    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 adaptArgumentIfNecessary(arg, parameter);
}

总结

参数转换的方法不仅仅这些，这里只是选取了几个比较常用的参数解析器简单的介绍了一下，有些直接在类中就完成了解析；但是有些还需要借助其他的类才能完成解析。

扩展

职责链设计模式，需要写一篇相关文章

AlwaysByYourSide
关注
专栏目录
使用HandlerMethodArgumentResolver给Controller注入会员信息
xxwd12的博客
05-30 1万+
1、在aop中进行校验登录，校验成功后将会员信息保存到ThreadLocal，调用 UserContext.setUser(user)方法; UserContext 类： public class UserContext { private static ThreadLocal<User> userContext = new ThreadLocal<User&...
SpringMVC源码深度解析
weixin_56644618的博客
10-29 3217
springmvc的源码解析，建议收藏，多看几遍！！！
springMVC源码解析--HandlerMethodArgumentResolverComposite参数解析器集合（二）
井底之蛙
01-10 3758
上一篇博客springMVC源码分析--HandlerMethodArgumentResolver参数解析器（一）中我们已经介绍了参数解析相关的东西，并且也提到了HandlerMethodArgumentResolverComposite，其简单来说就是所有的参数解析器的链表，保存了springMVC提供的所有的参数解析器，采用职责链的模式来完成参数解析器的查找，并完成参数解析生成目标对象。完整源
springMVC源码分析--HandlerMethodArgumentResolver参数解析器（一）
井底之蛙
01-10 6502
HandlerMethodArgumentResolver是用来为处理器解析参数的，主要用在HandlerMethod中，每个Resolver对应一种类型的参数，其实现类特别的多。HandlerMethodArgumentResolver接口及其实现类如下：HandlerMethodArgumentResolver的接口定义如下：（1）supportsParameter 用于判断是否支持对某种参数
Spring MVC 源码- HandlerAdapter 组件（三）之 HandlerMethodArgumentResolver
Coder_Boy_的博客
02-24 1941
来进行处理，如果有某一个参数解析器支持解析该方法参数，则使用它从请求体中获取到该方法参数的值，注意这里有一定的先后顺序，因为是通过 LinkedList 保存所有的实现类，排在前面的实现类则优先处理。参数解析器从请求中获取到对应的方法参数值，因为你无法确认哪个参数值对应哪个参数，所以需要先通过它从请求中解析出参数值，一一对应，然后才能调用该方法。方法，解析参数值的后置处理，空方法，子类可以覆盖，子类 PathVariableMethodArgumentResolver 会重写该方法。
SpringMVC源码分析-HandlerAdapter(8)-HandlerMethodArgumentResolver组件分析
BraveWangDev
07-09 293
HandlerMethodArgumentResolver HandlerMethodArgumentResolver用来为处理器解析参数 主要在InvocableHandlerMethod中使用 由于每个Resolver对应一种类型的参数,所以有很多实现类 HandlerMethodArgumentResolverComposite 其中HandlerMethodArgumentRe...
springmvc参数解析绑定
Eaeyson的博客
06-12 422
springmvc参数解析绑定流程
SpringMVC源码解析：参数解析与自定义处理器详解
本篇文章是SpringMVC源码分析系列的一部分，主要针对Spring MVC框架中Controller方法参数解析的深入探讨。SpringMVC作为当前Web MVC架构的流行选择，其灵活性体现在Controller方法支持各种类型的参数，如Integer、...
Spring MVC学习笔记之Spring MVC组件HandlerMethodArgumentResolver
向心行者
09-20 556
1、HandlerMethodArgumentResolver接口   HandlerMethodArgumentResolver接口及其实现类主要是为了实现解析处理器中处理器request的方法中的参数。因为前面提到的HandlerMethod类型的处理器，参数可以是任意的形式，所以这就为定义参数解析器带来的很大的复杂度，在Spring MVC中提供了数量庞大的参数解析器，类图如下： 因为HandlerMethodArgumentResolver家族非常庞大，所以查看类图时，需要放大或下载到本地再查看
Springboot之HandlerMethodArgumentResolver源码解析
choubayan4320的博客
08-05 226
Springboot版本2.0.5.release。 前一篇博客讲解了如何用自定义HandlerMethodArgumentResolver进行参数解析，现在来看看springmvc是如何实现这个的。 来看下RequestMappingHandlerAdapter，...
HandlerMethodArgumentResolver参数解析
程序员小潘
01-04 1133
被注解的方法就是一个请求处理器 handler，Spring MVC 会把该方法封装成 HandlerMethod 对象。HTTP 请求经过 RequestMappingInfo 条件匹配后最终路由到目标 HandlerMethod，接下来就是对目标方法的调用了。调用方法你得有参数吧，所以 Spring MVC 会先依赖 HandlerMethodArgumentResolverComposite 组件解析参数列表，再反射调用目标方法，本文重点参数的解析。
SpringMVC之分析HandlerMethodArgumentResolver请求对应处理器方法参数的解析过程(一)
398701344努力加油！
10-15 7986
在我们做Web开发的时候，会提交各种数据格式的请求，而我们的后台也会有相应的参数处理方式。SpringMVC就为我们提供了一系列的参数解析器，不管你是要获取Cookie中的值，Header中的值，JSON格式的数据，URI中的值。下面我们分析几个SpringMVC为我们提供的参数解析器。 在SpringMVC中为我们定义了一个参数解析的顶级父类：HandlerMethodArgumentReso
【springMVC源码分析】HandlerMethodArgumentResolver参数注入的秘密
sumengnan的博客
02-09 597
关键的接口 HandlerMethodArgumentResolver（处理器方法参数解析器） 它的实现类如下： 常用的有： ServletRequestMethodArgumentResolver和ServletResponseMethodArgumentResolver处理了自动绑定HttpServletRequest和HttpServletResponse RequestParamMapMethodArgumentResolver处理了@RequestParam Request..
Spring参数解析器的使用-HandlerMethodArgumentResolver
燕少江湖
04-29 761
Spring 参数解析器的简单使用-HandlerMethodArgumentResolver
SpringMVC源码解析三：RequestParamMethodArgumentResolver
qq_28825857的博客
08-09 1134
supportsParameter(parameter)这里有一个常用的解析器： RequestParamMethodArgumentResolver类中： 主要用来解析@RequestParam注解的参数 public boolean supportsParameter(MethodParameter parameter) { if (parameter.hasParam...
Spring核心接口：HandlerMethodArgumentResolver参数解析器
five-five
03-25 1692
在Spring中，参数解析器是一个接口，它负责将HTTP请求中的参数解析为控制器方法的参数。Spring提供了许多内置的参数解析器，用于处理不同类型的请求参数，例如查询参数、路径变量、请求头、请求体等。开发人员还可以自定义参数解析器，以处理特定的请求参数。除了Spring提供的内置参数解析器外，开发人员还可以自定义参数解析器，以处理特定的请求参数。自定义参数解析器需要实现HandlerMethodArgumentResolver接口，并在配置类中将其添加到WebMvcConfigurer中。
Spring Boot HandlerMethodArgumentResolver 使用和场景
最新发布
攻城狮不是猫
03-30 1735
为了将 HTTP 请求参数转换为 Java 对象，我们需要创建一个自定义的实现类。在这个类中，我们需要实现方法和方法。要在 Spring Boot 应用程序中使用自定义的实现类，我们需要将其注册到应用程序上下文中。为此，我们可以创建一个类，并实现接口。在这个类中，我们需要重写方法，并将自定义的实现类添加到参数解析器列表中。@Override要在 Spring Boot 应用程序中使用自定义的实现类，我们需要将其注册到应用程序上下文中。为此，我们可以创建一个类，并实现接口。在这个类中，我们需要重写。
HandlerMethodArgumentResolver源码分析
我就是我的博客
11-10 630
基于SpringBoot 2.2.0.RELEASE 先看下Spring对HandlerMethodArgumentResolver的接口定义 /** *用于将请求上下文中的方法参数解析为参数值的策略接口 */ public interface HandlerMethodArgumentResolver { /**是否MethodParamter是否能被该resolver解析器支持 *...
SpringMVC框架解析：模型-视图-控制器的分离
"SpringMVC是Spring框架的一部分，用于构建Web应用程序的模型-视图-控制器（MVC）架构。它提供了优雅的编程和配置模型，帮助开发者将数据、业务逻辑和用户界面有效地分离。Spring MVC的核心是DispatcherServlet，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值