Hibernate Criteria gibt Kinder mit FetchType.EAGER mehrmals zurück

Ich habe eine OrderKlasse mit einer Liste von OrderTransactionsund habe sie mit einer Eins-zu-Viele-Zuordnung im Ruhezustand wie folgt zugeordnet:

@OneToMany(targetEntity = OrderTransaction.class, cascade = CascadeType.ALL)
public List<OrderTransaction> getOrderTransactions() {
    return orderTransactions;
}

Diese Orderhaben auch ein Feld orderStatus, das zum Filtern mit den folgenden Kriterien verwendet wird:

public List<Order> getOrderForProduct(OrderFilter orderFilter) {
    Criteria criteria = getHibernateSession()
            .createCriteria(Order.class)
            .add(Restrictions.in("orderStatus", orderFilter.getStatusesToShow()));
    return criteria.list();
}

Dies funktioniert und das Ergebnis ist wie erwartet.

Nun , hier ist meine Frage : Warum, wenn ich die Art holen gesetzt explizit auf EAGER, tut die Orders mehrfach in der Ergebnisliste erscheinen?

@OneToMany(targetEntity = OrderTransaction.class, fetch = FetchType.EAGER, cascade = CascadeType.ALL)
public List<OrderTransaction> getOrderTransactions() {
    return orderTransactions;
}

Wie müsste ich meinen Kriteriencode ändern, um mit der neuen Einstellung das gleiche Ergebnis zu erzielen?

Dies ist tatsächlich das erwartete Verhalten, wenn ich Ihre Konfiguration richtig verstanden habe.

Sie erhalten dieselbe OrderInstanz in jedem der Ergebnisse, aber da Sie jetzt einen Join mit dem durchführen OrderTransaction, muss dieselbe Anzahl von Ergebnissen zurückgegeben werden, die ein regulärer SQL-Join zurückgibt

Eigentlich sollte es also mehrmals auftauchen. Dies wird vom Autor (Gavin King) selbst hier sehr gut erklärt: Es erklärt sowohl warum als auch wie man immer noch eindeutige Ergebnisse erzielt

Der Ruhezustand gibt keine eindeutigen Ergebnisse für eine Abfrage mit aktiviertem Outer Join-Abruf für eine Sammlung zurück (selbst wenn ich das eindeutige Schlüsselwort verwende). Zunächst müssen Sie SQL verstehen und wissen, wie OUTER JOINs in SQL funktionieren. Wenn Sie äußere Verknüpfungen in SQL nicht vollständig verstehen und verstehen, lesen Sie dieses FAQ-Element nicht weiter, sondern konsultieren Sie ein SQL-Handbuch oder ein Lernprogramm. Andernfalls verstehen Sie die folgende Erklärung nicht und beschweren sich im Hibernate-Forum über dieses Verhalten.

Typische Beispiele, die möglicherweise doppelte Referenzen desselben Order-Objekts zurückgeben:

List result = session.createCriteria(Order.class)
                    .setFetchMode("lineItems", FetchMode.JOIN)
                    .list();

---

<class name="Order">
    ...
    <set name="lineItems" fetch="join">

---

List result = session.createCriteria(Order.class)
                       .list();
List result = session.createQuery("select o from Order o left join fetch o.lineItems").list();

Alle diese Beispiele erzeugen dieselbe SQL-Anweisung:

SELECT o.*, l.* from ORDER o LEFT OUTER JOIN LINE_ITEMS l ON o.ID = l.ORDER_ID

Möchten Sie wissen, warum die Duplikate vorhanden sind? Schauen Sie sich die SQL-Ergebnismenge an. Hibernate versteckt diese Duplikate nicht auf der linken Seite des äußeren verbundenen Ergebnisses, sondern gibt alle Duplikate der Treibertabelle zurück. Wenn Sie 5 Bestellungen in der Datenbank haben und jede Bestellung 3 Werbebuchungen enthält, besteht die Ergebnismenge aus 15 Zeilen. Die Java-Ergebnisliste dieser Abfragen enthält 15 Elemente vom Typ Order. Von Hibernate werden nur Instanzen mit 5 Ordnungen erstellt, Duplikate der SQL-Ergebnismenge bleiben jedoch als doppelte Verweise auf diese 5 Instanzen erhalten. Wenn Sie diesen letzten Satz nicht verstehen, müssen Sie sich über Java und den Unterschied zwischen einer Instanz auf dem Java-Heap und einem Verweis auf eine solche Instanz informieren.

(Warum eine linke äußere Verknüpfung? Wenn Sie eine zusätzliche Bestellung ohne Werbebuchungen haben würden, würde die Ergebnismenge 16 Zeilen umfassen, wobei NULL die rechte Seite ausfüllt, wobei die Positionsdaten für eine andere Bestellung gelten. Sie möchten Bestellungen, auch wenn Sie haben keine Werbebuchungen, oder? Wenn nicht, verwenden Sie einen inneren Join-Abruf in Ihrem HQL.

Der Ruhezustand filtert diese doppelten Referenzen standardmäßig nicht heraus. Einige Leute (nicht Sie) wollen das tatsächlich. Wie können Sie sie herausfiltern?

So was:

Collection result = new LinkedHashSet( session.create*(...).list() );

Zusätzlich zu dem, was Eran erwähnt, besteht eine andere Möglichkeit, das gewünschte Verhalten zu erzielen, darin, den Ergebnis-Transformator einzustellen:

criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);

Versuchen

@Fetch (FetchMode.SELECT) 

beispielsweise

@OneToMany(targetEntity = OrderTransaction.class, fetch = FetchType.EAGER, cascade = CascadeType.ALL)
@Fetch (FetchMode.SELECT)
public List<OrderTransaction> getOrderTransactions() {
return orderTransactions;

}}

Verwenden Sie nicht List und ArrayList, sondern Set und HashSet.

@OneToMany(targetEntity = OrderTransaction.class, cascade = CascadeType.ALL)
public Set<OrderTransaction> getOrderTransactions() {
    return orderTransactions;
}

Mit Java 8 und Streams füge ich meiner Dienstprogrammmethode diese Rückgabeanweisung hinzu:

return results.stream().distinct().collect(Collectors.toList());

Streams entfernen Duplikate sehr schnell. Ich verwende Anmerkungen in meiner Entitätsklasse wie folgt:

@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
@JoinTable(name = "STUDENT_COURSES")
private List<Course> courses;

Ich denke, es ist besser in meiner App, eine Sitzung in einer Methode zu verwenden, bei der ich Daten aus der Datenbank benötige. Abschlusssitzung, wenn ich fertig bin. Natürlich habe ich meine Entity-Klasse so eingestellt, dass sie den Leasy-Fetch-Typ verwendet. Ich gehe zum Refactor.

Ich habe das gleiche Problem beim Abrufen von 2 zugeordneten Sammlungen: Benutzer hat 2 Rollen (Set) und 2 Mahlzeiten (Liste) und Mahlzeiten werden dupliziert.

@Table(name = "users")
public class User extends AbstractNamedEntity {

   @CollectionTable(name = "user_roles", joinColumns = @JoinColumn(name = "user_id"))
   @Column(name = "role")
   @ElementCollection(fetch = FetchType.EAGER)
   @BatchSize(size = 200)
   private Set<Role> roles;

   @OneToMany(fetch = FetchType.LAZY, mappedBy = "user")
   @OrderBy("dateTime DESC")
   protected List<Meal> meals;
   ...
}

DISTINCT hilft nicht (DATA-JPA-Abfrage):

@EntityGraph(attributePaths={"meals", "roles"})
@QueryHints({@QueryHint(name= org.hibernate.jpa.QueryHints.HINT_PASS_DISTINCT_THROUGH, value = "false")}) // remove unnecessary distinct from select
@Query("SELECT DISTINCT u FROM User u WHERE u.id=?1")
User getWithMeals(int id);

Endlich habe ich 2 Lösungen gefunden:

1. Ändern Sie die Liste in LinkedHashSet
2. Verwenden Sie EntityGraph nur mit dem Feld "Mahlzeit" und geben Sie LOAD ein, wodurch die deklarierten Rollen geladen werden (EAGER und BatchSize = 200, um ein N + 1-Problem zu vermeiden):

Endgültige Lösung:

@EntityGraph(attributePaths = {"meals"}, type = EntityGraph.EntityGraphType.LOAD)
@Query("SELECT u FROM User u WHERE u.id=?1")
User getWithMeals(int id);

Anstatt Hacks wie:

• Set anstatt List
• criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);

die Ihre SQL-Abfrage nicht ändern, können wir verwenden (unter Angabe von JPA-Spezifikationen)

q.select(emp).distinct(true);

Dadurch wird die resultierende SQL-Abfrage geändert, sodass ein DISTINCTdarin enthalten ist.

Es klingt nicht nach einem großartigen Verhalten, einen äußeren Join anzuwenden und doppelte Ergebnisse zu erzielen. Die einzige verbleibende Lösung besteht darin, unser Ergebnis mithilfe von Streams zu filtern. Dank Java8 gibt es eine einfachere Möglichkeit zum Filtern.

return results.stream().distinct().collect(Collectors.toList());