SpringMVC基础-08-数据转换 & 数据格式化 & 数据校验

代码示例

Department.java:

package com.atguigu.bean;

public class Department {

    private Integer id;
    private String departmentName;

    public Department() {
    }
    
    public Department(int i, String string) {
        this.id = i;
        this.departmentName = string;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getDepartmentName() {
        return departmentName;
    }

    public void setDepartmentName(String departmentName) {
        this.departmentName = departmentName;
    }

    @Override
    public String toString() {
        return "Department [id=" + id + ", departmentName=" + departmentName + "]";
    }
    
}

Employee.java:

package com.atguigu.bean;

import java.util.Date;

import javax.validation.constraints.Future;
import javax.validation.constraints.Past;

import org.hibernate.validator.constraints.Email;
import org.hibernate.validator.constraints.Length;
import org.hibernate.validator.constraints.NotEmpty;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.format.annotation.NumberFormat;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;

public class Employee {

    private Integer id;
    
    @NotEmpty(message="不能为空")
    @Length(min=5,max=17,message="我错了")
    private String lastName;

    
    @Email
    private String email;
    //1 male, 0 female
    private Integer gender;
    

    //规定页面提交的日期格式  
    //@Past：必须是一个过去的时间
    //@Future ：必须是一个未来的时间
    @DateTimeFormat(pattern="yyyy-MM-dd")
@Past
    @JsonFormat(pattern="yyyy-MM-dd")
    private Date birth = new Date();
    
    //假设页面，为了显示方便提交的工资是  ￥10,000.98
    @NumberFormat(pattern="#,###.##")
    private Double salary;
    
    @JsonIgnore
    private Department department;
    
    
    /**
     * @return the birth
     */
    public Date getBirth() {
        return birth;
    }

    /**
     * @param birth the birth to set
     */
    public void setBirth(Date birth) {
        this.birth = birth;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Integer getGender() {
        return gender;
    }

    public void setGender(Integer gender) {
        this.gender = gender;
    }

    public Department getDepartment() {
        return department;
    }

    public void setDepartment(Department department) {
        this.department = department;
    }

    public Employee(Integer id, String lastName, String email, Integer gender,
            Department department) {
        super();
        this.id = id;
        this.lastName = lastName;
        this.email = email;
        this.gender = gender;
        this.department = department;
    }

    public Employee() {
    }

    /* (non-Javadoc)
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        return "Employee [id=" + id + ", lastName=" + lastName + ", email="
                + email + ", gender=" + gender + ", birth=" + birth
                + ", department=" + department + "]";
    }
}

MyStringToEmployeeConverter.java:

package com.atguigu.component;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.convert.converter.Converter;

import com.atguigu.bean.Employee;
import com.atguigu.dao.DepartmentDao;

/**
 * 两个返回
 * 
 * S：Source T：Target 将s转为t
 * 
 * 
 */
public class MyStringToEmployeeConverter implements Converter<String, Employee> {

    @Autowired
    DepartmentDao departmentDao;
    
    /**
     * 自定义的转换规则
     */
    @Override
    public Employee convert(String source) {
        // TODO Auto-generated method stub
        // empAdmin-admin@qq.com-1-101
        System.out.println("页面提交的将要转换的字符串" + source);
        Employee employee = new Employee();
        if (source.contains("-")) {
            String[] split = source.split("-");
            employee.setLastName(split[0]);
            employee.setEmail(split[1]);
            employee.setGender(Integer.parseInt(split[2]));
            employee.setDepartment(departmentDao.getDepartment(Integer.parseInt(split[3])));
        }
        return employee;
    }

}

AjaxTestController.java:

package com.atguigu.controller;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Collection;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.atguigu.bean.Employee;
import com.atguigu.dao.EmployeeDao;

@Controller
public class AjaxTestController {
    
    @Autowired
    EmployeeDao employeeDao;
    
    /**
     * SpringMVC文件下载；
     * 
     * @param request
     * @return
     * @throws Exception
     */
    @RequestMapping("/download")
    public ResponseEntity<byte[]> download(HttpServletRequest request) throws Exception{
        
        //1、得到要下载的文件的流；
        //找到要下载的文件的真实路径
        ServletContext context = request.getServletContext();
        String realPath = context.getRealPath("/scripts/jquery-1.9.1.min.js");
        FileInputStream is = new FileInputStream(realPath);
        
        byte[] tmp = new byte[is.available()];
        is.read(tmp);
        is.close();
        
        //2、将要下载的文件流返回
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.set("Content-Disposition", "attachment;filename="+"jquery-1.9.1.min.js");
        
        return new ResponseEntity<byte[]>(tmp, httpHeaders, HttpStatus.OK);
    }
    
    /**
     * 将返回数据放在响应体中
     * 
     * ResponseEntity<String>：响应体中内容的类型
     * @return
     */
    //@ResponseBody
    @RequestMapping("/haha")
    public ResponseEntity<String> hahah(){
        
        MultiValueMap<String, String> headers = new HttpHeaders();
        String body = "<h1>success</h1>";
        headers.add("Set-Cookie", "username=hahahaha");
        
        return new ResponseEntity<String>(body , headers, HttpStatus.OK);
    }

    
    /**
     * 如果参数位置写HttpEntity<String>  str;
     * 比@RequestBody更强，可以拿到请求头；
     *  @RequestHeader("")
     * 
     * @param str
     * @return
     */
    @RequestMapping("/test02")
    public String test02(HttpEntity<String>  str){
        System.out.println(str);
        return "success";
    }
    
    /**
     * 
     */
    @RequestMapping("/test01")
    public String test01(@RequestBody String str){
        System.out.println("请求体："+str);
        return "success";
    }
    
    /**
     *  @RequestBody:请求体；获取一个请求的请求体
     *  @RequestParam:
     *  
     *  @ResponseBody：可以把对象转为json数据，返回给浏览器
     *  
     *  @RequestBody：接收json数据，封装为对象
     * @return
     */
    @RequestMapping("/testRequestBody")
    public String testRequestBody(@RequestBody Employee employee){
        System.out.println("请求体："+employee);
        return "success";
    }
    
    /**
     * 将返回的数据放在响应体中；
     * 如果是对象，jackson包自动将对象转为json格式
     * @return
     */
@ResponseBody
    @RequestMapping("/getallajax")
    public Collection<Employee> ajaxGetAll(){
        Collection<Employee> all = employeeDao.getAll();
        return all;
    }

}

EmployeeController.java:

package com.atguigu.controller;

import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.validation.Valid;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

import com.atguigu.bean.Department;
import com.atguigu.bean.Employee;
import com.atguigu.dao.DepartmentDao;
import com.atguigu.dao.EmployeeDao;

@Controller
public class EmployeeController {

    @Autowired
    EmployeeDao employeeDao;

    @Autowired
    DepartmentDao departmentDao;

    /**
     * 发送的请求是什么？
     * 
     * quickadd?empinfo=empAdmin-admin@qq.com-1-101
     * 
     * @RequestParam("empinfo")Employee employee; Employee employee =
     *                                  request.getParameter("empinfo");
     * 
     *                                  可以通过写一个自定义类型的转换器让其工作；
     * @param employee
     * @return
     */
    @RequestMapping("/quickadd")
    public String quickAdd(@RequestParam("empinfo") Employee employee) {
        System.out.println("封装：" + employee);
        employeeDao.save(employee);
        return "redirect:/emps";
    }

    /**
     * 查询所有员工
     * 
     * @return
     */
    @RequestMapping("/emps")
    public String getEmps(Model model) {
        Collection<Employee> all = employeeDao.getAll();
        model.addAttribute("emps", all);
        return "list";
    }

    @RequestMapping(value = "/emp/{id}", method = RequestMethod.DELETE)
    public String deleteEmp(@PathVariable("id") Integer id) {
        employeeDao.delete(id);
        return "redirect:/emps";
    }

    /**
     * 查询员工，来到修改页面回显
     * 
     * @param id
     * @param model
     * @return
     */
    @RequestMapping(value = "/emp/{id}", method = RequestMethod.GET)
    public String getEmp(@PathVariable("id") Integer id, Model model) {
        // 1、查出员工信息
        Employee employee = employeeDao.get(id);
        // 2、放在请求域中
        model.addAttribute("employee", employee);
        // 3、继续查出部门信息放在隐含模型中
        Collection<Department> departments = departmentDao.getDepartments();
        model.addAttribute("depts", departments);
        return "edit";
    }

    @RequestMapping(value = "/emp/{id}", method = RequestMethod.PUT)
    public String updateEmp(@ModelAttribute("employee") Employee employee/*
                                                                         */) {
        System.out.println("要修改的员工：" + employee);
        // xxxx 更新保存二合一；
        employeeDao.save(employee);
        return "redirect:/emps";
    }

    @ModelAttribute
    public void myModelAttribute(
            @RequestParam(value = "id", required = false) Integer id,
            Model model) {
        if (id != null) {
            Employee employee = employeeDao.get(id);
            model.addAttribute("employee", employee);
        }
        System.out.println("hahha ");
        // 1、先查出所有部门
        Collection<Department> departments = departmentDao.getDepartments();
        // 2、放在请求域中
        model.addAttribute("depts", departments);
    }

    /**
     * 保存员工
     * 
     * @param employee
     * @return
     */
    @RequestMapping(value = "/emp", method = RequestMethod.POST)
    public String addEmp(@Valid Employee employee, BindingResult result,
            Model model) {
        System.out.println("要添加的员工：" + employee);
        // 获取是否有校验错误
        boolean hasErrors = result.hasErrors();
        Map<String, Object> errorsMap = new HashMap<String, Object>();
        if (hasErrors) {
            List<FieldError> errors = result.getFieldErrors();
            for (FieldError fieldError : errors) {
                
                System.out.println("错误消息提示：" + fieldError.getDefaultMessage());
                System.out.println("错误的字段是？" + fieldError.getField());
                System.out.println(fieldError);
                System.out.println("------------------------");
                errorsMap.put(fieldError.getField(),
                        fieldError.getDefaultMessage());
            }
            model.addAttribute("errorInfo", errorsMap);
            System.out.println("有校验错误");
            return "add";
        } else {
            employeeDao.save(employee);
            // 返回列表页面；重定向到查询所有员工的请求
            return "redirect:/emps";
        }
    }

    /**
     * 去员工添加页面，去页面之前需要查出所有部门信息，进行展示的
     * 
     * @return
     */
    @RequestMapping("/toaddpage")
    public String toAddPage(Model model) {

        model.addAttribute("employee", new Employee());
        // 3、去添加页面
        return "add";
    }

}

HelloController.java:

package com.atguigu.controller;

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

@Controller
public class HelloController {
    
    @RequestMapping("/hello")
    public String handle01(){
        return "success";
    }

}

DepartmentDao.java:

package com.atguigu.dao;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

import org.springframework.stereotype.Repository;

import com.atguigu.bean.Department;

/**
 * 操作部门的dao
 * @author lfy
 *
 */
@Repository
public class DepartmentDao {

    private static Map<Integer, Department> departments = null;
    
    static{
        departments = new HashMap<Integer, Department>();
        
        departments.put(101, new Department(101, "D-AA"));
        departments.put(102, new Department(102, "D-BB"));
        departments.put(103, new Department(103, "D-CC"));
        departments.put(104, new Department(104, "D-DD"));
        departments.put(105, new Department(105, "D-EE"));
    }
    
    /**
     * 返回所有的部门
     * @return
     */
    public Collection<Department> getDepartments(){
        return departments.values();
    }
    
    /**
     * 按照部门id查询部门
     * @param id
     * @return
     */
    public Department getDepartment(Integer id){
        return departments.get(id);
    }
    
}

EmployeeDao.java:

package com.atguigu.dao;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import com.atguigu.bean.Department;
import com.atguigu.bean.Employee;


/**
 * EmployeeDao：操作员工
 * @author lfy
 *
 */
@Repository
public class EmployeeDao {

    private static Map<Integer, Employee> employees = null;
    
    @Autowired
    private DepartmentDao departmentDao;
    
    static{
        employees = new HashMap<Integer, Employee>();

        employees.put(1001, new Employee(1001, "E-AA", "aa@163.com", 1, new Department(101, "D-AA")));
        employees.put(1002, new Employee(1002, "E-BB", "bb@163.com", 1, new Department(102, "D-BB")));
        employees.put(1003, new Employee(1003, "E-CC", "cc@163.com", 0, new Department(103, "D-CC")));
        employees.put(1004, new Employee(1004, "E-DD", "dd@163.com", 0, new Department(104, "D-DD")));
        employees.put(1005, new Employee(1005, "E-EE", "ee@163.com", 1, new Department(105, "D-EE")));
    }
    
    //初始id
    private static Integer initId = 1006;
    
    /**
     * 员工保存/更新二合一方法；
     * @param employee
     */
    public void save(Employee employee){
        if(employee.getId() == null){
            employee.setId(initId++);
        }
        
        //根据部门id单独查出部门信息设置到员工对象中，页面提交的只需要提交部门的id
        employee.setDepartment(departmentDao.getDepartment(employee.getDepartment().getId()));
        employees.put(employee.getId(), employee);
    }
    
    /**
     * 查询所有员工
     * @return
     */
    public Collection<Employee> getAll(){
        return employees.values();
    }
    
    /**
     * 按照id查询某个员工
     * @param id
     * @return
     */
    public Employee get(Integer id){
        return employees.get(id);
    }
    
    /**
     * 删除某个员工
     * @param id
     */
    public void delete(Integer id){
        employees.remove(id);
    }
}

errors_en_US.properties:

#Email.email=email incorrect!~~
Email=email buzhengque~~~
NotEmpty=must not empty~~
Length.java.lang.String= length incorrect ,must between {2} and {1} ~~
Past=must a past time~~~
typeMismatch.birth=birth geshi buzhengque

errors_zh_CN.properties:

Email.email=u90AEu7BB1u4E0Du5BF9!~~
NotEmpty=u4E0Du80FDu4E3Au7A7A~~
Length.java.lang.String= u957Fu5EA6u4E0Du5BF9~~
Past=u65F6u95F4u5FC5u987Bu662Fu8FC7u53BBu7684~~~
typeMismatch.birth=u751Fu65E5u7684u683Cu5F0Fu4E0Du6B63u786E

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

    <context:component-scan base-package="com.atguigu"></context:component-scan>
    
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>

    <!-- 默认前端控制器是拦截所有资源（除过jsp），js文件就404了；要js文件的请求是交给tomcat处理的
    http://localhost:8080/7.SpringMVC_crud/scripts/jquery-1.9.1.min.js -->
    <!-- 告诉SpringMVC，自己映射的请求就自己处理，不能处理的请求直接交给tomcat -->
    <!-- 静态资源能访问，动态映射的请求就不行 -->
    <mvc:default-servlet-handler/>
    <!-- springmvc可以保证动态请求和静态请求都能访问 -->
    
    <!-- conversion-service="conversionService"：使用我们自己配置的类型转换组件 -->
    <mvc:annotation-driven conversion-service="conversionService"></mvc:annotation-driven>
    
    <!-- 告诉SpringMVC别用默认的ConversionService，
            而用我自定义的ConversionService、可能有我们自定义的Converter； -->
    <!-- 以后写自定义类型转换器的时候，就使用FormattingConversionServiceFactoryBean来注册；
    既具有类型转换还有格式化功能 -->
    <bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
        <!--converters转换器中添加我们自定义的类型转换器  -->
        <property name="converters">
            <set>
                <bean class="com.atguigu.component.MyStringToEmployeeConverter"></bean>
            </set>
        </property>
    </bean>
    
    <!-- 管理国际化资源文件 -->
    <bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
        <property name="basename" value="errors"></property>
    </bean>
</beans>

web.xml:

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         id="WebApp_ID" version="3.0">
    <display-name>8.SpringMVC_dataBinder</display-name>
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>

    <!-- The front controller of this Spring Web application,
    responsible for handling all application requests -->
    <servlet>
        <servlet-name>springDispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <!-- contextConfigLocation:指定SpringMVC配置文件位置 -->
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!-- Map all requests to the DispatcherServlet for handling -->
    <servlet-mapping>
        <servlet-name>springDispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!-- 配置一个字符编码的Filter；一定注意：字符编码filter一般都在其他Filter之前； -->
    <!--配置字符集编码的Filter-->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <!-- encoding：指定解决POST请求乱码 -->
        <init-param>
            <param-name>encoding</param-name>
            <!--不区分大小写-->
            <param-value>utf-8</param-value>
        </init-param>
        <init-param>
            <!-- forceEncoding:顺手解决响应乱码；response.setCharacterEncoding(this.encoding); -->
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!--支持Rest风格的Filter（开启PUT、DELETE请求）-->
    <filter>
        <filter-name>HiddenHttpMethodFilter</filter-name>
        <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>HiddenHttpMethodFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!-- 使用SpringMVC前端控制器写完就直接写字符编码过滤器；
        Tomcat一装上，上手就是server.xml的8080处添加URIEncoding="UTF-8"
     -->

</web-app>

emps.jsp:

<%@page import="java.util.Date"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
<%
    pageContext.setAttribute("ctp", request.getContextPath());
%>
<script type="text/javascript" src="scripts/jquery-1.9.1.min.js"></script>
</head>
<body>
<%=new Date() %>
<a href="${ctp }/getallajax">ajax获取所有员工</a><br/>

<div>

</div>
<script type="text/javascript">
    $("a:first").click(function(){
        //1、发送ajax获取所有员工上
        $.ajax({
            url:"${ctp}/getallajax",
            type:"GET",
            success:function(data){
                //console.log(data);
                $.each(data,function(){
                    var empInfo = this.lastName+"-->"+this.birth+"--->"+this.gender;
                    $("div").append(empInfo+"<br/>");
                });
            }
        });
        
        return false;
    });
</script>
</body>
</html>

index.jsp:

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!-- 访问项目就要展示员工列表页面 -->
<jsp:forward page="/emps"></jsp:forward>

testOther.jsp:

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
<%
    pageContext.setAttribute("ctp", request.getContextPath());
%>
</head>
<script type="text/javascript" src="scripts/jquery-1.9.1.min.js"></script>
<body>
    <form action="${ctp }/test02" method="post"
        enctype="multipart/form-data">
        <input name="username" value="tomcat" /> <input name="password"
            value="123456"> <input type="file" name="file" /> <input
            type="submit" />
    </form>
    <a href="${ctp }/testRequestBody">ajax发送json数据</a>
</body>
<script type="text/javascript">
    $("a:first").click(function() {
        //点击发送ajax请求，请求带的数据是json
        var emp = {
            lastName : "张三",
            email : "aaa@aa.com",
            gender : 0
        };
        //alert(typeof emp);
        //js对象
        var empStr = JSON.stringify(emp);
        //alert(typeof empStr);
        $.ajax({
            url : '${ctp}/testRequestBody',
            type : "POST",
            data : empStr,
            contentType : "application/json",
            success : function(data) {
                alert(data);
            }
        });
        return false;
    });
</script>
</html>

add.jsp:

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>员工添加</h1>
<!-- 
表单标签； 
    通过 SpringMVC的表单标签可以实现将模型数据中的属性和 HTML 表单元素相绑定，
    以实现表单数据更便捷编辑和表单值的回显
    1）、SpringMVC认为，表单数据中的每一项最终都是要回显的；
        path指定的是一个属性；这个属性是从隐含模型（请求域中取出的某个对象中的属性）；
        path指定的每一个属性，请求域中必须有一个对象，拥有这个属性；
                这个对象就是请求域中的command；
        modelAttribute=""：
        1)、以前我们表单标签会从请求域中获取一个command对象；把这个对象中的每一个属性对应的显示出来
        2)、可以告诉SpringMVC不要去取command的值了，我放了一个modelAttribute指定的值；
            取对象用的key就用我modelAttribute指定的；
-->
<%
    pageContext.setAttribute("ctp", request.getContextPath());
%>
<form:form action="${ctp }/emp" modelAttribute="employee" method="POST">
    <!-- path就是原来html-input的name项：需要写 
        path：
            1）、当做原生的name项
            2）、自动回显隐含模型中某个对象对应的这个属性的值
    -->
    lastName:<form:input path="lastName"/>
        <form:errorspath="lastName"/>-->${errorInfo.lastName }
    <br/>
    email:<form:input path="email"/>
        <form:errors path="email"/>-->${errorInfo.email }
        <br/>
    gender:<br/>
        男：<form:radiobutton path="gender" value="1"/><br/>
        女：<form:radiobutton path="gender" value="0"/><br/>
    birth:<form:input path="birth"/>
        <form:errors path="birth"/>--->${errorInfo.birth }
        <br/>
    dept:
        <!-- 
        items=""：指定要遍历的集合 ；自动遍历；遍历出的每一个元素是一个department对象
        itemLabel="属性名"：指定遍历出的这个对象的哪个属性是作为option标签体的值
        itemValue="属性名"：指定刚才遍历出来的这个对象的哪个属性是作为要提交 的value值
         -->
        <form:select path="department.id" 
            items="${depts }" 
            itemLabel="departmentName" 
            itemValue="id"></form:select><br/>
    <input type="submit" value="保存"/>
</form:form>




<!-- (Employee) -->
<%-- <form action="">
    lastName：<input type="text" name="lastName"/><br/>
    email:<input type="text" name="email"/><br/>
    gender：  <br/>
        男：<input type="radio" name="gender" value="1"/><br/>
        女：<input type="radio" name="gender" value="0"><br/>
    dept:
        <select name="department.id">
            <c:forEach items="${depts }" var="deptItem">
                <!-- 标签体中的是在页面的提示选项信息，value才是真正提交的值 -->
                <option value="${deptItem.id }">${deptItem.departmentName }</option>
            </c:forEach>
        </select>
    <input type="submit" value="提交"/>
</form> --%>
</body>
</html>

edit.jsp:

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
<%
    pageContext.setAttribute("ctp", request.getContextPath());
%>
</head>
<body>
<h1>员工修改页面</h1>
<!-- modelAttribute：这个表单的所有内容显示绑定的是请求域中 employee的值-->
<form:form action="${ctp }/emp/${employee.id }" 
    modelAttribute="employee" method="post">
    <input type="hidden" name="_method" value="put"/>
    <input type="hidden" name="id" value="${employee.id }"/>
    email:<form:input path="email"/><br/>
    gender:&nbsp;&nbsp;&nbsp;
        男:<form:radiobutton path="gender" value="1"/>&nbsp;&nbsp;&nbsp;
        女:<form:radiobutton path="gender" value="0"/><br/>
    dept:
        <form:select path="department.id" items="${depts }"
            itemLabel="departmentName" itemValue="id"></form:select>
            <br/>
    <input type="submit" value="修改"/>

</form:form>
</body>
</html>

list.jsp:

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<%
        pageContext.setAttribute("ctp", request.getContextPath());
%>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>员工列表</title>
<script type="text/javascript" src="${ctp }/scripts/jquery-1.9.1.min.js"></script>
</head>
<body>
    
    <h1>员工列表</h1>
    <table border="1" cellpadding="5" cellspacing="0">
        <tr>
            <th>ID</th>
            <th>lastName</th>
            <th>email</th>
            <th>gender</th>
            <th>birth</th>
            <th>departmentName</th>
            <th>EDIT</th>
            <th>DELETE</th>
        </tr>
        <c:forEach items="${emps }" var="emp">
            <tr>
                <td>${emp.id }</td>
                <td>${emp.lastName}</td>
                <td>${emp.email }</td>
                <td>${emp.gender==0?"女":"男" }</td>
                <td>${emp.birth}</td>
                <td>${emp.department.departmentName }</td>
                <td><a href="${ctp }/emp/${emp.id }">edit</a></td>
                <td><a href="${ctp }/emp/${emp.id }" class="delBtn">delete</a></td>
            </tr>
        </c:forEach>
    </table>
    <a href="${ctp }/toaddpage">添加员工</a><br/>
    
    <form action="${ctp }/quickadd">
        <!--将员工的所有信息都写上，自动封装对象  -->
        <input name="empinfo" value="empAdmin-admin@qq.com-1-101"/>
        <input type="submit" value="快速添加"/>
    </form>
    
    <form id="deleteForm" action="${ctp }/emp/${emp.id }" method="post">
        <input type="hidden" name="_method" value="DELETE" /> 
    </form>
    <script type="text/javascript">
        $(function(){
            $(".delBtn").click(function(){
                //0、确认删除？
                //1、改变表单的action指向；
                $("#deleteForm").attr("action",this.href);
                //2、提交表单；
                $("#deleteForm").submit();
                return false;
            });
        });
    </script>
</body>
</html>

success.jsp:

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>成功！</h1>
jackson-annotations-2.1.5.jar
jackson-core-2.1.5.jar
jackson-databind-2.1.5.jar
</body>
</html>

 相关依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>SpringMVC</artifactId>
        <groupId>com.atguigu</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <packaging>war</packaging>
    <artifactId>8.SpringMVC_dataBinder</artifactId>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.apache.taglibs/taglibs-standard-impl -->
        <dependency>
            <groupId>org.apache.taglibs</groupId>
            <artifactId>taglibs-standard-impl</artifactId>
            <version>1.2.5</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.taglibs/taglibs-standard-spec -->
        <dependency>
            <groupId>org.apache.taglibs</groupId>
            <artifactId>taglibs-standard-spec</artifactId>
            <version>1.2.5</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.hibernate.validator/hibernate-validator -->
        <dependency>
            <groupId>org.hibernate.validator</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>6.1.5.Final</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.11.0</version>
        </dependency>


    </dependencies>

</project>