Spring Hibernate更新多对多关联表时无法删除旧数据求助

根本原因 #

1. 关联维护端错位：你的Movie实体中@OneToMany(mappedBy="movie")表明，关联关系的维护权在MovieActor实体，Movie是被动的被维护端。此时Movie上的CascadeType.ALL无法触发删除旧关联的操作——因为旧的MovieActor实体仍持有对Movie的引用，而维护端的关系未被主动修改。
2. 单主键设计的干扰：MovieActor使用自增单主键而非复合主键（movie_id + actor_id），导致Hibernate无法通过关联键直接识别需要删除的旧关联，增加了关系判断的复杂度。

解决方案 #

方案一：将Movie改为关联维护端（推荐） #

通过调整映射配置，让Movie主动维护关联关系，配合orphanRemoval=true自动删除孤儿实体：

修改Movie实体

public class Movie {
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    @Column(name = "movie_id", columnDefinition = "bigint", unique = true, nullable = false)
    private Long id;

    @Column(name = "name", columnDefinition="varchar(255)", nullable=true)
    private String name;

    @OneToMany(cascade = CascadeType.ALL, fetch=FetchType.EAGER, orphanRemoval = true)
    @JoinColumn(name = "movie_id") // 直接指定外键，放弃mappedBy
    @JsonManagedReference
    private List<MovieActor> movieActors; // 修正变量名规范，首字母小写
}

修改MovieActor实体的movie字段

public class MovieActor implements Serializable {
    // ... 其他字段不变

    @ManyToOne()
    @JoinColumn(name="movie_id", insertable = false, updatable = false) // 禁止该字段维护外键
    @JsonBackReference
    private Movie movie;

    // ... actor字段不变
}

配置完成后，当你替换movie.setMovieActors(movieActors)时，Hibernate会自动删除旧的关联记录，同时插入新关联。

方案二：手动维护关联关系（不修改实体映射时使用） #

在更新方法中，先主动删除旧关联并移除列表引用，再添加新关联：

public String updateMovie(String movieData) throws JsonProcessingException {
    try {
        JSONObject movieObj = new JSONObject(movieData);
        
        Optional<Movie> movieOpt = movieRepository.findById(movieObj.getLong("id"));
        if (movieOpt.isEmpty())
            return "Movie does not exist";
        
        Movie movie = movieOpt.get();
        
        // 1. 备份旧关联，避免clear后丢失引用
        List<MovieActor> oldMovieActors = new ArrayList<>(movie.getMovieActors());
        // 移除movie与旧关联的绑定
        movie.getMovieActors().clear();
        // 删除数据库中的旧关联记录
        movieActorRepository.deleteAll(oldMovieActors);
        // 立即执行删除操作，避免与后续保存冲突
        movieRepository.flush();
        
        // 2. 添加新关联
        List<MovieActor> movieActors = new ArrayList<>();
        JSONArray actorIdArray = movieObj.getJSONArray("actor_ids");
        for (int i = 0; i < actorIdArray.length(); i++) {
            Optional<Actor> actorOpt = actorRepository.findById(actorIdArray.getLong(i));
            if (actorOpt.isEmpty())
                return "actor doesn't exist";
            
            MovieActor movieActor = new MovieActor();                
            movieActor.setMovie(movie);
            movieActor.setActor(actorOpt.get());
            movieActors.add(movieActor);    
        }
  
        movie.setMovieActors(movieActors);
        Movie updatedMovie = movieRepository.saveAndFlush(movie);
        
        return CustomResponse(HttpStatus.ACCEPTED.value(),updatedMovie);

    } catch (Exception e) {
        log.error("Exception", e);
        return CustomResponse(HttpStatus.INTERNAL_SERVER_ERROR.value(), e.getMessage());
    }
}

额外优化建议 #

将MovieActor的主键改为复合主键（movie_id + actor_id），更符合多对多关联表的设计规范，也能让Hibernate更精准地识别关联关系：

// 定义复合主键类
@Embeddable
public class MovieActorId implements Serializable {
    @Column(name = "movie_id")
    private Long movieId;
    @Column(name = "actor_id")
    private Long actorId;

    // 必须实现无参构造、equals和hashCode
    public MovieActorId() {}
    public MovieActorId(Long movieId, Long actorId) {
        this.movieId = movieId;
        this.actorId = actorId;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MovieActorId that = (MovieActorId) o;
        return Objects.equals(movieId, that.movieId) && Objects.equals(actorId, that.actorId);
    }

    @Override
    public int hashCode() {
        return Objects.hash(movieId, actorId);
    }
}

// 修改MovieActor实体
public class MovieActor implements Serializable {
    @EmbeddedId
    private MovieActorId id;

    @ManyToOne()
    @MapsId("movieId") // 映射复合主键的movieId字段
    @JoinColumn(name="movie_id")
    @JsonBackReference
    private Movie movie;

    @ManyToOne()
    @MapsId("actorId") // 映射复合主键的actorId字段
    @JoinColumn(name="actor_id")
    @JsonBackReference
    private Actor actor;
}

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