Java Hibernate manytomy IN子句

我在获取数据时遇到一些问题

我的实体：

@MappedSuperclass
public abstract class BaseJpa {

    @Id
    private Integer id;

    public Integer getId() {
        return id;
    }

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

@Entity
@Table(name="genres")
public class GenreJpa extends BaseJpa{

    private String name;

    public String getName() {
        return name;
    }

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

@Entity
@Table(name="movies")
public class MovieJpa extends BaseJpa{

    @Type(type="text")
    private String name;

    private String releaseDate;

    @Type(type="text")
    private String summary;

    @ManyToMany(cascade={CascadeType.REFRESH, CascadeType.MERGE}, fetch = FetchType.LAZY)
    private List<GenreJpa> genres;

    private long votes;

    private double rank;

    public long getVotes() {
        return votes;
    }

    public void setVotes(long votes) {
        this.votes = votes;
    }

    public double getRank() {
        return rank;
    }

    public void setRank(double rank) {
        this.rank = rank;
    }

    public String getName() {
        return name;
    }

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

    public String getReleaseDate() {
        return releaseDate;
    }

    public void setReleaseDate(String releaseDate) {
        this.releaseDate = releaseDate;
    }

    public String getSummary() {
        return summary;
    }

    public void setSummary(String summary) {
        this.summary = summary;
    }

    public List<GenreJpa> getGenres() {
        return genres;
    }

    public void setGenres(List<GenreJpa> genres) {
        this.genres = genres;
    }

}

假设我需要检索电影，它有喜剧和戏剧两种类型。我正试图用in（）实现这一点，但到目前为止我失败了。有人能提出一些解决这个问题的建议吗？或者我应该只使用本机sql而忽略动态和标准吗

EntityManager entityManager = EMF.get().createEntityManager();
MovieJpa movieJpa = null;
try{
    CriteriaBuilder builder = entityManager.getCriteriaBuilder();
    CriteriaQuery<MovieJpa> criteria = builder.createQuery(MovieJpa.class);
    Root<MovieJpa> root = criteria.from(MovieJpa.class);
    Root<GenreJpa> sub = criteria.from(GenreJpa.class);
    criteria.select(root);

    //root.get(MovieJpa_.genres).in(filter.getGenres());
    //sub.get(GenreJpa_.name).in(filter.getGenres())

    criteria.where(new Predicate[]{root.get(MovieJpa_.genres).in(filter.getGenres()),
                                   builder.between(root.get(MovieJpa_.rank), filter.getMinRank(), filter.getRank()),
                                   builder.between(root.get(MovieJpa_.votes ), filter.getMinVotes(), filter.getVotes())});
    movieJpa = entityManager.createQuery(criteria).setMaxResults(1).getResultList().get(0);

} catch (Exception e){
    e.printStackTrace();
} finally {
    entityManager.close();
}
return movieJpa;

public class Filter {

    private List<Genre> genres;

    private String genre;

    private String yearStart;

    private String yearEnd;

    private double rank;

    private double minRank;

    private double maxRank;

    private long votes;

    private long minVotes;

    private long maxVotes;
    --getters/setters

EntityManager EntityManager=EMF.get（）.createEntityManager（）；
MovieJpa MovieJpa=null；
试一试{
CriteriaBuilder=entityManager.getCriteriaBuilder（）；
CriteriaQuery criteria=builder.createQuery（MovieJpa.class）；
Root=criteria.from（MovieJpa.class）；
Root sub=criteria.from（GenreJpa.class）；
条件。选择（根）；
//（filter.getGenres（））中的root.get（MovieJpa_.genres）.in；
//sub.get（GenreJpa_u2;.name）.in（filter.getGenres（））
criteria.where（新谓词[]{root.get（MovieJpa_.genres）.in（filter.getGenres（）），
builder.between（root.get（MovieJpa.rank）、filter.getMinRank（）、filter.getRank（）），
builder.between（root.get（MovieJpa\uu.voces）、filter.getminvoces（）、filter.getvoces（））}）；
movieJpa=entityManager.createQuery（条件）.setMaxResults（1）.getResultList（）.get（0）；
}捕获（例外e）{
e、 printStackTrace（）；
}最后{
entityManager.close（）；
}
返回电影JPA；
公共类过滤器{
私人列表体裁；
私人弦乐体裁；
私有字符串开始；
私人字符串年底；
私人双职级；
私人双职级；
私有双maxRank；
私人长票；
私人长投票；
私人投票；
--能手/二传手

在以下内容中找到答案：

我所需要改变的就是使用。加入而不是。获取

        criteria.where(new Predicate[]{root.join(MovieJpa_.genres).in(genreJpaList),
                                       builder.between(root.get(MovieJpa_.rank), filter.getMinRank(), filter.getRank()),
                                       builder.between(root.get(MovieJpa_.votes ), filter.getMinVotes(), filter.getVotes())});
        movieJpa = entityManager.createQuery(criteria).setMaxResults(1).getResultList().get(0);

        criteria.where(new Predicate[]{root.join(MovieJpa_.genres).in(genreJpaList),
                                       builder.between(root.get(MovieJpa_.rank), filter.getMinRank(), filter.getRank()),
                                       builder.between(root.get(MovieJpa_.votes ), filter.getMinVotes(), filter.getVotes())});
        movieJpa = entityManager.createQuery(criteria).setMaxResults(1).getResultList().get(0);