Spring Boot JPA中@OneToMany列表出现重复数据问题排查

看起来你遇到的是JPA双向OneToMany关联中常见的集合重复问题，你的实现确实存在几个潜在的问题，咱们一步步拆解来看：

你的实现方案存在的核心问题 #

1. 双向关联未同步维护双方状态 #

JPA的双向关联要求关联的两端都要被正确维护，但你的follow方法只给关注者（follower）的followings列表添加了关系，却没有同步更新被关注者（followed）的followers列表。这种情况下，持久化上下文的状态和数据库实际状态会出现短暂不一致，后续加载实体时，JPA的缓存机制或查询逻辑可能会把新旧数据合并，导致重复项出现。

2. List集合类型的固有风险 #

你提到的《Duplicates in OneToMany annotated List》问题完全适用于你的场景——哪怕你有两个关联List。因为JPA对List类型的集合，默认依赖实体的equals/hashCode判断重复，如果你的FollowRelationship没有正确实现这两个方法，或者查询时触发了笛卡尔积（比如同时抓取多个关联集合），就会导致同一个关系被多次加入列表。

3. 缓存一致性隐患 #

JPA的一级缓存（会话级缓存）会缓存已加载的实体，如果在同一个会话中修改关联后未及时刷新缓存，后续读取实体时可能会拿到旧的集合状态，和数据库中的新记录合并后产生重复。

哪些特定场景会触发重复？ #

• 未同步双向关联时：调用follow方法后，在同一会话中立即加载被关注者的粉丝列表，此时被关注者的followers还是旧状态，后续再次加载时就可能重复添加数据库中已存在的关系。
• 使用JOIN FETCH多关联查询：如果查询User时同时抓取followers和followings，或者同时抓取其他关联实体，会产生笛卡尔积，导致List中出现重复的FollowRelationship实例。
• equals/hashCode实现错误：如果FollowRelationship的equals/hashCode没有基于主键（followRelationshipId）实现，而是用了date、from/to等非唯一字段，JPA会把同一个关系识别为不同元素，从而重复添加。
• 重复调用关注逻辑：如果业务逻辑中不小心重复调用follow方法，且未做重复关注校验，会导致同一个关系被多次加入集合并保存。

针对性解决方案 #

1. 正确维护双向关联的两端 #

修改你的follow方法，同步更新双方的关联关系，同时添加重复关注校验：

@Override
public void follow(Long followerId, Long followedId) throws UserNotFoundException {
    User follower = userRepository.findById(followerId)
        .orElseThrow(() -> new UserNotFoundException("Follower not found"));
    User followed = userRepository.findById(followedId)
        .orElseThrow(() -> new UserNotFoundException("Followed user not found"));

    // 先校验是否已关注，避免重复添加
    boolean alreadyFollowing = follower.getFollowings().stream()
        .anyMatch(rel -> rel.getTo().getUserId().equals(followedId));
    if (alreadyFollowing) {
        return;
    }

    FollowRelationship relationship = new FollowRelationship(new Date(), follower, followed);
    // 使用辅助方法确保关联双向绑定
    follower.addFollowing(relationship);
    followed.addFollower(relationship);

    userRepository.save(follower);
    userRepository.save(followed);
}

同时在User类中添加辅助方法，确保关联关系的双向绑定：

public void addFollowing(FollowRelationship relationship) {
    this.followings.add(relationship);
    relationship.setFrom(this);
}

public void addFollower(FollowRelationship relationship) {
    this.followers.add(relationship);
    relationship.setTo(this);
}

2. 改用Set替代List作为集合类型 #

Set天然不允许重复元素，只要FollowRelationship的equals/hashCode正确实现，就能从根源避免重复。修改User类的集合定义：

@Entity
public class User {
    // ...其他字段
    @OneToMany(mappedBy="to", cascade = CascadeType.ALL, orphanRemoval=true)
    private Set<FollowRelationship> followers = new HashSet<>();
    
    @OneToMany(mappedBy="from", cascade = CascadeType.ALL, orphanRemoval=true)
    private Set<FollowRelationship> followings = new HashSet<>();
    // ...getter/setter
}

然后正确实现FollowRelationship的equals/hashCode：

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    FollowRelationship that = (FollowRelationship) o;
    // 主键不为空时用主键判断，为空时用from和to的组合（避免未持久化实体的判断问题）
    if (followRelationshipId != null) {
        return followRelationshipId.equals(that.followRelationshipId);
    } else {
        return Objects.equals(from, that.from) && Objects.equals(to, that.to);
    }
}

@Override
public int hashCode() {
    return followRelationshipId != null ? 
        Objects.hash(followRelationshipId) : 
        Objects.hash(from, to);
}

3. 查询时避免笛卡尔积 #

如果需要用JOIN FETCH抓取关联集合，每次只抓取一个集合，或者用DISTINCT关键字去重：

// 使用DISTINCT避免笛卡尔积导致的重复
User user = entityManager.createQuery(
        "SELECT DISTINCT u FROM User u JOIN FETCH u.followers WHERE u.userId = :id", 
        User.class)
    .setParameter("id", userId)
    .getSingleResult();

4. 确保缓存与数据库同步 #

修改关联后，如果需要立即获取更新后的实体，调用flush()和refresh()同步缓存：

userRepository.save(follower);
userRepository.flush(); // 强制同步到数据库
userRepository.refresh(follower); // 从数据库刷新实体状态

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