一、响应数据和结果视图

1.1 返回值分类

1.1.1 返回字符串

import cn.gorit.entity.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
@Controller
@RequestMapping("/user")
public class UserController {
    // 返回字符串
    @RequestMapping("/testString")
    public String testString(Model model) {
        System.out.println("testString 执行了");
        User user = new User(); // 实体类 User
        user.setUsername("美美");
        user.setPassword("123321");
        user.setAge(18);
        model.addAttribute("user",user);
        return "success";
    }
}
// 前面经过视图解析器的处理，均会跳转到 success.jsp 的界面
    <h5>一、返回字符串</h5>
姓名：${user.username}</br>
密码：${user.password}</br>
年龄：${user.age}

1.1.2 返回 void

    /**
     * 返回 空，如果没有返回值，
     * 会默认请求 testVoid.jsp 结果是 404
     * 请求转发是一次请求
     * 重定向是两次请求
     */
    @RequestMapping("/testVoid")
    public void testVoid(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("testVoid 执行了");
        // 1. 编写请求转发的程序
        // request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request,response);
        // 2. 重定向
        // response.sendRedirect("../index.jsp");
        // 3. 直接进行相应
        PrintWriter out = response.getWriter();
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("gbk"); // 解决中文乱码
        response.setContentType("text/html;charset=gbk");
        out.print("你好");
        out.flush();
        out.close();
        return;
    }

1.1.3 返回值是 ModelAndView 对象

    // 和返回 字符串是一致的
    @RequestMapping("/testModelAndView")
    public ModelAndView testModelAndView()  {
        System.out.println("testModelAndView 执行了");
        //Spring 提供
        ModelAndView mv = new ModelAndView();
        User user = new User();
        user.setUsername("小风");
        user.setPassword("456");
        user.setAge(18);
        // 把 user 对象存储进 mv 对象中，也会把 user 对象存到 request 对象中
        mv.addObject("user",user);
        // 跳转到哪个页面
        mv.setViewName("success");
        return mv;
    }

1.2 转发和重定向

    /**
     * 使用关键字的形式进行转发或重定向
     * */
    @RequestMapping("/testForwardOrRedirect")
    public String testForwardOrRedirect()  {
        System.out.println("testForwardOrRedirect 执行了");
        // 请求的转发
//        return "forward:/WEB-INF/pages/success.jsp";
        // 重定向（返回根目录）
        return  "redirect:/index.jsp";
    }

1.3 ajax 响应 json 字符串

在 pom.xml 添加 json 解析依赖

<!--        json 解析-->
     <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-core</artifactId>
         <version>2.10.0</version>
     </dependency>
     <dependency>
         <groupId>com.fasterxml.jackson.core</groupId>
         <artifactId>jackson-annotations</artifactId>
         <version>2.10.0</version>
     </dependency>

编写前端 ajax 请求

    <button id="btn">发送 ajax</button>

    <script type="text/javascript">
        // 页面加载，绑定单击事件
        $(function () {
            $("#btn").click(function () {
                // alert("Hello");
                $.ajax({
                    url:"user/testAjax",
                    type:"post",
                    contentType:"application/json;charset=UTF-8",
                    data:'{"username":"hehe","password":"122","age":30}', // 传 json 数据
                    dataType:"json",
                    success:function (data) {
                        // data 为服务端响应的 json 数据，进行解析
                        alert(data);
                        alert(data.username);
                        alert(data.password);
                        alert(data.age);
                    }
                })
            })

        })
    </script>

ajax 响应（后端处理）

    // 模拟异步请求相应
    @RequestMapping("/testAjax")
    public @ResponseBody User testAjax(@RequestBody User user)  {
        System.out.println("testAjax 执行了");
        // 接收 客户端发送的 ajax 请求，传的是 json 字符串，后端吧 json 字符串封装到 user对象中
        System.out.println(user);
//       得到 json 串，并相应处理 {"username":"hehe","password":"122","age:30}
        // 做响应，模拟查询数据库
        user.setUsername("hehe");
        user.setAge(40);
        // 做响应
        return user;
    }

二、SpringMVC 实现文件上传

2.1 文件上传的原理前提

文件上传的前提

2.2 传统方式上传文件

上传依赖的 jar 包

<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.3</version>
</dependency>
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.5</version>
</dependency>文件

文件上传前端代码

    <h3>文件上传</h3>
    <form action="user/fileupload1" method="post" enctype="multipart/form-data">
        <input type="file" name="upload"/><br>
        <input type="submit" value="上传">
    </form>

后端 controller

@Controller
@RequestMapping("/user")
public class UserController {  

    @RequestMapping("/fileupload1")
    public String fileUpload(HttpServletRequest request) throws Exception {
        System.out.println("文件上传。。。");

        // 使用 fileupload 完成文件上传
        String path =  request.getSession().getServletContext().getRealPath("/uploads/");
        // 判断路径是否存在
        File file = new File(path);
        if (!file.exists()) {
            // 创建该文件夹
            file.mkdirs();
        }

        // 解析 request 对象，获取上传文件项
        DiskFileItemFactory factory = new DiskFileItemFactory();
        ServletFileUpload upload = new ServletFileUpload(factory);
        // 解析 request
        List<FileItem> items = upload.parseRequest(request);
        // 遍历
        for (FileItem item: items) {
            // 进行判断，当前的 item 对象是否为上传文件项
            if (item.isFormField()) {
                // 普通的表单项目
            } else {
                // 上传文件项
                // 获取到上传文件的名称
                String fileName = item.getName();
                // 把每一个文件名称设置唯一值， uuid
                String uuid = UUID.randomUUID().toString().replace("-","");
                fileName = uuid +"_"+ fileName;
                // 完成文件上传
                item.write(new File(path,fileName));
                // 删除临时文件
                item.delete();
            }
        }
        return "success";
    }

}

2.3 SpringMVC 提供的文件上传

上传原理

二、SpringMVC 常用功能 - 图2

这些 JAR包也是必要的！！

<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.3</version>
</dependency>
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.5</version>
</dependency>文件

前端页面

    <h3>文件上传 SpringMVC</h3>
    <form action="user/fileupload2" method="post" enctype="multipart/form-data">
        <input type="file" name="upload"/><br>
        <input type="submit" value="上传">
    </form>

Springmvc.xml

添加一个文件解析器

    <!-- 配置文件解析器对象 -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="10240" />
    </bean>

controller 编写

    // SpringMVC 文件上传
    @RequestMapping("/fileupload2")
    public String fileupload2(HttpServletRequest request, MultipartFile upload) throws Exception {
        System.out.println("文件上传。。。");

        // 使用 fileupload 完成文件上传
        String path =  request.getSession().getServletContext().getRealPath("/uploads/");
        // 判断路径是否存在
        File file = new File(path);
        if (!file.exists()) {
            // 创建该文件夹
            file.mkdirs();
        }
        // 上传文件项
        // 获取到上传文件的名称
        String fileName = upload.getOriginalFilename();
        // 把每一个文件名称设置唯一值， uuid
        String uuid = UUID.randomUUID().toString().replace("-","");
        fileName = uuid +"_"+ fileName;

        // 完成文件上传
        upload.transferTo(new File(path,fileName));
        return "success";
    }

2.4 跨服务器文件上传

二、SpringMVC 常用功能 - 图3

添加 jar 包即可，开两个 Tomcat服务器，使用不同的端口进行跨服务器上传文件
二、SpringMVC 常用功能 - 图4

三、SpringMVC 异常处理

3.1 异常处理思路

二、SpringMVC 常用功能 - 图5

3.2 处理异常

不知道为啥，我这里就总是报 500 错误

编写自定义异常类（做提示信息的）
编写异常处理器
配置异常处理器（跳转到显示页面）

前端跳转页面

    <!-- 异常处理报错~ -->
    <h3>异常处理</h3>
    <a href="user/testException">异常处理</a>

异常处理 controller 编写

@Controller
@RequestMapping("/user")
public class UserController {
    // 异常处理
    @RequestMapping("/testException")
    public String testException() throws SysException {
        System.out.println("testException。。。");
        try {
            // 模拟异常
            int a = 10/0;
        } catch (Exception e) {
            // 打印异常信息
            e.printStackTrace();
            // 抛出自定义异常信息
            throw new SysException("查询的所有用户出现了错误");
        }
        return "success";
    }
 }

自定义异常器

package cn.gorit.exception;

import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 异常处理器
 * */
public class SysExceptionResolver  implements HandlerExceptionResolver {

    /**
     * 处理异常业务逻辑
     * */
    @Override
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        // 获取异常对象
        SysException e = null;
        if (ex instanceof  SysException) {
            e = (SysException)ex;
        } else {
            e = new SysException("系统正在维护");
        }
        // 创建 ModelAndView 对象
        ModelAndView mv = new ModelAndView();
        mv.addObject("errorMsg", e.getMessage());
        mv.setViewName("error"); // 跳转的页面，这里要记得在 WEB-INF/pages 下编写一个 error.jsp
        return mv;
    }

}

package cn.gorit.exception;

/**
 * 自定义异常类
 * */
public class SysException extends Exception{
    // 存储提示新
    private String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public SysException(String message) {
        this.message = message;
    }
}

springmvc.xml 配置

    <!-- 配置异常处理器 -->
    <bean id="sysExceptionResolver" class="cn.gorit.exception.SysExceptionResolver"></bean>

四、SpringMVC 拦截器

4.1 拦截器作用

二、SpringMVC 常用功能 - 图6

4.2 编写拦截器

二、SpringMVC 常用功能 - 图7

4.3 拦截器编写

前端界面跳转

    <h3>拦截器</h3>
    <a href="test/testIntercepter">拦截器</a>

后端 controller 编写

package cn.gorit.controller;

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

@Controller
@RequestMapping("/test")
public class TestController {
    /**
     * 拦截器
     * */
    @RequestMapping("/testIntercepter")
    public String testIntercepter()  {
        System.out.println("testIntercepter。。。");

        return "success";
    }
}

拦截器类编写

package cn.gorit.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 自定义拦截器
 * */
public class MyInterceptor implements HandlerInterceptor {

    /**
     * 预处理
     * return true 表示放行，执行下一个拦截器，如果没有，则执行 controller方法
     * */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("拦截器执行了");
        return true;
    }

    /**
     * 后处理方法，controller 方法执行之后，success.jsp 执行之前
     * */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("拦截器执行了,succes.jsp 加载之前");
    }

    /**
     * success.jsp 执行了，该方法会执行
     * */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("拦截器执行了 success.jsp 之后");
    }
}

拦截器 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:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
           http://www.springframework.org/schema/mvc
           http://www.springframework.org/schema/mvc/spring-mvc.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <!-- 使用注解开发时，要告知 spring在创建容器时要扫描的包-->
    <context:component-scan base-package="cn.gorit"></context:component-scan>

    <!--    视图解析器对象 -->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>

    <!-- 前端控制器 有哪些静态资源不拦截  释放静态资源，否则静态资源无法访问 -->
    <mvc:resources mapping="/js/**" location="/js/"></mvc:resources>
    <mvc:resources mapping="/css/**" location="/csss/"></mvc:resources>
    <mvc:resources mapping="/images/**" location="/images/"></mvc:resources>

    <!-- 配置拦截器 -->
    <mvc:interceptors>
        <!-- 配置拦截器 -->
        <mvc:interceptor>
            <!-- 要拦截的具体方法 -->
            <mvc:mapping path="/**"/>
            <!-- 不要拦截的方法 -->
<!--            <mvc:exclude-mapping path=""/>-->
            <!-- 配置拦截器对象 -->
            <bean class="cn.gorit.interceptor.MyInterceptor"></bean>
        </mvc:interceptor>
    </mvc:interceptors>

    <!-- 开启 SpringMVC 注解的支持, 自定义类型转换器 -->
    <mvc:annotation-driven/>
</beans>

运行效果
二、SpringMVC 常用功能 - 图8

五、SpringMVC 开发中常用注解

5.1 修饰方法的 bean

5.1.1 Controller

控制层的 bean
5.1.2 RequestMapping 讲解
作用：建立请求 URL 和处理请求方法之间对应的关系。用于处理请求地址映射的注解，可用于类或方法上。

path：指定请求路径 url
value：value 属性和 path 属性是一样的，指定请求的实际地址，指定地址可以使用 URI Template模式，该属性用的最多
method：指定该方法的请求方式：GET、POST、PUT、DELETE 等等
params：指定限制请求参数的条件、仅当 request 请求头中的 Accept 类型中包含该指定类型时才返回
headers：指定限定请求头的条件，发送请求中必须包含指定 header 值，才能使用该方法处理请求
consumes 指定请求的提交内容类型（Content-Type），如 application/JSON, text/html

5.1.3 RestController

ResponseBody + Controller 注解组合，返回 JSON 数据
5.2 修饰请求参数的 bean
5.2.1 RequestParam （请求参数接收）

该方法类似于 Servlet 中 request.getParameter() 获取参数，而 RequestParam 可以使用方法传参的方式获取请求中携带的参数。

作用：

把请求中指定名称的参数给控制器中的形参赋值
用于接收基本数据类型参数

属性：

value：请求参数的名称
required：请求参数中是否必须提交此参数
defaultvalue: 请求参数的默认值

// jsp 代码
<a href="anno/testRequestParam?name=haha">常用注解</a>

@Controller
@RequestMapping("/anno")
public class AnnoController {

    @RequestMapping(value = "/testRequestParam")
    public String testAnno(@RequestParam(name="name") String username) {
        // 这样强制要求必须传 name，否则就把报错
        System.out.println("执行了");
        System.out.println("username:"+username);
        return "success";
    }
}

5.2.2 RequestBody（将返回的视图解析成 JSON 字符串）

PS：在 RestController 中包含了 Controller 和 RequestBody

作用：

用于获取请求体内容，直接使用得到的是 key=value&key1=value1 … 结构的数据
不适合 get 请求方法

赋值

value：请求参数的名称
required：是否必须有请求体，默认为：true，当取值为 get 时，请求方法会报错

// jsp 代码
    <form action="anno/testRequestBody" method="post">
        用户姓名:<input type="text" name="username"><br>
        用户年龄:<input type="text" name="age"><br>
        <input type="submit" value="提交">
    </form>

@Controller
@RequestMapping("/anno")
public class AnnoController {
    /**
     * 获取到请求体的内容
     * */
    @RequestMapping(value = "/testRequestBody")
    public String testRequestBody(@RequestBody String body) {
        System.out.println("执行了。。。");
        System.out.println(body);
        return "success";
    }
}

二、SpringMVC 常用功能 - 图9

5.2.3 PathVariable （获取请求 url 中的占位符数据）

作用：

拥有绑定 url 中的占位符的，例如：url中有/delete/{id}，id 是占位符

属性：

value：指定 url 中的占位符名称

Restful 风格的 URL

请求路径一样，可以根据不同的请求方式执行后台的不同方法
Restful 风格的 URL 优点
- 结构清晰
- 符合标准
- 易于理解
- 扩展方便

// jsp 代码
    <a href="anno/testPathVariable/10">PathVariable</a>

@Controller
@RequestMapping("/anno")
public class AnnoController {

    /**
     * PathVariable 注解
     * */
    @RequestMapping("/testPathVariable/{sid}")
    public String testPathVariable(@PathVariable(name = "sid") String id) {
        System.out.println("执行了。。。");
        System.out.println(id);
        return "success";
    }
}

二、SpringMVC 常用功能 - 图10

5.2.4 RequestHeader

作用：

用于获取请求头消息

属性：

value：提供消息头名称（对应 Request-Headers）
required：是否必须有此请求头

// jsp 代码
    <a href="anno/testRequestHeader">RequestHeader</a>

@Controller
@RequestMapping("/anno")
public class AnnoController {

    /**
     * 获取请求头的值
     * */
    @RequestMapping("/testRequestHeader")
    public String testRequestHeader(@RequestHeader(value = "Accept") String header) {
        System.out.println("执行了。。。");
        System.out.println(header);
        return "success";
    }
}

二、SpringMVC 常用功能 - 图11

5.2.5 CookieValue

作用：

用于把指定 cookie 名称的值传入控制器方法参数

属性：

value：指定 cookie 的名称
required：是否必须有此 cookie

// jsp 代码
    <a href="anno/testCookieValue">CookieValue</a>

@Controller
@RequestMapping("/anno")
public class AnnoController {

    /**
     * 获取 Cookie 的值
     * */
    @RequestMapping("/testCookieValue")
    public String testCookieValue(@CookieValue(value = "JSESSIONID") String cookieValue) {
        System.out.println("执行了。。。");
        System.out.println(cookieValue);
        return "success";
    }
}

二、SpringMVC 常用功能 - 图12

5.2.6 ModelAttribute （接收对象，接收模型数据）

作用：
- 该注解是 SpringMVC 4.3 版本以后加入的，它可以用于修饰方法和参数
- 出现在方法上，表示当前方法会在控制器的方法之前执行，先执行，它可以修饰没有返回值的方法，也可以修饰有具体返回值的方法
- 出现在参数上，获取指定的数据并给参数赋值（它可以直接接受对象）
属性：
- value：用于获取数据的 key， key 可以是 pojo 的属性名称，也可以是 map 结构的 key
应用场景：
- 当表单提交数据不是完整的实体类数据时，保证没有提交数据的字段使用数据库对象的数据
  
  使用 ModelAttribute 会将参数放入 request 域中，一般接收参数只要名称对应即可，可以不用这个注解

示例演示：

form 表单

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>    
<h2>传递对象</h2>
    <form action="login1" method="post">
        账户：<input type="text" name="username" /><br>
        密码：<input type="password" name="password"><br>
        <input type="submit" value="提交">
    </form>
</body>
</html>

实体类：User

public class User {    
    private Integer id;
    private String username;
    private String password;

    getter 和 setter 省略，有参、无参构造方法省略...

对应的 Controller 方法

@Controller
@RequestMapping("/")
public class AnnoController {

    // 这个 ModelAttribute 属性是不能乱改动的
    @RequestMapping("/login1")
    public String login1(@ModelAttribute("u") User u) {
        System.out.println(u.toString());
        return "index.jsp";
    }

}

index.jsp 页面

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h3>我进入了 jsp 页面,欢迎你 </h3>
    <h3>${u.username}  ${u.password}</h3>
</body>
</html>

补充解释：

ModelAttribute将接收的参数打包成一个对象，并把对象存在request域中，如果我们使用重定向的话，就得使用 Session 存取数据

index.html

index.jsp

5.2.7 SessionAttribute

作用：

用于多次执行控制器方法间的参数共享。
可以作用于类上，这样该类下的所有方法都会包含 session 域中的信息

属性：

value：用于指定存入的属性的名称
type：用于指定存入的数据类型

// jsp 代码
    <a href="anno/testSessionAttributes">SessionAttributes</a>

// java 代码 存到 request 域当中
@Controller
@RequestMapping("/anno")
public class AnnoController {
    /**
     * testSessionAttributes 注解
     * */
    @RequestMapping("/testSessionAttributes")
    public String testSessionAttributes(Model model) {
        System.out.println("testSessionAttributes 执行了。。。");
        // 底层会存储到 request 域对象中
        model.addAttribute("msg","World");
        return "success";
    }

}

// 存到 session 对象中
@Controller
@RequestMapping("/anno")
@SessionAttributes(value = {"msg"}) // 把 msg=World 存入到 session域中 （新增）
public class AnnoController {
    /**
     * testSessionAttributes 注解
     * */
    @RequestMapping("/testSessionAttributes")
    public String testSessionAttributes(Model model) {
        System.out.println("testSessionAttributes 执行了。。。");
        // 底层会存储到 request 域对象中
        model.addAttribute("msg","World");
        return "success";
    }

}

// pages/success.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h3>跳转成功了</h3>
    ${requestScope}

    ${sessionScope}
</body>
</html>

显示 request 域
二、SpringMVC 常用功能 - 图15

显示 session 域
二、SpringMVC 常用功能 - 图16

5.3 JSON 数据一些设置

PS：加入 JSON解析包的依赖，以下注解均用于实体类的属性中

<!--        json 解析-->
        <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-core</artifactId>
            <version>2.10.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.10.0</version>
        </dependency>

5.3.1 JsonIgnore

功能：筛除一些不需要返回到前台的属性
场景：我们想要返回一个实体类给前端，但是实体类包含password 字段，我们给该字段加上该注解，password 字段就不会返回至前端啦

5.3.2 JsonProperty

功能：给请求和返回的属性换一个别名
场景：如果返回的字段和数据库字段一致，容易导致数据库被逆向黑掉

5.3.3 Jsoninclude

功能：筛除某些不符合条件的属性
场景，比如返回的参数如果是空值，使用了如下注解，空值数据就不会返回啦

@JsonInclude(value = JsonInclude.Include.NON_NULL)
private String email;

5.3.4 JsonFormat

功能：返回格式化的数据

    @JsonFormat(pattern = "yyyy-MM-dd hh:mm:ss",locale = "zh",timezone = "GMT+8")
   v private Date makeTime;

六、SpringMVC 使用 JSR303 校验

6.1 导入 maven 依赖

    <dependency>
      <groupId>javax.validation</groupId>
      <artifactId>validation-api</artifactId>
      <version>1.1.0.Final</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-validator</artifactId>
      <version>5.1.2.Final</version>
    </dependency>

6.2 编写实体类

import org.hibernate.validator.constraints.Length;

import javax.validation.constraints.NotNull;
import javax.validation.constraints.Pattern;

public class Users {
    @NotNull
    private String account;
    @Length(max = 6,min = 4)
    private String passwrod;
    private String gender;
    private int age;
    @Pattern(regexp = "^\\d{11}$",message = "手机号长度不对")
    private String phoneNum;
    private String idCard;

    // getter 和 setter 省略，构造方法省略
}

6.3 编写控制层

package cn.gorit.controller;

import cn.gorit.entity.Users;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.validation.ObjectError;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.validation.Valid;

@Controller
public class UsersController {

    //跳转至注册的方法
    @RequestMapping("/toregesiter")
    public String tozhuce() {
        return "zhuce";
    }

    //bindingResult 获取校验的信息，服务单校验数使用
    @RequestMapping("/regesiter")
    public String zhuce(@Valid Users u, BindingResult br) {
        System.out.println(u.getAccount()+" "+u.getPhoneNum());
        for (ObjectError oe : br.getAllErrors()) {
            System.out.println(oe.getDefaultMessage());
        }
        if(br.hasErrors()) {
            return "zhuce";
        }
        return "index";
    }
}

6.4 前端页面编写

获取项目路径：${pageContext.request.contextPath}

    <form action="${pageContext.request.contextPath}/regesiter" method="post">
        <label>用户名：</label>
        <input type="text" name="account" /><br/>
        <label>密码：</label>
        <input type="password" name="passwrod" /><br/>
        <label>性别：</label>
        <input type="radio" name="gender" value="男" />男
        <input type="radio" name="gender" value="女" />女<br/>
        <label>年龄：</label>
        <input type="text" name="age" /><br/>
        <label>电话：</label>
        <input type="text" name="phoneNum" /><br/>
        <label>身份证：</label>
        <input type="text" name="idCard" /><br/>
        <input type="submit" value="注册" />
    </form>

二、SpringMVC 常用功能