Spring MVC学习

Spring MVC学习

一、HelloWorld搭建

搭建工程

配置maven工程

创建工程SpringMVC，在工程下创建ModuleSpringMVC-demo1。在SpringMVC-demo1下搭建Maven工程，在pom.xml中，设置打包方式为war，并加入依赖，如下。

<?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>

    <artifactId>SpringMVC-demo1</artifactId>
	
	<!--设置打包方式-->
    <packaging>war</packaging>

    <dependencies>
        <!-- SpringMVC -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.1</version>
        </dependency>

        <!-- 日志 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>

        <!-- ServletAPI -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>

        <!-- Spring5和Thymeleaf整合包 -->
        <dependency>
            <groupId>org.thymeleaf</groupId>
            <artifactId>thymeleaf-spring5</artifactId>
            <version>3.0.12.RELEASE</version>
        </dependency>
    </dependencies>

</project>

配置web.xml

注册SpringMVC的前端控制器DispatcherServlet。

新建src\main\webapp文件夹。

在Project Structure设置中，在对应的Module下的web栏目，添加web.xml至路径工程路径\SpringMVC\SpringMVC-demo1\src\main\webapp\Web-INF\web.xml。

web.xml有两种配置方式，默认配置方式与扩展配置方式。

a>默认配置方式

此配置作用下，SpringMVC的配置文件默认位于WEB-INF下，默认名称为<servlet-name>-servlet.xml，例如，以下配置所对应SpringMVC的配置文件位于WEB-INF下，文件名为springMVC-servlet.xml。

<!-- 配置SpringMVC的前端控制器，对浏览器发送的请求统一进行处理 -->
<servlet>
    <servlet-name>springMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>springMVC</servlet-name>
    <!--
        设置springMVC的核心控制器所能处理的请求的请求路径
        /所匹配的请求可以是/login或.html或.js或.css方式的请求路径
        但是/不能匹配.jsp请求路径的请求
    -->
    <url-pattern>/</url-pattern>
</servlet-mapping>

b>扩展配置方式

可通过<init-param>标签设置SpringMVC配置文件的位置和名称，通过<load-on-startup>标签设置SpringMVC前端控制器DispatcherServlet的初始化时间。

<!-- 配置SpringMVC的前端控制器，对浏览器发送的请求统一进行处理 -->
<servlet>
    <servlet-name>springMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 通过初始化参数指定SpringMVC配置文件的位置和名称 -->
    <init-param>
        <!-- contextConfigLocation为固定值 -->
        <param-name>contextConfigLocation</param-name>
        <!-- 使用classpath:表示从类路径查找配置文件，例如maven工程中的src/main/resources -->
        <param-value>classpath:springMVC.xml</param-value>
    </init-param>
    <!-- 
 		作为框架的核心组件，在启动过程中有大量的初始化操作要做
		而这些操作放在第一次请求时才执行会严重影响访问速度
		因此需要通过此标签将启动控制DispatcherServlet的初始化时间提前到服务器启动时
	-->
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>springMVC</servlet-name>
        <!--
        1. / :设置springMVC的核心控制器所能处理的请求的请求路径
        /所匹配的请求可以是/login或.html或.js或.css方式的请求路径
        但是/不能匹配.jsp请求路径的请求；
        2. /* : 包括.jsp在内的所有请求；
        -->
    <url-pattern>/</url-pattern>
</servlet-mapping>

创建请求控制器

由于前端控制器对浏览器发送的请求进行了统一的处理，但是具体的请求有不同的处理过程，因此需要创建处理具体请求的类，即请求控制器。

请求控制器中每一个处理请求的方法成为控制器方法。

因为SpringMVC的控制器由一个POJO（普通的Java类）担任，因此需要通过@Controller注解将其标识为一个控制层组件，交给Spring的IoC容器管理，此时SpringMVC才能够识别控制器的存在。

新建src/main/java/com/atguigu/mvc/controller文件夹，这里存放控制器。

创建springMVC的扩展配置文件（配置DispatcherServlet）

这个配置文件就是web.xml中的声明的扩展配置，新建src/main/resources/springMVC.xml。

这里设置了扫描组件<context:component-scan>，我们在控制器类上声明了@Controller，Spring MVC是无法直接找到这是一个控制器的，需要扫描组件进行指定扫描，才能找到声明为控制器的类。

这里配置了Thymeleaf视图解析器，对控制器返回的内容，进行解析。这里解析主要是在请求名称前面加上前缀与后缀，之后找到对应的页面，并实现跳转。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    
    <!--  扫描组件  -->
    <context:component-scan base-package="com.atguigu.mvc.controller"></context:component-scan>

    <!-- 配置Thymeleaf视图解析器 -->
    <bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
        <property name="order" value="1"/>
        <property name="characterEncoding" value="UTF-8"/>
        <property name="templateEngine">
            <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
                <property name="templateResolver">
                    <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
                        <!--在请求名称前面加上前缀和后缀，找到对应的页面，实现跳转-->
                        <!-- 视图前缀 -->
                        <property name="prefix" value="/WEB-INF/templates/"/>
                        
                        <!-- 视图后缀 -->
                        <property name="suffix" value=".html"/>
                        <property name="templateMode" value="HTML5"/>
                        <property name="characterEncoding" value="UTF-8" />
                    </bean>
                </property>
            </bean>
        </property>
    </bean>

</beans>

HelloWorld控制器编写

在src/main/java/com/atguigu/mvc/controller下新建HelloController.java。

这里通过@Controller声明这是一个控制器类。

添加类方法，这里的方法名与我们的请求没有直接的联系，那么是如何通过url请求找到对应的控制器方法呢。是通过@RequestMapping注解。

@RequestMapping：处理请求和控制器方法之间的映射关系。注解中的value属性可以与请求地址匹配（当只填写value属性时，可以省略value标注，直接填写匹配请求）。

package com.atguigu.mvc.controller;

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

@Controller
public class HelloController {

    // "/" --> /WEB-INF/templates/index.html
	
    //创建映射关系
    // @RequestMapping(value = "/") 只有value属性，可以省略
    @RequestMapping("/")
    public String index() {
        // 返回视图名称, 再通过视图解析器，加上前缀，加上后缀，寻找目标页面；
        return "index";
    }

    @RequestMapping("/target")
    public String toTarget() {
        return "target";
    }

}

页面编写

在src/main/resources/springMVC.xml中，视图解析器配置视图前缀为<property name="prefix" value="/WEB-INF/templates/"/>，所以视图文件都放在这个文件夹下。

新建src/main/webapp/WEB-INF/templates包，在templates下新建index.html, target.html页面。我们在index.html中要实现点击跳转target.html。

index.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>:)</h1>
    <!-- 这里两种跳转效果相同，如果设置为 /target ,则无法跳转成功，这里就变成了绝对路径访问。 -->
<!--    <a href="target">跳转target.html</a>-->
    <a th:href="@{/target}">跳转target.html</a>
</body>
</html>

target.html

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

可以在设置中，更改html生成模板，加入xmlns:ht="http://www.thymeleaf.org"，更加快捷。

配置Tomcat服务器

在Run/Debug Configurations中，添加Tomcat Server。

之后在添加的Tomcat Server中添加Artifact，这里注意pom配置了打包方式为war，这里才会有Artifact。


设置Name为springMVC，On ‘Update’ action设置为 Redeploy，On frame deactivation为 Update classes and resources。

在Deployment栏中，下面的Application context设置的是上下文访问路径，这里设置为/SpringMVC，所有访问都挂载在urlhttp://localhost:8080/SpringMVC/下了。

访问

二、RESTful

简介

具体说，就是 HTTP 协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。

它们分别对应四种基本操作：GET 用来获取资源，POST 用来新建资源，PUT 用来更新资源，DELETE 用来删除资源。

REST 风格提倡 URL 地址使用统一的风格设计，从前到后各个单词使用斜杠分开，不使用问号键值对方式携带请求参数，而是将要发送给服务器的数据作为 URL 地址的一部分，以保证整体风格的一致性。

操作	传统方式	REST风格
查询操作	getUserById?id=1	user/1–>get请求方式
保存操作	saveUser	user–>post请求方式
删除操作	deleteUser?id=1	user/1–>delete请求方式
更新操作	updateUser	user–>put请求方式

HiddenHttpmethodFilter过滤器

由于浏览器只支持发送get和post方式的请求，那么该如何发送put和delete请求呢？

SpringMVC 提供了 HiddenHttpMethodFilter 帮助我们将 POST 请求转换为 DELETE 或 PUT 请求

HiddenHttpMethodFilter 处理put和delete请求的条件：

a>当前请求的请求方式必须为post；

b>当前请求必须传输请求参数_method，_method设定为DELETE或PUT；

满足以上条件，HiddenHttpMethodFilter 过滤器就会将当前请求的请求方式转换为请求参数_method的值，因此请求参数_method的值才是最终的请求方式

在web.xml中注册HiddenHttpMethodFilter

<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>

RESTful案例

1、准备工作

新建ModulespringMVC-RESTful，搭建Spring MVC环境。

到目前位置，Spring MVC配置了两个过滤器，CharacterEncodingFilter和HiddenHttpMethodFilter，一个Servlet，DispatcherServlet。
在web.xml中注册时，过滤器必须先注册CharacterEncodingFilter。

web.xml

<?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">

    <!--  编码过滤器，一定要配置在请求处理器前，不然可能会失效  -->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceResponseEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!--  处理put、delete请求过滤器HiddenHttpMethodFilter -->
    <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>
    
    <!--  配置前端控制器DispatcherServlet  -->
    <servlet>
        <servlet-name>DispatcherServlet</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>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

这里还要提前准备一下dao层和bean包。

新建src/main/java/atguigu/rest/bean/Employee.java

package com.atguigu.rest.bean;

public class Employee {

    private Integer id;

    private String lastName;

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

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

    public Employee() {

    }

    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;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", lastName='" + lastName + '\'' +
                ", email='" + email + '\'' +
                ", gender=" + gender +
                '}';
    }

}

新建src/main/java/atguigu/rest/dao/EmployeeDao.java，这里模拟了存储数据。

package com.atguigu.rest.dao;

import com.atguigu.rest.bean.Employee;
import org.springframework.stereotype.Repository;

import java.util.*;

@Repository
public class EmployeeDao {

    private static Map<Integer, Employee> employees = null;

    static{
        employees = new HashMap<Integer, Employee>();

        employees.put(1001, new Employee(1001, "E-AA", "aa@163.com", 1));
        employees.put(1002, new Employee(1002, "E-BB", "bb@163.com", 1));
        employees.put(1003, new Employee(1003, "E-CC", "cc@163.com", 0));
        employees.put(1004, new Employee(1004, "E-DD", "dd@163.com", 0));
        employees.put(1005, new Employee(1005, "E-EE", "ee@163.com", 1));
    }

    private static Integer initId = 1006;

    public void save(Employee employee){
        if(employee.getId() == null){
            employee.setId(initId++);
        }
        employees.put(employee.getId(), employee);
    }

    public Collection<Employee> getAll(){
        return employees.values();
    }

    public Employee get(Integer id){
        return employees.get(id);
    }

    public void delete(Integer id){
        employees.remove(id);
    }
}

这里虽然建立了Dao层类，通过@Repository进行了声明并建立实例，但是需要在Spring MVC配置文件标注扫描位置才能生效。

src/main/resources/springMVC.xml

<context:component-scan base-package="com.atguigu.rest.controller, com.atguigu.rest.dao"></context:component-scan>

2、功能列表

功能	URL 地址	请求方式
访问首页√	/	GET
查询全部数据√	/employee	GET
删除√	/employee/2	DELETE
跳转到添加数据页面√	/toAdd	GET
执行保存√	/employee	POST
跳转到更新数据页面√	/employee/2	GET
执行更新√	/employee	PUT

3、首页

在src/main/weapp/WEB-INF/templates建立首页页面index.html。

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Index</title>
</head>
<body>
    <h1>Index</h1>
    <h2>:)</h2>

    <a th:href="@{/employee}">查看员工信息</a>

</body>
</html>

首页不需要经过其他逻辑处理，直接返回视图页面即可。所以在springMVC扩展配置文件src/main/resources/springMVC.xml中，配置视图控制器。

<mvc:view-controller path="/" view-name="index"></mvc:view-controller>

4、员工信息列表页面

在src/main/java/com/atguigu/rest/controller中，新建EmployeeController.java。

通过@Controller声明控制器并生成实例，同样也要在springMVC.xml中配置才能生效。

通过@Autowired根据类型自动注入属性实例EmployeeDao。

这里通过Model在服务器中存储了模型数据，最后返回视图页面employee_list。

@Controller
public class EmployeeController {

    @Autowired
    private EmployeeDao employeeDao;

    @RequestMapping(value = "/employee", method = RequestMethod.GET)
    public String getAllEmployee(Model model) {
        Collection<Employee> employeeList = employeeDao.getAll();
        // System.out.println("employeeList: " + employeeList);
        model.addAttribute("employeeList", employeeList);
        return "employee_list";
    }
    
}

在src/main/webapp/WEB-INF/templates/下添加employee_list.html。页面中的列表通过Thymeleaf获取服务器通过Model存储的数据。

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

    <table id="dataTable" border="1" cellspacing="0" cellpadding="0" style="text-align: center">
        <tr>
            <th colspan="5">Employee Info</th>
        </tr>
        <tr>
            <th>id</th>
            <th>lastName</th>
            <th>email</th>
            <th>gender</th>
            <th>options(<a th:href="@{/toAdd}">add</a>)</th>
        </tr>
        <tr th:each="employee : ${employeeList}">
            <td th:text="${employee.id}"></td>
            <td th:text="${employee.lastName}"></td>
            <td th:text="${employee.email}"></td>
            <td th:text="${employee.gender}"></td>
            <td>
                <!--  两种写法  -->
<!--                <a th:href="@{/employee/} + ${emploee.id}">delete</a>-->
                <a @click="deleteEmployee" th:href="@{'/employee/' + ${employee.id}}">delete</a>
                <a th:href="@{'/employee/' + ${employee.id}}">update</a>
            </td>
        </tr>
    </table>

    <!-- 作用：通过超链接控制表单的提交，将post请求转换为delete请求 -->
    <form id="deleteForm" method="post">
        <!-- HiddenHttpMethodFilter要求：必须传输_method请求参数，并且值为最终的请求方式 -->
        <input type="hidden" name="_method" value="delete">
    </form>

    <!--  thymeleaf访问静态资源  -->
    <script type="text/javascript" th:src="@{static/js/vue.js}"></script>
    <script type="text/javascript">
        var vue = new Vue({
            el:"#dataTable",
            methods:{
                deleteEmployee:function(event) {
                    // 根据id获取表单元素
                    var deleteForm = document.getElementById("deleteForm");
                    // 表单action设定为触发点击事件的超链接
                    deleteForm.action = event.target.href;
                    // 提交表单
                    deleteForm.submit();
                    // 取消超链接的默认行为
                    event.preventDefault();
                }
            }
        });
    </script>
</body>
</html>

5、删除员工信息

在员工信息列表页面employee_list.html能够看到删除按钮是一个超链接字段，直接点击会通过Get方式传送。这里的href要传参员工的id，使用Thymeleaf获取Model中的内容。

<a @click="deleteEmployee" th:href="@{'/employee/' + ${employee.id}}">delete</a>

href拼接也可以也可以这么写

<a th:href="@{/employee/} + ${emploee.id}">delete</a>

在页面下方多写了一份Post提交的表单form，就是希望通过点击超链接联动这个表单进行Post请求，在表单里设定的_method才是真正要进行的请求Delete。

	<!-- 作用：通过超链接控制表单的提交，将post请求转换为delete请求 -->
    <form id="deleteForm" method="post">
        <!-- HiddenHttpMethodFilter要求：必须传输_method请求参数，并且值为最终的请求方式 -->
        <input type="hidden" name="_method" value="delete">
    </form>

在src/main/webapp/static下导入vue.js。之后通过vue控制js进行联动，设定超链接点击事件@click=deleteEmployee，vue设置deleteEmployee函数执行将Post请求的表单deleteForm设定action为超链接存储的href，并屏蔽超链接本身的功能。

    <!--  thymeleaf访问静态资源  -->
    <script type="text/javascript" th:src="@{static/js/vue.js}"></script>
    <script type="text/javascript">
        var vue = new Vue({
            el:"#dataTable",
            methods:{
                deleteEmployee:function(event) {
                    // 根据id获取表单元素
                    var deleteForm = document.getElementById("deleteForm");
                    // 表单action设定为触发点击事件的超链接
                    deleteForm.action = event.target.href;
                    // 提交表单
                    deleteForm.submit();
                    // 取消超链接的默认行为
                    event.preventDefault();
                }
            }
        });
    </script>

在EmployeeController中，编写映射方法，这里传参通过占位符形式，需要在方法形参中通过@PathVariable进行参数匹配设定。通过dao层实例对象，执行删除方法后，通过重定向形式发送请求访问员工列表。

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

鼠标放在delete上时，可以看到左下角的url，符合请求映射规范。

6、添加员工信息

在员工信息列表页面的表格option栏后添加超链接<a th:href="@{/toAdd}">add</a>，点击发送url并跳转@{/toAdd}j。

employee_list.html

 <table id="dataTable" border="1" cellspacing="0" cellpadding="0" style="text-align: center">
        <tr>
            <th colspan="5">Employee Info</th>
        </tr>
        <tr>
            <th>id</th>
            <th>lastName</th>
            <th>email</th>
            <th>gender</th>
            <th>options(<a th:href="@{/toAdd}">add</a>)</th>
        </tr>
		...
    </table>

springMVC.xml中配置视图控制器，匹配到请求/toAdd，直接返回视图employee_add。

<mvc:view-controller path="/toAdd" view-name="employee_add"></mvc:view-controller>

src/main/webapp/WEB-INFO/templates/employee_add.html

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

    <form th:action="@{/employee}" method="post">
        LastName:<input type="text" name="lastName"><br/>
        email:<input type="text" name="email"><br/>
        gender:
            <input type="radio" name="gender" value="1">male
            <input type="radio" name="gender" value="0">female<br/>
        <input type="submit" name="submit" value="提交"><br/>
    </form>

</body>
</html>

页面里有Post方式提交的表单，表单action设定为@{/employee}，且提交的内容为Employee类的信息。

编写控制器映射url请求，通过请求url和请求类型RequestMethod.Post匹配，请求的内容通过实体类Employee传入。调用dao层方法新增信息。最后重定向访问员工列表页面。

EmployeeController.java

    @RequestMapping(value = "/employee", method = RequestMethod.POST)
    public String addEmployee(Employee employee) {
        System.out.println(employee);
        employeeDao.save(employee);
        return "redirect:/employee";
    }

7、更新员工信息

更新员工信息使用的页面和添加员工的页面的布局是相似的。区别是更新为了观感更好，要做信息回显。

员工信息页面中更新按钮，点击后发送请求url，url传入了点击的员工id，这里是通过Get方式请求的。

 <a th:href="@{'/employee/' + ${employee.id}}">update</a>

EmployeeController.java里填写对应的控制器进行请求映射，为了做信息回显，要根据传入的id查询员工信息，并存储到Model中，最后转发返回视图employee_update。

    @RequestMapping(value = "employee/{id}", method = RequestMethod.GET)
    public String updateEmployee(@PathVariable("id") Integer id, Model model) {
        Employee employee = employeeDao.get(id);
        model.addAttribute("employee", employee);
        return "employee_update";
    }

employee_update.html

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

    <form th:action="@{/employee}" method="post">
        <input type="hidden" name="_method" value="put">
        <input type="hidden" name="id" th:value="${employee.id}">
        LastName<input type="text" name="lastName" th:value="${employee.lastName}"><br/>
        email:<input type="text" name="email" th:value="${employee.email}"><br/>
        gender:
            <input type="radio" name="gender" value="1" th:field="${employee.gender}">male
            <input type="radio" name="gender" value="0" th:field="${employee.gender}">female<br/>
        <input type="submit" name="submit" value="更新"><br/>
    </form>

</body>
</html>

这里同样是通过表单的方式进行发送请求，因为是更新信息，想要发送Put请求，但是由于浏览器只能发送Get、Put请求，这里通过设定form的请求为Post，内部声明了隐藏的_method定义了真正的请求方式Put。

<input type="hidden" name="_method" value="put">

这里还设定了隐藏的employe_id，为了方便提交信息后续的更新。

EmployeeContoller.java添加相应的控制器请求映射。

@RequestMapping(value = "/employee", method = RequestMethod.PUT)
    public String updateEmployee(Employee employee) {
        employeeDao.save(employee);
        return "redirect:/employee";
    }

---

总结

提示：这里对文章进行总结：

例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。