Spring Boot教程之四十六： Spring Boot 与 H2 数据库

Spring Boot 与 H2 数据库

Spring Boot 中的 H2 数据库是一个嵌入式、开源和内存数据库。它是一个用 Java 编写的关系数据库管理系统。它是一个客户端/服务器应用程序。它将数据存储在内存中，而不是将数据长期生存在磁盘上。在这里我们将讨论怎样使用 H2 数据库在 Spring Boot中设置和执行一些基本利用。

在本文中，我们将探讨怎样将H2 数据库与Spring Boot集成。H2 是一个轻量级的内存数据库，可简化开辟和测试。我们将先容设置、重要功能和基本CRUD 利用，以有用增强您的 Spring Boot 应用程序。

什么是 H2 数据库？

H2 是一个用 Java 编写的轻量级快速 SQL 数据库。它可以在两种模式下运行：内存模式和嵌入式模式。内存模式对于测试和开辟特别有用，因为它允许您创建一个暂时数据库，该数据库在应用程序制止时会自动销毁。嵌入式模式适用于须要小型独立数据库的应用程序。

H2数据库的特点：

• 非常快，开源，JDBC API
  
• 嵌入式和服务器模式；基于磁盘或内存的数据库。
  
• 事务支持，多版本并发
  
• 基于浏览器的控制台应用程序
  
• 加密数据库
  
• 全文搜索
  
• 纯 Java，占用空间小：jar 文件大小约为 2.5 MB
  
• ODBC 驱动程序
  

在 Spring Boot 应用程序中设置 H2 数据库

以下是在 Spring Boot 应用程序中设置 H2 数据库的步骤。

步骤 1：添加依靠项

要在 Spring Boot 应用程序中使用H2 数据库，我们必须在pom.xml文件中添加以下依靠项：

h2 和 spring-boot-starter-data-jpa 依靠项：

1. <dependency>
2.       <groupId>org.springframework.boot</groupId>      
3.       <artifactId>spring-boot-starter-data-jpa</artifactId>
4. </dependency>
5. <dependency>
6.       <groupId>com.h2database</groupId>
7.       <artifactId>h2</artifactId>
8.       <scope>runtime</scope>
9. </dependency>

复制代码

步骤 2：设置应用程序属性

在文件中设置H2数据库 application.properties ：

1. # H2 Database
2. spring.h2.console.enabled=true
3. spring.datasource.url=jdbc:h2:mem:dcbapp
4. spring.datasource.driverClassName=org.h2.Driver
5. spring.datasource.username=sa
6. spring.datasource.password=password
7. spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

复制代码

我们还可以通过向application.yml文件添加属性来使用YAML 文件举行数据库设置，如下所示：

1. spring:
2.     h2:
3.          console.enabled: true
4.     datasource:
5.          url: jdbc:h2:mem:dcbapp
6.          driverClassName: org.h2.Driver
7.          username: sa
8.          password: password
9.      jpa:
10.          spring.jpa.database-platform: org.hibernate.dialect.H2Dialect

复制代码

让我们通过打开 H2 数据库控制台来相识这些属性是什么。

访问 H2 控制台

默认情况下，H2 数据库的控制台视图是禁用的。在访问 H2 数据库之前，我们必须使用以下属性启用它：

1. spring.h2.console.enabled=true

复制代码

一旦我们启用了 H2 控制台，如今我们就可以通过调用 URL http://localhost:8082/h2-console在浏览器中访问 H2 控制台。

留意：提供运行 Spring 应用程序的端口号

下图显示了 H2 数据库的控制台视图。

在 Spring Boot 中使用 H2 数据库执行 CRUD 利用

我们将通过创建 Spring Boot 应用程序和使用 H2 数据库来执行一些基本的 CRUD 利用。

步骤1：创建Spring Boot项目

参考这篇文章怎样使用 IntelliJ IDEA 创建 Spring Boot 项目并创建一个 Spring Boot 项目。

第 2 步：添加以下依靠项

• Spring Web
  
• H2 Database
  
• Lombok
  
• Spring Data JPA
  

以下是pom.xml文件的完整代码。请检查是否有遗漏。

pom.xml：

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.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.amiya</groupId>
    <artifactId>Spring-Boot-Demo-Project</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <name>Spring-Boot-Demo-Project</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-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
 

步骤 3：创建课程

创建 4 个包，然后在这些包中创建一些类和接口，如下图所示

• entity
  
• repository
  
• service
  
• controller
  

笔记：

• 绿色圆形图标“I”按钮是界面。
  
• 蓝色圆形图标‘C’按钮是种别。
  

步骤4：Entity Class

在 Department.java 文件中创建一个简单的POJO 类。

Department.java:

Java

// Java Program to Demonstrate Department File
// Importing required package modules
package com.amiya.springbootdemoproject.entity;
// Importing required classes (using jakarta.persistence now)
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
// Class
public class Department {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long departmentId;
    private String departmentName;
    private String departmentAddress;
    private String departmentCode;
}

步骤 5：创建存储库

创建一个简单的接口，并将该接口定名为 DepartmentRepository。正如我们上面讨论的那样，这个接口将扩展 CrudRepository。

示例：下面是DepartmentRepository.java文件的代码。

Java

package com.amiya.springbootdemoproject.repository;
import com.amiya.springbootdemoproject.entity.Department;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
// Annotation
@Repository
// Interface extending CrudRepository
public interface DepartmentRepository
    extends CrudRepository<Department, Long> {
}

步骤 6：创建服务类

在包内创建一个名为DepartmentService 的接口和一个名为DepartmentServiceImpl 的类。

示例 1-A：

Java

// Java Program to Demonstrate DepartmentService File
// Importing required package modules
package com.amiya.springbootdemoproject.service;
import com.amiya.springbootdemoproject.entity.Department;
// Importing required classes
import java.util.List;
// Interface
public interface DepartmentService {
    // Save operation
    Department saveDepartment(Department department);
    // Read operation
    List<Department> fetchDepartmentList();
    // Update operation
    Department updateDepartment(Department department,
                                Long departmentId);
    // Delete operation
    void deleteDepartmentById(Long departmentId);
}

示例 1-B：

Java

// Java Program to Demonstrate DepartmentServiceImpl.java
// File
// Importing required package modules
package com.amiya.springbootdemoproject.service;
import com.amiya.springbootdemoproject.entity.Department;
import com.amiya.springbootdemoproject.repository.DepartmentRepository;
import java.util.List;
import java.util.Objects;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
// Annotation
@Service
// Class
public class DepartmentServiceImpl
    implements DepartmentService {
    @Autowired
    private DepartmentRepository departmentRepository;
    // Save operation
    @Override
    public Department saveDepartment(Department department)
    {
        return departmentRepository.save(department);
    }
    // Read operation
    @Override public List<Department> fetchDepartmentList()
    {
        return (List<Department>)
            departmentRepository.findAll();
    }
    // Update operation
    @Override
    public Department
    updateDepartment(Department department,
                     Long departmentId)
    {
        Department depDB
            = departmentRepository.findById(departmentId)
                  .get();
        if (Objects.nonNull(department.getDepartmentName())
            && !"".equalsIgnoreCase(
                department.getDepartmentName())) {
            depDB.setDepartmentName(
                department.getDepartmentName());
        }
        if (Objects.nonNull(
                department.getDepartmentAddress())
            && !"".equalsIgnoreCase(
                department.getDepartmentAddress())) {
            depDB.setDepartmentAddress(
                department.getDepartmentAddress());
        }
        if (Objects.nonNull(department.getDepartmentCode())
            && !"".equalsIgnoreCase(
                department.getDepartmentCode())) {
            depDB.setDepartmentCode(
                department.getDepartmentCode());
        }
        return departmentRepository.save(depDB);
    }
    // Delete operation
    @Override
    public void deleteDepartmentById(Long departmentId)
    {
        departmentRepository.deleteById(departmentId);
    }
}

步骤 7：创建控制器

在包内创建一个名为DepartmentController 的类。

Java

// java Program to Illustrate DepartmentController File
// Importing required packages modules
package com.amiya.springbootdemoproject.controller;
import com.amiya.springbootdemoproject.entity.Department;
import com.amiya.springbootdemoproject.service.DepartmentService;
import java.util.List;
// Importing required classes
import jakarta.validation.Valid;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
// Annotation
@RestController
// Class
public class DepartmentController {
    @Autowired private DepartmentService departmentService;
    // Save operation
    @PostMapping("/departments")
    public Department saveDepartment(
        @Valid @RequestBody Department department)
    {
        return departmentService.saveDepartment(department);
    }
    // Read operation
    @GetMapping("/departments")
    public List<Department> fetchDepartmentList()
    {
        return departmentService.fetchDepartmentList();
    }
    // Update operation
    @PutMapping("/departments/{id}")
    public Department
    updateDepartment(@RequestBody Department department,
                     @PathVariable("id") Long departmentId)
    {
        return departmentService.updateDepartment(
            department, departmentId);
    }
    // Delete operation
    @DeleteMapping("/departments/{id}")
    public String deleteDepartmentById(@PathVariable("id")
                                       Long departmentId)
    {
        departmentService.deleteDepartmentById(
            departmentId);
        return "Deleted Successfully";
    }
}
访问 H2 数据库

以下是application.properties文件的属性。

1. server.port = 8082# H2 Database
2. spring.h2.console.enabled=true
3. spring.datasource.url=jdbc:h2:mem:dcbapp
4. spring.datasource.driverClassName=org.h2.Driver
5. spring.datasource.username=sa
6. spring.datasource.password=password
7. spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

复制代码

对于application.yml文件：

1. spring:
2.     h2:
3.         console.enabled=true
4.     datasource:
5.         url: jdbc:h2:mem:dcbapp
6.         driverClassName: org.h2.Driver
7.         username: sa
8.         password: password
9.     jpa:
10.         spring.jpa.database-platform: org.hibernate.dialect.H2Dialect

复制代码

如今运行您的应用程序，让我们在Postman中测试端点并参考我们的H2 数据库。

在 Postman 中测试端点

端点 1： POST – http://localhost:8082/departments/

端点 2： GET – http://localhost:8082/departments/

端点 3： PUT – http://localhost:8082/departments/1

端点 4：删除 – http://localhost:8082/departments/1

末了，H2 数据库如下图所示：

末了：

在本文中，我们学习了怎样设置、访问 H2 数据库以及怎样在 Postman 中测试端点以管理正在运行的数据库。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。