Os critérios do Hibernate retornam filhos várias vezes com FetchType.EAGER

Eu tenho uma Orderclasse que tem uma lista de OrderTransactionse mapeei com um mapeamento de Hibernate um-para-muitos assim:

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

Estes Orders também têm um campo orderStatus, que é usado para filtrar com os seguintes critérios:

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

Isso funciona e o resultado é o esperado.

Agora, aqui está minha pergunta : Por que, quando eu defino o tipo de busca explicitamente como EAGER, os Orders aparecem várias vezes na lista resultante?

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

Como eu teria que alterar meu código de critérios para chegar ao mesmo resultado com a nova configuração?

Este é realmente o comportamento esperado se eu entendi sua configuração corretamente.

Você obtém a mesma Orderinstância em qualquer um dos resultados, mas como agora você está fazendo uma junção com o OrderTransaction, ela deve retornar a mesma quantidade de resultados que uma junção sql regular retornará

Então, na verdade, deve aparecer várias vezes. isso é muito bem explicado pelo próprio autor (Gavin King) aqui : Ele explica por que e como ainda obter resultados distintos

O Hibernate não retorna resultados distintos para uma consulta com a busca de junção externa habilitada para uma coleção (mesmo se eu usar a palavra-chave distinta)? Primeiro, você precisa entender o SQL e como OUTER JOINs funcionam no SQL. Se você não entende e compreende totalmente as junções externas em SQL, não continue lendo este item da FAQ, mas consulte um manual ou tutorial de SQL. Caso contrário, você não entenderá a explicação a seguir e reclamará sobre esse comportamento no fórum do Hibernate.

Exemplos típicos que podem retornar referências duplicadas do mesmo 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 esses exemplos produzem a mesma instrução SQL:

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

Quer saber por que as duplicatas estão lá? Observe o conjunto de resultados SQL, o Hibernate não esconde essas duplicatas no lado esquerdo do resultado da junção externa, mas retorna todas as duplicatas da tabela de controle. Se você tiver 5 pedidos no banco de dados e cada pedido tiver 3 itens de linha, o conjunto de resultados terá 15 linhas. A lista de resultados Java dessas consultas terá 15 elementos, todos do tipo Order. Apenas 5 instâncias de Order serão criadas pelo Hibernate, mas duplicatas do conjunto de resultados SQL são preservadas como referências duplicadas a essas 5 instâncias. Se você não entende esta última frase, você precisa ler sobre Java e a diferença entre uma instância no heap Java e uma referência a tal instância.

(Por que uma junção externa à esquerda? Se você tivesse um pedido adicional sem itens de linha, o conjunto de resultados seria de 16 linhas com NULL preenchendo o lado direito, onde os dados do item de linha são para outro pedido. Você deseja pedidos mesmo que eles não têm itens de linha, certo? Caso contrário, use uma busca de junção interna em seu HQL).

O Hibernate não filtra essas referências duplicadas por padrão. Algumas pessoas (não você) realmente querem isso. Como você pode filtrá-los?

Como isso:

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

Além do que é mencionado por Eran, outra forma de obter o comportamento desejado, é definir o transformador de resultado:

criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);

experimentar

@Fetch (FetchMode.SELECT) 

por exemplo

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

}

Não use List e ArrayList, mas Set e HashSet.

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

Usando Java 8 e Streams, adiciono ao meu método de utilitário esta declaração de retorno:

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

Streams removem duplicatas muito rápido. Eu uso anotações em minha classe Entity assim:

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

Acho que é melhor no meu aplicativo usar sessão no método onde preciso de dados de banco de dados. Sessão de Closse quando eu terminar. Claro, configurei minha classe Entity para usar o tipo de busca leasy. Eu vou refatorar.

Tenho o mesmo problema para buscar 2 coleções associadas: o usuário possui 2 funções (Conjunto) e 2 refeições (Lista) e as refeições estão 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 não ajuda (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);

Finalmente encontrei 2 soluções:

1. Alterar lista para LinkedHashSet
2. Use EntityGraph apenas com o campo "refeição" e digite LOAD, que carregam os papéis conforme declarados (EAGER e por BatchSize = 200 para evitar o problema N + 1):

Solução final:

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

Em vez de usar hacks como:

• Set ao invés de List
• criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);

que não modificam sua consulta sql, podemos usar (citando especificações JPA)

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

que modifica a consulta sql resultante, tendo, portanto, um DISTINCTnele.

Não parece um bom comportamento aplicar uma junção externa e trazer resultados duplicados. A única solução que resta é filtrar nosso resultado usando fluxos. Obrigado java8 dando uma maneira mais fácil de filtrar.

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