如何使用Spring Boot、Maven和MySQL创建一个REST API

REST API的一个好处是它为我们的应用程序提供了灵活性和可扩展性。由于客户端和服务器是独立的，REST协议将数据存储与服务器中的用户界面分开。

有了这个，我们的应用程序可以快速扩展，主要是由于关注点的分离（前端与服务器的分离），这有助于我们的应用程序是松散的耦合。这也为将来修改我们的代码提供了灵活性，因为开发人员可以很容易地集成RESTful API，而不需要太多的附加工作。

目标

本文介绍了如何创建一个Spring Boot RESTful API，通过使用Hibernate（JPA（Java Persistence API）的一种实现）对MySQL数据库进行数据库调用来执行CRUD操作。

在本教程中，我们将建立一个员工管理系统，用于注册员工、读取、更新和删除员工的信息。

你还将学习如何使用Swagger UI记录你的API。

主要收获

• 如何用Tomcat服务器创建和设置Spring Boot应用程序。
• 在Spring Boot项目中配置MySQL数据库。
• 你将学会如何使用Hibernate实现对象关系映射。
• 用于依赖性管理的Maven。
• Java中的异常处理。
• 如何使用postman消费REST API。
• 如何使用Swagger记录API。

前提条件

要完全理解本教程，你需要具备以下条件。

• 对Java有良好的理解。
• 对Spring框架和Spring Boot有一点了解。
• 安装了Java开发工具包（JDK）或点击此链接进行安装。
• 安装了Postman API测试工具或点击此链接下载安装。
• 安装了Maven依赖管理器，或点击此链接下载并安装。
• 安装了IntelliJ代码编辑器或点击此链接进行安装。

项目初始化和设置

有不同的方法来设置一个新的Spring Boot应用程序。我们将使用 Spring初始化器.

方法1：使用IntelliJ设置

在本教程中，我们将学习如何使用IntelliJ来初始化Spring Boot项目。

Intellij有内置的扩展，可以使用Spring初始化器创建Spring Boot项目，这样可以更容易地在短时间内设置一个项目。

要开始运行IntelliJ IDEA ，并点击从File > New > Project ，创建一个新项目。

下一步是选择Spring initializer （用绿色突出显示）。

注意：如果你看一下用红色突出显示的部分，你会发现我们正在连接到网络上的Spring初始化器。

按照下面的步骤进行设置。

• 进入Maven项目属性，点击Next
• 给项目取个名字。就叫它employee_app 。
• 选择你希望项目所在的位置。
• 对于项目的Type ，选择Maven 。
• 本项目的Language 将是Java 。
• 让我们将Group 命名为com.lekwacious 。
• 让我们把Artifact 称为employee_app 。
• 使用下拉列表选择JavaSDK version 。
• 也选择你的Java version 。
• 我们将把我们的项目打包成一个Jar 文件。

JAR是Java ARchive的首字母缩写。它以ZIP文件格式出现，用于将许多文件聚合成一个。

选择Spring Boot版本（我选择了2.5.2）和你的项目所需的其他依赖项。正确的Spring Boot启动器将根据在pom.xml 文件中添加的选定的依赖项而被添加。

在选择了这些依赖性之后，点击Finish 按钮，如图所示。

这个项目将有三个依赖项，即。

• Spring web:使你的项目成为一个网络应用。spring-boot-starter-web 依赖关系中转地拉入所有与Web开发相关的依赖关系。它使用Spring MVC、REST和Tomcat作为默认的嵌入式服务器。
• Spring Data JPA:允许我们使用Spring Data和Hibernate在SQL数据库中持久化数据，Hibernate是JPA的一个实现。

JPA是一种规范，是Java EE（企业版）的一部分，定义了对象-关系映射（ORM）和管理持久化对象和关系数据库的API。它被认为是对象关系映射的一个标准方法。

由于JPA是一个规范，它本身并不执行任何操作。Hibernate是那些实现JPA的ORM（对象关系映射）工具之一。其他包括TopLink、MyBatis。

• MySQL Driver:它是一个将MySQL数据库连接到spring boot应用程序的依赖项。

方法2：使用Spring Initializer进行设置

另外，如果你没有使用IntelliJ，你可以使用 Spring Initializer来设置你的项目。

像我们上面那样输入Maven project 属性，包括依赖关系，然后点击Generate 按钮。这将产生一个zip 文件，并为你下载它。解压后在你喜欢的代码编辑器中打开，用Maven同步依赖关系。

Maven依赖性管理

pom.xml 文件中包含了我们项目的依赖项和Maven插件。

依赖项部分只包含我们添加到项目中的依赖项，即MySQL驱动、Spring Data JPA和SpringWeb。

以下是pom.xml 文件的一个例子。

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.2</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.lekwacious</groupId>
    <artifactId>employee_app</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>employee_app</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

配置MySQL、JPA和Hibernate

在src/main 文件夹内的资源文件夹中，打开application.properties 文件，并写入以下属性。

spring.datasource.url=jdbc:mysql://localhost:3306/employee_db?useSSL=false&serverTimezone=UTC&useLegacyDatetimeCode=false
spring.datasource.username=root
spring.datasource.password=mypassword

server.port=8081

spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.hibernate.ddl-auto=update

• spring.datasource.url:Springboot使用URL以及凭证（这里，MySQL被配置为3306端口，数据库名称为employee_db ）来建立与我们的MySQL数据库的数据库连接。
• spring.datasource.username & 属性是MySQL数据库的用户名和密码。(请使用安装在你电脑上的MySQL服务器的正确用户名和密码）。spring.datasource.password
• 默认的Spring Boot端口是8080 。我已经将我们的Spring Boot应用程序的端口配置为运行在8081 。
• Springboot.jpa.properties.hibernate.dialect:SQL方言使Hibernate为所选数据库生成更好的SQL。
• 我们已经将DDL（数据定义语言）设置为update 。

例如，update 操作将尝试添加新的列、约束等，但绝不会删除以前可能存在、但不再作为对象模型一部分的列或约束。

• 其他值包括：create-drop ，在任何时候你重新运行你的应用程序，都会在模式上删除对象，留下一个空的数据库。它适用于你正在运行的测试。

应用程序的进入点

通过简单地初始化你的项目，你的应用程序就可以被运行了。

这就是Spring Boot的魅力所在，它使创建独立的、基于生产级的Spring应用程序变得更加容易，你可以 "直接运行"。

在src/main/java/com/lekwacious/employee_app 文件夹中找到EmployeeAppApplication.java 文件。

package com.lekwacious.employee_app;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class EmployeeAppApplication {

    public static void main(String[] args) {
        SpringApplication.run(EmployeeAppApplication.class, args);
    }

}

Spring Boot应用程序应该有一个带有public static void main(String[] args) 方法的入口类，该方法被注解为@SpringBootApplication 注解，将用于启动应用程序。

启动时，@SpringBootApplication 注解会通知Spring框架扫描此包内的Spring组件并注册它们。

它还告诉Spring Boot启用Autoconfiguration ，这个过程中会根据classpath设置、属性设置和其他因素自动创建Bean。

@SpringBootApplication 注解由其他三个注解组成，即@EnableAutoConfiguration 、@ComponentScan 和@Configuration ，有助于自动配置。所以，我们可以称它为这三个注解的快捷方式。

现在，运行该应用程序。你可以通过点击IDEA上的播放按钮或在你的命令行上运行这个命令：mvn spring-boot:run 。

通过命令行导航到项目的根部并执行该命令。

轰隆隆!Tomcat开始在端口8081 。

项目结构

我们将把我们的代码组织成以下四个包。

1. **数据。**这个子包将容纳我们的数据访问层，它将包括我们的域和资源库。
2. **服务。**这是我们的业务逻辑所在。
3. **网络。**这个包将容纳我们的控制器。
4. **异常。**这是我们所有自定义异常的地方。

抛出异常对于建立一个有弹性的系统是非常重要的。

这个结构将确保客户端不能直接访问我们的数据库，而是通过控制器重定向请求。

控制器使用存储库调用正确的服务（业务逻辑），而存储库又对我们的数据库进行调用。这种架构也确保了关注点的分离。

下面是项目的结构。

创建域类

在数据package ，创建另一个名为models 的包。

在models 包内，创建一个名为Department 的enum class 。

Enum 是作为Java中的常量使用的。属性是隐含的 和 。Enums主要用于指定所有不会被变异的常量。例如，一周中的几天。final static

部门枚举类应该包含以下代码。

package com.lekwacious.employee_app.data.models;

public enum Department {
    HUMAN_RESOURCE,
    MARKETING,
    ENGINEERING
}

创建另一个名为Employee 的类，代码如下。

package com.lekwacious.employee_app.data.models;

import javax.persistence.*;
import java.util.Objects;

@Entity
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    private String firstName;
    private String lastname;
    private String phoneNumber;
    private String email;
    private double salary;
    @Enumerated(EnumType.STRING)
    private Department department;

    public Employee(){}
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getFirstName() {
        return firstName;
    }
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
    public String getLastname() {
        return lastname;
    }
    public void setLastname(String lastname) {
        this.lastname = lastname;
    }
    public String getPhoneNumber() {
        return phoneNumber;
    }
    public void setPhoneNumber(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    public Department getDepartment() {
        return department;
    }
    public void setDepartment(Department department) {
        this.department = department;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", firstName='" + firstName + '\'' +
                ", lastname='" + lastname + '\'' +
                ", phoneNumber='" + phoneNumber + '\'' +
                ", email='" + email + '\'' +
                ", salary=" + salary +
                ", department=" + department +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return Double.compare(employee.salary, salary) == 0 && Objects.equals(id, employee.id) && Objects.equals(firstName, employee.firstName) && Objects.equals(lastname, employee.lastname) && Objects.equals(phoneNumber, employee.phoneNumber) && Objects.equals(email, employee.email) && department == employee.department;
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, firstName, lastname, phoneNumber, email, salary, department);
    }
}

• @Entity 注释告诉Spring， 类是一个简单的POJO（Plain Old Java Object），应该被持久化在数据库中。Employee
• @Id 注解使 字段成为雇员表的主键，当它被持久化在数据库中时。id
• 我们使用@GeneratedValue 注解来指定主键生成策略。值auto ，指示数据库为该字段自动生成一个值。因此，Id 将被自动生成。
• @Enumerated 注解将枚举转换为一个字符串。
• 接下来，我们为字段创建了一个无参数构造器、设置器和获取器，并覆盖了toString 、equals 和hashCode 方法。

添加额外的Maven依赖项

在本节中，我们将向项目添加额外的依赖。

转到 Maven资源库并搜索以下依赖项，并将其添加到pom.xml 文件的依赖项部分。

• **Javax验证。**它用于在持久化到数据库之前验证对象的字段。
• **Io springfox。**一个依赖项，可以让我们记录我们的API。
• 在pom.xml 的dependencies标签中添加以下两个依赖项。
• 将新添加的依赖关系同步到应用程序中。

<dependencies>
    <dependency>
        <groupId>javax.validation</groupId>
        <artifactId>validation-api</artifactId>
    </dependency>
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-boot-starter</artifactId>
        <version>3.0.0</version>
    </dependency>
</dependencies>

有效载荷

在数据包内，创建一个名字为payloads 的包。

这个包将有两个子包request 和response ，分别处理我们的请求有效载荷和响应有效载荷。

请求有效载荷

在请求包内创建一个EmployeeRequest 类，代码如下。

package com.lekwacious.employee_app.data.payloads.request;

import com.lekwacious.employee_app.data.models.Department;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.validation.constraints.Email;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;

public class EmployeeRequest {
    @NotBlank
    @NotNull
    private String firstName;
    @NotBlank
    @NotNull
    private String lastname;
    @NotBlank
    @NotNull
    private String phoneNumber;
    @Email
    private String email;
    @NotBlank
    @NotNull
    private double salary;
    @NotBlank
    @NotNull
    @Enumerated(EnumType.STRING)
    private Department department;

    public String getFirstName() {
        return firstName;
    }
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
    public String getLastname() {
        return lastname;
    }
    public void setLastname(String lastname) {
        this.lastname = lastname;
    }
    public String getPhoneNumber() {
        return phoneNumber;
    }
    public void setPhoneNumber(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    public Department getDepartment() {
        return department;
    }
    public void setDepartment(Department department) {
        this.department = department;
    }
}

• @NotBlank 和 : 这两个注解检查和验证它们所映射的字段，以确保其值不是空白和空的。@NotNull
• @Email:它验证注解的字段是一个有效的电子邮件地址。
• 接下来，我们为该类的实例变量创建了设置器和获取器。

响应的有效载荷

在响应包内创建一个MessageReponse 类，代码如下。

package com.lekwacious.employee_app.data.payloads.response;

public class MessageResponse {

    private String message;

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

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

    public String getMessage(){
        return message;
    }
}

• 上面的代码是一个简单的POJO，有一个实例变量、一个构造函数、一个突变器（setters）和一个访问器（getters）。

存储库

在数据包内，创建一个名为repository 的子包。然后，创建一个名为EmployeeRepository 的接口，它扩展了JpaRepository 。

JpaRepository 是通用的，所以它需要一个模型类（Type）和主键的数据类型。

在EmployeeRepository 接口中写下以下代码。

package com.lekwacious.employee_app.data.repository;

import com.lekwacious.employee_app.data.models.Employee;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface EmployeeRepository extends JpaRepository<Employee, Integer> {
}

• @Repository 使该接口成为一个Bean。它与 注解的处理方式相同，因此它是 注解的一个特殊化。Bean只是Spring知道的Java类。@Component @Component
• 通过扩展JpaRepository 接口，我们继承了save,findAll,findById 方法。

雇员服务

在employee_app 包下创建一个service 包。

这个包将容纳我们的业务逻辑。为了确保更多的关注点分离，我们将把我们的服务分成两部分--一个接口，我们的业务逻辑的方法将在这里被声明，还有一个实现该接口的具体类。

用下面的代码创建一个接口，名称为employeeService 。

package com.lekwacious.employee_app.service;

import com.lekwacious.employee_app.data.models.Employee;
import com.lekwacious.employee_app.data.payloads.request.EmployeeRequest;
import com.lekwacious.employee_app.data.payloads.response.MessageResponse;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Optional;

@Component
public interface EmployeeService {
    MessageResponse createEmployee(EmployeeRequest employeeRequest);
    Optional<Employee> updateEmployee(Integer employeeId, EmployeeRequest employeeRequest);
    void deleteEmployee(Integer employeeId);
    Employee getASingleEmployee(Integer employeeId);
    List<Employee> getAllEmployee();
}

• @Component 注解是对 注解的简写。它将EmployeeService接口注册为应用程序上下文中的一个Bean，并使其在classpath扫描时可以被访问。@Bean
• 我们创建了五个方法，允许我们创建、更新、获取和删除雇员。

接下来，创建一个EmployeeServiceImpl 类，实现EmployeeService 接口，如图所示。

package com.lekwacious.employee_app.service;

import com.lekwacious.employee_app.data.models.Employee;
import com.lekwacious.employee_app.data.payloads.request.EmployeeRequest;
import com.lekwacious.employee_app.data.payloads.response.MessageResponse;
import com.lekwacious.employee_app.data.repository.EmployeeRepository;
import com.lekwacious.employee_app.exception.ResourceNotFoundException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
public class EmployeeServiceImpl implements EmployeeService {
    @Autowired
    EmployeeRepository employeeRepository;

    @Override
    public MessageResponse createEmployee(EmployeeRequest employeeRequest) {
        Employee newEmployee = new Employee();
        newEmployee.setFirstName(employeeRequest.getFirstName());
        newEmployee.setLastname(employeeRequest.getLastname());
        newEmployee.setPhoneNumber(employeeRequest.getPhoneNumber());
        newEmployee.setEmail(employeeRequest.getEmail());
        newEmployee.setSalary(employeeRequest.getSalary());
        newEmployee.setDepartment(employeeRequest.getDepartment());
        employeeRepository.save(newEmployee);
        return new MessageResponse("New Employee created successfully");

    }

    @Override
    public Optional<Employee> updateEmployee(Integer employeeId, EmployeeRequest employeeRequest)  throws ResourceNotFoundException{
        Optional<Employee> employee = employeeRepository.findById(employeeId);
        if (employee.isEmpty()){
        throw new ResourceNotFoundException("Employee", "id", employeeId);
        }
        else
        employee.get().setFirstName(employeeRequest.getFirstName());
        employee.get().setLastname(employeeRequest.getLastname());
        employee.get().setPhoneNumber(employeeRequest.getPhoneNumber());
        employee.get().setEmail(employeeRequest.getEmail());
        employee.get().setSalary(employeeRequest.getSalary());
        employee.get().setDepartment(employeeRequest.getDepartment());
        employeeRepository.save(employee.get());
        return employee;
    }

    @Override
    public Employee getASingleEmployee(Integer employeeId) throws ResourceNotFoundException{
        return employeeRepository.findById(employeeId).orElseThrow(() -> new ResourceNotFoundException("Employee", "id", employeeId));
    }

    @Override
    public List<Employee> getAllEmployee() {
        return employeeRepository.findAll();
    }
    @Override
    public void deleteEmployee(Integer employeeId) throws ResourceNotFoundException {
        if (employeeRepository.getById(employeeId).getId().equals(employeeId)){
            employeeRepository.deleteById(employeeId);
        }
        else throw new ResourceNotFoundException("Employee", "id", employeeId);
    }
}

• @服务专门是一个库方法的集合，管理应用程序业务逻辑的一个方面。它是@Component 的专门形式。通过@Service 注解，该类被注册在应用程序上下文中，并在classpath扫描时可以访问。
• @autowired 注解被用来执行字段依赖性注入。它自动将作为依赖豆的EmployeeRespository interface 注入到EmployeeServiceImpl 类中，这样我们就可以使用它。这是可能的，因为EmployeeRepository 被注解了@Repository 注解，使其成为一个Bean。
• EmployeeServiceImpl 类通过重写方法和实现它们来实现EmployeeService接口。
• 该类抛出了一个异常（ResourceNotFoundException- 这是我们创建的自定义异常类，它扩展了RunTimeException ），在这个异常中，为获取一个雇员而提供的Id在数据库中不存在。

控制器

在employee_app包下创建一个名为web 的包。这个包将容纳API的控制器。

创建一个EmployeeController类，代码如下。

package com.lekwacious.employee_app.web;

import com.lekwacious.employee_app.data.models.Employee;
import com.lekwacious.employee_app.data.payloads.request.EmployeeRequest;
import com.lekwacious.employee_app.data.payloads.response.MessageResponse;
import com.lekwacious.employee_app.service.EmployeeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/employee")
public class EmployeeController {

    @Autowired
    EmployeeService employeeService;

    @GetMapping("/all")
    public ResponseEntity<List<Employee>> getAllEmployees () {
        List<Employee> employees = employeeService.getAllEmployee();
        return new ResponseEntity<>(employees, HttpStatus.OK);
    }
    @GetMapping("/find/{id}")
    public ResponseEntity<Employee> getEmployeeById (@PathVariable("id") Integer id) {
        Employee employee = employeeService.getASingleEmployee(id);
        return new ResponseEntity<>(employee, HttpStatus.OK);
    }
    @PostMapping("/add")
    public ResponseEntity<MessageResponse> addEmployee( @RequestBody EmployeeRequest employee) {
        MessageResponse newEmployee = employeeService.createEmployee(employee);
        return new ResponseEntity<>(newEmployee, HttpStatus.CREATED);
    }
    @PutMapping("/update/{id}")
    public ResponseEntity<MessageResponse> updateEmployee( @PathVariable Integer id, @RequestBody EmployeeRequest employee) {
        MessageResponse updateEmployee = employeeService.updateEmployee(id, employee);
        return new ResponseEntity<>(updateEmployee, HttpStatus.OK);
    }
    @DeleteMapping("/delete/{id}")
    public ResponseEntity<?> deleteEmployee(@PathVariable("id") Integer id) {
        employeeService.deleteEmployee(id);
        return new ResponseEntity<>(HttpStatus.OK);
    }
}

• @RestController:这个注解将EmployeeController标记为一个HTTP请求处理程序，并允许Spring将其识别为一个RESTful服务。
• @RequestMapping("/employee") 注解将控制器中的资源端点的基本路径设置为/employee。
• 接下来，我们将EmployeeService自动连接到我们的控制器中，以使用它所声明的方法。这就是依赖性注入。
• @GetMapping 是 的快捷方式，用于映射HTTP GET请求到映射的控制器方法。我们用它来返回所有的雇员和一个雇员。@RequestMapping(method = RequestMethod.GET)
• @PathVariable 注解表明一个方法参数应该被绑定到URI模板变量。
• @PostMapping 是@RequestMapping的缩写，其中的方法等于POST。它用于映射HTTP POST请求到映射的控制器方法。
• @RequestBody:这个注解在注册的HttpMessageConverters的帮助下，负责将Web请求体与方法参数绑定。因此，当你向"/employee/add "URL发出带有Post JSON主体的POST请求时，HttpMessageConverters将JSON请求主体转换为Post对象并将其传递给addEmployee方法。
• @PutMapping 是@RequestMapping的一个缩写，其中方法等于PUT。它用于映射HTTP PUT请求到映射的控制器方法。
• @DeleteMapping:使用这个注解使映射的控制器方法准备好进行删除操作。它是@RequestMapping(method = RequestMethod.DELETE) 的一个快捷方式。

使用Postman测试

现在，让我们用Postman测试一下我们的API。

添加一个雇员记录

让我们重新运行应用程序，然后通过向POST 请求添加一个雇员，localhost:8081/employee/add 。

让我们再次检查我们的MySQL数据库以确认。轰！"。我们走吧。

获取所有雇员记录

向localhost:8081/employee/all 发出一个GET 请求，以获得所有的雇员。我已经添加了两个雇员。

轰！"。它已经返回了一个所有雇员的列表。我们可以再次检查MySQL Workbench。

获取一个雇员记录

向localhost:8081/employee/find/3 发出一个GET 请求，在URL末尾指定雇员的ID。在我们的例子中，ID 是3 。

更新一个雇员的记录

localhost:8081/employee/update/3 向PUT 发出请求，在URL的末尾指定雇员的ID。在我们的例子中，ID 是3。添加要更新的字段作为requestBody。

删除一个雇员记录

DELETE 向localhost:8081/employee/delete/3 发出请求，在URL的末尾添加要删除的todo的ID。在我们的例子中，ID 是3。我们得到一个200 OK ，显示一个成功的删除操作。

我们得到一个200 OK ，显示删除操作成功。如果我们检查一下MySQL数据库，在删除了一个雇员后，我们应该只剩下两个雇员。我们删除了ID为3的雇员。

用Swagger UI记录API

我们已经将io.springfox 依赖关系添加到pom.xml 。

有了这个依赖关系，我们将记录这些API，以便其他开发者可以轻松使用它们。在你的EmployeeController class 的类层次上添加下面的ApiResponses annotation 。

package com.lekwacious.employee_app.web;

import com.lekwacious.employee_app.data.models.Employee;
import com.lekwacious.employee_app.data.payloads.request.EmployeeRequest;
import com.lekwacious.employee_app.data.payloads.response.MessageResponse;
import com.lekwacious.employee_app.service.EmployeeService;
import io.swagger.annotations.ApiResponses;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

@RestController
@RequestMapping("/employee")
@ApiResponses(value = {
        @io.swagger.annotations.ApiResponse(code = 400, message = "This is a bad request, please follow the API documentation for the proper request format"),
        @io.swagger.annotations.ApiResponse(code = 401, message = "Due to security constraints, your access request cannot be authorized"),
        @io.swagger.annotations.ApiResponse(code = 500, message = "The server is down. Please bear with us."),
}
)
public class EmployeeController {
}

• 我们在类的层面上添加了来自swagger的@ApiResponse 注解。
• 进入http://localhost:8081/swagger-ui/ ，访问文档，测试我们的API是否还能正常工作。
• 使用Swagger API文档，http://localhost:8081/swagger-ui/ ，添加一个雇员，获取、更新和删除一个雇员。

结论

我们已经成功地使用Spring Boot、Maven作为依赖性管理工具和MySQL来存储数据构建了API。

你已经学会了如何在你的应用程序中抛出异常，从而建立一个有弹性的系统。你还学会了如何使用Swagger记录你的API。