如何在JPA一对多关联中结合分页高效获取最新关联实体

安全阿岳

2026-7-5

JPA一对多关联下分页获取主实体+最新关联实体的解决方案

问题根源

直接通过join/fetch关联一对多关系时，会产生笛卡尔积，导致主实体在查询结果中重复，分页逻辑失效（比如一页10条结果可能全是同一个主实体的不同关联记录）；而你当前在内存中通过stream().max()过滤最新关联的方式，不仅效率低下（需加载所有关联数据），也无法配合分页实现。

解决方案

方案1：JPQL子查询关联最新关联实体

通过子查询预先获取每个ExpectedVersionFE对应的最新ActualVersionFE的创建时间，再关联查询确保每个主实体只返回一次，完美适配分页逻辑：

// 构建JPQL查询
String jpql = """
    SELECT ev, av FROM ExpectedVersionFE ev
    LEFT JOIN ActualVersionFE av ON av.expectedVersionFE = ev
    WHERE av.createdAt = (
        SELECT MAX(av2.createdAt) FROM ActualVersionFE av2
        WHERE av2.expectedVersionFE = ev
    )
    ORDER BY ev.id DESC
""";

// 执行分页查询
TypedQuery<Object[]> query = entityManager.createQuery(jpql, Object[].class);
query.setFirstResult(page * pageSize); // page为当前页码，从0开始
query.setMaxResults(pageSize);

List<Object[]> results = query.getResultList();

// 转换为带最新关联的实体列表
List<ExpectedVersionFE> evList = results.stream()
    .map(arr -> {
        ExpectedVersionFE ev = (ExpectedVersionFE) arr[0];
        // 仅保留最新的关联实体
        ev.setActualVersionFEs(Collections.singleton((ActualVersionFE) arr[1]));
        return ev;
    })
    .collect(Collectors.toList());

用LEFT JOIN保证即使没有关联ActualVersionFE的主实体也能被返回，若仅需包含有最新关联的主实体，改用INNER JOIN即可。

方案2：CriteriaBuilder构建动态查询

如果需要动态拼接查询条件（比如多条件过滤），用CriteriaBuilder实现相同的子查询逻辑：

CriteriaBuilder cb = entityManager.getCriteriaBuilder();
CriteriaQuery<Object[]> cq = cb.createQuery(Object[].class);

Root<ExpectedVersionFE> evRoot = cq.from(ExpectedVersionFE.class);
Join<ExpectedVersionFE, ActualVersionFE> avJoin = evRoot.join("actualVersionFEs", JoinType.LEFT);

// 子查询：获取每个ExpectedVersionFE对应的最新创建时间
Subquery<LocalDateTime> maxDateSubquery = cq.subquery(LocalDateTime.class);
Root<ActualVersionFE> avSubRoot = maxDateSubquery.from(ActualVersionFE.class);
maxDateSubquery.select(cb.max(avSubRoot.get("createdAt")))
    .where(cb.equal(avSubRoot.get("expectedVersionFE"), evRoot));

// 过滤出每个主实体的最新关联实体
cq.where(cb.equal(avJoin.get("createdAt"), maxDateSubquery))
    .orderBy(cb.desc(evRoot.get("id")));

// 执行分页查询
TypedQuery<Object[]> query = entityManager.createQuery(cq);
query.setFirstResult(page * pageSize);
query.setMaxResults(pageSize);

// 结果转换逻辑同方案1

方案3：数据库窗口函数（推荐给支持的数据库）

如果你的数据库支持窗口函数（如MySQL 8+、PostgreSQL），可以用ROW_NUMBER()直接筛选每个主实体的最新关联实体，性能更优：

// 原生SQL查询
String nativeSql = """
    SELECT ev.*, av.*
    FROM EXPECTED_VERSION_FE ev
    LEFT JOIN (
        SELECT *, 
               ROW_NUMBER() OVER (PARTITION BY expected_version_fe_id ORDER BY created_at DESC) AS rn
        FROM ACTUAL_VERSION_FE
    ) av ON ev.id = av.expected_version_fe_id AND av.rn = 1
    ORDER BY ev.id DESC
    LIMIT :offset, :size
""";

// 执行查询并映射结果
Query nativeQuery = entityManager.createNativeQuery(nativeSql, Object[].class);
nativeQuery.setParameter("offset", page * pageSize);
nativeQuery.setParameter("size", pageSize);

List<Object[]> results = nativeQuery.getResultList();
// 结果转换逻辑同方案1

配合@BatchSize的优化方案

若你希望保留原有实体结构，先分页获取主实体再批量加载最新关联：

分页获取主实体列表：

List<ExpectedVersionFE> evList = entityManager.createQuery(
        "SELECT ev FROM ExpectedVersionFE ev ORDER BY ev.id DESC", ExpectedVersionFE.class)
    .setFirstResult(page * pageSize)
    .setMaxResults(pageSize)
    .getResultList();

批量查询所有主实体对应的最新关联：

List<ActualVersionFE> latestAvList = entityManager.createQuery(
        "SELECT av FROM ActualVersionFE av " +
        "WHERE av.expectedVersionFE IN :evList " +
        "AND av.createdAt IN (" +
        "    SELECT MAX(av2.createdAt) FROM ActualVersionFE av2 " +
        "    WHERE av2.expectedVersionFE = av.expectedVersionFE" +
        ")", ActualVersionFE.class)
    .setParameter("evList", evList)
    .getResultList();

手动映射关联关系：

Map<Long, ActualVersionFE> evIdToLatestAv = latestAvList.stream()
    .collect(Collectors.toMap(
        av -> av.getExpectedVersionFE().getId(),
        av -> av,
        (existing, replacement) -> existing // 处理重复（理论上不会出现）
    ));

evList.forEach(ev -> {
    ActualVersionFE latestAv = evIdToLatestAv.get(ev.getId());
    ev.setActualVersionFEs(latestAv != null ? Collections.singleton(latestAv) : new LinkedHashSet<>());
});

这种方式避免了N+1查询，仅需2次数据库交互，结合@BatchSize（若保留）可进一步优化，但不如前三种方案直接在查询层面过滤高效。

内容的提问来源于stack exchange，提问作者bokzor