SpringMVC参数传递源码解析

最新推荐文章于 2023-12-23 18:24:05 发布
最新推荐文章于 2023-12-23 18:24:05 发布
阅读量412 收藏 3
点赞数
分类专栏： 笔记 文章标签： spring mvc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33034955/article/details/107589658
版权

SpringMVC参数传递

一：直接将请求参数名作为Controller中方法的形参

public String login (String username,String password) ：

解释：括号中的参数必须与页面Form 表单中的 name 名字相同

二：使用@RequestParam 绑定请求参数参数值

举例：public String login(RequestParam (“username”) String name) :

解释：双引号中的username 必须与页面 name 名字相同，String name 中的name可以随便写

三：用注解@RequestMapping接收参数的方法

    @RequestMapping(value="/login/{username}/{password}")

public String login(@PathVariable(“username”) String name，@PathVariable(“password”) String name)

解释:上面的 @RequestMapping(value="/login/{username}/{password}") 是以注解的方式写在方法上的。注解上的usernname和 password 必须好页面上name 相同

四：使用Pojo对象（就是封装的类，类中封装的字段作为参数）绑定请求参数值，原理是利用Set的页面反射机制找到User对象中的属性

举例：@ReauestMapping（value=/login”）

public String login(User user){

解释：就是把封装的一个类当成一个参数放在方法中，封装类中的属性就是就是参数。

五：使用原生的Servlet API 作为Controller 方法的参数

public String login(HttpServletRequest request){

String usernma=Request.getParameter(“username”);

}

解释：使用request 请求页面参数的方式获取从页面传过来的参数

参数传递原理解析：
最初的Controller

@RequestMapping(value = "/user",method = RequestMethod.POST)
    @ResponseBody
    public String getUser(User user){
        return user.toString();
    }
  • 首先再DispatcherServlet的doDispatch()中执行了：mv = ha.handle(processedRequest, response, mappedHandler.getHandler());来执行handler
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpServletRequest processedRequest = request;
    HandlerExecutionChain mappedHandler = null;
    boolean multipartRequestParsed = false;

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

    try {
        ModelAndView mv = null;
        Exception dispatchException = null;

        try {
            processedRequest = checkMultipart(request);
            multipartRequestParsed = (processedRequest != request);

            // Determine handler for the current request.
            mappedHandler = getHandler(processedRequest);
            if (mappedHandler == null) {
                noHandlerFound(processedRequest, response);
                return;
            }

            // Determine handler adapter for the current request.
            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

            // Process last-modified header, if supported by the handler.
            String method = request.getMethod();
            boolean isGet = "GET".equals(method);
            if (isGet || "HEAD".equals(method)) {
                long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                    return;
                }
            }

            if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                return;
            }

            // Actually invoke the handler.
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

            if (asyncManager.isConcurrentHandlingStarted()) {
                return;
            }

            applyDefaultViewName(processedRequest, mv);
            mappedHandler.applyPostHandle(processedRequest, response, mv);
        }
        catch (Exception ex) {
            dispatchException = ex;
        }
        catch (Throwable err) {
            // As of 4.3, we're processing Errors thrown from handler methods as well,
            // making them available for @ExceptionHandler methods and other scenarios.
            dispatchException = new NestedServletException("Handler dispatch failed", err);
        }
        processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    }
    catch (Exception ex) {
        triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
    }
    catch (Throwable err) {
        triggerAfterCompletion(processedRequest, response, mappedHandler,
                               new NestedServletException("Handler processing failed", err));
    }
    finally {
        if (asyncManager.isConcurrentHandlingStarted()) {
            // Instead of postHandle and afterCompletion
            if (mappedHandler != null) {
                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
            }
        }
        else {
            // Clean up any resources used by a multipart request.
            if (multipartRequestParsed) {
                cleanupMultipart(processedRequest);
            }
        }
    }
}
  • mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
@Override
@Nullable
public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
    throws Exception {

    return handleInternal(request, response, (HandlerMethod) handler);
}
  • 继续往下走
@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);
    }

    if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
        if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
            applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
        }
        else {
            prepareResponse(response);
        }
    }

    return mav;
}
  • mav = invokeHandlerMethod(request, response, handlerMethod);执行handler的方法
@Nullable
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);
        if (this.argumentResolvers != null) {
            invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
        }
        if (this.returnValueHandlers != null) {
            invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
        }
        invocableMethod.setDataBinderFactory(binderFactory);
        invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);

        ModelAndViewContainer mavContainer = new ModelAndViewContainer();
        mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
        modelFactory.initModel(webRequest, mavContainer, invocableMethod);
        mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);

        AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
        asyncWebRequest.setTimeout(this.asyncRequestTimeout);

        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
        asyncManager.setTaskExecutor(this.taskExecutor);
        asyncManager.setAsyncWebRequest(asyncWebRequest);
        asyncManager.registerCallableInterceptors(this.callableInterceptors);
        asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);

        if (asyncManager.hasConcurrentResult()) {
            Object result = asyncManager.getConcurrentResult();
            mavContainer = (ModelAndViewContainer) asyncManager.getConcurrentResultContext()[0];
            asyncManager.clearConcurrentResult();
            LogFormatUtils.traceDebug(logger, traceOn -> {
                String formatted = LogFormatUtils.formatValue(result, !traceOn);
                return "Resume with async result [" + formatted + "]";
            });
            invocableMethod = invocableMethod.wrapConcurrentResult(result);
        }

        invocableMethod.invokeAndHandle(webRequest, mavContainer);
        if (asyncManager.isConcurrentHandlingStarted()) {
            return null;
        }

        return getModelAndView(mavContainer, modelFactory, webRequest);
    }
    finally {
        webRequest.requestCompleted();
    }
}

WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod):获取参数绑定的工厂

ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);获取Model工厂

ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod)：创建执行handler的方法

invocableMethod.invokeAndHandle(webRequest, mavContainer);执行handler方法

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

    Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
    setResponseStatus(webRequest);

    if (returnValue == null) {
        if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
            disableContentCachingIfNecessary(webRequest);
            mavContainer.setRequestHandled(true);
            return;
        }
    }
    else if (StringUtils.hasText(getResponseStatusReason())) {
        mavContainer.setRequestHandled(true);
        return;
    }

    mavContainer.setRequestHandled(false);
    Assert.state(this.returnValueHandlers != null, "No return value handlers");
    try {
        this.returnValueHandlers.handleReturnValue(
            returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
    }
    catch (Exception ex) {
        if (logger.isTraceEnabled()) {
            logger.trace(formatErrorForReturnValue(returnValue), ex);
        }
        throw ex;
    }
}

Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);调用这个方法来执行request

  • Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
@Nullable
public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
                               Object... providedArgs) throws Exception {

    Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
    if (logger.isTraceEnabled()) {
        logger.trace("Arguments: " + Arrays.toString(args));
    }
    return doInvoke(args);
}

它首先根据Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);获取了方法的参数值

  • Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
			Object... providedArgs) throws Exception {
		//获取方法参数
		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);
			args[i] = findProvidedArgument(parameter, providedArgs);
			if (args[i] != null) {
				continue;
			}
			if (!this.resolvers.supportsParameter(parameter)) {
				throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
			}
			try {
				args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
			}
			catch (Exception ex) {
				// Leave stack trace for later, exception may actually be resolved and handled...
				if (logger.isDebugEnabled()) {
					String exMsg = ex.getMessage();
					if (exMsg != null && !exMsg.contains(parameter.getExecutable().toGenericString())) {
						logger.debug(formatArgumentError(parameter, exMsg));
					}
				}
				throw ex;
			}
		}
		return args;
}

args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);来解析参数值

  • args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
@Override
@Nullable
public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
                              NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
	//获取参数解析器
    HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
    if (resolver == null) {
        throw new IllegalArgumentException("Unsupported parameter type [" +
                                           parameter.getParameterType().getName() + "]. supportsParameter should be called first.");
    }
    return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
}

resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);解析参数

  • resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
@Override
@Nullable
public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
                                    NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

    Assert.state(mavContainer != null, "ModelAttributeMethodProcessor requires ModelAndViewContainer");
    Assert.state(binderFactory != null, "ModelAttributeMethodProcessor requires WebDataBinderFactory");

    String name = ModelFactory.getNameForParameter(parameter);
    ModelAttribute ann = parameter.getParameterAnnotation(ModelAttribute.class);
    if (ann != null) {
        mavContainer.setBinding(name, ann.binding());
    }

    Object attribute = null;
    BindingResult bindingResult = null;

    if (mavContainer.containsAttribute(name)) {
        attribute = mavContainer.getModel().get(name);
    }
    else {
        // Create attribute instance
        try {
            attribute = createAttribute(name, parameter, binderFactory, webRequest);
        }
        catch (BindException ex) {
            if (isBindExceptionRequired(parameter)) {
                // No BindingResult parameter -> fail with BindException
                throw ex;
            }
            // Otherwise, expose null/empty value and associated BindingResult
            if (parameter.getParameterType() == Optional.class) {
                attribute = Optional.empty();
            }
            bindingResult = ex.getBindingResult();
        }
    }

    if (bindingResult == null) {
        // Bean property binding and validation;
        // skipped in case of binding failure on construction.
        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());
            }
        }
        // Value type adaptation, also covering java.util.Optional
        if (!parameter.getParameterType().isInstance(attribute)) {
            attribute = binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);
        }
        bindingResult = binder.getBindingResult();
    }

    // Add resolved attribute and BindingResult at the end of the model
    Map<String, Object> bindingResultModel = bindingResult.getModel();
    mavContainer.removeAttributes(bindingResultModel);
    mavContainer.addAllAttributes(bindingResultModel);

    return attribute;
}

attribute = createAttribute(name, parameter, binderFactory, webRequest);在这创建的绑定对象

  • attribute = createAttribute(name, parameter, binderFactory, webRequest);
@Override
protected final Object createAttribute(String attributeName, MethodParameter parameter,
                                       WebDataBinderFactory binderFactory, NativeWebRequest request) throws Exception {

    String value = getRequestValueForAttribute(attributeName, request);
    if (value != null) {
        Object attribute = createAttributeFromRequestValue(
            value, attributeName, parameter, binderFactory, request);
        if (attribute != null) {
            return attribute;
        }
    }

    return super.createAttribute(attributeName, parameter, binderFactory, request);
}
  • return super.createAttribute(attributeName, parameter, binderFactory, request);
protected Object createAttribute(String attributeName, MethodParameter parameter,
			WebDataBinderFactory binderFactory, NativeWebRequest webRequest) throws Exception {

		MethodParameter nestedParameter = parameter.nestedIfOptional();
		Class<?> clazz = nestedParameter.getNestedParameterType();

		Constructor<?> ctor = BeanUtils.findPrimaryConstructor(clazz);
		if (ctor == null) {
			Constructor<?>[] ctors = clazz.getConstructors();
			if (ctors.length == 1) {
				ctor = ctors[0];
			}
			else {
				try {
					ctor = clazz.getDeclaredConstructor();
				}
				catch (NoSuchMethodException ex) {
					throw new IllegalStateException("No primary or default constructor found for " + clazz, ex);
				}
			}
		}

		Object attribute = constructAttribute(ctor, attributeName, parameter, binderFactory, webRequest);
		if (parameter != nestedParameter) {
			attribute = Optional.of(attribute);
		}
		return attribute;
	}

在这里收先获取了参数里的对象的构造器，然后根据构造器创建除了对象，

然后返回到上一步，紧接着执行了：bindRequestParameters(binder, webRequest);来绑定参数值

  • bindRequestParameters(binder, webRequest);
@Override
protected void bindRequestParameters(WebDataBinder binder, NativeWebRequest request) {
   ServletRequest servletRequest = request.getNativeRequest(ServletRequest.class);
   Assert.state(servletRequest != null, "No ServletRequest");
   ServletRequestDataBinder servletBinder = (ServletRequestDataBinder) binder;
   servletBinder.bind(servletRequest);
}

它首先获取到了request对象以及绑定对象，最后执行了数据绑定方法：servletBinder.bind(servletRequest);****

  • servletBinder.bind(servletRequest);
public void bind(ServletRequest request) {
    MutablePropertyValues mpvs = new ServletRequestParameterPropertyValues(request);
    MultipartRequest multipartRequest = WebUtils.getNativeRequest(request, MultipartRequest.class);
    if (multipartRequest != null) {
        bindMultipart(multipartRequest.getMultiFileMap(), mpvs);
    }
    addBindValues(mpvs, request);
    doBind(mpvs);
}

protected void doBind(MutablePropertyValues mpvs) {
    checkAllowedFields(mpvs);
    checkRequiredFields(mpvs);
    applyPropertyValues(mpvs);
}

protected void applyPropertyValues(MutablePropertyValues mpvs) {
    try {
        // Bind request parameters onto target object.
        getPropertyAccessor().setPropertyValues(mpvs, isIgnoreUnknownFields(), isIgnoreInvalidFields());
    }
    catch (PropertyBatchUpdateException ex) {
        // Use bind error processor to create FieldErrors.
        for (PropertyAccessException pae : ex.getPropertyAccessExceptions()) {
            getBindingErrorProcessor().processPropertyAccessException(pae, getInternalBindingResult());
        }
    }
}

最终执行完。完成了参数的绑定

Boboboobo
关注
专栏目录
springboot 参数传递（表单传递）
weixin_43931625的博客
12-18 2600
springboot参数传递（表单传递） ************************************* 相关注解 @Requestparam @Target({ElementType.PARAMETER}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface RequestPara...
SpringMvc参数传递
m0_52012606的博客
04-01 2454
SpringMvc两种映射规则 1.spring mvc 默认参数映射规则：名字一致 自动映射 2.spring mvc自定义映射规则：可以通过注解来实现=> @RequestParam 传递基本数据类型 @RequestParam，POST和GET均支持 注解定义 @Target({ElementType.PARAMETER}) // 只能作用于参数上 @Retention(RetentionPolicy.RUNTIME) @Documented public @interface ..
springmvc 响应封装_SpringMVC 源码解读笔记
weixin_39628271的博客
12-31 103
MVC 模式早已被大家熟知，多多少少大家都接触过一些MVC的框架比如stuts,webwork,springmvc，当我们谈论到MVC时其实就是了解他的这种分层理念，职责清晰化，抛弃了原来的混合开发模式，把程序的交互分为了Model 数据处理层，View 视图处理层，Contro 逻辑控制层， 职责清晰明了，更利于程序的扩展和维护。当然我们只简简单单的知道这些东西还不够，我们还需要深入这些设计模式...
SpringMVC案列以及源码讲解
weixin_46300935的博客
06-29 730
目录 SpringMVC 概述 入门案例 入门案例制作 入门案例工作流程分析 SpringMVC 技术架构图 基本配置 常规配置（Controller加载控制） 静态资源加载 中文乱码处理 注解驱动 请求 普通类型参数传参 POJO类型参数传参 数组与集合类型参数传参 类型转换器 日期类型格式转换 自定义类型转换器 请求映射 @RequestMapping 方法注解 类注解 响应 页面跳转 页面访问快捷设定 (InternalResour...
springMVC方法参数值注入简要源码分析
mrdu_somefun的博客
04-15 3317
1. 开始之前的唠嗑 懒惰是前进道路上最大的敌人，懒着懒着心就飘远了，荒废了许久的博客今天稍微重新拾起来，今天带了一篇springMVC源码分析之参数注入。 2. 步入正题 稍微了解springMVC的同学知道，在springMVC的应用中，它采用的中心转发的一种设计模式吧，中心转发这个词是我自己鼓捣出来了，请各位自行理解，何谓中心转发呢，其实就是所有请求一律经过spring中心拦截器拦截派
[MVC - 参数原理】详解SpringMVC中Controller的方法中参数的工作原理[附带源码分析]
叁滴水 的博客
05-22 927
 https://www.cnblogs.com/sunny3096/p/7215906.html
SpringMVC源码解析
xxxzzzqqq_的博客
03-20 287
设置整个系统的主题。主题就是系统的整体样式或风格，可通过Spring MVC框架提供的主题（theme）设置应用的整体样式风格，提高用户体验。标注的对象，如果代理模式是jdk或者cglib代理的话，会在spring容器中产生2个bean,一个是代理的bean,一个是原始的bean,原始的bean的beanName被。，但不像传统的 Web 服务器有容器概念，加载一个 Web 应用可以小于 10MB 内存，它提供了对Servlet3.1的支持(方法，又是模板模式，空方法，让子类复写进行逻辑处理，例如子类。
springmvc项目源码
最新发布
02-04
在 Spring MVC 中，模型数据通常通过 `@ModelAttribute` 注解传递，视图解析则由 `ViewResolver` 完成。你可以看到 `jsp`、`freemarker` 或 `thymeleaf` 等视图技术的使用，它们将模型数据渲染成用户可见的页面。 ...
springmvc框架源码.zip
12-18
本压缩包包含SpringMVC的源码，对于学习和理解SpringMVC的工作原理及其内部机制非常有价值。 1. **DispatcherServlet**：SpringMVC的核心组件，它作为前端控制器，负责接收HTTP请求，并根据请求信息（如URL、HTTP...
Spring MVC参数传递中文乱码解决方法分享
08-28
* Spring MVC 在启动完成后执行方法源码解析 * SpringMVC 拦截器实现监听 session 是否过期详解 * SpringMVC 开发 RESTful API 之用户查询代码详解 这些文章将为您提供更多关于 Spring MVC 框架的知识和经验。
Spring MVC 学习 之 - URL参数传递详解
08-31
本篇文章主要介绍了SpringMVC-URL参数传递，在学习 Spring Mvc 过程中，有必要来先了解几个关键参数，有兴趣的可以了解一下。
SpringMVC后台接收请求参数的几种方式Demo
10-03
SpringMVC后台接收请求参数的几种方式源码。总结了常用的注解，介绍GET和POST请求方式下的参数传递方法。
springmvc参数注入源码剖析&源码扩展
黄小厮的博客
08-21 985
项目中使用json传递数据，定义了一套统一的格式，如下所示，但是实际上业务层面只需要处理data节点的数据，sign、signType参数由框架层面进行验签处理。项目中的web层使用了springmvc、resteasy框架，为了方便接收data节点的json数据，笔者扩展了springmvc的源码，添加了自定义的HandlerMethodArgumentResolver。 { "s
springmvc源码-参数解析
小小少年的博客
11-28 258
该篇博客介绍了调用的部分逻辑，这篇主要介绍了实现Controller接口和实现HttpRequestHandler接口这两种方式的调用，这两种方式比较简单，就是通过强转，然后调用目标方法即可，麻烦的是下面这种，通过@Controller注解声明的controller，在这篇博客中会仔细介绍 对于通过@Controller、@RequestMapping()这种通过注解，声明handlerMethod的方式，会分为以下三步： 1.对请求中的参数进行解析 2.调用目标方法 3.对返回参数进行解析 对参数进行解析
springMVC参数绑定源码分析
wangfenglei123456的博客
11-26 1187
springMVC参数绑定源码分析
springmvc参数收集与类型转换源码解析
u013905744的专栏
10-18 446
springmvc参数收集与类型转换源码解析
三、SpringMVC之参数封装
暖阳阳
04-22 1319
三、SpringMVC之参数封装 一、基本数据欸型的参数 1.页面传递的参数，都需要配置到方法参数列表上 2.页面传递的参数名称必须要参数列表上的参数名称一致 3对与基本数据类型springMVC框架可以自动转型 4.特殊的类型： 配置类型转化器（将string类型参数转化为date类型） 控制器方法 /** * 接收基本数据类型的参数 * 1页面传递的参...
SpringMVC接受参数详解—基本类型和包装类篇
m0_53308817的博客
12-23 921
相信小伙伴们都会有给controller传参的经历，但是springmvc内部是如何处理这些参数的。今天就带大家来看一看使用基本类型或包装类情况下的实现。
Spring MVC系列【17】参数处理流程源码解析
记录知识、锤炼自我
06-06 543
Spring MVC系列【17】参数处理流程源码解析
springmvc源码深度解析
05-18
下面我们从 DispatcherServlet 入手，深度解析 Spring MVC 的源码。 1. DispatcherServlet DispatcherServlet 是整个 Spring MVC 框架的核心，它是一个 Servlet，所有的请求都会经过它。DispatcherServlet 的主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值