Hibernate löst MultipleBagFetchException aus - kann nicht gleichzeitig mehrere Beutel abrufen

Question

Hibernate löst diese Ausnahme bei der Erstellung der SessionFactory aus:

org.hibernate.loader.MultipleBagFetchException: kann nicht mehrere Taschen gleichzeitig abrufen

Dies ist mein Testfall:

Elternteil.java

@Entity
public Parent {

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

 @OneToMany(mappedBy="parent", fetch=FetchType.EAGER)
 // @IndexColumn(name="INDEX_COL") if I had this the problem solve but I retrieve more children than I have, one child is null.
 private List<Child> children;

}

Kind.java

@Entity
public Child {

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

 @ManyToOne
 private Parent parent;

}

Was ist mit diesem Problem? Was kann ich tun?

---

EDITAR

OK, das Problem, das ich habe, ist, dass eine andere "übergeordnete" Entität innerhalb meiner übergeordneten ist, mein wirkliches Verhalten ist dies:

Elternteil.java

@Entity
public Parent {

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

 @ManyToOne
 private AnotherParent anotherParent;

 @OneToMany(mappedBy="parent", fetch=FetchType.EAGER)
 private List<Child> children;

}

AnotherParent.java

@Entity
public AnotherParent {

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

 @OneToMany(mappedBy="parent", fetch=FetchType.EAGER)
 private List<AnotherChild> anotherChildren;

}

Hibernate mag keine zwei Sammlungen mit FetchType.EAGER aber das scheint ein Fehler zu sein, ich mache keine ungewöhnlichen Dinge...

Entfernen von FetchType.EAGER de Parent o AnotherParent löst das Problem, aber ich brauche es, also ist die wirkliche Lösung die Verwendung von @LazyCollection(LazyCollectionOption.FALSE) anstelle von FetchType (Dank an Bozho für die Lösung).

Answer 1

Ich denke, eine neuere Version von Hibernate (mit Unterstützung von JPA 2.0) sollte dies handhaben. Aber ansonsten können Sie es umgehen, indem Sie die Sammlungsfelder mit annotieren:

@LazyCollection(LazyCollectionOption.FALSE)

Denken Sie daran, die fetchType Attribut aus dem @*ToMany Bemerkung.

Beachten Sie jedoch, dass in den meisten Fällen eine Set<Child> ist besser geeignet als List<Child> Wenn Sie also nicht wirklich eine List - anstreben Set

Aber denken Sie daran, dass Sie bei der Verwendung von Sets wird nicht die Unterlage zu beseitigen Kartesisches Produkt wie beschrieben von Vlad Mihalcea in seiner Antwort ¡!

Answer 2

Wechseln Sie einfach von List Typ zu Set Typ.

Aber denken Sie daran, dass Sie wird nicht die Unterlage zu beseitigen Kartesisches Produkt wie beschrieben von Vlad Mihalcea in seiner Antwort ¡!

Answer 3

Wir haben die folgenden Einrichtungen:

Und, Sie wollen ein Elternteil abholen Post Einheiten zusammen mit allen comments y tags Sammlungen.

Wenn Sie mehr als eine JOIN FETCH Richtlinien:

List<Post> posts = entityManager
.createQuery(
    "select p " +
    "from Post p " +
    "left join fetch p.comments " +
    "left join fetch p.tags " +
    "where p.id between :minId and :maxId", Post.class)
.setParameter("minId", 1L)
.setParameter("maxId", 50L)
.getResultList();

Hibernate wirft die berüchtigte:

org.hibernate.loader.MultipleBagFetchException: cannot simultaneously fetch multiple bags [
  com.vladmihalcea.book.hpjp.hibernate.fetching.Post.comments,
  com.vladmihalcea.book.hpjp.hibernate.fetching.Post.tags
]

Hibernate erlaubt es nicht, mehr als eine Tasche abzurufen, da dies ein kartesisches Produkt erzeugen würde.

Die schlechteste "Lösung"

Sie werden viele Antworten, Blogbeiträge, Videos oder andere Ressourcen finden, die Ihnen sagen, dass Sie eine Set anstelle einer List für Ihre Sammlungen.

Das ist ein schlechter Ratschlag. Tun Sie das nicht!

Verwendung von Sets anstelle von Lists macht die MultipleBagFetchException verschwinden, aber das kartesische Produkt bleibt bestehen, was eigentlich noch schlimmer ist, da Sie das Leistungsproblem erst lange nach der Anwendung dieser "Lösung" bemerken werden.

Die richtige Lösung

Sie können den folgenden Trick anwenden:

List<Post> posts = entityManager
.createQuery(
    "select distinct p " +
    "from Post p " +
    "left join fetch p.comments " +
    "where p.id between :minId and :maxId ", Post.class)
.setParameter("minId", 1L)
.setParameter("maxId", 50L)
.setHint(QueryHints.PASS_DISTINCT_THROUGH, false)
.getResultList();

posts = entityManager
.createQuery(
    "select distinct p " +
    "from Post p " +
    "left join fetch p.tags t " +
    "where p in :posts ", Post.class)
.setParameter("posts", posts)
.setHint(QueryHints.PASS_DISTINCT_THROUGH, false)
.getResultList();

In der ersten JPQL-Abfrage, distinct geht NICHT zur SQL-Anweisung. Deshalb setzen wir die PASS_DISTINCT_THROUGH JPA-Abfrage-Hinweis zu false .

DISTINCT hat in JPQL zwei Bedeutungen, und hier brauchen wir es, um die Java-Objektreferenzen zu deduplizieren, die von getResultList auf der Java-Seite, nicht auf der SQL-Seite.

Solange Sie höchstens eine Sammlung mit JOIN FETCH dann wird es Ihnen gut gehen.

Durch die Verwendung mehrerer Abfragen vermeiden Sie das kartesische Produkt, da jede andere Sammlung als die erste über eine zweite Abfrage abgerufen wird.

Sie könnten noch mehr tun

Wenn Sie die FetchType.EAGER Strategie zur Kartierungszeit für @OneToMany o @ManyToMany Assoziationen, dann kann es leicht zu einer MultipleBagFetchException .

Am besten wechseln Sie von FetchType.EAGER a Fetchype.LAZY da eager fetching eine schreckliche Idee ist, die zu kritischen Leistungsproblemen der Anwendung führen kann.

Schlussfolgerung

Vermeiden Sie FetchType.EAGER und wechseln Sie nicht von List a Set nur weil Hibernate dadurch die MultipleBagFetchException unter den Teppich gekehrt. Holen Sie immer nur eine Sammlung auf einmal, dann wird alles gut.

Solange Sie dies mit der gleichen Anzahl von Abfragen tun, wie Sie Sammlungen zu initialisieren haben, ist alles in Ordnung. Initialisieren Sie die Sammlungen nur nicht in einer Schleife, da dies zu N+1-Abfrageproblemen führt, die ebenfalls schlecht für die Leistung sind.

Answer 4

Fügen Sie eine Hibernate-spezifische @Fetch-Annotation zu Ihrem Code hinzu:

@OneToMany(mappedBy="parent", fetch=FetchType.EAGER)
@Fetch(value = FetchMode.SUBSELECT)
private List<Child> childs;

Dies sollte das Problem beheben, das mit dem Hibernate-Fehler zusammenhängt HHH-1718

Answer 5

Nach dem Ausprobieren jeder einzelnen Option, die in diesem und anderen Beiträgen beschrieben wird, bin ich zu dem Schluss gekommen, dass die Lösung die folgende ist.

In jeder XToMany-Stelle @ XXXToMany(mappedBy="parent", fetch=FetchType.EAGER) und unmittelbar danach

@Fetch(value = FetchMode.SUBSELECT)

Das hat bei mir funktioniert