SpringBoot2.x教程：H2内存数据库CRUD实战指南

作者：暴富20212025.11.13 11:31浏览量：0

简介：本文详细介绍SpringBoot2.x整合H2内存数据库实现CRUD操作的全流程，涵盖依赖配置、实体类设计、Repository接口定义及Controller层实现，适合快速搭建测试环境。

SpringBoot2.x系列教程25—SpringBoot整合H2内存数据库实现CRUD操作

一、H2内存数据库简介

H2数据库是一款轻量级的Java关系型数据库，支持内存模式和磁盘模式两种运行方式。其核心优势在于零配置启动和嵌入式集成，尤其适合SpringBoot项目的本地开发与测试场景。内存模式下，数据库生命周期与JVM进程绑定，重启后数据自动清空，这一特性使其成为单元测试、原型开发的理想选择。

1.1 内存模式与持久化模式对比

特性 内存模式 磁盘模式
数据存储 JVM堆内存 文件系统
启动速度 极快（无需IO） 较慢（需加载文件）
数据持久性 进程终止后丢失 永久保存
适用场景 测试、临时数据存储 生产环境、长期数据存储

1.2 为什么选择H2进行开发测试？

  • 无服务器依赖：无需安装MySQL/PostgreSQL等外部数据库
  • 自动初始化：支持SQL脚本自动执行（schema.sql/data.sql）
  • Web控制台：内置可视化界面，方便调试
  • 多模式兼容：支持MySQL/Oracle等SQL语法模拟

二、SpringBoot整合H2配置详解

2.1 依赖管理（pom.xml）

  1. <dependencies>
  2.     <!-- Spring Data JPA -->
  3.     <dependency>
  4.         <groupId>org.springframework.boot</groupId>
  5.         <artifactId>spring-boot-starter-data-jpa</artifactId>
  6.     </dependency>
  8.     <!-- H2 Database -->
  9.     <dependency>
  10.         <groupId>com.h2database</groupId>
  11.         <artifactId>h2</artifactId>
  12.         <scope>runtime</scope>
  13.     </dependency>
  15.     <!-- Lombok（可选） -->
  16.     <dependency>
  17.         <groupId>org.projectlombok</groupId>
  18.         <artifactId>lombok</artifactId>
  19.         <optional>true</optional>
  20.     </dependency>
  21. </dependencies>

2.2 配置文件（application.yml）

  1. spring:
  2.   datasource:
  3.     url: jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1;MODE=MYSQL
  4.     driver-class-name: org.h2.Driver
  5.     username: sa
  6.     password: 
  7.   h2:
  8.     console:
  9.       enabled: true
  10.       path: /h2-console
  11.       settings:
  12.         web-allow-others: true
  13.   jpa:
  14.     hibernate:
  15.       ddl-auto: update
  16.     show-sql: true
  17.     properties:
  18.       hibernate:
  19.         format_sql: true

关键参数说明：

  • DB_CLOSE_DELAY=-1：防止JVM退出时自动关闭数据库
  • MODE=MYSQL：兼容MySQL语法（可选PostgreSQL/Oracle等）
  • ddl-auto: update：自动更新表结构（生产环境慎用）

三、CRUD操作实现

3.1 实体类设计（User.java）

  1. @Entity
  2. @Table(name = "t_user")
  3. @Data
  4. public class User {
  5.     @Id
  6.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  7.     private Long id;
  9.     @Column(nullable = false, length = 50)
  10.     private String username;
  12.     @Column(nullable = false, length = 100)
  13.     private String email;
  15.     @Column(name = "create_time")
  16.     private LocalDateTime createTime;
  18.     @PrePersist
  19.     public void prePersist() {
  20.         this.createTime = LocalDateTime.now();
  21.     }
  22. }

3.2 Repository接口定义

  1. public interface UserRepository extends JpaRepository<User, Long> {
  2.     // 自定义查询方法
  3.     List<User> findByUsernameContaining(String keyword);
  5.     @Query("SELECT u FROM User u WHERE u.email = :email")
  6.     Optional<User> findByEmail(@Param("email") String email);
  7. }

3.3 Service层实现

  1. @Service
  2. @RequiredArgsConstructor
  3. public class UserService {
  4.     private final UserRepository userRepository;
  6.     public User create(User user) {
  7.         return userRepository.save(user);
  8.     }
  10.     public Optional<User> findById(Long id) {
  11.         return userRepository.findById(id);
  12.     }
  14.     public List<User> findAll() {
  15.         return userRepository.findAll();
  16.     }
  18.     public User update(Long id, User userDetails) {
  19.         return userRepository.findById(id)
  20.                 .map(user -> {
  21.                     user.setUsername(userDetails.getUsername());
  22.                     user.setEmail(userDetails.getEmail());
  23.                     return userRepository.save(user);
  24.                 })
  25.                 .orElseThrow(() -> new RuntimeException("User not found"));
  26.     }
  28.     public void delete(Long id) {
  29.         userRepository.deleteById(id);
  30.     }
  31. }

3.4 Controller层实现

  1. @RestController
  2. @RequestMapping("/api/users")
  3. @RequiredArgsConstructor
  4. public class UserController {
  5.     private final UserService userService;
  7.     @PostMapping
  8.     public ResponseEntity<User> create(@RequestBody User user) {
  9.         User savedUser = userService.create(user);
  10.         return ResponseEntity.status(HttpStatus.CREATED).body(savedUser);
  11.     }
  13.     @GetMapping("/{id}")
  14.     public ResponseEntity<User> findById(@PathVariable Long id) {
  15.         return userService.findById(id)
  16.                 .map(ResponseEntity::ok)
  17.                 .orElse(ResponseEntity.notFound().build());
  18.     }
  20.     @GetMapping
  21.     public ResponseEntity<List<User>> findAll() {
  22.         return ResponseEntity.ok(userService.findAll());
  23.     }
  25.     @PutMapping("/{id}")
  26.     public ResponseEntity<User> update(@PathVariable Long id, @RequestBody User user) {
  27.         User updatedUser = userService.update(id, user);
  28.         return ResponseEntity.ok(updatedUser);
  29.     }
  31.     @DeleteMapping("/{id}")
  32.     public ResponseEntity<Void> delete(@PathVariable Long id) {
  33.         userService.delete(id);
  34.         return ResponseEntity.noContent().build();
  35.     }
  36. }

四、H2控制台使用指南

4.1 访问控制台

启动应用后，访问 http://localhost:8080/h2-console，配置如下：

  • JDBC URL: jdbc:h2:mem:testdb
  • User Name: sa
  • Password: （留空）

4.2 常用SQL操作

  1. -- 创建表（JPA自动生成时无需手动执行）
  2. CREATE TABLE t_user (
  3.     id BIGINT AUTO_INCREMENT PRIMARY KEY,
  4.     username VARCHAR(50) NOT NULL,
  5.     email VARCHAR(100) NOT NULL,
  6.     create_time TIMESTAMP
  7. );
  9. -- 插入测试数据
  10. INSERT INTO t_user (username, email) VALUES 
  11. ('admin', 'admin@example.com'),
  12. ('user1', 'user1@example.com');
  14. -- 查询数据
  15. SELECT * FROM t_user WHERE username LIKE '%ad%';

五、最佳实践与注意事项

5.1 开发阶段推荐配置

  1. 数据初始化脚本：

    • 在src/main/resources下创建data.sql（启动时执行）
    • 示例：
      1. INSERT INTO t_user (username, email) VALUES ('test', 'test@example.com');

  2. 多环境配置：

    1. # application-dev.yml
    2. spring:
    3.   datasource:
    4.     url: jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1
    6. # application-prod.yml
    7. spring:
    8.   datasource:
    9.     url: jdbc:mysql://localhost:3306/prod_db

5.2 常见问题解决方案

  1. H2控制台404错误：

    • 检查@EnableH2Console注解（SpringBoot2.x默认已启用）
    • 确认spring.h2.console.enabled=true

  2. 表不存在错误：

    • 确认spring.jpa.hibernate.ddl-auto配置
    • 检查实体类是否添加@Entity注解

  3. 中文乱码问题：

    • 在URL中添加字符集参数：
      1. jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1;MODE=MYSQL;CHARACTER_ENCODING=UTF-8

六、进阶用法

6.1 自定义H2模式

  1. @Configuration
  2. public class H2Config {
  3.     @Bean
  4.     public ServletRegistrationBean<H2ConsoleServlet> h2ConsoleServlet() {
  5.         return new ServletRegistrationBean<>(
  6.             new H2ConsoleServlet(), "/h2-console/*");
  7.     }
  9.     @Bean
  10.     public WebServerFactoryCustomizer<TomcatServletWebServerFactory> containerCustomizer() {
  11.         return container -> container.addConnectorCustomizers(
  12.             connector -> connector.setProperty("relaxedQueryChars", "|[]"));
  13.     }
  14. }

6.2 与Spring Security集成

  1. @Configuration
  2. public class SecurityConfig extends WebSecurityConfigurerAdapter {
  3.     @Override
  4.     protected void configure(HttpSecurity http) throws Exception {
  5.         http.authorizeRequests()
  6.             .antMatchers("/h2-console/**").permitAll()
  7.             .anyRequest().authenticated()
  8.             .and()
  9.             .csrf().disable()  // H2控制台需要禁用CSRF
  10.             .headers().frameOptions().disable();  // 允许H2的iframe
  11.     }
  12. }

七、总结与扩展

通过本文的实践，我们完成了SpringBoot2.x与H2内存数据库的完整集成，实现了：

  1. 零配置启动内存数据库
  2. 基于JPA的CRUD操作
  3. 内置Web控制台调试
  4. 多模式兼容性配置

扩展建议：

  • 生产环境替换为MySQL/PostgreSQL时，只需修改application.yml中的datasource配置
  • 结合Spring Profile实现多环境数据源切换
  • 使用Flyway或Liquibase进行数据库版本控制

H2数据库特别适合以下场景：

  • 微服务单元测试
  • 快速原型开发
  • 演示环境搭建
  • 持续集成流水线

完整代码示例已上传至GitHub，包含Postman测试集合和详细README文档。读者可克隆仓库后直接运行测试，体验完整的CRUD操作流程。

最热文章