【SpringMVC从入门到实战教程】第三章 SpringMVC 注解开发

偏执的太偏执、 2024-04-28 13:22 14阅读 0赞

## 三、SpringMVC 注解开发 ##

### 3.1 基本步骤 ###

#### 3.1.1 前端控制器 ####

<?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
             version="4.0">
        
        <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>*.do</url-pattern>
        </servlet-mapping>
    
        <welcome-file-list>
            <welcome-file>/views/index.jsp</welcome-file>
        </welcome-file-list>
    </web-app>

#### 3.1.2 mvc命名空间与标签规范 ####

<?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:p="http://www.springframework.org/schema/p"
            xmlns:context="http://www.springframework.org/schema/context"
            xmlns:aop="http://www.springframework.org/schema/aop"
            xmlns:mvc="http://www.springframework.org/schema/mvc"
            xsi:schemaLocation="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
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
    </beans>

#### 3.1.3 组件扫描 ####

<context:component-scan base-package="com.newcapec.controller"/>

#### 3.1.4 MVC注解驱动 ####

SpringMVC使用 \`<mvc:annotation-driven>\` 自动加载RequestMappingHandlerMapping（处理器映射器）和RequestMappingHandlerAdapter（处理器适配器），并且默认加载了很多参数绑定的方法，比如json转换解析器。可用在springmvc.xml配置文件中使用\`<mvc:annotation-driven>\`替代注解处理器和适配器的配置。

<mvc:annotation-driven/>

#### 3.1.5 视图解析器 ####

配置视图解析器的前缀和后缀，可简化视图的访问地址。

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        
        <property name="prefix" value="/views/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

**配置视图解析器的前缀与后缀访问路径的变化：**

*  物理视图名称：配置之前，视图的真实访问路径为，/views/success.jsp
 *  逻辑视图名称：配置之后，视图的简化访问路径为，success
 *  物理视图名 = 前缀 + 逻辑视图名 + 后缀

#### 3.1.6 处理器 ####

@Controller
    public class UserController {
    
        /**
         * 新增请求
         *
         * @RequestMapping 位置：类和方法
         * 作用：将请求路径与处理请求的方法关联
         * 注意：在配置路径时，路径需要以/开头
         */
        @RequestMapping("/addUser.do")
        public ModelAndView addUser() {
            System.out.println("新增用户请求...");
            ModelAndView modelAndView = new ModelAndView();
            modelAndView.addObject("message", "add user");
            /**
             * 配置视图解析器的前后缀之后访问路径的变化：/views/ /views/success.jsp .jsp
             * 在ModelAndView对象中设置的视图地址：逻辑视图名称 != 视图访问路径（物理视图名称）
             * 视图访问地址 = 前缀 + 逻辑视图名称 + 后缀
             */
            //modelAndView.setViewName("/views/success.jsp");
            modelAndView.setViewName("success");
            return modelAndView;
        }
    
        @RequestMapping("/editUser.do")
        public ModelAndView editUser() {
            System.out.println("编辑用户请求...");
            ModelAndView modelAndView = new ModelAndView();
            modelAndView.addObject("message", "edit user");
            modelAndView.setViewName("success");
            return modelAndView;
        }
    
        @RequestMapping("/removeUser.do")
        public ModelAndView removeUser() {
            System.out.println("删除用户请求...");
            ModelAndView modelAndView = new ModelAndView();
            modelAndView.addObject("message", "remove user");
            modelAndView.setViewName("success");
            return modelAndView;
        }
    
        @RequestMapping("/findUser.do")
        public ModelAndView findUser() {
            System.out.println("查询用户请求...");
            //模拟数据
            List<String> list = new ArrayList<>();
            list.add("zhangsan");
            list.add("lisi");
            list.add("tom");
            list.add("jerry");
            ModelAndView modelAndView = new ModelAndView();
            modelAndView.addObject("list", list);
            modelAndView.setViewName("success");
            return modelAndView;
        }
    }

#### 3.1.7 视图 ####

在webapp目录下建立“views”子目录，所有视图放置在“views”子目录中。

**index.jsp：**

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <base href="${pageContext.request.contextPath}/">
        <title>Title</title>
    </head>
    <body>
        <div style="text-align: center">
            <h1>首页</h1>
            <p><a href="addUser.do">新增用户</a></p>
            <p><a href="editUser.do">编辑用户</a></p>
            <p><a href="removeUser.do">删除用户</a></p>
            <p><a href="findUser.do">查询用户</a></p>
            <p><a href="url.do">路径映射1</a></p>
            <p><a href="getUrl.do">路径映射2</a></p>
            <p><a href="test.do">路径映射3</a></p>
            <p><a href="api/add.do">路径前缀</a></p>
            <p><a href="api/find.do">请求方法的限制</a></p>
            <form action="api/find.do" method="post">
                <button type="submit">提交</button>
            </form>
            <p><a href="forwardPage.do">请求转发到视图</a></p>
            <p><a href="redirectPage.do">重定向到视图</a></p>
            <p><a href="forwardController.do">请求转发到Controller</a></p>
            <p><a href="redirectController.do">重定向到Controller</a></p>
            <p><a href="returnVoid.do">无返回值</a></p>
            <p><a href="modelParam.do">Model类型的形参</a></p>
            <p><a href="views/simple.jsp">简单类型的形参</a></p>
            <p><a href="requestParam.do?empno=20">@RequestParam</a></p>
            <p><a href="dateTimeFormat.do?date=2022-03-21">@DateTimeFormat</a></p>
            <p><a href="requestHeader.do">@RequestHeader</a></p>
            <p><a href="setCookie.do">设置Cookie</a></p>
            <p><a href="getCookie.do">获取Cookie</a></p>
            <p><a href="views/pojo.jsp">POJO类型的形参</a></p>
            <p><a href="getBirthday.do?birthday=1993-04-17">Converter</a></p>
            <p><a href="getPoint.do?myPoint=125,369">Formatter</a></p>
            <p><a href="views/array.jsp">数组类型的形参</a></p>
            <p><a href="views/list.jsp">集合类型的形参</a></p>
            <p><a href="getUser.do">SessionAttribute</a></p>
            <p><a href="views/login.jsp">登录</a></p>
        </div>
    </body>
    </html>

**success.jsp：**

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    <html>
    <head>
        <base href="${pageContext.request.contextPath}/">
        <title>Title</title>
    </head>
    <body>
        <div style="text-align: center">
            <h1>响应页面</h1>
            <p>${message}</p>
            <ul>
                <c:forEach items="${list}" var="s">
                    <li>${s}</li>
                </c:forEach>
            </ul>
        </div>
    </body>
    </html>

### 3.2 @ResquestMapping注解 ###

一个控制器内有多个处理请求的方法，如 UserController 里通常有增加用户、修改用户信息、删除指定用户、根据条件获取用户列表等。每个方法负责不同的请求操作，而 @RequestMapping 就负责将请求映射到对应的控制器方法上。

在基于注解的控制器类中可以为每个请求编写对应的处理方法。使用 @RequestMapping 注解将请求与处理方法一 一对应即可。

@RequestMapping 注解可用于类或方法上。用于类上，表示类中的所有响应请求的方法都以该地址作为父路径。

**@RequestMapping 注解常用属性如下：**

1、value 属性  
value 属性是 @RequestMapping 注解的默认属性，因此如果只有 value 属性时，可以省略该属性名，如果有其它属性，则必须写上 value 属性名称。  
@RequestMapping(value="toUser")  
@RequestMapping("toUser")  
value 属性支持通配符匹配，如 @RequestMapping(value="toUser/\*") 表示 http://localhost:8080/toUser/1 或 http://localhost:8080/toUser/hahaha 都能够正常访问。  
  
2、path 属性  
path 属性和 value 属性都用来作为映射使用。即 @RequestMapping(value="toUser") 和 @RequestMapping(path="toUser") 都能访问 toUser() 方法。  
  
3、name 属性  
name属性相当于方法的注释，使方法更易理解。如 @RequestMapping(value = "toUser",name = "获取用户信息")。  
  
4、method 属性  
method 属性用于表示该方法支持哪些 HTTP 请求。如果省略 method 属性，则说明该方法支持全部的 HTTP 请求。  
  
5、params 属性  
params 属性用于指定请求中规定的参数。  
@RequestMapping(value = "toUser",params = "type")  
以上代码表示请求中必须包含 type 参数时才能执行该请求。即 http://localhost:8080/toUser?type=xxx 能够正常访问 toUser() 方法，而 http://localhost:8080/toUser 则不能正常访问 toUser() 方法。  
@RequestMapping(value = "toUser",params = "type=1")  
以上代码表示请求中必须包含 type 参数，且 type 参数为 1 时才能够执行该请求。即 http://localhost:8080/toUser?type=1 能够正常访问 toUser() 方法，而 http://localhost:8080/toUser?type=2 则不能正常访问 toUser() 方法。  
  
6、header 属性  
header 属性表示请求中必须包含某些指定的 header 值。  
@RequestMapping(value = "toUser",headers = "Referer=http://www.xxx.com") 表示请求的 header 中必须包含了指定的“Referer”请求头，以及值为“http://www.xxx.com”时，才能执行该请求。  
  
7、consumers 属性  
consumers 属性用于指定处理请求的提交内容类型（Content-Type），例如：application/json、text/html。如  
@RequestMapping(value = "toUser",consumers = "application/json")。  
  
8、produces 属性  
produces 属性用于指定返回的内容类型，返回的内容类型必须是 request 请求头（Accept）中所包含的类型。如 @RequestMapping(value = "toUser",produces = "application/json")。

除此之外，produces 属性还可以指定返回值的编码。如 @RequestMapping(value = "toUser",produces = "application/json,charset=utf-8")，表示返回 utf-8 编码。

使用 @RequestMapping 来完成映射，具体包括 4 个方面的信息项：请求 URL、请求参数、请求方法和请求头。

#### 3.2.1 url映射 ####

对url（请求路径）和handler（处理器）的方法进行映射。

@Controller
    public class RequestMappingController {
    
        /**
         * @RequestMapping
         * 位置：方法
         * 属性：value和path一致，都是配置映射的路径
         * 注意：value和path的类型为字符串数组，在注解的属性中，如果类型为数组并且数组中的数据只有一个
         *      可以不使用数组，仅使用数组中的数据类型
         *      并且，多个请求路径可映射到同一个处理请求的方法上
         */
        //@RequestMapping(path = "/url.do")
        @RequestMapping(value = {"/url.do", "/getUrl.do" ,"/test.do"})
        public ModelAndView url(){
            System.out.println("测试@RequestMapping注解中的url映射功能...");
            return new ModelAndView("success");
        }
    }

**注意：**

*  value的值可为字符串或字符串数组，可以将多个url映射到同一个方法。
 *  请求路径的前斜杠，可加可不加，如果不加SpringMVC在查找映射时会自动加入，但是建议加上斜杠表示此字符串为路径。

#### 3.2.2 请求前缀 ####

在控制器handler类上添加@RequestMapping(url)指定通用请求前缀，限制此类下的所有方法请求url必须以请求前缀开头，通过此方法对url进行分类管理。

/**
     * @RequestMapping
     * 位置：类
     * 作用：在该处理器中所有的方法映射路径前，都添加前缀
     *
     * 以前的路径：/add.do
     * 添加前缀之后：/api/add.do
     *
     * 项目中使用：
     * 用户模块：
     * @RequestMapping("/user")
     * /user/add.do
     * /user/edit.do
     * /user/remove.do
     * /user/find.do
     */
    @Controller
    @RequestMapping("/api")
    public class RequestMappingController {
    
        @RequestMapping("/add.do")
        public ModelAndView add(){
            System.out.println("测试@RequestMapping注解使用在处理器的类上...");
            return new ModelAndView("success");
        }
    }

#### 3.2.3 限制http请求方法 ####

出于安全性考虑，对http的链接进行方法限制。如果限制请求为post方法，进行get请求，会出现报错。

*  **限定GET方法**

/**
     * @RequestMapping注解中的method属性
     * 作用：用于限制http的请求方法
     *
     * method = RequestMethod.GET标签当前方法只能接收GET请求，其他请求方法会拒绝访问
     * 响应状态码为405表示http请求的方式与处理请求方法的限制不匹配
     */
    @RequestMapping(value = "/find.do", method = RequestMethod.GET)
    public ModelAndView find(){
        System.out.println("测试@RequestMapping注解对http协议中的请求方法的限制");
        return new ModelAndView("success");
    }

如果通过POST访问则报错：

![ea2a92238af847e6915ca0817d4d053a.png][]

*  **限定POST方法**

@RequestMapping(value = "/find.do", method = RequestMethod.POST)
    public ModelAndView find(){
        System.out.println("测试@RequestMapping注解对http协议中的请求方法的限制");
        return new ModelAndView("success");
    }

如果通过GET访问则报错：

![e201a4cb92474ab59e4ed91bb711f7bb.png][]

*  **GET和POST都可以**

@RequestMapping(value = "/find.do", method = {RequestMethod.POST, RequestMethod.GET})
    public ModelAndView find(){
        System.out.println("测试@RequestMapping注解对http协议中的请求方法的限制");
        return new ModelAndView("success");
    }

### 3.3 Controller方法返回值 ###

#### 3.3.1 ModelAndView类型 ####

需要方法结束时，定义ModelAndView，将model和view分别进行设置。

#### 3.3.2 String类型 ####

3.3.2.1 请求转发到视图

**Controller方法返回字符串可以为逻辑视图名，通过视图解析器将其解析为物理视图地址：**

@Controller
    public class MethodReturnController {
        /**
         * 返回值类型为字符串String
         *
         * 回顾前奏知识：JavaWeb阶段两种页面跳转
         * 请求转发：共享request对象，属于服务器行为，页面中url地址不会变化
         * 重定向：不同的request对象，属于客户端行为，页面中url地址发生变化
         *
         * 1.请求转发到视图（JSP页面）
         * 2.重定向到视图（JSP页面）
         * 3.请求转发到处理器方法
         * 4.重定向到处理器方法
         */
        /**
         * 1.请求转发到视图
         * 方法的返回字符串：就是将要跳转的逻辑视图名称
         */
        @RequestMapping("/forwardPage.do")
        public String forwardPage(HttpServletRequest request){
            System.out.println("请求转发到JSP...");
            request.setAttribute("message", "hello");
            return "ok"; //表示请求转发到/views/ok.jsp页面中
        }
    }

**ok.jsp：**

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <base href="${pageContext.request.contextPath}/">
        <title>Title</title>
    </head>
    <body>
        <div style="text-align: center">
            <h1>跳转成功--ok.jsp</h1>
            <p>从request域中获取数据为：${requestScope.message}</p>
        </div>
    </body>
    </html>

3.3.2.2 重定向到视图

**Controller方法返回字符串为：在跳转视图路径前，添加`redirect:`前缀**

@Controller
    public class MethodReturnController {
        /**
         * 2.重定向到视图
         * 在返回值字符串的前面添加redirect:的前缀
         */
        @RequestMapping("/redirectPage.do")
        public String redirectPage(HttpServletRequest request){
            System.out.println("重定向到JSP...");
            request.setAttribute("message", "hello");
            return "redirect:/views/ok.jsp";
        }
    }

**注意：在redirect:前缀之后不能使用逻辑视图名，必须使用物理视图名。**

3.3.2.3 请求转发到处理器方法

**请求转发到同一个或另一个处理器的方法中，Controller方法返回字符串为：在跳转视图路径前，添加`forward:`前缀。**

@Controller
    public class MethodReturnController {
        /**
         * 3.请求转发到处理器方法
         * 在返回值字符串的前面添加forward:的前缀
         *
         * 注意：在forward:前缀之后不能使用逻辑视图名，必须使用物理视图名
         */
        @RequestMapping("/forwardController.do")
        public String forwardController(HttpServletRequest request){
            System.out.println("请求转发到另一个Controller的方法中....");
            request.setAttribute("message", "hello other");
            return "forward:/other.do";
        }
    }

**OtherController.java：**

@Controller
    public class OtherController {
    
        @RequestMapping("/other.do")
        public String other(HttpServletRequest request){
            System.out.println("OtherController处理器执行了....");
            System.out.println("request域对象中的数据为：" + request.getAttribute("message"));
            return "ok";
        }
    }

3.3.2.4 重定向到处理器方法

**重定向到同一个或另一个处理器的方法中，Controller方法返回字符串为：在跳转视图路径前，添加`redirect:`前缀。**

@Controller
    public class MethodReturnController {
        /**
         * 4.重定向到处理器方法
         * 在返回值字符串的前面添加redirect:的前缀
         *
         * 注意：在redirect:前缀之后不能使用逻辑视图名，必须使用物理视图名
         */
        @RequestMapping("/redirectController.do")
        public String redirectController(HttpServletRequest request){
            System.out.println("重定向到另一个Controller的方法中....");
            request.setAttribute("message", "helloworld");
            return "redirect:/other.do";
        }
    }

#### 3.3.3 void无返回值 ####

**在Controller方法形参上可以定义request对象和response对象，使用request或response指定响应结果。**

@RequestMapping("/returnVoid.do")
    public void returnVoid(HttpServletRequest request, HttpServletResponse response) throws IOException {
        System.out.println("处理器中方法没有返回值...");
        // request.getRequestDispatcher("").forward(request, response);
        // response.sendRedirect("");
        response.getWriter().println("<html><body><h1>success...</h1></body></html>");
    }

### 3.4 参数绑定 ###

#### 3.4.1 SpringMVC参数绑定过程 ####

客户端请求key/value数据，经过参数绑定，将key/value数据绑定到Controller方法的形参上。

![38a35f91db50401f9dcc0e251c588681.png][]

**注意：在SpringMVC中，接收页面提交的数据是通过方法的参数（形参）来接收，而不是在Controller类定义成员变量（实参）接收。**

#### 3.4.2 默认支持的类型 ####

直接在controller方法形参上定义下边类型，就可以使用这些对象。在参数绑定过程中，如果遇到下边类型直接进行绑定。

HttpServletRequest，通过request对象获取请求信息。  
  
HttpServletResponse，通过response处理响应信息。  
  
HttpSession，通过session对象得到session中存放的对象。  
  
Model/ModelMap，Model是一个接口，ModelMap是一个接口实现。作用：将model数据填充到request域。

@Controller
    public class ParameterController {
        /**
         * 默认支持的类型
         * Model替代request域对象
         */
        @RequestMapping("/modelParam.do")
        public String modelParam(Model model){
            System.out.println("modelParam方法执行了...");
            model.addAttribute("message", "hello model");
            return "ok";
        }
    }

#### 3.4.3 简单类型 ####

通过处理器方法的形参接收请求参数，并且自动将其转换为指定的类型（基本数据，包装类，日期类型）。

@Controller
    public class ParameterController {
        /**
         * 简单类型形参
         * 通过处理器方法的形参接收请求参数，并且自动将其转换为指定的类型（基本数据，包装类，日期类型）
         *
         * 注意：
         * 1.请求参数名称与形参名保持一致
         * 2.日期类型默认格式为yyyy/MM/dd
         * 3.如果类型转换出现问题，SpringMVC并不会抛出异常，而是一个警告日志，客户端会收到400的响应状态码
         */
        @RequestMapping("/simple.do")
        public String simple(Integer empno, String ename, String job, Double sal, Date hiredate){
    
            System.out.println("员工编号：" + empno);
            System.out.println("员工姓名：" + ename);
            System.out.println("员工岗位：" + job);
            System.out.println("员工薪资：" + sal);
            System.out.println("入职日期：" + hiredate);
            return "index";
        }
    }

**simple.jsp：**

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <base href="${pageContext.request.contextPath}/">
        <title>Title</title>
    </head>
    <body>
        <div style="text-align: center">
            <h1>简单参数类型</h1>
            <form action="simple.do" method="post">
                <p>员工编号：<input type="text" name="empno"></p>
                <p>员工姓名：<input type="text" name="ename"></p>
                <p>员工岗位：<input type="text" name="job"></p>
                <p>员工薪资：<input type="text" name="sal"></p>
                <p>入职日期：<input type="text" name="hiredate"></p>
                <p><button>提交</button></p>
            </form>
        </div>
    </body>
    </html>

**注意**：

*  请求参数名称与形参名保持一致。
 *  日期类型默认格式为yyyy/MM/dd。
 *  如果类型转换出现问题，SpringMVC并不会抛出异常，而是一个警告日志，客户端会收到400的响应状态码。

![dfc0c6effc3f4aa3af3f0b0cb85d7e80.png][]

*  **@RequestParam**

**通过@RequestParam注解也可对简单类型的参数进行绑定：**

*  使用@RequestParam，不用限制request传入参数名称和Controller方法的形参名称一致。
 *  通过required属性指定参数是否必须要传入，如果设置为true，没有传入参数，报400错误。
 *  可以使用defaultvalue设置默认值，即使required=true也可以不传参数值。

@Controller
    public class ParameterController {
        /**
         * @RequestParam
         * 位置：方法的形参
         * 作用：
         * 1.value/name: 请求参数与方法形参进行映射
         * 2.required: 默认值为true，表示当前请求中必须带有该参数
         * 3.defaultValue: 形参的默认值
         */
        @RequestMapping("/requestParam.do")
        public String requestParam(@RequestParam(value = "empno", required = false, defaultValue = "100") Integer id){
            System.out.println("请求参数:" + id);
            return "index";
        }
    }

*  **@DateTimeFormat**

**按照指定格式进行日期格式化：**

@Controller
    public class ParameterController {
        /**
         * @DateTimeFormat
         * 位置：方法的形参，成员变量
         * 作用：按照指定格式进行日期格式化
         */
        @RequestMapping("/dateTimeFormat.do")
        public String dateTimeFormat(@DateTimeFormat(pattern = "yyyy-MM-dd") Date date){
            System.out.println("日期为:" + date);
            return "index";
        }
    }

*  **@RequestHeader**

**获取指定的请求头信息：**

@Controller
    public class ParameterController {
        /**
         * @RequestHeader
         * 位置：方法的形参
         * 作用：获取指定的请求头信息
         */
        @RequestMapping("/requestHeader.do")
        public String requestHeader(@RequestHeader("Accept-Encoding") String encoding){
            System.out.println("请求头信息:" + encoding);
            return "index";
        }
    }

*  **@CookieValue**

**获取指定的Cookie值：**

@Controller
    public class ParameterController {
        /**
         * 设置Cookie
         * 会话：HttpSession，存储在服务器端，Cookie存储HttpSession对象的唯一标识JSESSIONID
         */
        @RequestMapping("/setCookie.do")
        public String setCookie(HttpServletResponse response){
            System.out.println("设置Cookie...");
            Cookie myCookie = new Cookie("username", "xiaoming");
            myCookie.setPath("/");
            // 设置myCookie的有效期为一天
            myCookie.setMaxAge(60 * 60 * 24);
            response.addCookie(myCookie);
            return "index";
        }
    
        /**
         * @CookieValue
         * 位置：方法的形参
         * 作用：获取指定的Cookie值
         */
        @RequestMapping("/getCookie.do")
        public String getCookie(@CookieValue("username") String username){
            System.out.println("Cookie:" + username);
            return "index";
        }
    }

#### 3.4.4 POJO类型 ####

*  获取请求参数，并且创建指定POJO对象。
 *  对象的成员变量名称与请求参数名称一致，就可以将请求参数值设置在POJO对象中。
 *  对象的成员变量也是一个POJO对象时，那么请求参数的名称为：POJO类型的成员变量名.成员变量名。

**POJO类：**

public class Dept {
        
        private Integer deptno;
        private String dname;
    
        public Integer getDeptno() {
            return deptno;
        }
    
        public void setDeptno(Integer deptno) {
            this.deptno = deptno;
        }
    
        public String getDname() {
            return dname;
        }
    
        public void setDname(String dname) {
            this.dname = dname;
        }
    
        @Override
        public String toString() {
            return "Dept{" +
                    "deptno=" + deptno +
                    ", dname='" + dname + '\'' +
                    '}';
        }
    }
    
    
    public class Emp {
        
        private Integer empno;
        private String ename;
        private String job;
        private Double sal;
        /**
         * @DateTimeFormat可以用在形参，也可以用在字段、方法上，都是用来做日期格式化的
         */
        @DateTimeFormat(pattern = "yyyy-MM-dd")
        private Date hiredate;
    
        private Dept dept;
    
        public Integer getEmpno() {
            return empno;
        }
    
        public void setEmpno(Integer empno) {
            this.empno = empno;
        }
    
        public String getEname() {
            return ename;
        }
    
        public void setEname(String ename) {
            this.ename = ename;
        }
    
        public String getJob() {
            return job;
        }
    
        public void setJob(String job) {
            this.job = job;
        }
    
        public Double getSal() {
            return sal;
        }
    
        public void setSal(Double sal) {
            this.sal = sal;
        }
    
        public Date getHiredate() {
            return hiredate;
        }
    
        public void setHiredate(Date hiredate) {
            this.hiredate = hiredate;
        }
    
        public Dept getDept() {
            return dept;
        }
    
        public void setDept(Dept dept) {
            this.dept = dept;
        }
    
        @Override
        public String toString() {
            return "Emp{" +
                    "empno=" + empno +
                    ", ename='" + ename + '\'' +
                    ", job='" + job + '\'' +
                    ", sal=" + sal +
                    ", hiredate=" + hiredate +
                    ", dept=" + dept +
                    '}';
        }
    }

**处理器：**

@Controller
    public class ParameterController {
        /**
         * POJO类型的形参
         * 要求：请求参数名称必须与POJO对象中成员名称保持一致
         *
         * springmvc获取请求参数，并且创建指定POJO对象，
         * 根据请求参数名与POJO对象成员变量的名称，通过setter方法进行赋值
         */
        @RequestMapping("/pojoParam.do")
        public String pojoParam(Emp emp){
            System.out.println(emp);
            return "redirect:/views/index.jsp";
        }
    }

**pojo.jsp：**

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <base href="${pageContext.request.contextPath}/">
        <title>Title</title>
    </head>
    <body>
        <div style="text-align: center">
            <h1>POJO参数类型</h1>
            <form action="pojoParam.do" method="post">
                <p>员工编号：<input type="text" name="empno"></p>
                <p>员工姓名：<input type="text" name="ename"></p>
                <p>员工岗位：<input type="text" name="job"></p>
                <p>员工薪资：<input type="text" name="sal"></p>
                <p>入职日期：<input type="text" name="hiredate"></p>
                <p>部门：<select name="dept.deptno">
                    <option value="1">人力部</option>
                    <option value="2">研发部</option>
                    <option value="3">销售部</option>
                </select></p>
                <p><button>提交</button></p>
            </form>
        </div>
    </body>
    </html>

#### 3.4.5 自定义类型转换器 ####

*  SpringMVC中自带了很多转换器，可完成大多数Java类型的转换工作。
 *  ConversionService是Spring类型转换体系的核心接口。
 *  可以利用org.springframework.format.support.FormattingConversionServiceFactoryBean在IOC容器中定义一个ConversionService。SpringMVC将自动识别出ConversionService，并在处理器方法参数绑定等场合使用它进行数据类型的转换。

**3.4.5.1 Converter接口**

org.springframework.core.convert.converter.Converter接口，特点：可将任意类型转换为另一个任意类型。

**实现类：**

/**
     * 自定义的全局日期格式转换器
     * 实现Converter<S, T>接口
     * S : 原有类型，待转换类型
     * T : 转换之后的类型
     */
    public class DateConverter implements Converter<String, Date> {
        private String partten = "yyyy-MM-dd";
        
        public void setPartten(String partten) {
            this.partten = partten;
        }
        /**
         * 日期格式转换
         * @param source 待转换类型的字符串数据
         * @return 转换之后的日期类型数据
         */
        @Override
        public Date convert(String source) {
            System.out.println("全局日期格式转换工具执行了....");
            SimpleDateFormat sdf = new SimpleDateFormat(partten);
            try {
                return sdf.parse(source);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            return null;
        }
    }

**配置：**

<mvc:annotation-driven conversion-service="formattingConversionService"/>
    
    
    <bean id="formattingConversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
        
        <property name="converters">
            <set>
                <bean class="com.newcapec.util.DateConverter">
                    
                </bean>
            </set>
        </property>
    </bean>

**处理器：**

@Controller
    public class ParameterController {
        
        @RequestMapping("/getBirthday.do")
        public String getBirthday(Date birthday) {
            System.out.println("生日：" + birthday);
            return "index";
        }
    }

**3.4.5.2 Formatter接口**

org.springframework.format.Formatter接口，特点：可将任意指定类型转换为String类型，也可将String类型转换为任意指定类型。

**自定义类型：**

public class MyPoint {
        private int x;
        private int y;
    
        public MyPoint() {
        }
    
        public MyPoint(int x, int y) {
            this.x = x;
            this.y = y;
        }
    
        public int getX() {
            return x;
        }
    
        public void setX(int x) {
            this.x = x;
        }
    
        public int getY() {
            return y;
        }
    
        public void setY(int y) {
            this.y = y;
        }
    
        @Override
        public String toString() {
            return "MyPoint{" +
                    "x=" + x +
                    ", y=" + y +
                    '}';
        }
    }

**实现类：**

/**
     * 类型格式化器
     * 实现Formatter<T>接口
     * T : 转换之后的格式
     *
     * Converter与Formatter
     * Converter可以实现任意两种类型之间的转换，单向转换，只能将第一个泛型的类型转换为第二个泛型的类型
     * Formatter只能实现String与任意类型之间的格式化，双向转换
     */
    public class MyPointFormatter implements Formatter<MyPoint> {
        @Override
        public MyPoint parse(String text, Locale locale) throws ParseException {
            //125,369
            String[] ss = text.split(",");
            return new MyPoint(Integer.parseInt(ss[0]),Integer.parseInt(ss[1]));
        }
    
        @Override
        public String print(MyPoint object, Locale locale) {
            return null;
        }
    }

**配置：**

**处理器：**

@Controller
    public class ParameterController {
        @RequestMapping("/getPoint.do")
        public String getPoint(MyPoint myPoint) {
            System.out.println("坐标：" + myPoint);
            return "index";
        }
    }

#### 3.4.6 数组类型 ####

将页面上通过多选框选中多个的id，传到Controller方法的形参，方法形参使用数组接收页面请求的多个id，实现批量删除。

@Controller
    public class ParameterController {
        /**
         * 数组类型的参数
         * 客户端的提交规则: 一个请求参数名称对应多个请求参数值
         * 原生Servlet: String[] request.getParametervalues()
         * 
         * 特殊情况：
         * 当形参为数组类型，而请求参数值中的数据又是以逗号间隔，SpringMVC会按照逗号进行拆分，解析到数组中
         * 例如：请求参数为 ids=1,2,3,4,5  形参: 数组{1,2,3,4,5}
         */
        @RequestMapping("/removeBatch.do")
        public String removeBatch(Integer[] ids){
            System.out.println("批量删除的id为：" + Arrays.toString(ids));
            return "index";
        }
    }

**array.jsp：**

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <base href="${pageContext.request.contextPath}/">
        <title>Title</title>
    </head>
    <body>
        <div style="text-align: center">
            <h1>批量删除</h1>
            <form action="removeBatch.do">
                <table border="1" width="500" align="center">
                    <tr>
                        <th><input type="checkbox"></th>
                        <th>部门编码</th>
                        <th>部门名称</th>
                    </tr>
                    <tr>
                        <td><input type="checkbox" name="ids" value="10"/></td>
                        <td>10</td>
                        <td>研发部</td>
                    </tr>
                    <tr>
                        <td><input type="checkbox" name="ids" value="20"/></td>
                        <td>20</td>
                        <td>人力部</td>
                    </tr>
                    <tr>
                        <td><input type="checkbox" name="ids" value="30"/></td>
                        <td>30</td>
                        <td>企划部</td>
                    </tr>
                </table>
                <button>提交</button>
            </form>
        </div>
    </body>
    </html>

#### 3.4.7 集合类型 ####

SpringMVC无法直接绑定集合类型的形参，需要利用POJO对象才可实现。可将集合类型定义为一个POJO类的属性，该POJO类型作为Controller方法的形参。

**POJO类：**

public class CollectionBean {
        private List<Dept> deptList;
    
        public List<Dept> getDeptList() {
            return deptList;
        }
    
        public void setDeptList(List<Dept> deptList) {
            this.deptList = deptList;
        }
    }

**Controller：**

@Controller
    public class ParameterController {
        /**
         * 集合类型的参数
         * 注意：springmvc中集合类型不能直接作为形参
         *      需要通过一个pojo对象包装，在一个pojo对象中含有一个集合类型的成员变量
         *
         * 批量新增或编辑数据
         */
        // public String insertBatch(List<String> list){ //错误的，不支持的
        //
        // }
        @RequestMapping("/insertBatch.do")
        public String insertBatch(CollectionBean bean){
            System.out.println("批量提交的部门：" + bean.getDeptList());
            return "index";
        }
    }

**list.jsp：**

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <base href="${pageContext.request.contextPath}/">
        <title>Title</title>
    </head>
    <body>
        <div style="text-align: center">
            <h1>批量新增</h1>
            <form action="insertBatch.do" method="post">
                <table border="1" width="500" align="center">
                    <tr>
                        <th>部门编码</th>
                        <th>部门名称</th>
                    </tr>
                    <tr>
                        
                        <td><input type="text" name="deptList[0].deptno"></td>
                        <td><input type="text" name="deptList[0].dname"></td>
                    </tr>
                    <tr>
                        <td><input type="text" name="deptList[1].deptno"></td>
                        <td><input type="text" name="deptList[1].dname"></td>
                    </tr>
                    <tr>
                        <td><input type="text" name="deptList[2].deptno"></td>
                        <td><input type="text" name="deptList[2].dname"></td>
                    </tr>
                </table>
                <button>提交</button>
            </form>
        </div>
    </body>
    </html>

#### 3.4.8 @SessionAttribute ####

从HttpSession中获取指定对象数据。

@Controller
    public class ParameterController {
        /**
         * @SessionAttribute
         * 位置：方法的形参
         * 作用：从HttpSession中获取指定对象数据
         */
        @RequestMapping("/getUser.do")
        public String getUser(@SessionAttribute("loginUser") User user){
            System.out.println("登录用户:" + user);
            return "index";
        }
    }

**用户类：**

public class User {
    
        private String username;
        private String password;
    
        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;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "username='" + username + '\'' +
                    ", password='" + password + '\'' +
                    '}';
        }
    }

**登录Controller：**

@Controller
    public class LoginController {
    
        @RequestMapping("/login.do")
        public String login(User user, HttpSession session){
            System.out.println("登录操作...");
            session.setAttribute("loginUser", user);
            return "index";
        }
    }

**login.jsp：**

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <base href="${pageContext.request.contextPath}/">
        <title>Title</title>
    </head>
    <body>
        <div style="text-align: center">
            <h1>登录</h1>
            <form action="login.do" method="post">
                <p>用户名：<input type="text" name="username"></p>
                <p>密 码：<input type="text" name="password"></p>
                <p><button>提交</button></p>
            </form>
        </div>
    </body>
    </html>

[ea2a92238af847e6915ca0817d4d053a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/efc70b8f356947a7bff2af0fb4659113.png
[e201a4cb92474ab59e4ed91bb711f7bb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/344bdec39f4d41a2bfd9c261b3044ad1.png
[38a35f91db50401f9dcc0e251c588681.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/7ca09c86f43e4ac582b83dfb3d2ef5a6.png
[dfc0c6effc3f4aa3af3f0b0cb85d7e80.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/32dae130b11a47aa8e461fcdbb01fcc1.png