JPA Hibernate多对多关联下非实体轻量POJO查询性能优化问题

针对Player与Team多对多关联场景中，JPQL查询轻量POJO产生重复行、Java端合并性能瓶颈的问题，提供以下几种可行方案：

方案一：数据库端聚合团队信息，避免重复行 #

利用数据库的字符串聚合函数，在查询阶段直接将每个玩家的所有团队信息拼接为单个字段，返回无重复的玩家行，再在POJO中解析为团队列表。

JPQL查询示例（适配主流数据库） #

// MySQL 版本（使用GROUP_CONCAT）
String jpql = "SELECT new pojos.PlayerPojo(e.id, e.firstName, e.lastName, " +
              "FUNCTION('GROUP_CONCAT', CONCAT(t.id, ':', t.name), ',')) " +
              "FROM Player e LEFT JOIN e.teams t " +
              "GROUP BY e.id, e.firstName, e.lastName";

// PostgreSQL 版本（使用STRING_AGG）
String jpql = "SELECT new pojos.PlayerPojo(e.id, e.firstName, e.lastName, " +
              "FUNCTION('STRING_AGG', CONCAT(t.id, ':', t.name), ',')) " +
              "FROM Player e LEFT JOIN e.teams t " +
              "GROUP BY e.id, e.firstName, e.lastName";

// Oracle 版本（使用LISTAGG）
String jpql = "SELECT new pojos.PlayerPojo(e.id, e.firstName, e.lastName, " +
              "FUNCTION('LISTAGG', CONCAT(t.id, ':', t.name), ',') WITHIN GROUP (ORDER BY t.id)) " +
              "FROM Player e LEFT JOIN e.teams t " +
              "GROUP BY e.id, e.firstName, e.lastName";

对应的PlayerPojo结构 #

public class PlayerPojo {
    private Long id;
    private String firstName;
    private String lastName;
    private List<TeamMini> teams;

    // 构造函数：接收拼接的团队字符串
    public PlayerPojo(Long id, String firstName, String lastName, String teamsStr) {
        this.id = id;
        this.firstName = firstName;
        this.lastName = lastName;
        this.teams = parseTeams(teamsStr);
    }

    // 解析拼接字符串为TeamMini列表
    private List<TeamMini> parseTeams(String teamsStr) {
        List<TeamMini> list = new ArrayList<>();
        if (teamsStr == null || teamsStr.isEmpty()) {
            return list;
        }
        String[] teamParts = teamsStr.split(",");
        for (String part : teamParts) {
            String[] idName = part.split(":");
            if (idName.length == 2) {
                list.add(new TeamMini(Long.parseLong(idName[0]), idName[1]));
            }
        }
        return list;
    }

    // 内部静态类：轻量Team信息
    public static class TeamMini {
        private Long id;
        private String name;

        public TeamMini(Long id, String name) {
            this.id = id;
            this.name = name;
        }

        // Getters
    }

    // Getters
}

优点：查询结果无重复行，无需Java端复杂合并，减少数据传输量和内存占用，性能最优。
缺点：依赖数据库特定聚合函数，需根据使用的数据库调整JPQL语句。

方案二：Java端高效分组合并 #

如果不想依赖数据库特性，可保留原查询结构，但用Stream API高效分组替代逐行合并，降低时间复杂度。

查询与合并代码示例 #

// 执行JPQL查询，返回Tuple类型结果
TypedQuery<Tuple> query = entityManager.createQuery(
    "SELECT e.id, e.firstName, e.lastName, t.id, t.name " +
    "FROM Player e LEFT JOIN e.teams t",
    Tuple.class
);
List<Tuple> results = query.getResultList();

// 用Stream分组构建PlayerPojo
Map<Long, PlayerPojo> playerMap = results.stream()
    .collect(Collectors.toMap(
        tuple -> tuple.get(0, Long.class), // 以PlayerID为分组键
        tuple -> new PlayerPojo(
            tuple.get(0, Long.class),
            tuple.get(1, String.class),
            tuple.get(2, String.class),
            new ArrayList<>()
        ),
        (existing, newOne) -> existing // 重复键时保留已存在的POJO
    ));

// 填充每个玩家的团队列表
results.forEach(tuple -> {
    Long teamId = tuple.get(3, Long.class);
    if (teamId != null) {
        PlayerPojo pojo = playerMap.get(tuple.get(0, Long.class));
        pojo.getTeams().add(new PlayerPojo.TeamMini(
            teamId,
            tuple.get(4, String.class)
        ));
    }
});

// 最终得到去重后的玩家列表
List<PlayerPojo> playerList = new ArrayList<>(playerMap.values());

优点：不依赖数据库特性，代码跨数据库兼容。
缺点：查询结果仍会返回重复行，但Stream分组的时间复杂度为O(n)，比传统逐行合并的O(n²)性能提升明显。

方案三：分两次查询避免重复行 #

先查询所有玩家的基础信息，再批量查询玩家与团队的关联关系，最后在Java端关联数据。

代码示例 #

// 第一步：查询所有玩家基础信息
List<PlayerPojo> playerList = entityManager.createQuery(
    "SELECT new pojos.PlayerPojo(e.id, e.firstName, e.lastName) " +
    "FROM Player e",
    PlayerPojo.class
).getResultList();

// 将玩家列表转为Map，方便后续关联
Map<Long, PlayerPojo> playerMap = playerList.stream()
    .collect(Collectors.toMap(PlayerPojo::getId, p -> p));

// 第二步：批量查询所有玩家-团队关联（需定义多对多中间表实体）
List<Tuple> teamRelations = entityManager.createQuery(
    "SELECT pt.player.id, pt.team.id, pt.team.name " +
    "FROM PlayerTeam pt",
    Tuple.class
).getResultList();

// 关联团队信息到玩家POJO
teamRelations.forEach(tuple -> {
    Long playerId = tuple.get(0, Long.class);
    PlayerPojo pojo = playerMap.get(playerId);
    if (pojo != null) {
        pojo.getTeams().add(new PlayerPojo.TeamMini(
            tuple.get(1, Long.class),
            tuple.get(2, String.class)
        ));
    }
});

优点：两次查询都无重复行，数据传输量小，内存占用低。
缺点：需要依赖多对多关联的中间表实体（若JPA未自动生成，需手动定义），或改用原生SQL查询中间表。

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