Spring Boot H2 简明教程
Spring Boot & H2 - Overview
What is H2?
H2 数据库是一个开源、嵌入式且内存驻留的关系数据库管理系统。它使用 Java 编写,提供一个客户端/服务器应用程序。它将数据存储在系统内存中,而不是磁盘。一旦程序关闭,数据也会丢失。当我们不想保留数据以及单元测试整体功能时,可以使用内存数据库。其他一些流行的内存数据库包括 HSQLDB 或 HyperSQL 数据库以及 Apache Derby。H2 是其他嵌入式数据库中最流行的数据库。
Advantages of H2 Database
以下是 H2 提供的优势列表 -
-
No configuration - Spring Boot 本质上支持 H2,不需要额外的配置来配置 H2 数据库。
-
Easy to Use - H2 数据库非常易于使用。
-
Lightweight and Fast - H2 数据库非常轻量级,而且由于处于内存中,因此非常快。
-
Switch configurations - 使用配置文件,您可以轻松地在生产级别数据库和内存数据库之间切换。
-
Supports Standard SQL and JDBC - H2 数据库支持标准 SQL 的几乎所有功能以及 JDBC 的操作。
-
Web Based Console - H2 数据库可以通过其基于 Web 的控制台应用程序进行管理。
Configuring H2 Database
将 H2 数据库添加为 maven 依赖项,就是这样。
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
尽管 Spring Boot 会自动配置 H2 数据库。我们可以在 application.properties 中指定它们来覆盖默认配置,如下所示。
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true
Spring Boot & H2 - Environment Setup
本章将指导你如何准备一个开发环境来开始你使用 Spring Framework 的工作。它还将教你如何在设置 Spring Framework 之前在你的机器上设置 JDK、Tomcat 和 Eclipse −
Step 1 - Setup Java Development Kit (JDK)
Java SE 可免费下载。若要下载 click here,请下载与你的操作系统兼容的版本。
按照说明下载 Java,并运行 .exe 在你的计算机上安装 Java。在计算机上安装 Java 后,你需要设置环境变量来指向正确的安装目录。
Setting Up the Path for Windows 2000/XP
假设你已将 Java 安装在 c:\Program Files\java\jdk 目录中 −
-
右键单击“我的电脑”,然后选择“属性”。
-
单击“高级”选项卡下的“环境变量”按钮。
-
现在,编辑“Path”变量,并添加路径到 Java 可执行目录的末尾。例如,如果路径当前设置为 C:\Windows\System32,请以下面的方式编辑它
C:\Windows\System32;c:\Program Files\java\jdk\bin
Setting Up the Path for Windows 95/98/ME
假设你已将 Java 安装在 c:\Program Files\java\jdk 目录中 −
-
编辑“C:\autoexec.bat”文件并在末尾添加以下行 −
SET PATH=%PATH%;C:\Program Files\java\jdk\bin
Setting Up the Path for Linux, UNIX, Solaris, FreeBSD
环境变量 PATH 应设置为指向已安装 Java 二进制文件的位置。如果你在这方面遇到问题,请参阅 shell 文档。
例如,如果你使用 bash 作为你的 shell,那么你将在 .bashrc 的末尾添加以下行 −
export PATH=/path/to/java:$PATH'
或者,如果你使用诸如 Borland JBuilder、Eclipse、IntelliJ IDEA 或 Sun ONE Studio 这样的集成开发环境 (IDE),则必须编译并运行一个简单程序来确认 IDE 知道你在何处安装了 Java。否则,你必须按照 IDE 文档中给出的内容执行正确的设置。
Step 2 - Setup Eclipse IDE
本教程中的所有示例都是使用 Eclipse IDE 编写的。因此,我们建议你应该在你机器上安装 Eclipse 的最新版本。
要安装 Eclipse IDE,请从 www.eclipse.org/downloads 下载最新的 Eclipse 二进制文件。下载安装文件后,将二进制分发包解压到方便的位置。例如,在 Windows 上的 C:\eclipse 中,或 Linux/Unix 上的 /usr/local/eclipse 中,最后相应地设置 PATH 变量。
可以通过在 Windows 机器上执行以下命令启动 Eclipse,或者你只需双击 eclipse.exe
%C:\eclipse\eclipse.exe
可以通过在 Unix(Solaris、Linux 等)机器上执行以下命令启动 Eclipse −
$/usr/local/eclipse/eclipse
Step 3 - Setup m2eclipse
M2Eclipse 是一个 Eclipse 插件,它对于将 Apache Maven 集成到 Eclipse IDE 中非常有用。我们在本教程中使用 maven 来构建 spring boot 项目,并使用 m2eclipse 在 eclipse 内运行示例。
使用 Eclipse IDE 中的 Install New Software 对话框安装最新的 M2Eclipse 版本,并将其指向这个 p2 存储库: https://download.eclipse.org/technology/m2e/releases/latest/
Step 4 - Setup Spring Boot Project
现在,如果一切正常,则可以继续设置 Spring Boot。以下是下载和在机器上安装 Spring Boot 项目的简单步骤。
-
转到 spring Initializr 链接以创建一个 spring boot 项目, https://start.spring.io/ 。
-
选择项目作为 Maven Project 。
-
Select language as Java.
-
选择 Spring Boot 版本作为 2.5.3 。
-
将项目元数据设定为 - 组为 com.tutorialspoint ,工件为 springboot-h2 ,名称为 springboot-h2 ,描述为 Demo project for Spring Boot and H2 Database ,包名为 com.tutorialspoint.springboot-h2 。
-
Select packaging as Jar.
-
Select java as 11.
-
添加依赖关系为 Spring Web, Spring Data JPA, H2 Database and Spring Boot DevTools 。
现在点击生成按钮来生成项目结构。
一旦基于 maven 的 Spring Boot 项目下载完成,然后将 maven 项目导入 eclipse,其余操作由 eclipse 处理。它将下载 maven 依赖关系,并构建项目以使之可以进行进一步的开发。
Step 5 - POSTMAN for REST APIs Testing
POSTMAN 是一款用来测试基于 REST 的 API 的有用工具。要安装 POSTMAN,可从 www.postman.com/downloads/ 下载最新的 POSTMAN 二进制文件。下载完可安装文件后,按照说明进行安装并使用。
Spring Boot & H2 - Project Setup
如前一章 Environment Setup 中所述,我们在 Eclipse 中导入了 Spring Boot 生成的项目。现在让我们在 src/main/java 文件夹中创建以下结构。
-
com.tutorialspoint.controller.EmployeeController ——一个REST基于控制器实现REST基于API。
-
com.tutorialspoint.entity.Employee ——一个实体类表示数据库中对应的表。
-
com.tutorialspoint.repository.EmployeeRepository ——一个存储库接口来执行crud操作库。
-
com.tutorialspoint.service.EmployeeService ——一个服务类来执行业务操作库函数。
-
com.tutorialspoint.springbooth2.SprintBootH2Application ——一个SpringBoot应用程序类。
SprintBootH2Application类已存在。我们须创建上述包和相关类和接口如下所示——
Entity - Entity.java
以下为Employee的默认代码。它表示一个带id,name,age和email列的Employee表。
package com.tutorialspoint.entity;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table
public class Employee {
@Id
@Column
private int id;
@Column
private String name;
@Column
private int age;
@Column
private String email;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
Repository - EmployeeRepository.java
以下为实现上述实体创建CRUD操作的存储库的默认代码,Employee。
package com.tutorialspoint.repository;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import com.tutorialspoint.entity.Employee;
@Repository
public interface EmployeeRepository extends CrudRepository<Employee, Integer> {
}
Service - EmployeeService.java
以下为实现库函数操作的服务的默认代码。
package com.tutorialspoint.service;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.tutorialspoint.entity.Employee;
import com.tutorialspoint.repository.EmployeeRepository;
@Service
public class EmployeeService {
@Autowired
EmployeeRepository repository;
public Employee getEmployeeById(int id) {
return null;
}
public List<Employee> getAllEmployees(){
return null;
}
public void saveOrUpdate(Employee employee) {
}
public void deleteEmployeeById(int id) {
}
}
Controller - EmployeeController.java
以下为实现REST API的控制器的默认代码。
package com.tutorialspoint.controller;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.tutorialspoint.entity.Employee;
import com.tutorialspoint.service.EmployeeService;
@RestController
@RequestMapping(path = "/emp")
public class EmployeeController {
@Autowired
EmployeeService employeeService;
@GetMapping("/employees")
public List<Employee> getAllEmployees(){
return null;
}
@GetMapping("/employee/{id}")
public Employee getEmployee(@PathVariable("id") int id) {
return null;;
}
@DeleteMapping("/employee/{id}")
public void deleteEmployee(@PathVariable("id") int id) {
}
@PostMapping("/employee")
public void addEmployee(@RequestBody Employee employee) {
}
@PutMapping("/employee")
public void updateEmployee(@RequestBody Employee employee) {
}
}
Application - SprintBootH2Application.java
以下为用于使用上述类的Application的更新代码。
package com.tutorialspoint.sprintbooth2;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
@ComponentScan({"com.tutorialspoint.controller","com.tutorialspoint.service"})
@EntityScan("com.tutorialspoint.entity")
@EnableJpaRepositories("com.tutorialspoint.repository")
@SpringBootApplication
public class SprintBootH2Application {
public static void main(String[] args) {
SpringApplication.run(SprintBootH2Application.class, args);
}
}
Spring Boot & H2 - REST APIs
与上一章 Application Setup 一样,我们在 Spring Boot 项目中创建了所需文件。现在在 POSTMAN 中创建以下集合来测试 REST API。
-
GET Get All Employees − 这是一个返回所有员工的 GET 请求。
-
POST Add an Employee − 这是一个创建员工的 POST 请求。
-
PUT Update an Employee − 这是一个更新现有员工的 PUT 请求。
-
GET An Employee − 这是一个获取通过其 id 识别的员工的 GET 请求。
-
Delete An Employee − 这是一个删除通过其 id 识别的员工的删除请求。
Add an Employee
在 POSTMAN 中设置以下参数。
-
HTTP Method − POST
-
正文 - An employee JSON
{
"id": "1",
"age": "35",
"name": "Julie",
"email": "julie@gmail.com"
}
Update an Employee
在 POSTMAN 中设置以下参数。
-
HTTP Method − PUT
-
正文 - An employee JSON
{
"id": "1",
"age": "35",
"name": "Julie",
"email": "julie.roberts@gmail.com"
}
GET An Employees
在 POSTMAN 中设置以下参数。
-
HTTP Method − GET
-
URL - http://localhost:8080/emp/employee/1 − 其中 1 为员工 ID
Delete An Employees
在 POSTMAN 中设置以下参数。
-
HTTP Method − DELETE
-
URL - http://localhost:8080/emp/employee/1 − 其中 1 为员工 ID
Spring Boot & H2 - Console
与上一章 Application Setup 一样,我们在 Spring Boot 项目中创建了所需文件。现在让我们来更新位于 src/main/resources 和 pom.xml 中的 application.properties,以使用 maven-resources-plugin 的不同版本。
application.properties
spring.datasource.url=jdbc:h2:mem:testdb
pom.xml
...
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-resources-plugin</artifactId>
<version>3.1.0</version>
</plugin>
</plugins>
</build>
...
Run the application
在 Eclipse 中,按照在 Application Setup 准备期间准备 Employee Application 配置。
Eclipse 控制台将显示类似的输出。
[INFO] Scanning for projects...
[INFO]
[INFO] -----------------< com.tutorialspoint:sprint-boot-h2 >------------------
[INFO] Building sprint-boot-h2 0.0.1-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
...
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v2.5.2)
...
2021-07-24 20:51:11.347 INFO 9760 --- [ restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer
: Tomcat initialized with port(s): 8080 (http)
...
2021-07-24 20:51:11.840 INFO 9760 --- [ restartedMain] o.s.b.a.h2.H2ConsoleAutoConfiguration
: H2 console available at '/h2-console'. Database available at 'jdbc:h2:mem:testdb'
...
2021-07-24 20:51:14.805 INFO 9760 --- [ restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer
: Tomcat started on port(s): 8080 (http) with context path ''
2021-07-24 20:51:14.823 INFO 9760 --- [ restartedMain] c.t.s.SprintBootH2Application
: Started SprintBootH2Application in 7.353 seconds (JVM running for 8.397)
服务器启动并运行后,在浏览器中打开 localhost:8080/h2-console ,然后点击“测试连接”以验证数据库连接。
点击“连接”按钮,H2 数据库窗口将如以下所示出现 -
Spring Boot & H2 - Add Record
让我们现在更新到目前创建的项目,以准备一个完整的添加记录 API 并对其进行测试。
Update Service
// Use repository.save() to persist Employee entity in database
public void saveOrUpdate(Employee employee) {
repository.save(employee);
}
EmployeeService
package com.tutorialspoint.service;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.tutorialspoint.entity.Employee;
import com.tutorialspoint.repository.EmployeeRepository;
@Service
public class EmployeeService {
@Autowired
EmployeeRepository repository;
public Employee getEmployeeById(int id) {
return null;
}
public List<Employee> getAllEmployees(){
return null;
}
public void saveOrUpdate(Employee employee) {
repository.save(employee);
}
public void deleteEmployeeById(int id) {
}
}
Update Controller
// Use service.saveOrUpdate() to persist Employee entity in database
@PostMapping("/employee")
public void addEmployee(@RequestBody Employee employee) {
employeeService.saveOrUpdate(employee);
}
EmployeeController
package com.tutorialspoint.controller;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.tutorialspoint.entity.Employee;
import com.tutorialspoint.service.EmployeeService;
@RestController
@RequestMapping(path = "/emp")
public class EmployeeController {
@Autowired
EmployeeService employeeService;
@GetMapping("/employees")
public List<Employee> getAllEmployees(){
return null;
}
@GetMapping("/employee/{id}")
public Employee getEmployee(@PathVariable("id") int id) {
return null;;
}
@DeleteMapping("/employee/{id}")
public void deleteEmployee(@PathVariable("id") int id) {
}
@PostMapping("/employee")
public void addEmployee(@RequestBody Employee employee) {
employeeService.saveOrUpdate(employee);
}
@PutMapping("/employee")
public void updateEmployee(@RequestBody Employee employee) {
}
}
Run the application
在 Eclipse 中,按照在 Application Setup 准备期间准备 Employee Application 配置。
Eclipse 控制台将显示类似的输出。
[INFO] Scanning for projects...
...
2021-07-24 20:51:14.823 INFO 9760 --- [ restartedMain] c.t.s.SprintBootH2Application
: Started SprintBootH2Application in 7.353 seconds (JVM running for 8.397)
服务器启动并运行后,使用 Postman 执行 POST 请求 -
在 POSTMAN 中设置以下参数。
-
HTTP Method − POST
-
正文 - An employee JSON
{
"id": "1",
"age": "35",
"name": "Julie",
"email": "julie@gmail.com"
}
单击发送按钮并检查响应状态是否为 OK。现在打开 H2 控制台并使用以下查询验证已插入的记录 -
Select * from Employee;
它应显示以下结果 -
ID AGE EMAIL NAME
1 35 julie@gmail.com Julie
Spring Boot & H2 - Get Record
现在让我们来更新到目前为止创建的项目,以准备一个完整的获取记录 API 并对其进行测试。
Update Service
// Use repository.findById() to get Employee entity by Id
public Employee getEmployeeById(int id) {
return repository.findById(id).get();
}
EmployeeService
package com.tutorialspoint.service;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.tutorialspoint.entity.Employee;
import com.tutorialspoint.repository.EmployeeRepository;
@Service
public class EmployeeService {
@Autowired
EmployeeRepository repository;
public Employee getEmployeeById(int id) {
return repository.findById(id).get();
}
public List<Employee> getAllEmployees(){
return null;
}
public void saveOrUpdate(Employee employee) {
repository.save(employee);
}
public void deleteEmployeeById(int id) {
}
}
Update Controller
// Use service.getEmployeeById() to get Employee entity from database
@GetMapping("/employee/{id}")
public Employee getEmployee(@PathVariable("id") int id) {
return employeeService.getEmployeeById(id);
}
EmployeeController
package com.tutorialspoint.controller;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.tutorialspoint.entity.Employee;
import com.tutorialspoint.service.EmployeeService;
@RestController
@RequestMapping(path = "/emp")
public class EmployeeController {
@Autowired
EmployeeService employeeService;
@GetMapping("/employees")
public List<Employee> getAllEmployees(){
return null;
}
@GetMapping("/employee/{id}")
public Employee getEmployee(@PathVariable("id") int id) {
return employeeService.getEmployeeById(id);
}
@DeleteMapping("/employee/{id}")
public void deleteEmployee(@PathVariable("id") int id) {
}
@PostMapping("/employee")
public void addEmployee(@RequestBody Employee employee) {
employeeService.saveOrUpdate(employee);
}
@PutMapping("/employee")
public void updateEmployee(@RequestBody Employee employee) {
}
}
Run the application
在 Eclipse 中,按照在 Application Setup 准备期间准备 Employee Application 配置。
Eclipse 控制台将显示类似的输出。
[INFO] Scanning for projects...
...
2021-07-24 20:51:14.823 INFO 9760 --- [ restartedMain] c.t.s.SprintBootH2Application
: Started SprintBootH2Application in 7.353 seconds (JVM running for 8.397)
服务器启动并运行后,使用 Postman 先执行 POST 请求以添加记录。
在 POSTMAN 中设置以下参数。
-
HTTP Method − POST
-
正文 - An employee JSON
{
"id": "1",
"age": "35",
"name": "Julie",
"email": "julie@gmail.com"
}
点击发送按钮并检查响应状态是否为 OK。现在发送一个 GET 请求来获取该记录。
在 POSTMAN 中设置以下参数。
-
HTTP Method − GET
单击发送按钮并验证响应。
{
"id": "1",
"age": "35",
"name": "Julie",
"email": "julie@gmail.com"
}
Spring Boot & H2 - Get All Records
让我们现在更新到目前创建的项目,以准备一个完整的所有记录获取 API 并对其进行测试。
Update Service
// Use repository.findAll() to get all Employee records
public List<Employee> getAllEmployees(){
List<Employee> employees = new ArrayList<Employee>();
repository.findAll().forEach(employee -> employees.add(employee));
return employees;
}
EmployeeService
package com.tutorialspoint.service;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.tutorialspoint.entity.Employee;
import com.tutorialspoint.repository.EmployeeRepository;
@Service
public class EmployeeService {
@Autowired
EmployeeRepository repository;
public Employee getEmployeeById(int id) {
return repository.findById(id).get();
}
public List<Employee> getAllEmployees(){
List<Employee> employees = new ArrayList<Employee>();
repository.findAll().forEach(employee -> employees.add(employee));
return employees;
}
public void saveOrUpdate(Employee employee) {
repository.save(employee);
}
public void deleteEmployeeById(int id) {
}
}
Update Controller
// Use service.getAllEmployees() to get a list of employees from database
@GetMapping("/employees")
public List<Employee> getAllEmployees(){
return employeeService.getAllEmployees();
}
EmployeeController
package com.tutorialspoint.controller;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.tutorialspoint.entity.Employee;
import com.tutorialspoint.service.EmployeeService;
@RestController
@RequestMapping(path = "/emp")
public class EmployeeController {
@Autowired
EmployeeService employeeService;
@GetMapping("/employees")
public List<Employee> getAllEmployees(){
return employeeService.getAllEmployees();
}
@GetMapping("/employee/{id}")
public Employee getEmployee(@PathVariable("id") int id) {
return employeeService.getEmployeeById(id);
}
@DeleteMapping("/employee/{id}")
public void deleteEmployee(@PathVariable("id") int id) {
}
@PostMapping("/employee")
public void addEmployee(@RequestBody Employee employee) {
employeeService.saveOrUpdate(employee);
}
@PutMapping("/employee")
public void updateEmployee(@RequestBody Employee employee) {
}
}
Run the application
在 Eclipse 中,按照在 Application Setup 准备期间准备 Employee Application 配置。
Eclipse 控制台将显示类似的输出。
[INFO] Scanning for projects...
...
2021-07-24 20:51:14.823 INFO 9760 --- [ restartedMain] c.t.s.SprintBootH2Application
: Started SprintBootH2Application in 7.353 seconds (JVM running for 8.397)
服务器启动并运行后,使用 Postman 先执行 POST 请求以添加记录。
在 POSTMAN 中设置以下参数。
-
HTTP Method − POST
-
正文 - An employee JSON
{
"id": "1",
"age": "35",
"name": "Julie",
"email": "julie@gmail.com"
}
单击发送按钮并检查响应状态是否为 OK。现在执行 GET 请求以获取所有记录。
在 POSTMAN 中设置以下参数。
-
HTTP Method − GET
单击发送按钮并验证响应。
[{
"id": "1",
"age": "35",
"name": "Julie",
"email": "julie@gmail.com"
}]
Spring Boot & H2 - Update Record
让我们现在更新到目前为止创建的项目以准备一个完整的更新记录API并对其进行测试。
Update Controller
// Use service.saveOrUpdate() to update an employee record
@PutMapping("/employee")
public void updateEmployee(@RequestBody Employee employee) {
employeeService.saveOrUpdate(employee);
}
EmployeeController
package com.tutorialspoint.controller;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.tutorialspoint.entity.Employee;
import com.tutorialspoint.service.EmployeeService;
@RestController
@RequestMapping(path = "/emp")
public class EmployeeController {
@Autowired
EmployeeService employeeService;
@GetMapping("/employees")
public List<Employee> getAllEmployees(){
return employeeService.getAllEmployees();
}
@GetMapping("/employee/{id}")
public Employee getEmployee(@PathVariable("id") int id) {
return employeeService.getEmployeeById(id);
}
@DeleteMapping("/employee/{id}")
public void deleteEmployee(@PathVariable("id") int id) {
employeeService.deleteEmployeeById(id);
}
@PostMapping("/employee")
public void addEmployee(@RequestBody Employee employee) {
employeeService.saveOrUpdate(employee);
}
@PutMapping("/employee")
public void updateEmployee(@RequestBody Employee employee) {
employeeService.saveOrUpdate(employee);
}
}
Run the application
在 Eclipse 中,按照在 Application Setup 准备期间准备 Employee Application 配置。
Eclipse 控制台将显示类似的输出。
[INFO] Scanning for projects...
...
2021-07-24 20:51:14.823 INFO 9760 --- [ restartedMain] c.t.s.SprintBootH2Application
: Started SprintBootH2Application in 7.353 seconds (JVM running for 8.397)
服务器启动并运行后,使用 Postman 先执行 POST 请求以添加记录。
在 POSTMAN 中设置以下参数。
-
HTTP Method − POST
-
正文 - An employee JSON
{
"id": "1",
"age": "35",
"name": "Julie",
"email": "julie@gmail.com"
}
单击发送按钮并检查响应状态是否为OK。
现在发出Put请求来更新该记录。
在 POSTMAN 中设置以下参数。
-
HTTP Method − PUT
-
正文 - An employee JSON
{
"id": "1",
"age": "35",
"name": "Julie",
"email": "julie.roberts@gmail.com"
}
单击发送按钮并验证响应状态是否为OK。
现在发出GET请求来获取所有记录。
在 POSTMAN 中设置以下参数。
-
HTTP Method − GET
单击发送按钮并验证响应。
[{
"id": "1",
"age": "35",
"name": "Julie",
"email": "julie.roberts@gmail.com"
}]
Spring Boot & H2 - Delete Record
现在,让我们更新到目前为止创建的项目,以准备一个完整的 Delete Record API 并对其进行测试。
Update Service
// Use repository.deleteById() to delete an Employee record
public void deleteEmployeeById(int id) {
repository.deleteById(id);
}
EmployeeService
package com.tutorialspoint.service;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.tutorialspoint.entity.Employee;
import com.tutorialspoint.repository.EmployeeRepository;
@Service
public class EmployeeService {
@Autowired
EmployeeRepository repository;
public Employee getEmployeeById(int id) {
return repository.findById(id).get();
}
public List<Employee> getAllEmployees(){
List<Employee> employees = new ArrayList<Employee>();
repository.findAll().forEach(employee -> employees.add(employee));
return employees;
}
public void saveOrUpdate(Employee employee) {
repository.save(employee);
}
public void deleteEmployeeById(int id) {
repository.deleteById(id);
}
}
Update Controller
// Use service.deleteEmployeeById() to delete an employee by id
@DeleteMapping("/employee/{id}")
public void deleteEmployee(@PathVariable("id") int id) {
employeeService.deleteEmployeeById(id);
}
EmployeeController
package com.tutorialspoint.controller;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.tutorialspoint.entity.Employee;
import com.tutorialspoint.service.EmployeeService;
@RestController
@RequestMapping(path = "/emp")
public class EmployeeController {
@Autowired
EmployeeService employeeService;
@GetMapping("/employees")
public List<Employee> getAllEmployees(){
return employeeService.getAllEmployees();
}
@GetMapping("/employee/{id}")
public Employee getEmployee(@PathVariable("id") int id) {
return employeeService.getEmployeeById(id);
}
@DeleteMapping("/employee/{id}")
public void deleteEmployee(@PathVariable("id") int id) {
employeeService.deleteEmployeeById(id);
}
@PostMapping("/employee")
public void addEmployee(@RequestBody Employee employee) {
employeeService.saveOrUpdate(employee);
}
@PutMapping("/employee")
public void updateEmployee(@RequestBody Employee employee) {
}
}
Run the application
在 Eclipse 中,按照在 Application Setup 准备期间准备 Employee Application 配置。
Eclipse 控制台将显示类似的输出。
[INFO] Scanning for projects...
...
2021-07-24 20:51:14.823 INFO 9760 --- [ restartedMain] c.t.s.SprintBootH2Application
: Started SprintBootH2Application in 7.353 seconds (JVM running for 8.397)
服务器启动并运行后,使用 Postman 先执行 POST 请求以添加记录。
在 POSTMAN 中设置以下参数。
-
HTTP Method − POST
-
正文 - An employee JSON
{
"id": "1",
"age": "35",
"name": "Julie",
"email": "julie@gmail.com"
}
单击发送按钮并检查响应状态是否为OK。
现在发送一个 Delete 请求以删除该记录。
在 POSTMAN 中设置以下参数。
-
HTTP Method − DELETE
单击发送按钮并验证响应状态是否为OK。
现在发出GET请求来获取所有记录。
在 POSTMAN 中设置以下参数。
-
HTTP Method − GET
单击发送按钮并验证响应。
[]
Spring Boot & H2 - Unit Test Controller
与前一章一样,我们已经完成了 REST API。现在,让我们在 src/main/test 文件夹中创建以下结构。
-
com.tutorialspoint.controller.EmployeeControllerTest - 一个单元测试类,用于对 EmployeeController 的所有方法进行单元测试。
-
com.tutorialspoint.repository.EmployeeRepositoryTest - 一个单元测试类,用于对 EmployeeRepository 的所有方法进行单元测试。
-
com.tutorialspoint.service.EmployeeServiceTest - 一个单元测试类,用于对 EmployeeService 的所有方法进行单元测试。
SprintBootH2ApplicationTests 类已存在。我们需要创建上述包和相关类。
EmployeeControllerTest
要测试 REST 控制器,我们需要以下注释和类:
-
@ExtendWith(SpringExtension.class) ——使用SpringExtension类将类标记为以测试用例运行。
-
@SpringBootTest(classes = SprintBootH2Application.class) - 配置 Spring Boot 应用程序。
-
@AutoConfigureMockMvc - 用于自动配置 MockMVC 以模拟 HTTP 请求和响应。
-
@Autowired private MockMvc mvc; - 在测试中使用的 MockMvc 对象。
-
@MockBean private EmployeeController employeeController - 要测试的 EmployeeController 模拟对象。
以下是 EmployeeControllerTest 的完整代码。
package com.tutorialspoint.controller;
import static org.hamcrest.core.Is.is;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.doNothing;
import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.web.servlet.MockMvc;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tutorialspoint.entity.Employee;
import com.tutorialspoint.sprintbooth2.SprintBootH2Application;
@ExtendWith(SpringExtension.class)
@SpringBootTest(classes = SprintBootH2Application.class)
@AutoConfigureMockMvc
public class EmployeeControllerTest {
@Autowired
private MockMvc mvc;
@MockBean
private EmployeeController employeeController;
@Test
public void testGetAllEmployees() throws Exception {
Employee employee = getEmployee();
List<Employee> employees = new ArrayList<>();
employees.add(employee);
given(employeeController.getAllEmployees()).willReturn(employees);
mvc.perform(get("/emp/employees/").contentType(APPLICATION_JSON)).andExpect(status().isOk())
.andExpect(jsonPath("$[0].name", is(employee.getName())));
}
@Test
public void testGetEmployee() throws Exception {
Employee employee = getEmployee();
given(employeeController.getEmployee(1)).willReturn(employee);
mvc.perform(get("/emp/employee/" + employee.getId()).contentType(APPLICATION_JSON)).andExpect(status().isOk())
.andExpect(jsonPath("name", is(employee.getName())));
}
@Test
public void testDeleteEmployee() throws Exception {
Employee employee = getEmployee();
doNothing().when(employeeController).deleteEmployee(1);
mvc.perform(delete("/emp/employee/" + employee.getId()).contentType(APPLICATION_JSON))
.andExpect(status().isOk()).andReturn();
}
@Test
public void testAddEmployee() throws Exception {
Employee employee = getEmployee();
doNothing().when(employeeController).addEmployee(employee);
mvc.perform(post("/emp/employee/").content(asJson(employee)).contentType(APPLICATION_JSON))
.andExpect(status().isOk()).andReturn();
}
@Test
public void testUpdateEmployee() throws Exception {
Employee employee = getEmployee();
doNothing().when(employeeController).updateEmployee(employee);
mvc.perform(put("/emp/employee/").content(asJson(employee)).contentType(APPLICATION_JSON))
.andExpect(status().isOk()).andReturn();
}
private Employee getEmployee() {
Employee employee = new Employee();
employee.setId(1);
employee.setName("Mahesh");
employee.setAge(30);
employee.setEmail("mahesh@test.com");
return employee;
}
private static String asJson(final Object obj) {
try {
return new ObjectMapper().writeValueAsString(obj);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
Spring Boot & H2 - Unit Test Service
要测试服务,我们需要以下注释和类——
-
@ExtendWith(SpringExtension.class) ——使用SpringExtension类将类标记为以测试用例运行。
-
@SpringBootTest(classes = SprintBootH2Application.class) - 配置 Spring Boot 应用程序。
-
@MockBean private EmployeeService employeeService - 要测试的 EmployeeService 模拟对象。
以下是 EmployeeServiceTest 的完整代码。
package com.tutorialspoint.service;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.doNothing;
import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import com.tutorialspoint.entity.Employee;
import com.tutorialspoint.sprintbooth2.SprintBootH2Application;
@ExtendWith(SpringExtension.class)
@SpringBootTest(classes = SprintBootH2Application.class)
public class EmployeeServiceTest {
@MockBean
private EmployeeService employeeService;
@Test
public void testGetAllEmployees() throws Exception {
Employee employee = getEmployee();
List<Employee> employees = new ArrayList<>();
employees.add(employee);
given(employeeService.getAllEmployees()).willReturn(employees);
List<Employee> result = employeeService.getAllEmployees();
assertEquals(result.size(), 1);
}
@Test
public void testGetEmployee() throws Exception {
Employee employee = getEmployee();
given(employeeService.getEmployeeById(1)).willReturn(employee);
Employee result = employeeService.getEmployeeById(1);
assertEquals(result.getId(), 1);
}
@Test
public void testDeleteEmployee() throws Exception {
doNothing().when(employeeService).deleteEmployeeById(1);
employeeService.deleteEmployeeById(1);
assertTrue(true);
}
@Test
public void testSaveOrUpdateEmployee() throws Exception {
Employee employee = getEmployee();
doNothing().when(employeeService).saveOrUpdate(employee);
employeeService.saveOrUpdate(employee);
assertTrue(true);
}
private Employee getEmployee() {
Employee employee = new Employee();
employee.setId(1);
employee.setName("Mahesh");
employee.setAge(30);
employee.setEmail("mahesh@test.com");
return employee;
}
}
Spring Boot & H2 - Unit Test Repository
要测试存储库,我们需要以下注释和类:
-
@ExtendWith(SpringExtension.class) ——使用SpringExtension类将类标记为以测试用例运行。
-
@SpringBootTest(classes = SprintBootH2Application.class) - 配置 Spring Boot 应用程序。
-
@Transactional - 用于标记存储库以执行 CRUD 操作。
-
@Autowired private EmployeeRepository employeeRepository - 要测试的 EmployeeRepository 对象。
以下是 EmployeeRepositoryTest 的完整代码。
package com.tutorialspoint.repository;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.ArrayList;
import java.util.List;
import javax.transaction.Transactional;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import com.tutorialspoint.entity.Employee;
import com.tutorialspoint.sprintbooth2.SprintBootH2Application;
@ExtendWith(SpringExtension.class)
@Transactional
@SpringBootTest(classes = SprintBootH2Application.class)
public class EmployeeRepositoryTest {
@Autowired
private EmployeeRepository employeeRepository;
@Test
public void testFindById() {
Employee employee = getEmployee();
employeeRepository.save(employee);
Employee result = employeeRepository.findById(employee.getId()).get();
assertEquals(employee.getId(), result.getId());
}
@Test
public void testFindAll() {
Employee employee = getEmployee();
employeeRepository.save(employee);
List<Employee> result = new ArrayList<>();
employeeRepository.findAll().forEach(e -> result.add(e));
assertEquals(result.size(), 1);
}
@Test
public void testSave() {
Employee employee = getEmployee();
employeeRepository.save(employee);
Employee found = employeeRepository.findById(employee.getId()).get();
assertEquals(employee.getId(), found.getId());
}
@Test
public void testDeleteById() {
Employee employee = getEmployee();
employeeRepository.save(employee);
employeeRepository.deleteById(employee.getId());
List<Employee> result = new ArrayList<>();
employeeRepository.findAll().forEach(e -> result.add(e));
assertEquals(result.size(), 0);
}
private Employee getEmployee() {
Employee employee = new Employee();
employee.setId(1);
employee.setName("Mahesh");
employee.setAge(30);
employee.setEmail("mahesh@test.com");
return employee;
}
}