Restful的详细介绍~

RESTFUL简介：

Restful是我们看待服务器的一种方式，我们都知道Java一切皆对象，因此在Java中，我们可以将所有的内容都看成对象，而在这里，RESTFUL是我们看待服务器的一种方式，我们可将服务器中的所有内容看成资源，"一切皆资源"，每个资源是服务器上一个可命名的抽象概念，例如一张图片，一个文件，一首歌,数据库中的一张表等等，这些都可以是资源，那么我们该如何表示这个资源呢？在Restful中，我们可通过一个名词进行表示，其实也就是该资源的名字，就比如，在现实生活中，我们需要去一个班级寻找一个学生，那么就需要通过其名字，名字就是学生作为资源的名称，因此在服务器中，我们寻找一个资源，也是需要通过其名称进行寻找

RESTFUL的模拟实现：

在服务器中，需要某一个资源，我们可通过其名称，但同一个资源又有不同的操作方式，那么该如何表示对同一个资源的不同操作方式呢？ 在Restful中，我们可通过四个表示操作方式的动词，GET[查询资源，获取资源],POST[新建资源],PUT[修改资源],DELETE[删除资源]，REST风格与传统方式不同的是，它提倡URL地址使用统一的风格设计，从前到后各个单词使用斜杠分开，不使用传统的问号键值对方式携带请求参数，而是将要发送给服务器的数据作为URL地址的一部分，以保证整体风格的一致性，如下所示为传统方式与REST风格的对比：

在这里插入图片描述

使用RESTFUL实现对信息的操作的准备工作

第一步：创建新的maven项目–>指定打包的方式，并且导入依赖

 <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>
        </dependency>
        <!-- Spring和Thymeleaf整合包-->
        <dependency>
            <groupId>org.thymeleaf</groupId>
            <artifactId>thymeleaf-spring5</artifactId>
            <version>3.0.12.RELEASE</version>
        </dependency>
    </dependencies>

第二步：在项目结构中，添加web模块，如下所示：

在这里插入图片描述

第三步：在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">
    <!--设置Spring的编码过滤器 -->
    <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>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    
    <!--设置SpringMVC的前端控制器 -->
    <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:restful.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

注意：如果web.xml文件中含有多个过滤器，那么编码过滤器需要放在最前面，原因是编码过滤器设置的是编码，而在设置编码之前，我们不能获取任何的请求参数，否则会导致设置的编码无效果

第四步：创建控制层Controller

第五步：在resources目录下创建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/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 http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <context:component-scan base-package="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>
    <mvc:annotation-driven/>
    <mvc:view-controller path="/" view-name="index"></mvc:view-controller>
</beans>

第六步：在WEB-INF目录下，创建templates子目录，并且创建index.html和success.html

index.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>index</title>
</head>
<body>
<h1>欢迎进入首页！</h1>
</body>
</html>

success.html:

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

使用RESTFUL实现对信息的查询操作：

创建控制器方法：

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

@Controller
public class RestfulTestController {
    @RequestMapping(value = "/user", method = RequestMethod.GET)
    public String getUser() {
        System.out.println("查询所有的用户信息-->/user->get");
        return "success";
    }
}

index.html文件中添加如下超链接：

<a th:href="@{/user}">查询用户信息</a>

浏览器中运行如下所示：

在这里插入图片描述

控制台输出：

在这里插入图片描述

使用RESTFUL实现对信息的条件查询操作：

创建控制器方法：

package Controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class RestfulTestController {
    @RequestMapping(value = "/user/{id}",method = RequestMethod.GET)
    public String getUserId(@PathVariable("id") Integer id){
        System.out.println("通过id查询用户信息-->/user/"+id+"->get");
        return "success";
    }
}

index.html文件中添加如下超链接：

<a th:href="@{/user/1}">查询id为1的用户信息</a>

浏览器中运行如下所示：

在这里插入图片描述

控制台输出：

在这里插入图片描述

使用RESTFUL实现对信息的添加操作：

创建控制器方法：

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

@Controller
public class RestfulTestController {
    @RequestMapping(value = "/user",method = RequestMethod.POST)
    public String insertUser(){
        System.out.println("添加用户信息--->/user->post");
        return "success";
    }
}

index.html文件中添加如下超链接：

<form th:action="@{/user}" method="post">
    <input type="submit" value="添加用户信息">
</form>

浏览器中运行如下所示：

在这里插入图片描述

控制台输出：

在这里插入图片描述

注意：浏览器目前只能发送get和post请求，若要发送put和delete请求，需要在web.xml中配置一个过滤器HiddenHttpMethodFilter处理隐藏的 HTTP 方法，如下所示，在web.xml文件中设置请求方式的过滤器

隐藏的 HTTP 方法是一种在 HTML 表单中使用 POST 方法来模拟其他 HTTP 方法（如 PUT、DELETE、PATCH）的技术。通过在表单中添加一个name为 _method 的隐藏字段(type=hidden)，并将其value设置为要模拟的 HTTP 方法(如：delete/put)，可以实现对应的操作。通过配置隐藏 HTTP 方法过滤器，可以在 Spring MVC 应用程序中使用 POST 方法来模拟其他 HTTP 方法，以便支持 RESTful 风格的请求。

<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实现对信息的修改操作：

在index.html中添加form表单实现修改操作

<form th:action="@{/user}" method="post">
    <input type="hidden" name="_method" value="put">
    <input type="submit" value="修改用户信息">
</form>

编写控制器方法

 @RequestMapping(value = "/user",method = RequestMethod.PUT)
    public String updateUser(){
        System.out.println("修改用户信息--->/user->put");
        return "success";
    }

重新部署项目，运行结果如下所示：

在这里插入图片描述

控制台输出如下所示：

在这里插入图片描述

使用RESTFUL实现对信息的删除操作：

在index.html中添加form表单实现删除操作

<form th:action="@{/user}" method="post">
    <input type="hidden" name="_method" value="delete">
    <input type="submit" value="删除用户信息">
</form>

编写控制器方法

@RequestMapping(value = "/user",method = RequestMethod.DELETE)
    public String deleteUser(){
        System.out.println("删除用户信息--->/user->delete");
        return "success";
    }

重新部署项目，运行结果如下所示：

在这里插入图片描述

控制台输出如下所示：

在这里插入图片描述

Restful案例准备工作：

第一步：创建实体类

package Pojo;

public class Employee {
    private Integer id;
    private String lastName;
    private Integer gender;

    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 Integer getGender() {
        return gender;
    }

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

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

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

    public Employee() {
    }
}

第二步：创建实体类DAO层

package Dao;

import Pojo.Employee;
import org.springframework.stereotype.Repository;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

@Repository
public class EmployeeDao {
    private  static Map<Integer,Employee> employeeMap=null;
    //初始化数据
    static {
        employeeMap=new HashMap<Integer,Employee>();
        employeeMap.put(1001,new Employee(1001,"E-AA",1));
        employeeMap.put(1002,new Employee(1002,"E-BB",1));
        employeeMap.put(1003,new Employee(1003,"E-CC",0));
        employeeMap.put(1004,new Employee(1001,"E-DD",0));
        employeeMap.put(1005,new Employee(1005,"E-EE",1));
    }
    private static Integer initID=1006;
    public void save(Employee employee){
   		//设置当前的用户id自增
        if(employee.getId()==null){
            employee.setId(initID++);
        }
        employeeMap.put(employee.getId(),employee);
    }
    //获得用户的所有信息
    public Collection<Employee> getAll(){
        return employeeMap.values();
    }
    //根据id获取用户信息
    public Employee get(Integer id){
        return employeeMap.get(id);
    }
    //根据id删除用户信息
    public void delete(Integer id){
        employeeMap.remove(id);
    }
}

第三步：创建实体类控制层

package Controller;

import org.springframework.stereotype.Controller;

@Controller
public class EmployeeController {
}

实现列表功能：

package Controller;

import Dao.EmployeeDao;
import Pojo.Employee;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import java.util.Collection;

@Controller
public class EmployeeController {
    @Autowired
    //注意：如果这里的employeeDao报错，那么有两个原因：1：DAO层未添加@Repository注解 2：DAO层的类未被XML文件扫描到
    private EmployeeDao employeeDao;

    @RequestMapping(value = "/employee",method = RequestMethod.GET)
    public String getAllEmployee(Model model ){
        //获取所有的用户信息
        Collection<Employee> employeeCollection=employeeDao.getAll();
        //将所有员工的信息在请求域中共享
     model.addAttribute("employeeCollection",employeeCollection);
        return "employee_list";
    }
}

employee_list.html：

在 Thymeleaf 中，th:each 是一个迭代器属性，用于循环遍历集合或数组。它的语法是 th:each="item : ${collection}"，
其中 item 是每次迭代的元素，${collection} 是要遍历的集合或数组，将每个元素赋值给名为 item 的变量。通常，这个循环语句会嵌套在 HTML 的表格（<table>）中，以便在每次迭代中生成表格的行（<tr>）。

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>employee_list</title>
</head>
<body>
<table>
  <tr>
  <th colspan="5">employee list</th>
  </tr>
  <tr>
    <th>id</th>
    <th>lastName</th>
    <th>email</th>
    <th>gender</th>
    <th>options</th>
  </tr>
  <!--由于表格中的信息需要我们从集合中一个个拿取，因此需要使用到迭代器来遍历 -->
  <tr th:each="employee:${employeeCollection}">
    <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 href="">delete</a>
      <a href="">update</a>
    </td>
  </tr>
</table>
</body>
</html>

index.html:

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>index</title>
</head>
<body>
<h1>欢迎进入首页！</h1>
<a th:href="@{/employee}">查询所有的员工信息 </a>
</body>
</html>

重新部署项目，运行如下所示：

在这里插入图片描述

RestFul处理静态资源：

什么是静态资源？

静态资源是指在Web应用程序中不经常变化的文件，如HTML、CSS、JavaScript、图像、字体文件等。这些文件在服务器上存储为静态文件，并在客户端请求时直接返回给浏览器，不需要经过服务器端的处理。

静态资源通常用于呈现网页的外观和功能，如布局、样式、交互行为等。它们不包含动态生成的内容，而是在开发过程中预先创建和维护的文件。

与动态资源相比，静态资源的特点是内容相对稳定，不需要经常变化。由于不需要服务器端的处理，静态资源的响应速度通常更快，可以有效地减轻服务器的负载。

在Web开发中，静态资源通常存储在服务器的特定目录下，并通过URL路径来访问。例如，一个CSS文件可以通过<link>标签的href属性引入，一个JavaScript文件可以通过<script>标签的src属性引入。

在工程中使用静态资源：

第一步：将静态资源放置当前目录的webapp下，注意不要放在WEB-INF目录下了，如下所示：

在这里插入图片描述

第二步：

在html文件的<head>标签中通过<link>标签引入该静态资源，如下所示：

<!--注意：这里的路径不需要加webapp,因为webapp只是用来存放静态资源的，具体的路径看target中的目录，如下所示，target中是以static直接开头的 -->
<link rel="stylesheet" th:href="@{/static/css/index_work.css}">

在这里插入图片描述

第三步：在XML文件中添加如下所示两个标签，否则静态资源不会被应用的到当前项目，并且打开浏览器的检查页面会出现404错误

<mvc:annotation-driven/>
<mvc:default-servlet-handler/>

原因是：如果当前工程和tomcat配置了同样的资源，那么以工程的为准，由于当前工程的web.xml配置的前端控制器DispatcherServlet的url-pattern是/，tomcat的web.xml配置的DefaultServlet的url-pattern也是/，此时，浏览器发送的请求会优先被DispatcherServlet进行处理，但是DispatcherServlet无法处理静态资源，这就导致我们引入的静态资源发生404错误

解决方法为我们需要同时配置<mvc:default-servlet-handler/>和<mvc:annotation-driven/>，这表示浏览器发送的请求会先被DispatcherServlet处理，无法处理再交给DefaultServlet处理

引入静态资源后，我们需要先对当前项目进行清理，再对其重新进行打包，防止target中没有该静态资源

此时部署项目，显示如下所示：

在这里插入图片描述

实现添加功能：

第一步：配置关于添加功能的视图控制器，如下所示:

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

第二步创建对应的视图：添加页面的视图employee_add.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="UTF-8">
  <title>add employee</title>
  <link rel="stylesheet" th:href="@{/static/css/index_work.css}">
</head>
<body>
<form th:action="@{/employee}" method="post">
<table>
  <tr>
    <th colspan="2">add employee</th>
  </tr>
  <tr>
    <td>lastName</td>
    <td>
      <input type="text" name="lastName">
    </td>
  </tr>
  <tr>
    <td>email</td>
    <td>
      <input type="text" name="email">
    </td>
  </tr>
  <tr>
    <td>gender</td>
    <td>
      <input type="radio" name="gender" value="1">male
      <input type="radio" name="gender" value="0">famale
    </td>
  </tr>
  <tr>
    <td colspan="2">
      <input type="submit" value="add">
    </td>
  </tr>
</table>
</form>
</body>
</html>

第三步：实现点击添加功能即跳转到该页面，如下所示：在employee_list.html中进行如下修改

在这里插入图片描述

第二步，编写控制器方法处理添加的请求

//虽然这里的路径具体信息也是/employee，但是二者的请求方式不同，而我们在index.html中是以超链接也就是get方式对请求进行处理，因此会匹配到查询的控制器方法
@RequestMapping(value = "/employee",method = RequestMethod.POST)
    public String addEmployee(Employee employee){//直接获取实体类对象
        employeeDao.save(employee);
        //使用户看到添加完成之后的页面，因此继续访问列表功能
        return "redirect:/employee";
    }

实现修改功能：

修改功能为什么不使用视图控制器呢？

原因是视图控制器只适用于简单的请求处理场景，对于复杂的业务逻辑，可能还需要编写自定义的控制器来处理请求，对于上述的添加功能，我们只需要跳转到添加用户信息的页面即可，而修改功能，业务逻辑就复杂了一些，我们需要先根据id获取需要修改的用户信息，再进行修改

第一步：创建处理修改用户信息的控制器方法

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

第二步：在employee_list.html中添加有关修改功能的超链接

<!--正确写法 -->
 <a th:href="@{'/employee/'+${employee.id}}">update</a>
 <!--错误写法：${employee.id}是请求参数，不能直接以路径的形式进行传输 -->
<!-- <a th:href="@{/employee/${employee.id}}">update</a>-->

第二步，编写控制器方法处理修改的请求

@RequestMapping(value = "/employee/{id}",method = RequestMethod.GET)
    public String toupdateEmployee(@PathVariable("id") Integer id,Model model){//修改功能
        Employee employee= employeeDao.get(id);
        model.addAttribute("employee",employee);
        //跳转到上文获取到的id的修改页面
        return "employee_update";
    }

第三步：创建修改功能的视图

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="UTF-8">
  <title>update employee</title>
  <link rel="stylesheet" th:href="@{/static/css/index_work.css}">
</head>
<body>
<form th:action="@{/employee}" method="post">
  <input type="hidden" name="_method" value="put">
  <input type="hidden" name="id" th:value="${employee.id}">
  <table>
    <tr>
      <th colspan="2">add employee</th>
    </tr>
    <tr>
      <td>lastName</td>
      <td>
        <input type="text" name="lastName" th:value="${employee.lastName}">
      </td>
    </tr>
    <tr>
      <td>email</td>
      <td>
        <input type="text" name="email" th:value="${employee.email}">
      </td>
    </tr>
    <tr>
      <td>gender</td>
      <td>
        <input type="radio" name="gender" value="1" th:field="${employee.gender}">male
        <input type="radio" name="gender" value="0" th:field="${employee.gender}">famale
      </td>
    </tr>
    <tr>
      <td colspan="2">
        <input type="submit" value="update">
      </td>
    </tr>
  </table>
</form>
</body>
</html>

实现删除功能：

删除功能的麻烦之处在于，需要使用超链接来控制表单的提交，因为删除功能要发送的请求是delete，因此我们需要一个表单，将其请求方式设置为post，再传递请求参数为_method,其值为delete，让其表单提交，我们才能发送delete请求

但是不能如下所示这样写

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

原因是当前的超链接功能相同，那么都会跳转到修改的页面，因此需要重新设置请求方式为delete的表单

<form method="post">
        <input type="hidden" name="_method" value="delete">
</form>

点击该超链接，控制该表单的提交，把当前的href属性赋值给下面表单的action属性

<script type="text/javascript" th:src="@{/static/js/vue.js}"></script>
<script type="text/javascript">
        var vue=new Vue({
            el:"#app",
            methods:{
                deleteEmployee(){
                    //获取form表单
                    var form=document.getElementsByTagName("form")[0];
                    //将超链接的href属性值赋值给form表单的action属性,event.target表示当前触发时间的标签
                    form.action=event.target.href;
                    //表单提交
                    form.submit();
                    //阻止超链接的默认行为
                    event.preventDefault();
                }
            }
        });
</script>

注意：超链接都有默认行为，点击超链接一定会将请求发送到当前href所设置的请求地址，当前我们是通过表单提交的，我们不能让超链接执行其默认行为，因此需要通过preventDefault()去阻止其行为。

employee_list.html完整代码如下所示：

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="UTF-8">
  <title>employee_list</title>
  <link rel="stylesheet" th:href="@{/static/css/index_work.css}">
</head>
<body>
<div id="app">
<table >
  <tr>
    <th colspan="5">employee list</th>
  </tr>
  <tr>
    <th>id</th>
    <th>lastName</th>
    <th>email</th>
    <th>gender</th>
    <th>options(<a th:href="@{/to/add}">add</a>)</th>
  </tr>
  <tr th:each="employee:${employeeCollection}">
    <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/'+${employee.id}}">update</a>

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

     </td>
   </tr>
 </table>
<form method="post">
        <input type="hidden" name="_method" value="delete">
</form>
</div>
<script type="text/javascript" th:src="@{/static/js/vue.js}"></script>
<script type="text/javascript">
        var vue=new Vue({
            el:"#app",
            methods:{
                deleteEmployee(){
                    //获取form表单
                    var form=document.getElementsByTagName("form")[0];
                    //将超链接的href属性值赋值给form表单的action属性,event.target表示当前触发时间的标签
                    form.action=event.target.href;
                    //表单提交
                    form.submit();
                    //阻止超链接的默认行为
                    event.preventDefault();
                }
            }
        });
</script>
 </body>
 </html>

编写其对应的控制器方法：

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/51656.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

idea中设置maven本地仓库和自动下载依赖jar包

idea中设置maven本地仓库和自动下载依赖jar包

1.下载maven 地址&#xff1a;maven3.6.3 解压缩在D:\apache-maven-3.6.3-bin\apache-maven-3.6.3\目录下新建文件夹repository打开apache-maven-3.6.3-bin\apache-maven-3.6.3\conf文件中的settings.xml编辑&#xff1a;新增本地仓库路径 <localRepository>D:\apache-…
阅读更多...
ChatGPT与高等教育变革：价值、影响及未来发展

ChatGPT与高等教育变革：价值、影响及未来发展

最近一段时间&#xff0c;ChatGPT吸引了社会各界的目光&#xff0c;它可以撰写会议通知、新闻稿、新年贺信&#xff0c;还可以作诗、写文章&#xff0c;甚至可以撰写学术论文。比尔盖茨、马斯克等知名人物纷纷为此发声&#xff0c;谷歌、百度等知名企业纷纷宣布要提供类似产品。…
阅读更多...
WIZnet W5100S-EVB-Pico DHCP 配置教程（三）

WIZnet W5100S-EVB-Pico DHCP 配置教程（三）

DHCP协议介绍 什么是DHCP&#xff1f; 动态主机配置协议DHCP&#xff08;Dynamic Host Configuration Protocol&#xff09;是一种网络管理协议&#xff0c;用于集中对用户IP地址进行动态管理和配置。 DHCP于1993年10月成为标准协议&#xff0c;其前身是BOOTP协议。DHCP协议由…
阅读更多...
ceph集群中RBD的性能测试、性能调优

ceph集群中RBD的性能测试、性能调优

文章目录 rados benchrbd bench-write测试工具Fio测试ceph rbd块设备的iops性能测试ceph rbd块设备的带宽测试ceph rbd块设备的延迟 性能调优 rados bench 参考&#xff1a;https://blog.csdn.net/Micha_Lu/article/details/126490260 rados bench为ceph自带的基准测试工具&am…
阅读更多...
常见网关对比

常见网关对比

常见网关对比 目前常见的开源网关大致上按照语言分类有如下几类&#xff1a; Nginxlua &#xff1a;OpenResty、Kong、Orange、Abtesting gateway 等 Java &#xff1a;Zuul/Zuul2、Spring Cloud Gateway、Kaazing KWG、gravitee、Dromara soul 等 Go &#xff1a;Janus、fa…
阅读更多...
多线程只需这一篇足够

多线程只需这一篇足够

开玩笑的 本篇详细讲述了多线程的各种细节及操作方法 对锁的各种操作&#xff0c;以及原子性的阐述 原谅我嚣张的标题 Begin&#xff1a;本篇文章尽可能详细的讲述了线程的概念、使用、安全问题&#xff0c;以及消费者生产者模型的设计理念和实现代码。对于单例模式的两种实现代…
阅读更多...
spring6——容器

spring6——容器

文章目录 容器&#xff1a;IocIoc容器控制反转&#xff08;Ioc&#xff09;依赖注入IoC容器在Spring的实现 基于XML管理Bean搭建环境获取bean依赖注入setter注入构造器注入特殊值处理字面量赋值null值xml实体CDATA节 特殊类型属性注入为对象类型属性赋值方式一&#xff1a;引入…
阅读更多...
1400*B. I Hate 1111(思维+数学)

1400*B. I Hate 1111(思维+数学)

Example input 3 33 144 69 output YES YES NO 题意&#xff1a; 问一个数字是否可以由 11&#xff0c;111&#xff0c;1111&#xff0c;11111...... 任意倍数加和所得。 解析&#xff1a; 可以观察到 1111%110&#xff0c;11111%1110&#xff0c;而后面更大的11111111…
阅读更多...
Python入门【函数用法和底层分析、函数简介 、函数的定义和调用、形参和实参、文档字符串(函数的注释) 、函数也是对象，内存底层分析】(十)

Python入门【函数用法和底层分析、函数简介 、函数的定义和调用、形参和实参、文档字符串(函数的注释) 、函数也是对象，内存底层分析】(十)

&#x1f44f;作者简介&#xff1a;大家好&#xff0c;我是爱敲代码的小王&#xff0c;CSDN博客博主,Python小白 &#x1f4d5;系列专栏&#xff1a;python入门到实战、Python爬虫开发、Python办公自动化、Python数据分析、Python前后端开发 &#x1f4e7;如果文章知识点有错误…
阅读更多...
在 “小小容器” WasmEdge 里运行小小羊驼 llama 2

在 “小小容器” WasmEdge 里运行小小羊驼 llama 2

昨天&#xff0c;特斯拉前 AI 总监、OpenAI 联合创始人 Andrej Karpathy 开源了 llama2.c 。 只用 500 行纯 C 语言就能训练和推理 llama 2 模型的框架&#xff0c;没有任何繁杂的 python 依赖。这个项目一推出就受到大家的追捧&#xff0c;24 小时内 GitHub 收获 4000 颗星&am…
阅读更多...
机器学习深度学习——权重衰减

机器学习深度学习——权重衰减

&#x1f468;‍&#x1f393;作者简介&#xff1a;一位即将上大四&#xff0c;正专攻机器学习的保研er &#x1f30c;上期文章&#xff1a;机器学习&&深度学习——模型选择、欠拟合和过拟合 &#x1f4da;订阅专栏&#xff1a;机器学习&&深度学习 希望文章对你…
阅读更多...
Spring Boot 缓存 Cache 入门

Spring Boot 缓存 Cache 入门

Spring Boot 缓存 Cache 入门 1.概述 在系统访问量越来越大之后&#xff0c;往往最先出现瓶颈的往往是数据库。而为了减少数据库的压力&#xff0c;我们可以选择让产品砍掉消耗数据库性能的需求。 当然也可以引入缓存,在引入缓存之后&#xff0c;我们的读操作的代码&#xff…
阅读更多...
嵌入式硬件系统的基本组成

嵌入式硬件系统的基本组成

嵌入式硬件系统的基本组成 嵌入式系统的硬件是以包含嵌入式微处理器的SOC为核心&#xff0c;主要由SOC、总线、存储器、输入/输出接口和设备组成。 嵌入式微处理器 每个嵌入式系统至少包含一个嵌入式微处理器 嵌入式微处理器体系结构可采用冯.诺依曼&#xff08;Von Neumann&…
阅读更多...
leetcode 55. 跳跃游戏

leetcode 55. 跳跃游戏

2023.7.29 本题不用纠结于可以跳几步&#xff0c;可以聚焦于覆盖范围&#xff0c;即 当前位置当前跳数 能够覆盖的范围&#xff0c;若这个范围足以到达最后一个位置&#xff0c;则返回true&#xff1b;若for循环结束&#xff0c;则还没返回true&#xff0c;则返回false。 下面看…
阅读更多...
24考研数据结构-第一章 绪论

24考研数据结构-第一章 绪论

数据结构 引用文章第一章&#xff1a;绪论1.0 数据结构在学什么1.1 数据结构的基本概念1.2 数据结构的三要素1.3 算法的基本概念1.4 算法的时间复杂度1.4.1 渐近时间复杂度1.4.2 常对幂指阶1.4.3 时间复杂度的计算1.4.4 最好与最坏时间复杂度 1.5 算法的空间复杂度1.5.1 空间复…
阅读更多...
如何建立Docker私有仓库?

如何建立Docker私有仓库?

文章目录 docker私有仓库harborHarbor仓库部署Harbor仓库使用 docker私有仓库 Docker 私有仓库是一个用于存储和管理 Docker 镜像的私有存储库。它允许你在内部网络中创建和管理 Docker 镜像&#xff0c;并提供了更好的安全性和控制&#xff0c;因为你可以完全控制谁能够访问和…
阅读更多...
jmeter接口测试、压力测试简单实现

jmeter接口测试、压力测试简单实现

jmeter测试的组件执行顺序&#xff1a; 测试计划—>线程组—>配置元件—>前置处理器—>定时器—>逻辑控制器—>取样器—>后置处理器—>断言—>监听器 组件的作用范围&#xff1a; 同级组件同级组件下的子组件父组件 目前市面上的三类接口 1、基…
阅读更多...
PyCharm安装pip依赖，如何添加国内镜像源？

PyCharm安装pip依赖，如何添加国内镜像源？

目录 前言 PyCharm如何安装依赖 PyCharm如何配置国内镜像源 前言 首先我们都知道&#xff0c;使用pip安装依赖的方式&#xff0c;却很少有人知道使用PyCharm如何安装依赖。 PyCharm如何安装依赖 但你会发现&#xff0c;基本都是安装失败的&#xff0c;因为你是去外网下载的…
阅读更多...
[JAVAee]文件操作-IO

[JAVAee]文件操作-IO

本文章讲述了通过java对文件进行IO操作 IO:input/output,输入/输出. 建议配合文章末尾实例食用 目录 文件 文件的管理 文件的路径 文件的分类 文件系统的操作 File类的构造方法 File的常用方法 文件内容的读写 FileInputStream读取文件 构造方法 常用方法 Scan…
阅读更多...
探索容器镜像安全管理之道

探索容器镜像安全管理之道

邓宇星&#xff0c;Rancher 中国软件架构师&#xff0c;7 年云原生领域经验&#xff0c;参与 Rancher 1.x 到 Rancher 2.x 版本迭代变化&#xff0c;目前负责 Rancher for openEuler(RFO)项目开发。 最近 Rancher v2.7.4 发布了&#xff0c;作为一个安全更新版本&#xff0c;也…
阅读更多...
最新文章

Copyright @ 2022~2023