Hibernate Criteria devuelve hijos varias veces con FetchType.EAGER

Tengo una Orderclase que tiene una lista de OrderTransactionsy la asigné con un mapeo de Hibernate de uno a muchos así:

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

Estos Ordermensajes también tienen un campo orderStatus, que se utiliza para filtrar con los siguientes criterios:

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

Esto funciona y el resultado es el esperado.

Ahora, aquí está mi pregunta : ¿Por qué, cuando establezco el tipo de búsqueda explícitamente en EAGER, aparecen las Orders varias veces en la lista resultante?

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

¿Cómo tendría que cambiar mi código de Criterios para alcanzar el mismo resultado con la nueva configuración?

Este es realmente el comportamiento esperado si entendí su configuración correctamente.

Obtiene la misma Orderinstancia en cualquiera de los resultados, pero como ahora está haciendo una combinación con OrderTransaction, debe devolver la misma cantidad de resultados que una combinación SQL regular

Entonces, en realidad, debería aparecer varias veces. Esto se explica muy bien por el propio autor (Gavin King) aquí : explica por qué y cómo obtener resultados distintos

Hibernate no devuelve resultados distintos para una consulta con la búsqueda de combinación externa habilitada para una colección (incluso si uso la palabra clave distinta). Primero, debe comprender SQL y cómo funcionan las OUTER JOIN en SQL. Si no comprende y comprende completamente las combinaciones externas en SQL, no continúe leyendo este artículo de preguntas frecuentes, pero consulte un manual o tutorial de SQL. De lo contrario, no comprenderá la siguiente explicación y se quejará de este comportamiento en el foro de Hibernate.

Ejemplos típicos que pueden devolver referencias duplicadas del mismo objeto Order:

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();

Todos estos ejemplos producen la misma declaración SQL:

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

¿Quieres saber por qué hay duplicados? Mire el conjunto de resultados de SQL, Hibernate no oculta estos duplicados en el lado izquierdo del resultado combinado externo, pero devuelve todos los duplicados de la tabla inicial. Si tiene 5 pedidos en la base de datos y cada pedido tiene 3 elementos de línea, el conjunto de resultados será de 15 filas. La lista de resultados de Java de estas consultas tendrá 15 elementos, todos de tipo Order. Hibernate solo creará 5 instancias de Order, pero los duplicados del conjunto de resultados de SQL se conservan como referencias duplicadas a estas 5 instancias. Si no comprende esta última oración, debe leer sobre Java y la diferencia entre una instancia en el montón de Java y una referencia a dicha instancia.

(¿Por qué una combinación externa a la izquierda? Si tuviera un pedido adicional sin líneas de pedido, el conjunto de resultados sería 16 filas con NULL llenando el lado derecho, donde los datos de la línea de pedido son para otro pedido. Desea pedidos incluso si no tienen líneas de pedido, ¿verdad? De lo contrario, utilice una búsqueda de combinación interna en su HQL).

Hibernate no filtra estas referencias duplicadas de forma predeterminada. Algunas personas (no tú) realmente quieren esto. ¿Cómo puedes filtrarlos?

Me gusta esto:

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

Además de lo mencionado por Eran, otra forma de obtener el comportamiento que desea es configurar el transformador de resultado:

criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);

tratar

@Fetch (FetchMode.SELECT) 

por ejemplo

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

}

No use List y ArrayList, sino Set y HashSet.

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

Usando Java 8 y Streams agrego en mi método de utilidad esta declaración de devolución:

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

Las secuencias eliminan los duplicados muy rápido. Yo uso la anotación en mi clase Entity así:

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

Creo que es mejor en mi aplicación usar la sesión en el método donde necesito datos de la base de datos. Cierre la sesión cuando termine. Por supuesto, configuré mi clase Entity para usar el tipo de búsqueda leasy. Voy a refactorizar.

Tengo el mismo problema para buscar 2 colecciones asociadas: el usuario tiene 2 roles (Conjunto) y 2 comidas (Lista) y las comidas están duplicadas.

@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 no ayuda (consulta DATA-JPA):

@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);

Por fin he encontrado 2 soluciones:

1. Cambiar lista a LinkedHashSet
2. Use EntityGraph con solo el campo "comida" y escriba LOAD, que cargan los roles como lo declararon (EAGER y por BatchSize = 200 para evitar el problema N + 1):

Solución final:

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

En lugar de usar trucos como:

• Set en vez de List
• criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);

que no modifican su consulta sql, podemos usar (citando especificaciones JPA)

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

que modifica la consulta sql resultante, por lo que tiene un DISTINCTarchivo.

No parece un buen comportamiento aplicar una combinación externa y generar resultados duplicados. La única solución que queda es filtrar nuestro resultado usando streams. Gracias java8 por dar una forma más fácil de filtrar.

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