Hibernate多对多关联SQLIntegrityConstraintViolationException重复插入问题求助

问题场景 #

我用Hibernate实现Video与Actor的多对多关联（一个视频对应多个演员，一个演员参演多部视频），Actor实体的name字段有唯一约束。当保存包含已存在Actor的新Video时，会间歇性抛出java.sql.SQLIntegrityConstraintViolationException: Duplicate entry错误，期望Hibernate能自动识别已存在的同名Actor，直接复用其ID插入关联表film_actors，而非重复插入。

实体类代码 #

Video实体 #

@Entity
@Table(name = "videos")
public class Video implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String title;

    private int year;

    @ManyToMany(cascade = {CascadeType.ALL})
    @JoinTable(
            name = "film_actors",
            joinColumns = @JoinColumn(name = "film_id"),
            inverseJoinColumns = @JoinColumn(name = "actor_id")
    )
    private Set<Actor> actors = new HashSet<>();

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

        Video video = (Video) o;

        return title != null ? title.equals(video.title) : video.title == null;
    }

    @Override
    public int hashCode() {
        return title != null ? title.hashCode() : 0;
    }

    //getters setters
}

Actor实体 #

@Entity
@Table(name = "actors")
public class Actor {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;

    @Column(unique = true)
    private String name;

    @ManyToMany(mappedBy = "actors")
    private Set<Video> video = new HashSet<>();

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

        Actor actor = (Actor) o;

        return name != null ? name.equals(actor.name) : actor.name == null;
    }

    @Override
    public int hashCode() {
        return name != null ? name.hashCode() : 0;
    }
}

临时解决方案 #

目前通过手动查询替换关联Actor的方式解决，代码如下：

@Override
public void save(Video video) throws SQLException {

    Set<Actor> actors = video.getActors();
    Set<Actor> mapped = new HashSet<>();
    for (Actor actor : actors) {
        Actor fromDb = actorRepository.findByName(actor.getName());
        if (fromDb != null) {
            mapped.add(fromDb);
        } else {
            mapped.add(actor);
        }
    }
    video.setActors(mapped);

    videoRepository.save(video);
}

优化方案分析 #

Hibernate本身不会自动根据唯一约束判断实体是否存在并复用，因为它默认通过ID和持久化状态识别实体，但可以通过以下方式优化代码：

1. 调整级联策略 #

当前使用CascadeType.ALL会导致保存Video时尝试保存所有关联Actor，包括游离态的已有Actor。可以将级联改为CascadeType.PERSIST + CascadeType.MERGE，仅对新实体执行持久化，对游离态实体执行合并：

@ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE})
@JoinTable(
        name = "film_actors",
        joinColumns = @JoinColumn(name = "film_id"),
        inverseJoinColumns = @JoinColumn(name = "actor_id")
)
private Set<Actor> actors = new HashSet<>();

2. 封装“查找或创建”逻辑 #

将遍历查询的逻辑封装到ActorRepository中，简化业务代码：

// ActorRepository新增方法
public Actor findOrSaveByName(String name) {
    Actor actor = findByName(name);
    if (actor == null) {
        actor = new Actor();
        actor.setName(name);
        save(actor);
    }
    return actor;
}

// 优化后的Video保存方法
@Override
public void save(Video video) throws SQLException {
    Set<Actor> mappedActors = video.getActors().stream()
            .map(actor -> actorRepository.findOrSaveByName(actor.getName()))
            .collect(Collectors.toSet());
    video.setActors(mappedActors);
    videoRepository.save(video);
}

3. 利用持久化上下文缓存 #

由于Hibernate一级缓存的存在，同一事务内多次查询相同name的Actor只会访问一次数据库，不会带来额外性能开销，同时保证获取的是持久化状态的实体，避免重复插入。

总结 #

你的临时方案是可行的，但通过封装逻辑、调整级联策略可以让代码更简洁优雅。Hibernate无法自动完成“根据唯一键复用实体”的操作，必须手动查询替换，这是处理此类唯一约束关联场景的常规方式。

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