springmvc 接手map 讲一下springmvc

转载

信息小飞侠 2024-03-04 10:15:02

文章标签 springmvc 接手map spring java MVC xml 文章分类 架构后端开发

SpringMVC

1. 学习⽬标

springmvc 接手map 讲一下springmvc_springmvc 接手map

2. MVC 思想 & SpringMVC 框架概念与特点

2.1. 什么叫MVC？

模型-视图-控制器（MVC）是⼀个众所周知的以设计界⾯应⽤程序为基础的设计思想。它主要通过分离模型、视图及控制器在应⽤程序中的⻆⾊将业务逻辑从界⾯中解耦。通常，模型负责封装应⽤程序数据在视图层展示。视图仅仅只是展示这些数据，不包含任何业务逻辑。控制器负责接收来⾃⽤户的请求，并调⽤后台服务（service或者dao）来处理业务逻辑。处理后，后台业务层可能会返回了⼀些数据在视图层展示。控制器收集这些数据及准备模型在视图层展示。MVC模式的核⼼思想是将业务逻辑从界⾯中分离出来，允许它们单独改变⽽不会相互影响。

springmvc 接手map 讲一下springmvc_springmvc 接手map_02

2.2. 常⻅MVC框架运⾏性能⽐较

Jsp+servlet > struts1 > spring mvc > struts2+freemarker > struts2,ognl,值栈。
开发效率上,基本正好相反。值得强调的是，spring mvc开发效率和struts2不相上下，但从⽬前来
看，spring mvc 的流⾏度已远远超过struts2。

2.3. Spring MVC是什么?

Spring MVC是Spring家族中的⼀个web成员，它是⼀种基于Java的实现了Web MVC设计思想的请求驱动类型的轻量级Web框架，即使⽤了MVC架构模式的思想，将web层进⾏职责解耦，基于请求驱动指的就是使⽤请求-响应模型，框架的⽬的就是帮助我们简化开发，Spring MVC也是要简化我们⽇常Web开发的。

Spring MVC是服务到⼯作者思想的实现。前端控制器是DispatcherServlet；应⽤控制器拆为处理器映射器(Handler Mapping)进⾏处理器管理和视图解析器(View Resolver)进⾏视图管理；⽀持本地化/国际化（Locale）解析及⽂件上传等；提供了⾮常灵活的数据验证、格式化和数据绑定机制；提供了强⼤的约定⼤于配置（惯例优先原则）的契约式编程⽀持。

2.4. Spring MVC能帮我们做什么?

让我们能⾮常简单的设计出⼲净的Web层；
进⾏更简洁的Web层的开发；
天⽣与Spring框架集成（如IOC容器、AOP等）；
提供强⼤的约定⼤于配置的契约式编程⽀持；
能简单的进⾏Web层的单元测试；
⽀持灵活的URL到⻚⾯控制器的映射；
⾮常容易与其他视图技术集成，如jsp、Velocity、FreeMarker等等，因为模型数据不放在特定的API⾥，⽽是放在⼀个Model⾥（Map数据结构实现，因此很容易被其他框架使⽤）；
⾮常灵活的数据验证、格式化和数据绑定机制，能使⽤任何对象进⾏数据绑定，不必实现特定框架的API；
⽀持灵活的本地化等解析；
更加简单的异常处理；
对静态资源的⽀持；
⽀持Restful⻛格。

3. SpringMVC 请求流程 & 环境搭建

3.1. Spring MVC 请求处理流程分析

springmvc 接手map 讲一下springmvc_MVC_03

Spring MVC框架也是⼀个基于请求驱动的Web框架，并且使⽤了前端控制器模式（是⽤来提供⼀个集中的请求处理机制，所有的请求都将由⼀个单⼀的处理程序处理来进⾏设计，再根据请求映射规则分发给相应的⻚⾯控制器（动作/处理器）进⾏处理。⾸先让我们整体看⼀下Spring MVC处理请求的流程：

⾸先⽤户发送请求,请求被SpringMvc前端控制器（DispatherServlet）捕获；
前端控制器(DispatherServlet)对请求URL解析获取请求URI,根据URI, 调⽤HandlerMapping；
前端控制器(DispatherServlet)获得返回的HandlerExecutionChain（包括Handler对象以及
Handler对象对应的拦截器）；
DispatcherServlet 根据获得的HandlerExecutionChain，选择⼀个合适的HandlerAdapter。（附注：如果成功获得HandlerAdapter后，此时将开始执⾏拦截器的preHandler(…)⽅法）；
HandlerAdapter根据请求的Handler适配并执⾏对应的Handler；HandlerAdapter(提取Request
中的模型数据，填充Handler⼊参，开始执⾏Handler（Controller)。在填充Handler的⼊参过程
中，根据配置，Spring将做⼀些额外的⼯作：HttpMessageConveter：将请求消息（如Json、xml等数据）转换成⼀个对象，将对象转换为指定的响应信息。
数据转换：对请求消息进⾏数据转换。如String转换成Integer、Double等数据格式化：
数据格式化。如将字符串转换成格式化数字或格式化⽇期等
数据验证：验证数据的有效性（⻓度、格式等），验证结果存储到BindingResult或Error中）
Handler执⾏完毕，返回⼀个ModelAndView(即模型和视图)给HandlerAdaptor
HandlerAdaptor适配器将执⾏结果ModelAndView返回给前端控制器。
前端控制器接收到ModelAndView后，请求对应的视图解析器。
视图解析器解析ModelAndView后返回对应View;
渲染视图并返回渲染后的视图给前端控制器。
最终前端控制器将渲染后的⻚⾯响应给⽤户或客户端

3.2. Spring MVC 优势

清晰的⻆⾊划分：前端控制器（DispatcherServlet）、请求到处理器映射（HandlerMapping）、处理器适配器（HandlerAdapter）、视图解析器（ViewResolver）、处理器或⻚⾯控制器（Controller）、验证器（ Validator）、命令对象（Command 请求参数绑定到的对象就叫命令对象）、表单对象（Form Object 提供给表单展示和提交到的对象就叫表单对象）。
分⼯明确，⽽且扩展点相当灵活，可以很容易扩展，虽然⼏乎不需要；
和Spring 其他框架⽆缝集成，是其它Web框架所不具备的；
可适配，通过HandlerAdapter可以⽀持任意的类作为处理器；
可定制性，HandlerMapping、ViewResolver等能够⾮常简单的定制；
功能强⼤的数据验证、格式化、绑定机制；
利⽤Spring提供的Mock对象能够⾮常简单的进⾏Web层单元测试；
本地化、主题的解析的⽀持，使我们更容易进⾏国际化和主题的切换。
强⼤的JSP标签库，使JSP编写更容易。
还有⽐如RESTful（⼀种软件架构⻛格，设计⻛格⽽不是标准，只是提供了⼀组设计原则和约束条件。它主要⽤于客户端和服务器交互类的软件，⽬前了解即可）⻛格的⽀持、简单的⽂件传、约定⼤于配置的契约式编程⽀持、基于注解的零配置⽀持等等。

3.3. Spring MVC 环境搭建

3.3.1. 开发环境

Idea + Maven + Jdk1.8 + Jetty

3.3.2. 新建 Maven webApp

Idea 下创建 spring_mvc ⼯程(作为义后创建springmvc项目模板)

3.3.3. pom.xml 坐标添加

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.suntao</groupId>
    <artifactId>spring_mvc</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>spring_mvc Maven Webapp</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.example.com</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- spring web -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.2.4.RELEASE</version>
        </dependency>

        <!-- spring mvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.4.RELEASE</version>
        </dependency>

        <!-- web servlet -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.0.1</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>spring_mvc</finalName>
        <plugins>
            <!-- 编译环境插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <!-- jetty插件 -->
            <plugin>
                <groupId>org.eclipse.jetty</groupId>
                <artifactId>jetty-maven-plugin</artifactId>
                <version>9.4.27.v20200227</version>
                <configuration>
                    <scanIntervalSeconds>10</scanIntervalSeconds>
                    <!-- 设置端⼝ -->
                    <httpConnector>
                        <port>8989</port>
                    </httpConnector>
                    <!-- 设置项⽬路径 -->
                    <webAppConfig>
                        <contextPath>/spring_mvc</contextPath>
                    </webAppConfig>
                </configuration>
            </plugin>
        </plugins>

    </build>
</project>

3.3.4. 配置 web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app  id="WebApp_ID" version="3.0"
          xmlns="http://java.sun.com/xml/ns/javaee"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
          http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
    <!-- 编码过滤 utf-8 -->
    <filter>
        <description>char encoding filter</description>
        <filter-name>encodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!-- servlet请求分发器 -->
    <servlet>
        <servlet-name>springMvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring.xml</param-value>
        </init-param>
        <!-- 表示启动容器时初始化该Servlet -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springMvc</servlet-name>
        <!-- 这是拦截请求， "/"代表拦截所有请求，"*.do"拦截所有.do请求 -->
        <url-pattern>/</url-pattern>
        <!--    <url-pattern>*.do</url-pattern>-->
    </servlet-mapping>
</web-app>

要想启动我们的 SpringMVC 环境，⽬前对于 mvc 框架的配置还未进⾏。以上在 web.xml 中引⽤了spring.xml ⽂件。

3.3.5. spring.xml 配置

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
 http://www.springframework.org/schema/mvc
 http://www.springframework.org/schema/mvc/spring-mvc.xsd
 http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 开启扫描器 -->
    <context:component-scan base-package="com.suntao.springmvc.controller"/>
    <!-- 使⽤默认的 Servlet 来响应静态⽂件 -->
    <mvc:default-servlet-handler/>
    <!-- 开启注解驱动-->
    <mvc:annotation-driven/>
    <!-- 配置视图解析器 -->
    <bean
            class="org.springframework.web.servlet.view.InternalResourceViewResolver"
            id="internalResourceViewResolver">
        <!-- 前缀：在WEB-INF⽬录下的jsp⽬录下 -->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!-- 后缀：以.jsp结尾的资源 -->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

3.3.6. ⻚⾯控制器的编写

package com.suntao.springmvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class HelloController {
     /**
     * 请求映射地址 /hello
     * @return
     */
     @RequestMapping("/hello")
     public ModelAndView hello(){
         ModelAndView mv=new ModelAndView();
         mv.addObject("hello", "hello spring mvc");
         mv.setViewName("hello");
         return mv;
     }

}

3.3.7. 添加视图⻚⾯

在 WEB-INF 下新建 jsp ⽂件夹，并在⽂件夹下新建 hello.jsp

<%--
  Created by IntelliJ IDEA.
  User: Trycol
  Date: 2020/11/26
  Time: 20:35
  To change this template use File | Settings | File Templates.
--%>
<%@page language="java" pageEncoding="UTF-8" %>
<%
    String path = request.getContextPath();
    String basePath =
            request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() +
                    path + "/";
%>
<!DOCTYPE HTML>
<html>
    <head>
        <base href="<%=basePath %>">
        <title>My JSP 'hello.jsp' starting page</title>
        <meta http-equiv="pragma" content="no-cache">
        <meta http-equiv="cache-control" content="no-cache">
        <meta http-equiv="expires" content="0">
        <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
        <meta http-equiv="description" content="This is my page">
    </head>
    <body>
        <!-- el表达式接收参数值 -->
        ${hello}
    </body>
</html>

3.3.8. 启动 jetty 服务器

springmvc 接手map 讲一下springmvc_spring_04

访问地址：http://localhost:8989/spring_mvc/hello

springmvc 接手map 讲一下springmvc_springmvc 接手map_05

4. URL 地址映射配置 & 参数绑定

4.1. URL 地址映射配置之 @RequestMapping

通过注解 @RequestMapping 将请求地址与⽅法进⾏绑定，可以在类级别和⽅法级别声明。类级别的注解负责将⼀个特定的请求路径映射到⼀个控制器上，将 url 和类绑定；通过⽅法级别的注解可以细化映射，能够将⼀个特定的请求路径映射到某个具体的⽅法上，将 url 和类的⽅法绑定。

4.1.1. 映射单个 URL

@RequestMapping("") 或 @RequestMapping(value="")

/**
     * @RequestMapping 声明在⽅法上⾯，映射单个 URL
     * 访问地址：（如果有类路径需要写在⽅法路径前⾯）
     * http://ip:port/springmvc01/test01
     * @return
     */
    @RequestMapping("/test01")
    public ModelAndView test01(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("hello","test01");
        modelAndView.setViewName("hello");
        return modelAndView;
    }
}
/**
     * 路径开头是否加 斜杠"/" 均可
     * @RequestMapping("/请求路径") 与 @RequestMapping("请求路径")均可
     * 建议加上，如：@RequestMapping("/test02")
     * 访问地址：（如果有类路径需要写在⽅法路径前⾯）
     * http://ip:port/springmvc01/test02
     * @return
     */
    @RequestMapping("test02")
    public ModelAndView test02(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("hello","test02");
        modelAndView.setViewName("hello");
        return modelAndView;
    }

4.1.2. 映射多个 URL

@RequestMapping({"",""}) 或 @RequestMapping(value={"",""})

/**
     * @RequestMapping 声明在⽅法上⾯，映射多个 URL
     * ⽀持⼀个⽅法绑定多个 url 的操作
     * 访问地址：（如果有类路径需要写在⽅法路径前⾯）
     * http://ip:port/springmvc01/test03_01
     * http://ip:port/springmvc01/test03_02
     * @return
     */
    @RequestMapping({"/test03_01","/test03_02"})
	//@RequestMapping(value = {"/test03_01","/test03_02"})
    public ModelAndView test03(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("hello","test03");
        modelAndView.setViewName("hello");
        return modelAndView;
    }

4.1.3. 映射 URL 在控制器上

⽤于类上，表示类中的所有响应请求的⽅法都是以该地址作为⽗路径。

package com.suntao.springmvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
@RequestMapping("/url")
public class UrlController {
    /**
     * @RequestMapping 声明在类上⾯，类中的的⽅法都是以该地址作为⽗路径
     * 声明级别：
     * 类级别 + ⽅法级别 （/类路径/⽅法路径）
     * 访问地址：
     * http://ip:port/springmvc01/url/test04
     * @return
     */
    @RequestMapping("/test04")
    public ModelAndView test04(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("hello","test04");
        modelAndView.setViewName("hello");
        return modelAndView;
    }
}

4.1.4. 设置 URL 映射的请求⽅式

默认没有设置请求⽅式，在HTTP 请求中最常⽤的请求⽅法是 GET、POST，还有其他的⼀些⽅法，如：DELET、PUT、HEAD 等。

可以通过 method 属性设置⽀持的请求⽅式，如 method=RequestMethod.POST；如设置多种请求⽅式，以⼤括号包围，逗号隔开即可。

/**
	* 设置请求⽅式
	* 通过 method 属性设置⽅法⽀持的请求⽅式，默认 GET请求和 POST等请求都⽀持。
	* 设置了请求⽅式，则只能按照指定的请求⽅式请求。
		* 访问地址：（只能使⽤POST请求访问）
			* http://ip:port/springmvc01/url/test05
	* @return
*/
@RequestMapping(value = "/test05",method = RequestMethod.POST)
public ModelAndView test05(){
	ModelAndView modelAndView = new ModelAndView();
	modelAndView.addObject("hello","test05");
	modelAndView.setViewName("hello");
	return modelAndView;
}

注：get可以通过http://localhost:8989/springmvc01/url/test05直接访问，post不能，只能使⽤POST请求访问

4.1.5. 通过参数名称映射 URL

/**
     * 通过参数名称访问
     * 通过参数的形式访问
     * 访问地址：
     * http://ip:port/springmvc01/url?test06
     * @return
     */
    @RequestMapping(params = "test06")
    public ModelAndView test06(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("hello","test06");
        modelAndView.setViewName("hello");
        return modelAndView;
    }

通过：http://localhost:8989/springmvc01/url?test06，进行访问

4.2. 参数绑定

客户端请求的参数到控制器功能处理⽅法上的参数的绑定，对于参数绑定⾮常灵活。

4.2.1. 基本数据类型

/**
     * 基本类型数据绑定
     * 参数值必须存在。如果没有指定参数值，也没有设置参数默认值，则会报500异常。
     *
     * @param age
     * @param money
     */
    @RequestMapping("data01")
    public void data01(int age, double money) {
        System.out.println("age:" + age + ", money:" + money);
    }

未绑定结果：

springmvc 接手map 讲一下springmvc_java_06

/**
     * 基本类型数据绑定
     * 通过注解 @RequestParam 标记⼀个形参为请求参数。（注解声明在形参的前⾯）
     * 可以通过注解的属性设置相关内容
     * 设置参数的默认值 defaultValue
     *
     * @param age
     * @param money
     */
    @RequestMapping("data02")
    public void data02(@RequestParam(defaultValue = "18") int age, @RequestParam(defaultValue = "10.0") double money) {
        System.out.println("age:" + age + ", money:" + money);
    }

/**
     * 基本类型数据绑定
     * 通过注解 @RequestParam 标记⼀个形参为请求参数。（注解声明在形参的前⾯）
     * 可以通过注解的属性设置相关内容
     * 设置参数的参数名（别名） name
     *
     * @param age
     * @param money
     */
    @RequestMapping("data03")
    public void data03(@RequestParam(defaultValue = "18", name = "userAge") int age, @RequestParam(defaultValue = "10.0", name = "userMoney") double money) {
        System.out.println("age:" + age + ", money:" + money);
    }

两种方式结果：

页面结果：EL表达式未获取值

springmvc 接手map 讲一下springmvc_java_07

IDEA结果：

springmvc 接手map 讲一下springmvc_springmvc 接手map_08

4.2.2. 包装类型

/**
     * 包装类型数据绑定 （如果数据是基本类型，建议使⽤包装类型）
     * 客户端请求参数名与⽅法形参名保持⼀致，默认参数值为null
     * 可以通过 @RequestParam 的name属性设置参数的别名，defaultValue属性设置参数默认
     值
     * @param age
     * @param money
     */
    @RequestMapping("data05")
    public void data05(Integer age, Double money){
        System.out.println("age:" + age + ", money:" + money);
    }

结果：

springmvc 接手map 讲一下springmvc_MVC_09

4.2.3. 字符串类型

/**
     * 字符串数据绑定
     * 客户端请求参数名与⽅法形参名保持⼀致，默认参数值为null
     * 可以通过 @RequestParam 的name属性设置参数的别名，defaultValue属性设置参数默认
     值
     * @param userName
     * @param userPwd
     */
    @RequestMapping("data04")
    public void data04(String userName, String userPwd){
        System.out.println("userName:" + userName + ", userPwd:" + userPwd);
    }

springmvc 接手map 讲一下springmvc_java_10

4.2.4. 数组类型

/**
     * 数组类型数据绑定
     * 客户端传参形式：ids=1&ids=2&ids=3
     * @param ids
     */
    @RequestMapping("/data06")
    public void data06(String[] ids){
        for(String id : ids){
            System.out.println(id + "---");
        }
    }

注意：数组类型没给值和基本数据类型结果一样

/**
     * JavaBean 数据绑定
     * 客户端请求的参数名与JavaBean对象的属性字段名保持⼀致
     * @param user
     */
    @RequestMapping("/data07")
    public void data07(User user) {
        System.out.println(user);
    }

User.java

package com.suntao.springmvc.po;

public class User {

    private int id;
    private String userName;
    private String userPwd;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getUserPwd() {
        return userPwd;
    }
    public void setUserPwd(String userPwd) {
        this.userPwd = userPwd;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", userName=" + userName + ", userPwd="
                + userPwd + "]";
    }
}

结果：

springmvc 接手map 讲一下springmvc_MVC_11

4.2.6. List 类型

此时 User 实体需要定义对应 list 属性。（对于集合的参数绑定，⼀般需要使⽤ JavaBean 对象进⾏包装）
User.java

package com.suntao.springmvc.po;

import java.util.ArrayList;
import java.util.List;

public class User {

    private int id;
    private String userName;
    private String userPwd;

    private List<Phone> phones = new ArrayList<Phone>();

    public List<Phone> getPhones() {
        return phones;
    }
    public void setPhones(List<Phone> phones) {
        this.phones = phones;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }

    public void setUserPwd(String userPwd) {
        this.userPwd = userPwd;
    }

    @Override
    public String toString() {
        return "User [id=" + id + ", userName=" + userName + ", userPwd="
                + userPwd + ", phones=" + phones + "]";
    }
}

Phone.java

package com.suntao.springmvc.po;

public class Phone {
    private String num;
    public String getNum() {
        return num;
    }
    public void setNum(String num) {
        this.num = num;
    }
    @Override
    public String toString() {
        return "Phone [num=" + num + "]";
    }
}

Jsp ⻚⾯定义

<form action="data08" method="post">
    <input name="phones[0].num" value="123456" />
    <input name="phones[1].num" value="4576" />
    <button type="submit"> 提交</button>
</form>

Controller ⽅法

@RequestMapping("/data08")
public void data08(User user){
	System.out.println(user);
}

结果：

springmvc 接手map 讲一下springmvc_java_12

4.2.7. Set 类型

Set 和 List 类似，也需要绑定在对象上，⽽不能直接写在 Controller ⽅法的参数中。但是，绑定Set数据时，必须先在Set对象中add相应的数量的模型对象。

package com.suntao.springmvc.po;


import java.util.HashSet;
import java.util.Set;

public class User {
    private int id;
    private String userName;
    private String userPwd;

    private Set<Phone> phones = new HashSet<Phone>();


    public User() {
        phones.add(new Phone());
        phones.add(new Phone());
        phones.add(new Phone());
    }
    /*public List<Phone> getPhones() {
    return phones;
    }
    public void setPhones(List<Phone> phones) {
    this.phones = phones;
    }*/
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getUserPwd() {
        return userPwd;
    }
    public void setUserPwd(String userPwd) {
        this.userPwd = userPwd;
    }
    public Set<Phone> getPhones() {
        return phones;
    }
    public void setPhones(Set<Phone> phones) {
        this.phones = phones;
    }
}

Controller ⽅法:

@RequestMapping("/data09")
public void data09(User user){
	System.out.println(user);
}

表单⻚⾯

<form action="data09" method="post">
	<input name="phones[0].num" value="123456" />
	<input name="phones[1].num" value="4576" />
	<input name="phones[2].num" value="4576" />
	<button type="submit"> 提交</button>
</form>

4.2.8. Map 类型

Map最为灵活，它也需要绑定在对象上，⽽不能直接写在Controller⽅法的参数中

public class User {
 private int id;
 private String userName;
 private String userPwd;

 private Set<Phone> phones=new HashSet<Phone>();

 private Map<String, Phone> map=new HashMap<String, Phone>();

 // private List<Phone> phones=new ArrayList<Phone>();


 public User() {
 phones.add(new Phone());
 phones.add(new Phone());
 phones.add(new Phone());

 }
 /*public List<Phone> getPhones() {
 return phones;
 }
 public void setPhones(List<Phone> phones) {
 this.phones = phones;
 }*/
 public int getId() {
 return id;
 }
 public void setId(int id) {
 this.id = id;
 }
 public String getUserName() {
 return userName;
 }
 public void setUserName(String userName) {
 this.userName = userName;
 }
 public String getUserPwd() {
 return userPwd;
 }
 public void setUserPwd(String userPwd) {
 this.userPwd = userPwd;
 }
 public Set<Phone> getPhones() {
 return phones;
 }
 public void setPhones(Set<Phone> phones) {
 this.phones = phones;
 }
 public Map<String, Phone> getMap() {
 return map;
 }
 public void setMap(Map<String, Phone> map) {
 this.map = map;
 }
}

Controller ⽅法

@RequestMapping("/data10")
    public void data10(User user){
        Set<Entry<String, Phone>> set = user.getMap().entrySet();
        for(Entry<String, Phone> entry:set){
            System.out.println(entry.getKey()+"--"+entry.getValue().getNum());

        }
    }

表单⻚⾯

<form action="data10" method="post">
	<input name="map['1'].num" value="123456" />
	<input name="map['2'].num" value="4576" />
	<input name="map['3'].num" value="4576" />
	<button type="submit"> 提交</button>
</form>

5. 请求转发与重定向的问题

SpringMVC 默认采⽤服务器内部转发的形式展示⻚⾯信息。同样也⽀持重定向⻚⾯。

5.1. 重定向

重定向是发⼀个302的状态码给浏览器，浏览器⾃⼰去请求跳转的⽹⻚。地址栏会发⽣改变。
重定向以 redirect: 开头:

/**
 * 重定向到JSP⻚⾯
 * @return
 */
@RequestMapping(value="/view01")
public String view01(){
	return "redirect:view.jsp";
}

/**
 * 重定向到JSP⻚⾯
 * 传递参数
 * @return
 */
@RequestMapping(value="/view02")
public String view02(){
	return "redirect:view.jsp?uname=zhangsan&upwd=123456";
}

/**
 * 重定向到JSP⻚⾯
 * 传递参数 （传递中⽂参数会出现乱码）
 * @return
 */
@RequestMapping(value="/view03")
public String view03(){
	return "redirect:view.jsp?uname=张三&upwd=123456";
}

/**
 * 重定向到JSP⻚⾯
 * 传递参数 （通过 RedirectAttributes 对象设置重定向参数，避免中⽂乱码问题）
 * @param redirectAttributes
 * @return
 */
@RequestMapping(value="/view04")
public String view04(RedirectAttributes redirectAttributes){
	redirectAttributes.addAttribute("uname","张三");
	redirectAttributes.addAttribute("upwd","123456");
	return "redirect:view.jsp";
}

/**
     * 重定向到JSP⻚⾯
     * 返回 ModelAndView 对象
     * @param modelAndView
     * @return
     */
    @RequestMapping(value="/view06")
    public ModelAndView view06(ModelAndView modelAndView){
        modelAndView.addObject("uname","李四");
        modelAndView.addObject("upwd","123321");
        modelAndView.setViewName("redirect:view.jsp");
        return modelAndView;
    }
    /**
     * 重定向到Controller
     * 返回 ModelAndView 对象
     * @param modelAndView
     * @return
     */
    @RequestMapping(value="/view07")
    public ModelAndView view07(ModelAndView modelAndView){
        modelAndView.addObject("uname","admin");
        modelAndView.setViewName("redirect:test01");
        return modelAndView;
    }

⻚⾯中获取参数值

${param.参数名}

5.2. 请求转发

请求转发，直接调⽤跳转的⻚⾯，让它返回。对于浏览器来说，它⽆法感觉服务器有没有forward。地址栏不发⽣改变。可以获取请求域中的数据。
请求转发以 forward: 开头

/**
     * 请求转发到JSP⻚⾯
     */
    @RequestMapping("/view08")
    public String view08(){
        return "forward:view.jsp";
    }
    /**
     * 请求转发到JSP⻚⾯
     * 设置参数
     */
    @RequestMapping("/view09")
    public String view09(){
        return "forward:view.jsp?uname=张三&upwd=123456";
    }
    /**
     * 请求转发到JSP⻚⾯
     * 设置请求域
     */
    @RequestMapping("/view10")
    public String view10(Model model){
        model.addAttribute("uname","张三");
        return "forward:view.jsp";
    }
    /**
     * 请求转发到JSP⻚⾯ （默认）
     * 默认会去指定⽬录下找JSP⻚⾯ （配置⽂件中设置的）
     */
    @RequestMapping("/view11")
    public String view11(){
        return "/../../view";
    }
    /**
     * 请求转发到 Controller
     * @return
     */
    @RequestMapping("/view12")
    public ModelAndView view12(ModelAndView modelAndView){
        modelAndView.setViewName("forward:test01");
        return modelAndView;
    }
    /**
     * 请求转发到 Controller
     * 传递参数
     * @return
     */
    @RequestMapping("/view13")
    public ModelAndView view13(ModelAndView modelAndView){
        modelAndView.setViewName("forward:test01?uname=admin");
        return modelAndView;
    }

获取传递的参数： $springmvc 接手map 讲一下springmvc_java_13$ {请求域中设置的名称}

6. SpringMVC 之 JSON 数据开发

6.1. 基本概念

Json 在企业开发中已经作为通⽤的接⼝参数类型，在⻚⾯（客户端）解析很⽅便。SpringMVC 对于json 提供了良好的⽀持，这⾥需要修改相关配置，添加 json 数据⽀持功能

6.1.1. @ResponseBody

该注解⽤于将 Controller 的⽅法返回的对象，通过适当的 HttpMessageConverter 转换为指定格式
后，写⼊到 Response 对象的 body 数据区。
返回的数据不是 html 标签的⻚⾯，⽽是其他某种格式的数据时（如 json、xml 等）使⽤（通常⽤于ajax 请求）。

6.1.2. @RequestBody

该注解⽤于读取 Request 请求的 body 部分数据，使⽤系统默认配置的 HttpMessageConverter 进⾏解析，然后把相应的数据绑定到要返回的对象上，再把 HttpMessageConverter 返回的对象数据绑定到 controller 中⽅法的参数上。

6.2. 使⽤配置

6.2.1. pom.xml 添加 json相关坐标

<!-- 添加json 依赖jar包 -->
<dependency>
 <groupId>com.fasterxml.jackson.core</groupId>
 <artifactId>jackson-core</artifactId>
 <version>2.10.0</version>
</dependency>
<dependency>
 <groupId>com.fasterxml.jackson.core</groupId>
 <artifactId>jackson-databind</artifactId>
 <version>2.10.0</version>
</dependency>
<dependency>
 <groupId>com.fasterxml.jackson.core</groupId>
 <artifactId>jackson-annotations</artifactId>
 <version>2.10.0</version>
</dependency

6.2.2. 修改spring.xml

<!-- mvc 请求映射 处理器与适配器配置 -->
<mvc:annotation-driven>
 <mvc:message-converters>
 <bean
class="org.springframework.http.converter.StringHttpMessageConverter" />
 <bean
class="org.springframework.http.converter.json.MappingJackson2HttpMessageConve
rter" />
 </mvc:message-converters>
</mvc:annotation-driven>

6.2.3. 注解使⽤

6.2.3.1. @ResponseBody

@Controller
@RequestMapping("/user")
public class UserController {
 	/**
 	* @ResponseBody 返回的是JOSN格式的数据，返回JavaBean对象
 	* 注解设置在⽅法体上
 	* @return
 	*/
 @RequestMapping("queryUser01")
 @ResponseBody
 public User queryUser01(){
 	User user = new User();
 	user.setId(1);
 	user.setUserName("zhangsan");
 	user.setUserPwd("123456");
 	// 返回的是user对象
	 return user;
 }
 /**
 * @ResponseBody 返回的是JOSN格式的数据，返回JavaBean对象
 * 注解设置在⽅法返回对象前，修饰符之后
 * @return
 */
 @RequestMapping("queryUser02")
 public @ResponseBody User queryUser02(){
 	User user = new User();
 	user.setId(2);
 	user.setUserName("lisi");
 	user.setUserPwd("123321");
 	// 返回的是user对象
	return user;
 }

 /**
 * @ResponseBody 返回的是JOSN格式的数据，返回集合
 * @return
 */
 @RequestMapping("/queryUser03")
 @ResponseBody
 public List<User> queryUser03(){
 	List<User> list = new ArrayList<>();
 	User user01 = new User();
 	user01.setId(1);
 	user01.setUserName("zhangsan");
 	user01.setUserPwd("123456");
 	User user02 = new User();
 	user02.setId(2);
 	user02.setUserName("lisi");
 	user02.setUserPwd("123321");
 	list.add(user01);
 	list.add(user02);
 	// 返回的是user集合
 	return list;
 	}
}

6.2.3.2. @RequestBody

@RequestBody 注解常⽤来处理 content-type 不是默认的 application/x-www-form-urlcoded 类型
的内容，⽐如说：application/json 或者是application/xml 等。⼀般情况下来说常⽤其来处理
application/json 类型。@RequestBody接受的是⼀个 json 格式的字符串，⼀定是⼀个字符串。

通过 @RequestBody 可以将请求体中的 JSON 字符串绑定到相应的 bean 上，当然，也可以将其分别绑定到对应的字符串上。

/**
 * @RequestBody 规定请求的参数是JOSN格式的字符串
 * 注解设置在形参前⾯
 * @param user
 * @return
 */
@RequestMapping("/getUser")
@ResponseBody
public User getUser(@RequestBody User user){
 	System.out.println(user);
 	return user;
	}

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
 	<title>JSON处理</title>
 	<%-- 引⼊Jquery的核⼼JS⽂件 --%>
 	<script type="text/javascript" src="js/jquery-3.4.1.js"></script>
	</head>
<body>
 	<input type="button" value="JSON数据测试" onclick="test()"/>
 	<script type="text/javascript">
 	/**
 	* 请求传递JSON格式的数据
 	* 返回JSON格式的数据
 	*/
 function test(){
 	$.ajax({
 	// 请求⽅式 Get|Post
 	type: "post",
 	// 请求路径
	 url: "user/getUser",
 	// 预期服务器返回的额数据类型
 	dataType: "json",
	 // 设置服务器请求类型的数据类型为JSON格式
 	contentType: "application/json;charset=utf-8",
	 // 传递给服务器的参数
 	data:'{"userName":"admin","userPwd":"123456"}',
 	// 回调函数，接收服务器返回的响应的结果 （函数中的形参⽤来接收服务器返回的数据）
 	success:function(data){
 	console.log(data);
 }
 })
 }
 </script>
</body>
</html>

7. 总结

SpringMVC 第⼀天相关知识点内容，这⾥需要重点理解 MVC 核⼼思想，SpringMVC 请求执⾏原理，能够借助 Idea + Maven 环境完成 SpringMVC 基本环境的搭建与测试操作，重点掌握SpringMVC 请求到 Handler ⽅法映射对应的 URL 地址的配置、SpringMVC 环境下⻚⾯转发与重定向实现配置，在SpringMVC 环境下能够实现 Json 形式的参数绑定操作以及 Json 结果到客户
端响应的处理。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：java spring data mongodb 排序 spring jpa排序

下一篇：java形参设置可传可不传 java形参赋值

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯