Spring MVC——入门介绍

Bertha 。 2023-10-06 19:28 8阅读 0赞

#### 目录 ####

*  1.SpringMVC简介
 *   *  1.1.MVC概述
     *  1.2.SpringMVC概述
     *  1.3.SpringMVC的特点
 *  2.SpringMVC入门案例——Hello World !
 *   *  2.1.开发环境介绍
     *  2.2.创建Maven工程
     *  2.3.配置web.xml
     *  2.4.创建请求控制器
     *  2.5.创建 Spring MVC 的配置文件
     *  2.6.测试 HelloWorld
     *  2.8.总结
 *  3.@RequestMapping注解
 *   *  （1）@RequestMapping注解的功能
     *  （2）@RequestMapping注解的位置
     *  （3）@RequestMapping注解的value属性
     *  （4）@RequestMapping注解的method属性
     *  （5）@RequestMapping注解的params属性（了解）
     *  （6）@RequestMapping注解的headers属性（了解）
     *  （7）SpringMVC支持ant风格的路径
     *  （8）SpringMVC支持路径中的占位符（重点）
 *  4.SpringMVC获取请求参数
 *   *  （1）通过ServletAPI获取
     *  （2）通过控制器方法的形参获取请求参数
     *  （3）@RequestParam
     *  （4）@RequestHeader
     *  （5）@CookieValue
     *  （6）通过POJO获取请求参数
     *  （7）解决获取请求参数的乱码问题
 *  5.域对象共享数据
 *   *  （1）使用ServletAPI向request域对象共享数据
     *  （2）使用ModelAndView向request域对象共享数据
     *  （3）使用Model向request域对象共享数据
     *  （4）使用map向request域对象共享数据
     *  （5）使用ModelMap向request域对象共享数据
     *  （6）Model、ModelMap、Map的关系
     *  （7）向session域共享数据
     *  （8）向application域共享数据
 *  6.SpringMVC的视图
 *   *  （1）ThymeleafView
     *  （2）转发视图
     *  （3）重定向视图
     *  （4）视图控制器view-controller
 *  7.RESTful
 *   *  （1）RESTful简介
     *  （2）RESTful的实现
     *  （3）HiddenHttpMethodFilter
 *  8.RESTful案例
 *   *  （1）准备工作
     *  （2）功能清单
     *  （3）具体功能：访问首页
     *  （4）具体功能：查询所有员工数据
     *  （5）具体功能：删除一条员工信息
     *  （6）具体功能：跳转到添加数据页面
     *  （7）具体功能：添加员工信息
     *  （8）具体功能：跳转到更新数据页面
     *  （9）具体功能：对员工信息进行修改
 *  9.HttpMessageConverter
 *   *  （1）@RequestBody
     *  （2）RequestEntity
     *  （3）@ResponseBody
     *  （4）SpringMVC处理json数据
     *  （5）SpringMVC处理axios
     *  （6）@RestController注解
     *  （7）ResponseEntity
 *  10.文件上传和下载
 *   *  （1）文件下载
     *  （2）文件上传
 *  11.拦截器
 *  12.异常处理器
 *   *  （1）基于配置的异常处理
     *  （2）基于注解的异常处理
 *  13.注解配置SpringMVC
 *   *  （1）创建初始化类，代替web.xml
     *  （2）创建SpringConfig配置类，代替spring的配置文件
     *  （3）创建WebConfig配置类，代替SpringMVC的配置文件

> 本文章的笔记整理来自尚硅谷视频系列https://www.bilibili.com/video/BV1Ry4y1574R

## 1.SpringMVC简介 ##

### 1.1.MVC概述 ###

**① MVC是一种软件架构的思想，将软件按照模型、视图、控制器来划分。**

<table> 
 <thead> 
  <tr> 
   <th>M</th> 
   <th>Model，模型层，指工程中的JavaBean，作用是处理数据。</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>V</td> 
   <td>View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据。</td> 
  </tr> 
  <tr> 
   <td>C</td> 
   <td>Controller，控制层，指工程中的servlet，作用是接收请求和响应浏览器。</td> 
  </tr> 
 </tbody> 
</table>

**② JavaBean分为两类：**  
1）一类称为实体类Bean：专门存储业务数据的，如 Student、User 等。  
2）一类称为业务处理 Bean：指 Service 或 Dao 对象，专门用于处理业务逻辑和数据访问。  
**③ MVC的具体工作流程如下**：  
用户通过视图层发送请求到服务器，在服务器中请求被Controller接收，Controller调用相应的Model层处理请求，处理完毕将结果返回到Controller，Controller再根据请求处理的结果找到相应的View视图，渲染数据后最终响应给浏览器。

### 1.2.SpringMVC概述 ###

SpringMVC是Spring的一个后续产品，也是Spring的一个子项目。**SpringMVC 是 Spring 为表述层开发提供的一整套完备的解决方案**。在表述层框架历经 Strust、WebWork、Strust2 等诸多产品的历代更迭之后，目前业界普遍选择了 SpringMVC 作为首选方案。  
注：三层架构分为表述层（或表示层）、业务逻辑层、数据访问层，表述层表示前台页面以及后台servlet。

### 1.3.SpringMVC的特点 ###

① Spring 家族原生产品，与 IOC 容器等基础设施无缝对接。  
② 基于原生的Servlet，通过了功能强大的前端控制器DispatcherServlet，对请求和响应进行统一处理。  
③ 表述层各细分领域需要解决的问题全方位覆盖，提供全面解决方案。  
④ 代码清新简洁，大幅度提升开发效率。  
⑤ 内部组件化程度高，可插拔式组件即插即用，想要什么功能配置相应组件即可。  
⑥ 性能卓著，尤其适合现代大型、超大型互联网项目要求。

## 2.SpringMVC入门案例——Hello World ! ##

### 2.1.开发环境介绍 ###

① IDE：IDEA 2019.3  
② 构建工具：Maven3.8.1  
③ 服务器：Tomcat7  
④ Spring版本：5.3.1  
⑤ 数据库：MySQL5.5

### 2.2.创建Maven工程 ###

**为了方便代码的集中管理，这里是先创建一个普通的Java项目，然后再在里面创建各个需要的模块。**  
① 创建一个普通的 Java 项目，取名为SpringMVC。  
② 在该项目中创建Maven模块  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5LiA55Oi5rGf5rmW5oiR5rKJ5rWu_size_19_color_FFFFFF_t_70_g_se_x_16]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5LiA55Oi5rGf5rmW5oiR5rKJ5rWu_size_20_color_FFFFFF_t_70_g_se_x_16]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5LiA55Oi5rGf5rmW5oiR5rKJ5rWu_size_20_color_FFFFFF_t_70_g_se_x_16 1]  
③ 添加web模块  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5LiA55Oi5rGf5rmW5oiR5rKJ5rWu_size_12_color_FFFFFF_t_70_g_se_x_16]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5LiA55Oi5rGf5rmW5oiR5rKJ5rWu_size_20_color_FFFFFF_t_70_g_se_x_16 2]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5LiA55Oi5rGf5rmW5oiR5rKJ5rWu_size_20_color_FFFFFF_t_70_g_se_x_16 3]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5LiA55Oi5rGf5rmW5oiR5rKJ5rWu_size_17_color_FFFFFF_t_70_g_se_x_16]  
④ 将打包方式设置为war  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5LiA55Oi5rGf5rmW5oiR5rKJ5rWu_size_20_color_FFFFFF_t_70_g_se_x_16 4]

⑤ 在pom.xml中引入相关依赖

<dependencies>
        
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.1</version>
        </dependency>
    
        
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
    
        
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
    
        
        <dependency>
            <groupId>org.thymeleaf</groupId>
            <artifactId>thymeleaf-spring5</artifactId>
            <version>3.0.12.RELEASE</version>
        </dependency>
    </dependencies>

### 2.3.配置web.xml ###

<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:springMVC.xml</param-value>
        </init-param>
        
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        
        <url-pattern>/</url-pattern>
    </servlet-mapping>

### 2.4.创建请求控制器 ###

由于前端控制器对浏览器发送的请求进行了统一的处理，但是具体的请求有不同的处理过程，因此需要创建处理具体请求的类，即请求控制器请求控制器中每一个处理请求的方法成为控制器方法。又因为SpringMVC的控制器由一个POJO（普通的Java类）担任，因此需要通过@Controller注解将其标识为一个控制层组件，交给Spring的IoC容器管理，此时SpringMVC才能够识别控制器的存在。

package com.atguigu.restful.controller;
    
    import org.springframework.stereotype.Controller;
    
    @Controller
    public class HelloController {
        
    
    }

### 2.5.创建 Spring MVC 的配置文件 ###

根据web.xml中的配置，在resources目录下创建springMVC的配置文件，其文件名称为springMVC.xml。

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    
        
        <context:component-scan base-package="com.atguigu.restful.controller"></context:component-scan>
    
        
        <bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
            <property name="order" value="1"/>
            <property name="characterEncoding" value="UTF-8"/>
            <property name="templateEngine">
                <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
                    <property name="templateResolver">
                        <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
                            
                            <property name="prefix" value="/WEB-INF/templates/"/>
                            
                            <property name="suffix" value=".html"/>
                            <property name="templateMode" value="HTML5"/>
                            <property name="characterEncoding" value="UTF-8" />
                        </bean>
                    </property>
                </bean>
            </property>
        </bean>
    </beans>

### 2.6.测试 HelloWorld ###

① 实现对首页的访问，即在请求控制器中创建处理请求的方法。

package com.atguigu.restful.controller;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    
    @Controller
    public class HelloController {
        
        /*  
            1.通过@RequestMapping注解，可以通过请求路径匹配要处理的具体的请求
            2./表示的当前工程的上下文路径
        */
        @RequestMapping("/")
        public String index(){
        
            return "index";
        }
        
    	@RequestMapping("/target")
    	    public String toTarget(){
        
    	        return "target";
    	    }
    	}

② 通过超链接跳转到指定页面，在主页index.html中设置超链接

<!DOCTYPE html>
    <html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>首页</title>
    </head>
    <body>
        <h1>首页</h1>
        <a th:href="@{/target}">访问target页面！</a>
    </body>
    </html>

target.html页面代码如下：

<!DOCTYPE html>
    <html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>target</title>
    </head>
    <body>
        Hello World! 
    </body>
    </html>

③ 项目的总体结构如下图所示：  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5LiA55Oi5rGf5rmW5oiR5rKJ5rWu_size_15_color_FFFFFF_t_70_g_se_x_16]  
④ 在IDEA中配置项目并启动  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5LiA55Oi5rGf5rmW5oiR5rKJ5rWu_size_20_color_FFFFFF_t_70_g_se_x_16 5]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5LiA55Oi5rGf5rmW5oiR5rKJ5rWu_size_17_color_FFFFFF_t_70_g_se_x_16 1]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5LiA55Oi5rGf5rmW5oiR5rKJ5rWu_size_16_color_FFFFFF_t_70_g_se_x_16]

### 2.8.总结 ###

① 浏览器发送请求，若请求地址符合前端控制器的url-pattern，该请求就会被前端控制器DispatcherServlet处理。  
② 前端控制器会读取SpringMVC的核心配置文件，通过扫描组件找到控制器，将请求地址和控制器中@RequestMapping注解的value属性值进行匹配，若匹配成功，该注解所标识的控制器方法就是处理请求的方法  
③ 处理请求的方法需要返回一个字符串类型的视图名称，该视图名称会被视图解析器解析，加上前缀和后缀组成视图的路径，通过Thymeleaf对视图进行渲染，最终转发到视图所对应页面。

## 3.@RequestMapping注解 ##

### （1）@RequestMapping注解的功能 ###

从注解名称上我们可以看到，**@RequestMapping注解的作用就是将请求和处理请求的控制器方法关联起来，建立映射关系**。SpringMVC 接收到指定的请求，就会来找到在映射关系中对应的控制器方法来处理这个请求。

### （2）@RequestMapping注解的位置 ###

**@RequestMapping注解既可以标识在类上，也可以标识在方法上。**

<table> 
 <thead> 
  <tr> 
   <th>@RequestMapping标识一个类</th> 
   <th>设置映射请求的请求路径的初始信息</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>@RequestMapping标识一个方法</td> 
   <td>设置映射请求请求路径的具体信息</td> 
  </tr> 
 </tbody> 
</table>

@Controller 
    @RequestMapping("/test")   //映射所有以/test开始的请求路径，例如/test/aaa、/test/xxx等
    public class RequestMappingController {
         
    
    	//此时请求映射所映射的具体请求的请求路径为：/test/testRequestMapping 
    	@RequestMapping("/testRequestMapping") 
    	public String testRequestMapping(){
        
    		//跳转到 /WEB-INF/templates/success.html页面
    		return "success"; 
    	} 
    }

### （3）@RequestMapping注解的value属性 ###

① @RequestMapping注解的value属性通过请求的请求地址匹配请求映射。  
② @RequestMapping注解的value属性是一个字符串类型的数组，表示该请求映射能够匹配多个请求地址所对应的请求。并且**value属性必须设置**，至少通过请求地址匹配请求映射。  
③ 当@RequestMapping注解中只有value属性时，value可以省略不写。

<a th:href="@{/testRequestMapping}">测试RequestMapping注解的value属性-->/testRequestMapping</a><br>
    <a th:href="@{/test}">测试RequestMapping注解的value属性-->/test</a><br>

//当请求路径为 /testRequestMapping或者/test 时，调用该方法
    @RequestMapping(value = {
        "/testRequestMapping", "/test"})
    public String testRequestMapping(){
        
        return "success";
    }

### （4）@RequestMapping注解的method属性 ###

@RequestMapping注解的method属性通过请求的请求方式（get或post）来匹配请求映射，该属性是一个RequestMethod类型的数组，表示该请求映射能够匹配多种请求方式的请求。

<a th:href="@{/test}">测试@RequestMapping的value属性-->/test</a><br> 
    <form th:action="@{/test}" method="post">
    	<input type="submit">
    </form>

//当请求路径为 /testRequestMapping或者/test，并且请求方式为get或者post时，调用该方法
    @RequestMapping(
            value = {
        "/testRequestMapping", "/test"},
            method = {
        RequestMethod.GET, RequestMethod.POST}
    )
    public String success(){
        
        return "success";
    }

**注：对于处理指定请求方式的控制器方法，SpringMVC中提供了@RequestMapping的派生注解：**

<table> 
 <thead> 
  <tr> 
   <th>处理get请求的映射</th> 
   <th>@GetMapping</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>处理post请求的映射</td> 
   <td>@PostMapping</td> 
  </tr> 
  <tr> 
   <td>处理put请求的映射</td> 
   <td>@PutMapping</td> 
  </tr> 
  <tr> 
   <td>处理delete请求的映射</td> 
   <td>@DeleteMapping</td> 
  </tr> 
  <tr> 
   <td><strong>常用的请求方式有get，post，put，delete，但是目前浏览器只支持get和post，若在form表单提交时，为method设置了其他请求方式的字符串（put或delete），则按照默认的请求方式get处理。若要发送put和delete请求，则需要通过spring提供的过滤器HiddenHttpMethodFilter</strong>，这些在后面的RESTful部分会详细说明。</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

### （5）@RequestMapping注解的params属性（了解） ###

@RequestMapping注解的params属性通过请求的请求参数匹配请求映射，**该属性是一个字符串类型的数组，可以通过四种表达式设置请求参数和请求映射的匹配关系：**

<table> 
 <thead> 
  <tr> 
   <th>“param”</th> 
   <th>要求请求映射所匹配的请求必须携带param请求参数</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>“!param”</td> 
   <td>要求请求映射所匹配的请求必须不能携带param请求参数</td> 
  </tr> 
  <tr> 
   <td>“param=value”</td> 
   <td>要求请求映射所匹配的请求必须携带param请求参数且param=value</td> 
  </tr> 
  <tr> 
   <td>“param!=value”</td> 
   <td>要求请求映射所匹配的请求必须携带param请求参数但是param!=value</td> 
  </tr> 
 </tbody> 
</table>

<a th:href="@{/test(username='admin',password=123456)">
    	测试@RequestMapping的 params属性-->/test
    </a>

@RequestMapping( 
    	value = {
        "/testRequestMapping", "/test"} ,
    	method = {
        RequestMethod.GET, RequestMethod.POST} ,
    	params = {
        "username","password!=123456"} 
    )
    public String testRequestMapping(){
         
    	return "success"; 
    }

注：若当前请求满足@RequestMapping注解的value和method属性，但是不满足params属性，此时页面回报错400：Parameter conditions “username, password!=123456” not met for actual request parameters: username=\{admin\}, password=\{123456\}

### （6）@RequestMapping注解的headers属性（了解） ###

@RequestMapping注解的headers属性通过请求的请求头信息匹配请求映射，该属性是一个字符串类型的数组，可以通过四种表达式设置请求头信息和请求映射的匹配关系：

<table> 
 <thead> 
  <tr> 
   <th>“header”</th> 
   <th>要求请求映射所匹配的请求必须携带header请求头信息</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>“!header”</td> 
   <td>要求请求映射所匹配的请求必须不能携带header请求头信息</td> 
  </tr> 
  <tr> 
   <td>“header=value”</td> 
   <td>要求请求映射所匹配的请求必须携带header请求头信息且header=value</td> 
  </tr> 
  <tr> 
   <td>“header!=value”</td> 
   <td>要求请求映射所匹配的请求必须携带header请求头信息且header!=value</td> 
  </tr> 
 </tbody> 
</table>

<a th:href="@{/testParamsAndHeaders(username='admin',password=123)}">
    	测试RequestMapping注解的params属性-->/testParamsAndHeaders
    </a>

@RequestMapping(
            value = "/testParamsAndHeaders",
            params = {
        "username","password!=123456"},
            headers = {
        "Host=localhost:8080"}
    )
    public String testParamsAndHeaders(){
        
        return "success";
    }

若当前请求满足@RequestMapping注解的value和method属性，但是不满足headers属性，此时页面显示404错误，即资源未找到。

### （7）SpringMVC支持ant风格的路径 ###

<table> 
 <thead> 
  <tr> 
   <th>？</th> 
   <th>表示任意的单个字符</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>*</td> 
   <td>表示任意的0个或多个字符</td> 
  </tr> 
  <tr> 
   <td>**</td> 
   <td>表示任意的一层或多层目录</td> 
  </tr> 
 </tbody> 
</table>

<a th:href="@{/a1a/testAnt}">测试@RequestMapping可以匹配ant风格的路径-->使用?</a><br>
    <a th:href="@{/a1a/testAnt}">测试@RequestMapping可以匹配ant风格的路径-->使用*</a><br>
    <a th:href="@{/a1a/testAnt}">测试@RequestMapping可以匹配ant风格的路径-->使用**</a><br>

//注意：在使用**时，只能使用/**/xxx的方式
    //@RequestMapping("/a?a/testAnt")
    //@RequestMapping("/a*a/testAnt")
    @RequestMapping("/**/testAnt")
    public String testAnt(){
        
        return "success";
    }

### （8）SpringMVC支持路径中的占位符（重点） ###

<table> 
 <thead> 
  <tr> 
   <th>原始方式</th> 
   <th>/deleteUser?id=1</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>rest方式</td> 
   <td>/deleteUser/1</td> 
  </tr> 
  <tr> 
   <td><strong>SpringMVC路径中的占位符常用于RESTful风格中</strong>，当请求路径中将某些数据通过路径的方式传输到服务器中，就可以在相应的@RequestMapping注解的value属性中通过占位符{xxx}表示传输的数据，在通过@PathVariable注解，将占位符所表示的数据赋值给控制器方法的形参。</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

<a th:href="@{/testRest/1/admin}">测试路径中的占位符-->/testRest</a><br>

@RequestMapping("/testPath/{id}/{username}")
    public String testPath(@PathVariable("id")Integer id, @PathVariable("username") String username){
        
        System.out.println("id:"+id+",username:"+username);
        return "success";
    }

## 4.SpringMVC获取请求参数 ##

### （1）通过ServletAPI获取 ###

将HttpServletRequest作为控制器方法的形参，此时HttpServletRequest类型的参数表示封装了当前请求的请求报文的对象。

<a th:href="@{/testServletAPI(username='admin',password=123456)}">
    	测试使用servletAPI获取请求参数
    </a>

//形参位置的request表示当前请求
    @RequestMapping("/testServletAPI")
    public String testServletAPI(HttpServletRequest request){
        
        HttpSession session = request.getSession();
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        System.out.println("username:"+username+",password:"+password);
        return "success";
    }

### （2）通过控制器方法的形参获取请求参数 ###

在控制器方法的形参位置，**设置和请求参数同名的形参**，当浏览器发送请求，匹配到请求映射时，在DispatcherServlet中就会将请求参数赋值给相应的形参。

<a th:href="@{/testParam(username='admin',password=123456)}">
    	测试使用控制器的形参获取请求参数
    </a>

@RequestMapping("/testParam") 
    public String testParam(String username, String password){
        
    	System.out.println("username:"+username+",password:"+password); 
    return "success"; 
    }

通过控制器方法的形参获取请求参数时，需要注意以下几点：  
① 若请求所传输的请求参数中有多个同名的请求参数，此时可以在控制器方法的形参中设置字符串数组或者字符串类型的形参来接收此请求参数。  
② 若使用字符串数组类型的形参，此参数的数组中包含了每一个数据。  
③ 若使用字符串类型的形参，此参数的值为每个数据中间使用逗号拼接的结果。

### （3）@RequestParam ###

@RequestParam是将请求参数和控制器方法的形参创建映射关系，一共有三个属性：

<table> 
 <thead> 
  <tr> 
   <th>value</th> 
   <th>指定为形参赋值的请求参数的参数名</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>required</td> 
   <td>设置是否必须传输此请求参数，默认值为true</td> 
  </tr> 
  <tr> 
   <td>defaultValue</td> 
   <td>不考虑required属性值，当value所指定的请求参数没有传输或传输的值为""时，则使用默认值为形参赋值</td> 
  </tr> 
 </tbody> 
</table>

<form th:action="@{/testParam}" method="get">
        用户名：<input type="text" name="username"><br>
        密码：<input type="password" name="password"><br>
        爱好：<input type="checkbox" name="hobby" value="a">a
        <input type="checkbox" name="hobby" value="b">b
        <input type="checkbox" name="hobby" value="c">c<br>
        <input type="submit" value="测试使用控制器的形参获取请求参数">
    </form>

@RequestMapping("/testParam")
    public String testParam(
            //required=fasle表示传过来的参数不一定要有user_name
            @RequestParam(value = "user_name", required = false, defaultValue = "testName") 
            String username,String password,String[] hobby
        )   
        System.out.println("username:"+username+",password:"+password+",hobby:"+ Arrays.toString(hobby));
        return "success";
    }

需要注意的是，若required 设置为true时，则当前请求必须传输value所指定的请求参数，若没有传输该请求参数，且没有设置defaultValue属性，则页面报错400：Required String parameter ‘xxx’ is not present；若设置为false，则当前请求不是必须传输value所指定的请求参数，若没有传输，则注解所标识的形参的值为null。

### （4）@RequestHeader ###

@RequestHeader是将请求头信息和控制器方法的形参创建映射关系，它一共有三个属性：value、required、defaultValue，其用法与@RequestParam一样。

### （5）@CookieValue ###

@CookieValue是将cookie数据和控制器方法的形参创建映射关系，它一共有三个属性：value、required、defaultValue，其用法与@RequestParam一样。

### （6）通过POJO获取请求参数 ###

**可以在控制器方法的形参位置设置一个实体类类型的形参，此时若浏览器传输的请求参数的参数名和实体类中的属性名一致，那么请求参数就会为此属性赋值。**

//定义实体类对象
    package com.atguigu.restful.bean;
    
    public class User {
        
        
        private Integer id;
        
        private String username;
        
        private String password;
        
        private Integer age;
        
        private String sex;
        
        private String email;
        
        public User() {
        
        }
        
        public User(Integer id, String username, String password, Integer age, String sex, String email) {
        
            this.id = id;
            this.username = username;
            this.password = password;
            this.age = age;
            this.sex = sex;
            this.email = email;
        }
        
        @Override
        public String toString() {
        
            return "User{" +
                    "id=" + id +
                    ", username='" + username + '\'' +
                    ", password='" + password + '\'' +
                    ", age=" + age +
                    ", sex='" + sex + '\'' +
                    ", email='" + email + '\'' +
                    '}';
        }
        
        public Integer getId() {
        
            return id;
        }
        
        public void setId(Integer id) {
        
            this.id = id;
        }
        
        public String getUsername() {
        
            return username;
        }
        
        public void setUsername(String username) {
        
            this.username = username;
        }
        
        public String getPassword() {
        
            return password;
        }
        
        public void setPassword(String password) {
        
            this.password = password;
        }
        
        public Integer getAge() {
        
            return age;
        }
        
        public void setAge(Integer age) {
        
            this.age = age;
        }
        
        public String getSex() {
        
            return sex;
        }
        
        public void setSex(String sex) {
        
            this.sex = sex;
        }
        
        public String getEmail() {
        
            return email;
        }
        
        public void setEmail(String email) {
        
            this.email = email;
        }
    }

<form th:action="@{/testBean}" method="post">
        用户名：<input type="text" name="username"><br>
        密码：<input type="password" name="password"><br>
        性别：<input type="radio" name="sex" value="男">男<input type="radio" name="sex" value="女">女<br>
        年龄：<input type="text" name="age"><br>
        邮箱：<input type="text" name="email"><br>
        <input type="submit" value="使用实体类接收请求参数">
    </form>

@RequestMapping("/testBean")
    public String testBean(User user){
        
        System.out.println(user);
        return "success";
    }

### （7）解决获取请求参数的乱码问题 ###

解决获取请求参数的乱码问题，可以使用SpringMVC提供的编码过滤器CharacterEncodingFilter，但是必须在web.xml中进行注册。除此之外，SpringMVC中处理编码的过滤器一定要配置到其他过滤器之前，否则无效。

<filter>
        <filter-name>CharacterEncodingFilter</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>
        <init-param>
            <param-name>forceResponseEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

## 5.域对象共享数据 ##

### （1）使用ServletAPI向request域对象共享数据 ###

<a th:href="@{/testRequestByServletAPI}">
    	testRequestByServletAPI
    </a>

//使用servletAPI向request域对象共享数据
    @RequestMapping("/testRequestByServletAPI")
    public String  testRequestByServletAPI(HttpServletRequest request){
        
        request.setAttribute("testRequestScope","hello,servletAPI");
        return "success";
    }