Hibernate @ManyToMany懒加载引发N+1查询过慢的优化咨询

问题背景 #

我操作的PostgreSQL USERS表有50k条数据，USER与GROUP为多对多关系，通过USER_GROUP关联表（含user_id和group_id）连接，实体类关联定义如下：

@ManyToMany(fetch = FetchType.LAZY)
@JoinTable(name="user_group",
        joinColumns={
                @JoinColumn(name="user_uid", referencedColumnName="user_uid")},
        inverseJoinColumns={
                @JoinColumn(name="group_id", referencedColumnName="group_id")})
private Set<GroupEntity> groups = new HashSet<>();

实际数据库中极少用户拥有分组，我需要查询所有用户并将其对应分组名拼接成字符串。当前通过以下逻辑加载分组：

userList.forEach(user -> {
    String groupNames = String.join(",", user.getGroups().stream()
            .map(GroupEntity::getName)
            .collect(Collectors.toList()));
    // 后续处理分组名字符串
});

但查询速度极慢，核心原因是Hibernate的懒加载触发了N+1查询问题——为每个用户单独生成一条查询分组的SQL语句。我还考虑过创建数据库视图：

CREATE VIEW user_view AS 
SELECT user.user_id, group_names 
from user 
left outer join (
    select user_id, string_agg(group_name, ',') group_names 
    from user_group natural left join "group" 
    GROUP BY user_id
) AS g ON user.user_id = g.user_id;

想了解如何通过Hibernate（结合Quarkus Panache、Criteria API）高效实现需求。

优化方案 #

1. 解决N+1查询：一次性关联加载分组 #

直接在查询阶段通过JOIN加载分组，避免懒加载触发的多次查询：

Panache HQL查询

// LEFT JOIN FETCH保证所有用户被查询到，即使没有分组
List<UserEntity> userList = UserEntity.find("SELECT u FROM UserEntity u LEFT JOIN FETCH u.groups").list();

这条语句会让Hibernate生成一条包含用户和分组的关联SQL，一次性拉取所有数据，彻底解决N+1问题。

实体图（Entity Graph）实现（适用于复杂关联场景）

先在UserEntity上定义实体图：

@NamedEntityGraph(name = "UserWithGroups", attributeNodes = @NamedAttributeNode("groups"))
@Entity
public class UserEntity extends PanacheEntity {
    // ... 其他字段定义
    @ManyToMany(fetch = FetchType.LAZY)
    // ... 多对多关联定义
}

查询时指定使用该实体图：

List<UserEntity> userList = UserEntity.find("FROM UserEntity")
        .withEntityGraph("UserWithGroups")
        .list();

2. 数据库层面直接聚合分组名（推荐，性能最优） #

既然只需要分组名字符串，无需加载完整的GroupEntity对象，直接用PostgreSQL的string_agg函数在数据库完成拼接，减少数据传输和对象实例化开销：

Panache原生SQL查询

先定义DTO接收结果：

public class UserWithGroupsDto {
    public Long userId;
    public String username;
    public String groupNames;
    // 需提供与查询字段匹配的构造函数或无参构造
}

然后执行查询：

List<UserWithGroupsDto> userList = UserEntity.find("""
        SELECT u.user_uid as userId, u.username, COALESCE(g.groupNames, '') as groupNames
        FROM user u
        LEFT JOIN (
            SELECT ug.user_uid, string_agg(g.group_name, ',') as groupNames
            FROM user_group ug
            JOIN "group" g ON ug.group_id = g.group_id
            GROUP BY ug.user_uid
        ) g ON u.user_uid = g.user_uid
        """).project(UserWithGroupsDto.class).list();

COALESCE用于处理无分组用户的空值，返回空字符串。

Criteria API实现

CriteriaBuilder cb = entityManager.getCriteriaBuilder();
CriteriaQuery<UserWithGroupsDto> query = cb.createQuery(UserWithGroupsDto.class);

// 子查询：生成用户-分组名字符串映射
Subquery<String> groupSubquery = query.subquery(String.class);
Root<UserGroupEntity> ugRoot = groupSubquery.from(UserGroupEntity.class);
Join<UserGroupEntity, GroupEntity> groupJoin = ugRoot.join("group");
groupSubquery.select(cb.function("string_agg", String.class, groupJoin.get("name"), cb.literal(",")))
        .groupBy(ugRoot.get("userUid"));

// 主查询：关联用户与分组聚合结果
Root<UserEntity> userRoot = query.from(UserEntity.class);
query.select(cb.construct(UserWithGroupsDto.class,
        userRoot.get("userUid"),
        userRoot.get("username"),
        cb.coalesce(groupSubquery, cb.literal(""))))
        .where(cb.equal(userRoot.get("userUid"), ugRoot.get("userUid")));

List<UserWithGroupsDto> userList = entityManager.createQuery(query).getResultList();

3. 结合数据库视图的实现 #

你创建的视图可以直接映射到DTO或只读实体：

映射视图到DTO

public class UserViewDto {
    public Long userId;
    public String groupNames;
    // 其他需要的用户字段
}

通过Panache查询视图：

List<UserViewDto> userList = UserEntity.find("SELECT * FROM user_view").project(UserViewDto.class).list();

映射视图为只读实体

如果需要把视图当作实体操作（仅支持只读）：

@Entity
@Immutable
@Table(name = "user_view")
public class UserView extends PanacheEntityBase {
    @Id
    public Long userId;
    public String groupNames;
    // 其他用户字段映射
}

直接查询：

List<UserView> userList = UserView.listAll();

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