Java 后端 / 系统课时

测试 JPA 数据访问

测试 JPA 数据访问

本课构建一个部门与员工账户的最小数据模型,使用 @DataJpaTest 验证实体关联、派生查询、唯一约束和事务回滚,并说明为什么数据库约束测试必须主动执行 flush()。

学习目标

  • 使用 @DataJpaTest 加载实体、Repository、测试数据库和事务环境。
  • 验证关联保存、派生查询排序以及唯一约束异常。
  • 理解 flush()、一级缓存和测试结束自动回滚之间的关系。

DataJpaTest 的测试边界

@DataJpaTest 聚焦 JPA 数据访问切片,通常扫描实体和 Spring Data JPA Repository,并为每个测试方法开启事务。测试结束时默认回滚,因此不同用例可以共享数据库配置而不必手工删除本次写入的数据。

DataJpaTest 数据访问与事务回滚流程

建立实体与 Repository

部门是一方,员工账户是多方;员工邮箱在数据库层唯一。以下代码按文件名分别保存到同一包 com.example.employee。

java
package com.example.employee;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Department {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String code;

    protected Department() {
    }

    public Department(String code) {
        this.code = code;
    }

    public Long getId() {
        return id;
    }

    public String getCode() {
        return code;
    }
}
java
package com.example.employee;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;

@Entity
@Table(
        name = "employee_account",
        uniqueConstraints = @UniqueConstraint(
                name = "uk_employee_email",
                columnNames = "email"))
public class EmployeeAccount {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String email;

    @Column(nullable = false)
    private String name;

    @Column(nullable = false)
    private boolean active;

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    @JoinColumn(name = "department_id", nullable = false)
    private Department department;

    protected EmployeeAccount() {
    }

    public EmployeeAccount(
            String email,
            String name,
            boolean active,
            Department department) {
        this.email = email;
        this.name = name;
        this.active = active;
        this.department = department;
    }

    public String getName() {
        return name;
    }

    public Department getDepartment() {
        return department;
    }
}
java
package com.example.employee;

import org.springframework.data.jpa.repository.JpaRepository;

import java.util.List;

public interface EmployeeAccountRepository
        extends JpaRepository<EmployeeAccount, Long> {

    List<EmployeeAccount>
            findByDepartmentIdAndActiveTrueOrderByNameAsc(Long departmentId);
}

数据库约束写在实体映射中,查询方法名同时表达过滤条件和排序规则。测试应验证可观察结果,而不是只验证 Repository 方法“能够被调用”。

验证查询、约束与关联

flush() 会把待执行 SQL 立即发送到数据库,使唯一约束在断言范围内暴露;clear() 会清空一级缓存,随后查询得到的是数据库重新加载的实体,而不是刚刚保存在内存中的同一个对象。

java
package com.example.employee;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.transaction.AfterTransaction;

import java.util.List;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;

@DataJpaTest
class EmployeeAccountRepositoryTest {

    @Autowired
    private TestEntityManager entityManager;

    @Autowired
    private EmployeeAccountRepository repository;

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Test
    void shouldQueryActiveEmployeesAndLoadAssociation() {
        Department department =
                entityManager.persist(new Department("OPS"));

        entityManager.persist(new EmployeeAccount(
                "zoe@example.com", "Zoe", true, department));
        entityManager.persist(new EmployeeAccount(
                "amy@example.com", "Amy", true, department));
        entityManager.persist(new EmployeeAccount(
                "bob@example.com", "Bob", false, department));

        entityManager.flush();
        entityManager.clear();

        List<EmployeeAccount> result = repository
                .findByDepartmentIdAndActiveTrueOrderByNameAsc(
                        department.getId());

        assertThat(result)
                .extracting(EmployeeAccount::getName)
                .containsExactly("Amy", "Zoe");
        assertThat(result.get(0).getDepartment().getCode())
                .isEqualTo("OPS");
    }

    @Test
    void shouldRejectDuplicateEmailWhenFlushed() {
        Department department =
                entityManager.persist(new Department("DEV"));

        repository.saveAndFlush(new EmployeeAccount(
                "same@example.com", "Alice", true, department));
        repository.save(new EmployeeAccount(
                "same@example.com", "Ben", true, department));

        assertThatThrownBy(repository::flush)
                .isInstanceOf(DataIntegrityViolationException.class);
    }

    @Test
    void shouldRollBackInsertedRowsAfterTest() {
        Department department =
                entityManager.persist(new Department("QA"));
        entityManager.persist(new EmployeeAccount(
                "qa@example.com", "Quinn", true, department));
        entityManager.flush();

        Integer count = jdbcTemplate.queryForObject(
                "select count(*) from employee_account",
                Integer.class);
        assertThat(count).isEqualTo(1);
    }

    @AfterTransaction
    void verifyDatabaseWasRestored() {
        Integer employeeCount = jdbcTemplate.queryForObject(
                "select count(*) from employee_account",
                Integer.class);
        Integer departmentCount = jdbcTemplate.queryForObject(
                "select count(*) from department",
                Integer.class);

        assertThat(employeeCount).isZero();
        assertThat(departmentCount).isZero();
    }
}

@AfterTransaction 在测试事务完成后执行,因此这里能直接确认回滚后的数据库状态。不要使用抢占式超时让测试主体运行到另一个线程,否则写入可能脱离 Spring 管理的测试事务。

运行与验证

项目需要 spring-boot-starter-data-jpa、spring-boot-starter-test,并在测试运行时提供 H2 等嵌入式数据库。执行:

bash
mvn -Dtest=EmployeeAccountRepositoryTest test

预期输出:

text
[INFO] Tests run: 3, Failures: 0, Errors: 0, Skipped: 0
[INFO] BUILD SUCCESS

实际 SQL 日志、耗时和生成主键可能不同。通过结果说明查询、关联、约束和默认回滚已被验证,但仍不能证明生产数据库方言、索引和锁行为完全一致。

避免测试假阳性

只调用 save() 而不 flush(),SQL 可能推迟到事务结束才执行,约束异常就会落在断言之外。查询前不清空持久化上下文,也可能直接命中一级缓存,让错误映射暂时不暴露。

H2 适合快速切片测试,但生产使用 PostgreSQL、MySQL 等数据库时,应再增加基于真实方言的 Testcontainers 集成测试,并使用 @AutoConfigureTestDatabase(replace = NONE) 避免测试数据库被自动替换。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

测试 JPA 数据访问

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通