springmvc中形参的map/model对象是如何将它们添加的键值对放到request保存域中的

最新推荐文章于 2023-03-20 08:07:25 发布
最新推荐文章于 2023-03-20 08:07:25 发布
阅读量637 收藏
点赞数 1
分类专栏： java扩展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w55935/article/details/124807011
版权

java 开发语言 spring mvc

分析如何将map/model的数据放入request保存域

  • 以下源码不需要全看，主要看写了中文注释的地方即可，一步一步进去就明白了
/*首先是进入到DispatcherServlet这个中央控制器中的doDispatcher()方法里的这一步（每个请求都会经由
DispatcherServlet处理，进入到doDispatcher()方法）*/
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
//=========进入ha.handle
public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
    throws Exception {

    return handleInternal(request, response, (HandlerMethod) handler);
}
//================进入handleInternal
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;
}
//================进入invokeHandlerMethod(request, response, handlerMethod);
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);

        //这里会创建mavContainer
        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();
    }
}
//===================进入invocableMethod.invokeAndHandle(webRequest, mavContainer);
public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
                            Object... providedArgs) throws Exception {

    //invokeFOrRequest，进入的就是这里
    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;
    }
}
//=================进入invokeForRequest(webRequest, mavContainer, providedArgs)
public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
                               Object... providedArgs) throws Exception {

    //进入这里面会返回args数组，这个args数组保存的就是我们需要的每个参数解析后的值/对象
    Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
    if (logger.isTraceEnabled()) {
        logger.trace("Arguments: " + Arrays.toString(args));
    }
    //!!!!执行我们的控制器方法，底层是一系列反射
    return doInvoke(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;
    }

    //args数组保存的就是每个参数的值
    Object[] args = new Object[parameters.length];
    //这个for循环一次对每个参数进行赋值，存放在args数组中
    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)
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);
	}
//================分两步，先进入getArgumentResolver(parameter)找到当前参数对应的参数解析器
private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
    //从缓存中直接获取这个参数对应的解析器，第一次的话肯定没有
    HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
    if (result == null) {
        //从所有的argumentResolvers里面一个一个找，找到了就放入缓存里，这个缓存将参数作为键，解析器作为值下一调用直接获取
        for (HandlerMethodArgumentResolver resolver : this.argumentResolvers) {
            //判断此解析器是否支持当前参数，例如参数是否包含某注解，因此对应某解析器，对象参数也有对应的解析器
            if (resolver.supportsParameter(parameter)) {
                result = resolver;
                this.argumentResolverCache.put(parameter, result);
                break;
            }
        }
    }
    return result;
}
//================第二步：再进入resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory)
public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
                              NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

    Assert.state(mavContainer != null, "ModelAndViewContainer is required for model exposure");
    //！！！！！！！！！！！！！！！！！！！！！！！！！！！！！关键，这里可以看见我们返回的是mavContainer对象的defaultModel属性
    //无论参数是map还是model还是modelmap，他们的解析器虽然不同，但是resolveArgument()方法都是返回mavContainer.getModel()
    //！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
    return mavContainer.getModel();
}
//=================进入mavContainer.getModel()
public ModelMap getModel() {
    //这里可以看见，如果使用的是默认的模型的话，返回的就是mavContainer这个对象的defaultModel属性
    if (useDefaultModel()) {
        return this.defaultModel;
    }
    else {
        if (this.redirectModel == null) {
            this.redirectModel = new ModelMap();
        }
        return this.redirectModel;
    }
}

  • 由上可知，我们参数中map/model最终得到的都是mavContainer这个对象的defaultModel属性，这个属性的类型是BindingAwareModelMap，之前讲过这个BindingAwareModelMap实现了map/model这两个接口，因此返回这个类型我们的map或者model都可以接收。

    • 而且如果我们参数同时有map和model，返回的对象实际上是同一个，以为上面可以看到实际上就是调用mavContainer.getModel()返回的，而mavContainer这个对象的创建是在解析参数之前，一次请求映射只会创建一个，因此mavContainer.getModel()返回的是同一个对象。

    • 此时我们使用map或者model添加键值对实际上都会动态绑定到BindingAwareModelMap这个类型调用它的添加方法，因此我们map/model添加的键值对都放在同一个对象里，而这个对象实际上就是mavContainer的defualtModel属性，因此我们添加过后这个属性就有了对应的数据。

    • 例如这样添加

      map.put("1",123);
model.addAttribute("2",123);

      添加过后image-20220516194059723

      • 可以看到defalutModel这个属性有了对应的键值对数据

  • 然后执行完了控制器里面的方法后返回到invocableMethod.invokeAndHandle(webRequest, mavContainer)这一步

    protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
                                           HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

    ServletWebRequest webRequest = new ServletWebRequest(request, response);
    try {
        //...省略很多
        //这里创建的mavContainer对象
        ModelAndViewContainer mavContainer = new ModelAndViewContainer();
        //...省略很多

        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();
    }
}
//===================进入getModelAndView(mavContainer, modelFactory, webRequest)方法
private ModelAndView getModelAndView(ModelAndViewContainer mavContainer,
                                     ModelFactory modelFactory, NativeWebRequest webRequest) throws Exception {

    modelFactory.updateModel(webRequest, mavContainer);
    if (mavContainer.isRequestHandled()) {
        return null;
    }
    //得到我们操作更新过的模型，如果不是重定向请求就是default这个
    ModelMap model = mavContainer.getModel();
    //将这个mavContainer映射的视图名称和模型数据都作为参数new一个ModelAndView对象出来，这个就是我们最后得到的，这里返回它
    //！！！！！！！！！！！！！！！！！！！！！！！
    ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, mavContainer.getStatus());
    if (!mavContainer.isViewReference()) {
        mav.setView((View) mavContainer.getView());
    }
    if (model instanceof RedirectAttributes) {
        Map<String, ?> flashAttributes = ((RedirectAttributes) model).getFlashAttributes();
        HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
        if (request != null) {
            RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes);
        }
    }
    return mav;
}
//之后就是将这个创建出来的mav层层返回直到mv = ha.handle(processedRequest, response, mappedHandler.getHandler())这里

  • 至此，我们已经将我们控制器方法里面的键值对添加到了doDispatcher方法里面的mav对象中，之后真正将这个mav对象中的模型数据放到request保存域中的方法是mv = ha.handle(processedRequest, response, mappedHandler.getHandler())之后的processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException)这个方法

    image-20220516195845213

    进入processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException)方法：

    private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
			@Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
			@Nullable Exception exception) throws Exception {
    //...省略一些不相关的
    
		// Did the handler return a view to render?
		if (mv != null && !mv.wasCleared()) {
            //render方法渲染视图，进入这里！！！！！！！！！！！！！！！！！！！
			render(mv, request, response);
			if (errorView) {
				WebUtils.clearErrorRequestAttributes(request);
			}
		}
    //后面的省略
}
//========================进入render(mv, request, response);
protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
		//...省略一些不相关的
		try {
			if (mv.getStatus() != null) {
				request.setAttribute(View.RESPONSE_STATUS_ATTRIBUTE, mv.getStatus());
				response.setStatus(mv.getStatus().value());
			}
            //继续进入这个render方法！！！！！！
			view.render(mv.getModelInternal(), request, response);
		}
    	//后面的省略
}
//======================进入view.render(mv.getModelInternal(), request, response);
public void render(@Nullable Map<String, ?> model, HttpServletRequest request,
			HttpServletResponse response) throws Exception {

		if (logger.isDebugEnabled()) {
			logger.debug("View " + formatViewName() +
					", model " + (model != null ? model : Collections.emptyMap()) +
					(this.staticAttributes.isEmpty() ? "" : ", static attributes " + this.staticAttributes));
		}

		Map<String, Object> mergedModel = createMergedOutputModel(model, request, response);
		prepareResponse(request, response);
    	//这里是重点，进入这个方法！！！！！！！！！！！！！！！！！
		renderMergedOutputModel(mergedModel, getRequestToExpose(request), response);
	}
//=====================进入renderMergedOutputModel(mergedModel, getRequestToExpose(request), response)
protected void renderMergedOutputModel(
			Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {

		// Expose the model object as request attributes.
    	//这里就是暴露mdoel的数据作为RequestAttributes，进去！！！！！！！！！！！！！
		exposeModelAsRequestAttributes(model, request);
		//后面的省略
}
//====================进去exposeModelAsRequestAttributes(model, request);
protected void exposeModelAsRequestAttributes(Map<String, Object> model,
                                              HttpServletRequest request) throws Exception {

    //可以看到就是遍历model的每一个键值对，将它用request对象的setAttribute()方法设置
    model.forEach((name, value) -> {
        if (value != null) {
            request.setAttribute(name, value);
        }
        else {
            request.removeAttribute(name);
        }
    });
}

  • 至此分析完毕。

一酒。
关注
专栏目录
springMvc 处理模型数据 ModelAndView Map及Model @SeesionAttributes @ModelAttribute
chengqingshihuishui的博客
01-19 353
1、Spring MVC 提供了以下几种途径输出数据到模型中： （1）ModelAndView: 处理方法返回值类型为 ModelAndView时, 方法体即可通过该对象添加模型数据 （2）Map 及 Model: 入参为org.springframework.ui.Model、org.springframework.ui.ModelMap 或 java.uti.Map 时，处理方法返回时，Map 中的数据会自动添加到模型中。 （3）@SessionAttributes: 将模型中的某个属性暂存到Ht
SpringMVC --- 获取请求参数、域对象共享数据、视图
最新发布
乌云的博客
04-01 502
将 HttpServletRequest 作为控制器方法的形参，此时 HttpServletRequest 类型的参数表示封装了当前请求的请求报文的对象。
SpringMVC中使用servlet以及，处理模型数据(将数据存入request,session)。
weixin_45078981的博客
07-22 872
一、Servlet API 1.Spring MVC可以使用Servlet API作为请求方法的参数。 HttpServletRequest HttpServletResponse HttpSession Local InputStream OutputStream Read Write 示例：将ServletAPI作为方法的参数，方法中就可以使用api所对应的方法。 @RequestMapp...
将map集合存在jsp中request请求范围内
weixin_46259203的博客
05-05 285
` Map<String, String> map1 = new HashMap<>(); map1.put("k1", "王永亮"); map1.put("k2", "张三"); request.setAttribute("map", map1);
ASP中使用集合
It's my life
04-09 791
 大多数 ASP 内建对象支持集合。集合是存储字符串、数字、对象和其他值的地方。除了在存储或取出项目时集合会自动扩展与搜索外，集合与数组非常相近。与数组不同的是，集合被修改后，项目的位置将会移动。可以通过集合中项目的名称、索引或者通过在集合的所有项目中遍历访问项目。通过名称和索引访问项目通过使用项目名称可以访问集合中的具体项目。例如，Contents 集合拥有在 Session 对象中保存的所有变
request对象
weixin_43694465的博客
01-07 239
6 request对象 6.1 获取请求参数 问题1、什么是请求参数？ 浏览器在发送请求访问服务器的过程中，通过请求携带给服务器的数据就是请求参数。比如：在浏览器的地址栏中输入URL地址，URL地址后面可以拼接参数： 或者也可以通过form表单和表单项向服务器发送数据 问题2、如何获取请求参数？ 示例： 问题3、获取请求参数时的中文乱码问题？ 乱码产生的原因:在中文数据进行编码时 和进行解...
Java打怪之路----SpringMVC框架之获取请求参数与保存域对象
weixin_44020747的博客
12-06 510
（一）servletAPI获取请求参数 通过request.getParameter获取 <form th:action="@{/testServlet}" method="post"> 用户名：<input type="text" name="username"><br> 密码：<input type="password" name="password"><br> <input type="submit" value
java model 传值,springMVC学习记录——传值问题
weixin_42472941的博客
03-19 787
web开发中的数据传递(jsp→controller / controller→jsp)是客户端和服务端交互的基础，那么，springMVC中传值是怎么进行的呢？此博文记录一下springMVC框架中的基础的数据传递配置一、jsp→controller1、在控制层程序中通过 request.getParameter(name属性的值) 获取表单中的提交数据，(form表单中的name属性命名的in...
SpringMVC——在IDEA中的学习流程
qq_39108448的博客
09-16 332
springMVC——学习流程 一个模型 - 视图 - 控制器（MVC）的Web框架建立在中央前端控制器 1、简单的hello.jsp请求响应 流程： 导jar包 在web.xml加入spring监听，以及springmvc的核心配置（配置文件的地址，拦截器） 配置applicationContext.xml（扫描除Controller类；导入pringmvc.xml）和pringmvc.xml...
JavaEE_Mybatis_SpringMVC_SpringMVC_SpringMVC的Model中数据的作用域(位置)
迎难而上
12-08 6406
在学习SpringMVC中遇到Model 和 HttpServletRequst 数据放置的位置，对数据放置的位置比较困惑，写了以下的测试 本例通过HttpServletRequst 和 Model 中设置数据的两种，并redirect 到一个controller 比较两种方法是否都能接收到数据 测试代码 import cn.itcast.ssm.po.ItemsEx
SpringMVC学习四（@ModelMap @RequestBody等等的说明）
weixin_30639719的博客
09-28 205
参考如下 http://www.cnblogs.com/HD/p/4107674.html http://www.cnblogs.com/qiankun-site/p/5774325.html @responseBody注解的使用 1、 　　@responseBody注解的作用是将controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到r...
SpringMVC中参数接收(String、对象、list、map等类型)
weixin_45362837的博客
07-12 2295
SpringMVC中参数接收 接收参数语法说明: springmvc中使用控制器方法参数来收集客户端的请求参数,因此在接收请求参数时直接在需要控制器方法声明即可,springmvc可以自动根据指定类型完成类型的转换操作 参数类型大概有： 基本类型或者 String 类型、对象类型、list类型、map类型等。。。 接收参数的各种测试： import com.krystal.entity.User; import com.krystal.vo.CollectionVO; import org.springfr
【SpringMVC学习笔记（五）！！敲黑板！！】SpringMVC返回值类型及响应数据类型
qq_43097201的博客
03-09 214
使用Model对象 这里我们可以使用Model对象，就类似于setAttribute的方式来设置键值对，存储在request域，然后jsp页面的话，就可以直接通过 ${user.username}、${user.password}、${user.age} 来进行显示，但是要注意不要忽略EL表达式，要打开支持，使用 isELIgnored = "false" 打开对EL表达式的支持： ...
SpringMVC学习总结（四）使用ModelAndView、Model、Map、ModelMap向request域对象共享数据/向session、application域对象共享数据
ZaynFox的博客
08-28 747
我们知道，四大域对象包括：pageContext、request、session和application，而pageContext有效范围为一个jsp页面，太小了，而application有效范围为整个web工程，又太大了。因此我们平时的开发中在域对象中共享数据主要是用request和session。 我们来搭建本博客的环境： 首先，创建一个 web 模块并配置好web.xml和部署Tomcat 其次，在webapp/WEB-INF/templates/下创建index.html和target.html（名
SpringMVC学习(4)：模型数据处理
Jex的博客
01-28 348
前言 SpringMVC框架作为一个MVC框架，很重要的一项工作是在控制器获取模型数据并返回给客户端，即在JSP页面展示模型数据，使用的技术是通过EL表达式从域对象中取值。 JSP四大作用域对应的四个内置对象分别是 request，session，pageContext，application。开发中经常用到的域对象是request和session，pageContext和application可...
Spring3 MVC （三）---请求处理方法 参数及返回值总结
F & Q的专栏
10-26 581
@RequestMapping(“/xxxx”) public String aaa(){ } 在处理用户请求的方法里 ， 1：参数 a）aaa（）无参 b）aaa（@PathVariable(” “) 类型 变量） 用来接收将参数作为URL传递的类型处理 c）aaa（Httpservletrequest 啊 respons啊 session啊 等
SpringMVC中Model的使用
小白的记录
01-04 1780
SpringMVC会把Model（模型信息）中的的数据放入到request域对象中，页面可以通过EL表达式来取request域中的数据。我们可以先写一个案例，在后台使用Model的addAttribute方法，页面使用EL表达式取数据。 创建ModelController @Controller @RequestMapping(value = "/model") public class ModelController { /** * Model的使用 * @param...
【SpringMVC】SpringMVC方式，向作用域对象共享数据（ModelAndView、Model、map、ModelMap）
ebb29bbe的博客
03-20 424
SpringMVC方式，向作用域对象共享数据（ModelAndView、Model、map、ModelMap）
SpringMVC3.0中Map与Model数据模型详解及使用
当Spring MVC框架接收到HTTP请求时，如果处理方法参数类型为ModelMap或者Model，它会自动将当前请求的隐含模型对象（即HttpSession或RequestScope中的数据）传递给这些参数。 `ModelMap`是Spring MVC提供的一个扩展...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一酒。

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值