JPARepository查询Chat时返回重复Message实体问题排查

项目结构 #

简化后的实体类关系如下：

实体类代码（简化版） #

@Entity
public class Chat {
    @Id
    @GeneratedValue
    private Long id;

    @ManyToMany
    @JoinTable(
            name = "user_chat",
            joinColumns = @JoinColumn(name = "chat"),
            inverseJoinColumns = @JoinColumn(name = "user")
    )
    private Set<User> users = new HashSet<>();

    @OneToMany(mappedBy = "chat", cascade = CascadeType.ALL)
    private List<Message> messages = new ArrayList<>();


    public void addMessage(Message message){
        this.messages.add(message);
    }
}


@Entity
public class Message {
    private @Id @GeneratedValue Long id;

    @ManyToOne
    @JoinColumn(name="senderId", nullable=false)
    private User sender;

    @Column(name="value")
    private String value;

    @ManyToOne()
    @JoinColumn(name = "chat")
    private Chat chat;
}


@Entity
public class User implements UserDetails {
    private @Id
    @GeneratedValue
    Long id;

    @OneToMany(mappedBy = "sender", cascade = CascadeType.ALL)
    private List<Message> messagesSent;

    @ManyToMany(mappedBy = "users")
    private Set<Chat> chats = new HashSet<>();
}

问题Repository代码 #

public interface ChatRepository extends JpaRepository<Chat,Long> {
    @Query("SELECT c FROM Chat c JOIN c.users u WHERE u.id IN :usersIDs GROUP BY c HAVING COUNT(DISTINCT u) = :numberOfUsers")
    Optional<Chat> getChat(@Param("usersIDs") List<Long> usersIDs, int numberOfUsers);
}

问题现象 #

检索到的Chat对象中，每个Message实体都重复出现两次。

问题分析 #

查询中使用JOIN c.users u会生成包含Chat-User关联的SQL结果集，当懒加载messages集合时，Hibernate会基于当前查询上下文（包含多条User行）进行关联查询，导致每个Message与每个User行匹配，最终出现重复——本质是多对多关联引发的笛卡尔积问题。

已尝试的解决方案 #

• 修改Repository查询，添加LEFT JOIN条件，未解决；
• 在messages字段添加@Fetch (FetchMode.SELECT)；
• 在查询上添加@Transactional；
• 重写Message的equals()和hashCode()方法；
• 添加DISTINCT关键字并调整查询，出现SQL模式错误；
• 使用子查询调整查询，仅改变重复模式，未解决问题。

有效解决方案 #

方案1：使用DISTINCT结合EntityGraph避免笛卡尔积 #

修改Repository查询，添加DISTINCT并通过EntityGraph指定预加载关联，让Hibernate正确处理重复实体：

public interface ChatRepository extends JpaRepository<Chat,Long> {
    @Query("SELECT DISTINCT c FROM Chat c JOIN c.users u WHERE u.id IN :usersIDs GROUP BY c HAVING COUNT(DISTINCT u) = :numberOfUsers")
    @EntityGraph(attributePaths = {"messages", "users"})
    Optional<Chat> getChat(@Param("usersIDs") List<Long> usersIDs, int numberOfUsers);
}

DISTINCT会让Hibernate对Chat实体去重，EntityGraph则指定一次性加载messages和users关联，避免后续懒加载时的重复问题。

方案2：将messages集合改为Set #

把Chat类中的List<Message>改为Set<Message>，利用Set的去重特性自动过滤重复Message：

@OneToMany(mappedBy = "chat", cascade = CascadeType.ALL)
private Set<Message> messages = new HashSet<>();

需确保Message类正确实现equals()和hashCode()（基于id字段即可）：

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Message message = (Message) o;
    return id != null && id.equals(message.id);
}

@Override
public int hashCode() {
    return getClass().hashCode();
}

方案3：修改查询逻辑，避免直接JOIN users #

改用子查询定位符合条件的Chat，避免生成包含多User行的结果集：

public interface ChatRepository extends JpaRepository<Chat,Long> {
    @Query("SELECT c FROM Chat c WHERE SIZE(c.users) = :numberOfUsers AND c.users.id IN :usersIDs")
    Optional<Chat> getChat(@Param("usersIDs") List<Long> usersIDs, int numberOfUsers);
}

这种方式Hibernate会生成更简洁的查询，不会产生笛卡尔积，从根源避免Message重复。

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