StackOverflowError manytomany：MapStruct-Spring boot-hibernate

Question

@Getter @Setter
@NoArgsConstructor
@Entity()
@Table(name = "Actor")
@EqualsAndHashCode(exclude = "films")
public class Actor implements Serializable {

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

    @NotBlank(message = "name is required")
    private String name;

    @ManyToMany(mappedBy = "actors")
    private Set<Film> films;
}

电影实体

@Getter @Setter
@NoArgsConstructor
@Entity @Table(name = "Film")
@EqualsAndHashCode(exclude = "actors")
public class Film implements Serializable {

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

    @ManyToOne
    @JoinColumn(name = "Director_id")
    private Director director;

    @ManyToMany()
    @JoinTable(
            name = "Actor_has_Film",
            joinColumns = @JoinColumn(name = "Film_id"),
            inverseJoinColumns = @JoinColumn(name = "Actor_id"))
    private Set<Actor> actors;

    public void addActor(Actor actor) {
        this.actors.add(actor);
    }
}

Actordto

@Getter @Setter
@NoArgsConstructor
public class ActorDTO {

    private Long id;
    private String name;    
    private Set<FilmDTO> films;
}

FilmdTo

@Getter @Setter
@NoArgsConstructor
public class FilmDTO {

    private Long id;
    private DirectorDTO director;    
    private Set<ActorDTO> actors;
}

public interface DataMapper<D, E> {
    E toEntity(D dto);
    D toDto(E entity);
    List<E> toEntity(List<D> dtoList);
    List<D> toDto(List<E> entityList);
}

@Mapper(componentModel = "spring", uses = { })
public interface ActorMapper extends DataMapper<ActorDTO, Actor> {
}

电影映射器

@Mapper(componentModel = "spring", uses = { })
public interface FilmMapper extends DataMapper<FilmDTO, Film> {
}

FilmServices

@Service("filmServices")
public class FilmServices implements Services<FilmDTO> {

    @Autowired @Qualifier("filmRepository")
    private FilmRepository filmRepository;

    @Autowired @Qualifier("actorRepository")
    private ActorRepository actorRepository;

    private FilmMapper filmMapper;

    public FilmServices(FilmMapper filmMapper) {
        this.filmMapper = filmMapper;
    }

    public FilmDTO addActorToFilm(Long filmId, Long actoId) {
        Optional<Film> filmByIdOptional = filmRepository.findById(filmId);
        Optional<Actor> actorByIdOptional = actorRepository.findById(actoId);
        FilmDTO filmDtoWithNewActor = null;

        if (!filmByIdOptional.isPresent())
            throw new RuntimeException("The Film with id '" + filmId + "' does not exist");

        if (!actorByIdOptional.isPresent())
            throw new RuntimeException("The Actor with id '" + actoId + "' does not exist");

        Film film = filmByIdOptional.get();
        Actor actorToAdd = actorByIdOptional.get();

        boolean hasActorInFilm = film.getActors().stream()
            .anyMatch(actor -> actor.getName().equals(actorToAdd.getName()));

        if (!hasActorInFilm) {
            film.addActor(actorToAdd);
            Film filmWithNewActor = filmRepository.save(film);
            filmDtoWithNewActor = filmMapper.toDto(filmWithNewActor); // HERE THROW EXCEPTION
        } else {
            throw new RuntimeException("The Actor with id '" + actoId + "' already exist in the film");
        }

        return filmDtoWithNewActor;

    }
}

输出日志：

Hibernate: select films0_.Actor_id as actor_id2_1_0_, films0_.Film_id as film_id1_1_0_, film1_.id as id1_3_1_, film1_.Director_id as director4_3_1_, director2_.id as id1_2_2_ from Actor_has_Film films0_ inner join Film film1_ on films0_.Film_id=film1_.id left outer join Director director2_ on film1_.Director_id=director2_.id where films0_.Actor_id=?
2020-04-07 15:27:26.296 ERROR 742 --- [nio-8080-exec-5] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Handler dispatch failed; nested exception is java.lang.StackOverflowError] with root cause

java.lang.StackOverflowError: null
    at ar.com.ada.sb.relationship.model.mapper.FilmMapperImpl.actorSetToActorDTOSet(FilmMapperImpl.java:188) ~[classes/:na]
    at ar.com.ada.sb.relationship.model.mapper.FilmMapperImpl.toDto(FilmMapperImpl.java:53) ~[classes/:na]
    at ar.com.ada.sb.relationship.model.mapper.FilmMapperImpl.filmSetToFilmDTOSet(FilmMapperImpl.java:165) ~[classes/:na]
    at ar.com.ada.sb.relationship.model.mapper.FilmMapperImpl.actorToActorDTO(FilmMapperImpl.java:182) ~[classes/:na]
    at ar.com.ada.sb.relationship.model.mapper.FilmMapperImpl.actorSetToActorDTOSet(FilmMapperImpl.java:194) ~[classes/:na]

我将非常感谢你的帮助

Answer 1

尝试这个方法，实例化这两个属性的hashset<>()，您只需要一个方向映射，保留actor端映射的注释。

电影

@Entity @Table(name = "Film") 
@JsonIgnoreProperties({"hibernateLazyInitializer", "handler"})
public class Film implements Serializable {

    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "Film_id", updatable = false, nullable = false)
    private Long id;

    @ManyToOne
    @JoinColumn(name = "Director_id")
    private Director director;

    @ManyToMany(fetch = FetchType.LAZY,
        cascade = {
                CascadeType.ALL
        },
        targetEntity= ActorModel.class
    )
    @JoinTable(name = "Actor_has_Film",
        joinColumns = { @JoinColumn(name = "Film_id") },
        inverseJoinColumns = { @JoinColumn(name = "Actor_id") })
    @JsonProperty("actors")
    private Set<Actor> actors = new HashSet<>();

    public void addActor(Actor actor) {
      this.actors.add(actor);
    }
}

演员

@Entity()
@Table(name = "Actor")
@JsonIgnoreProperties({"hibernateLazyInitializer", "handler"})
public class Actor implements Serializable {

    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "Actor_id", updatable = false, nullable = false)
    private Long id;

    @NotBlank(message = "name is required")
    private String name;

    /*@ManyToMany(mappedBy = "actors")
    @JsonIgnore
    private Set<Film> films = new HashSet<>();*/
}