2. SpringMVC 请求与响应

文章目录

• 1. 请求映射路径
• 2. 请求参数
• • 2.1 get 请求发送普通参数
  • 2.2 post 请求发送普通参数
  • 2.3 五种类型的参数传递
  • • 2.4.1 普通参数
    • 2.4.2 POJO 数据类型
    • 2.4.3 嵌套 POJO 类型参数
    • 2.4.4 数组类型参数
    • 2.4.5 集合类型参数
• 3. json 数据传输参数（重点）
• • 3.1 传输 json 普通数组
  • 3.2 传输 json 对象
  • 3.3 传输 json 对象数组
• 4. 日期类型参数传递
• 5. 响应 json 数据
• • 5.1 响应 / 跳转页面（了解）
  • 5.2 响应文本数据（了解）
  • 5.3 响应 json 数据
  • • 5.3.1 响应 POJO 对象
    • 5.3.2 响应 POJO 对象集合
    • 5.3.3 @ResponseBody 注解

1. 请求映射路径

环境准备：

(1) 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/maven-v4_0_0.xsd">

  <modelVersion>4.0.0</modelVersion>
  <packaging>war</packaging>

  <name>springmvc03_request_mapping</name>
  <groupId>com.itheima</groupId>
  <artifactId>springmvc03_request_mapping</artifactId>
  <version>1.0-SNAPSHOT</version>

  <properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
  </properties>

  <dependencies>
    <!--导入springmvc与servlet的依赖-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope><!--防止与tomcat插件冲突-->
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
  </dependencies>
  <!--tomcat插件-->
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.1</version>
        <configuration>
          <port>80</port><!--tomcat端口号-->
          <path>/</path><!--虚拟目录-->
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>
           

(2) ServletControllerInitConfig

// 定义一个servlet容器启动的配置类
// 要继承AbstractAnnotationConfigDispatcherServletInitializer
public class ServletControllerInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    //加载Spring配置类
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return null;
    }
    //加载SpringMVC配置类
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    //设置哪些请求由springMVC处理
    @Override
    protected String[] getServletMappings() {
        //所有请求都由springMVC处理
        return new String[]{"/"};
    }
}
           

(3) SpringMvcConfig

@Configuration
@ComponentScan("com.itheima.controller")
public class SpringMvcConfig {
}
           

(4) UserController

//使用Controller定义bean
@Controller
public class UserController {
    // 当前操作的请求映射路径：用户发出哪个请求能调用到这个方法
    @RequestMapping("/user/save")
    // 设置当前操作的返回值类型
    // 把返回的东西整体作为响应的内容给到外面
    @ResponseBody
    // 处理请求的方法
    // 返回值为String：执行完这个方法，要对外返回json数据
    public String save(){
        System.out.println("user save ...");
        return "{'module':'user save'}";
    }
    @RequestMapping("/user/delete")
    @ResponseBody
    public String delete(){
        System.out.println("user delete ...");
        return "{'module':'user delete'}";
    }
}
           

(5) BookController

@Controller
public class BookController {
    @RequestMapping("/book/save")
    @ResponseBody
    public String save(){
        System.out.println("book save...");
        return "{'module':'book save'}";
    }
}
           

在 UserController 和 BookController 中，都有 save 方法，若两者的请求映射路径都为 “/save”，则两者的访问路径就都成了 http://localhost/save，会冲突。

解决方法就是如上面代码一样，设置模块名作为请求映射路径的前置。这样，访问路径就分别为：http://localhost/user/save，http://localhost/book/save。

这样在同一个模块中出现命名冲突的情况就比较少了。

问题是解决了，但是每个方法前面都需要进行修改，写起来比较麻烦而且还有很多重复代码，如果 “/user” 后期发生变化，所有的方法都需要改，耦合度太高。

优化方案： 把请求映射路径的前缀写到类上面，这样方法上只写剩余路径即可。

//使用Controller定义bean
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/save")
    @ResponseBody
    public String save(){
        System.out.println("user save ...");
        return "{'module':'user save'}";
    }
    @RequestMapping("/delete")
    @ResponseBody
    public String delete(){
        System.out.println("user delete ...");
        return "{'module':'user delete'}";
    }
}
           

@Controller
@RequestMapping("/book")
public class BookController {
    @RequestMapping("/save")
    @ResponseBody
    public String save(){
        System.out.println("book save...");
        return "{'module':'book save'}";
    }
}
           

2. 请求参数

2.1 get 请求发送普通参数

//使用Controller定义bean
@Controller
public class UserController {
    @RequestMapping("/commonParam")
    @ResponseBody
    public String save(String name){
        System.out.println("普通参数传递 name="+name+" age="+age);
        return "{'module':'common param'}";
    }
}
           

用 postman 发送带参数的 get 请求，收到请求结果：

同时，处理请求的方法也接收到参数，输出：

GET 请求中文乱码

如果请求中传递的参数有中文，那么接收到的参数会出现中文乱码问题。

如发送请求: http://localhost/commonParam?name=张三&age=18，处理请求的方法接收的参数会是：

原因在于：虽然 Tomcat 8.5 以后的版本已经处理了中文乱码的问题，但是 IDEA 中的 Tomcat 插件目前只到 Tomcat7，所以需要修改 pom.xml 来解决 GET 请求中文乱码问题。

<?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/maven-v4_0_0.xsd">

  <modelVersion>4.0.0</modelVersion>
  <packaging>war</packaging>

  <name>springmvc04_request_param</name>
  <groupId>com.itheima</groupId>
  <artifactId>springmvc04_request_param</artifactId>
  <version>1.0-SNAPSHOT</version>

  <properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
  </properties>

  <dependencies>
    <!--导入springmvc与servlet的依赖-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope><!--防止与tomcat插件冲突-->
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
  </dependencies>
  <!--tomcat插件-->
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.1</version>
        <configuration>
          <port>80</port><!--tomcat端口号-->
          <path>/</path><!--虚拟目录-->
          <uriEncoding>UTF-8</uriEncoding><!--访问路径编解码字符集-->
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>
           

2.2 post 请求发送普通参数

后台代码不区分 get 请求和 post 请求，所以仍用前面的代码来处理 post 请求。

用 postman 发送带参数的 post 请求：

收到请求结果：

同时，处理请求的方法也接收到参数，输出：

post 请求中文乱码

post 请求发送中文参数时，处理请求的方法打印获取的参数也会出现乱码问题。

解决方法：在 ServletContainersInitConfig 中配置过滤器。

// 定义一个servlet容器启动的配置类
// 要继承AbstractAnnotationConfigDispatcherServletInitializer
public class ServletControllerInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    //加载Spring配置类
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return null;
    }
    //加载SpringMVC配置类
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    //设置哪些请求由springMVC处理
    @Override
    protected String[] getServletMappings() {
        //所有请求都由springMVC处理
        return new String[]{"/"};
    }
    //乱码处理
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("UTF-8");
        return new Filter[]{filter};
    }
}
           

2.3 五种类型的参数传递

前面我们已经能够使用 GET 或 POST 来发送请求和数据，但所携带的数据都是比较简单，接下来在这个基础上，我们来研究一些比较复杂的参数传递，常见的参数种类有:

• 普通参数
• POJO 类型参数
• 嵌套 POJO 类型参数
• 数组类型参数
• 集合类型参数

这些参数如何发送，后台该如何接收？下面将逐个介绍（都以 get 请求为例，post 请求同理）。

2.4.1 普通参数

普通参数 url 地址传参，请求参数名与形参变量名相同，定义形参即可接收参数。

请求结果：

控制台输出：

如果地址参数名与形参不同该如何解决?

如：发出请求

http://localhost/commonParam?userName=tom&age=18

解决方案:使用

@RequestParam

注解

2.4.2 POJO 数据类型

简单数据类型一般处理的是参数个数比较少的请求，如果参数比较多，那么后台接收参数的时候就比较复杂，这个时候可以使用 POJO 数据类型（实体类）。

POJO 参数：若请求参数名与形参对象属性名相同，POJO 类型的形参就可接收到参数。

请求结果：

控制台输出：

2.4.3 嵌套 POJO 类型参数

请求结果：

控制台输出：

2.4.4 数组类型参数

举个简单的例子，如果前端需要获取用户的爱好，爱好绝大多数情况下都是多个，如何发送请求数据和接收数据呢?

数组参数：请求参数名与形参对象属性名相同，且请求参数为多个同名参数，定义数组类型即可接收参数。

请求结果：

控制台输出：

2.4.5 集合类型参数

数组能接收多个值，那么集合是否也可以实现这个功能呢?

注：同名请求参数可以使用

@RequestParam

注解映射到对应名称的集合对象中作为数据。对于简单数据类型使用数组会比集合更简单些。

请求结果：

控制台输出：

3. json 数据传输参数（重点）

现在比较流行的开发方式为异步调用，前后台以异步方式进行交换，传输的数据使用的是 json。所以前端如果发送的是 json 数据，后端该如何接收?

三种常见的 json 数据类型：

json 普通数组

(["value1","value2","value3",...])

json 对象

({key1:value1,key2:value2,...})

json 对象数组

([{key1:value1,...},{key2:value2,...}])

对于上述数据，前端如何发送，后端如何接收?

3.1 传输 json 普通数组

(1) pom.xml 添加依赖

SpringMVC 默认使用 jackson 处理 json 的转换，所以需要添加 jackson 依赖。

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.9.0</version>
</dependency>
           

(2) 开启自动转换 json 数据的支持

@EnablewebMvc

注解功能强大，该注解整合了多个功能。此处仅使用其中一部分功能，即 json 数据进行自动类型转换。

@Configuration
@ComponentScan("com.itheima.controller")
@EnableWebMvc//开启将json转换成对象的功能
//以后把@EnableWebMvc当做标配配置上去，不要省略
public class SpringMvcConfig {
}
           

(3) PostMan 编写 json 数据

(4) 后台处理请求的方法

@RequestBody

注解将请求中请求体所包含的数据传递给方法的形参，此注解一个方法只能使用一次。（因为数据在请求体中，不在请求参数中，所以不能用@RequestParam注解）

//使用Controller定义bean
@Controller
public class UserController {
	@RequestMapping("/listParamForJson")
	@ResponseBody
	public String listParamForJson(@RequestBody List<String> likes){
	    System.out.println("list common(json)参数传递 list="+likes);
	    return "{'module':'list common for json param'}";
	}
}
           

运行程序后，用 postman 发送 json 数据，得到请求结果：

控制台输出：

3.2 传输 json 对象

要求：json 数据与形参对象属性名相同。

前两步与 3.1 相同。

(3) PostMan 编写 json 数据

(4) 后台处理请求的方法

//使用Controller定义bean
@Controller
public class UserController {
	@RequestMapping("/pojoParamForJson")
	@ResponseBody
	public String pojoParamForJson(@RequestBody User user){
	    System.out.println("pojo(json)参数传递 user="+user);
	    return "{'module':'pojo for json param'}";
	}
}
           

运行程序后，用 postman 发送 json 数据，得到请求结果：

控制台输出：

3.3 传输 json 对象数组

要求：json 数组数据与集合泛型属性名相同。

前两步与 3.1 相同。

(3) PostMan 编写 json 数据

(4) 后台处理请求的方法

//使用Controller定义bean
@Controller
public class UserController {
	@RequestMapping("/listPojoParamForJson")
	@ResponseBody
	public String listPojoParamForJson(@RequestBody List<User> list){
	    System.out.println("list pojo(json)参数传递 list="+list);
	    return "{'module':'list pojo for json param'}";
	}
}
           

运行程序后，用 postman 发送 json 数据，得到请求结果：

控制台输出：

@RequestBody 与 @RequestParam

区别：

@RequestParam 用于接收 url 地址传参，表单传参【application/x-www-formurlencoded】（请求映射参数）

@RequestBody 用于接收 json 数据【application/json】（请求体）

应用：

后期开发中，发送 json 格式数据为主，@RequestBody 应用较广。

如果发送非 json 格式数据，选用 @RequestParam 接收请求参数。

4. 日期类型参数传递

前面处理过简单数据类型、POJO 数据类型、数组和集合数据类型以及 json 数据类型，接下来要处理一种开发中比较常见的一种数据类型：日期类型。

日期类型比较特殊，因为对于日期的格式有 N 多中输入方式，比如：

• 2088-08-18
• 2088/08/18
• 08/18/2088
• …

针对这么多日期格式，SpringMVC 该如何接收？

(3) PostMan 编写 json 数据

(4) 后台处理请求的方法

//使用Controller定义bean
@Controller
public class UserController {
	@RequestMapping("/dataParam")
	@ResponseBody
	public String dataParam(Date date,
	        @DateTimeFormat(pattern = "yyyy-MM-dd") Date date1,
	        @DateTimeFormat(pattern = "yyyy/MM/dd HH:mm:ss") Date date2) {
	    System.out.println("参数传递 date=" + date);
	    System.out.println("参数传递 date1=" + date1);
	    System.out.println("参数传递 date2=" + date2);
	    return "{'module':'data param'}";
	}
}
           

运行程序后，用 postman 发送 json 数据，得到请求结果：

控制台输出：

参数传递 date=Sun Feb 12 00:00:00 CST 2023
参数传递 date1=Sun Feb 12 00:00:00 CST 2023
参数传递 date2=Sun Feb 12 15:59:33 CST 2023
           

内部实现原理

讲解内部原理之前，需要先思考个问题：

前端传递字符串，后端使用日期 Date 接收

前端传递 json 数据，后端使用对象接收

前端传递字符串，后端使用 Integer 接收

后台需要的数据类型有很多种，在数据的传递过程中存在很多类型的转换，谁来做这个类型转换呢？是SpringMVC。

SpringMVC是如何实现类型转换的?

答：SpringMVC中提供了很多类型转换接口和实现类

在框架中，有一些类型转换接口，其中有 ：

(1) Converter 接口：

Converter 接口的实现类：

框架中有提供很多对应 Converter 接口的实现类，用来实现不同数据类型之间的转换，如：

请求参数年龄数据（String→Integer）

日期格式转换（String → Date）

(2) HttpMessageConverter 接口

该接口是实现对象与 json 之间的转换工作

5. 响应 json 数据

SpringMVC 接收到请求和数据后，进行一些了的处理，当然这个处理可以是转发给 Service，Service 层再调用 Dao 层。不管怎样，处理完以后，都需要将结果告知给用户。

比如：根据用户 ID 查询用户信息、查询用户列表、新增用户等。

对于响应，主要就包含两部分内容：

• 响应页面
• 响应数据
  • 文本数据
  • json数据

之前学 servlet 时主要是响应页面。在学习异步提交之后，还可以响应数据。

因为异步调用是目前的主流方式，所以我们需要更关注的就是如何返回 json 数据，对于其他了解即可。

5.1 响应 / 跳转页面（了解）

(1) 准备页面 page.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>hello springmvc</title>
</head>
<body>
    <h1>hello springmvc</h1>
</body>
</html>
           

(2) 在 Controller 中设置返回页面

//使用Controller定义bean
@Controller
public class UserController {
    @RequestMapping("/toJumpPage")
    //注意
    //1.此处不能添加@ResponseBody,如果加了该注入，会直接将page.jsp当字符串返回前端
    //2.方法需要返回String
    public String toJumpPage(){
        return "page.jsp";
    }
}
           

在浏览器地址栏输入：http://localhost/toJumpPage，得到：

5.2 响应文本数据（了解）

postman 发出请求：

响应请求：

@Controller
public class UserController {
	@RequestMapping("/toText")
	//这里的@ResponseBody注解不能省略
	//否则会把“response text”当做页面名称查找，找不到该页面就报404错误
	@ResponseBody
	public String toText(){
	    System.out.println("返回纯文本数据");
	    return "response text";
	}
}
           

后台响应，发回请求结果：

控制台输出：

返回纯文本数据
           

5.3 响应 json 数据

5.3.1 响应 POJO 对象

postman 发出请求：

响应请求：

//使用Controller定义bean
@Controller
public class UserController {
	@RequestMapping("/toJsonPOJO")
	@ResponseBody
	public User pojoToJson(){
	    System.out.println("返回json对象数据");
	    User user = new User();
	    user.setName("tom");
	    user.setAge(8);
	    return user;
	}
}
           

后台响应，发回请求结果：

控制台输出：

返回json对象数据
           

5.3.2 响应 POJO 对象集合

postman 发出请求：

响应请求：

@Controller
public class UserController {
	@RequestMapping("/toJsonList")
	@ResponseBody
	public List<User> toJsonList() {
	    System.out.println("返回json对象集合");
	    User user1 = new User();
	    user1.setName("tom");
	    user1.setAge(8);
	    User user2 = new User();
	    user2.setName("jerry");
	    user2.setAge(5);
	    List<User> userList = new ArrayList<User>();
	    userList.add(user1);
	    userList.add(user2);
	    return userList;
	}
}
           

后台响应，发回请求结果：

控制台输出：

返回json对象集合
           

5.3.3 @ResponseBody 注解

• @ResponseBody 注解可以写在类或方法上
• 写在类上就是该类的所有方法都有 @ReponseBody 功能
• 当方法上有 @ReponseBody 注解后
  • 方法的返回值为字符串，会将其作为文本内容直接响应给前端。
  • 方法的返回值为对象，会将对象转换成 json 响应给前端。

相关属性 pattern：指定日期时间格式字符串