Em muitos casos há a necessidade do uso de mais de uma lista de objetos dentro de uma classe, como por exemplo, um Produto que possui uma lista de cores e uma lista de movimentação. No Hibernate, trabalhar com esse tipo de objeto pode ser um problema devido a um erro relacionado ao uso de duas ou mais listas (“cannot simultaneously fetch multiple bags”). Não se preocupe, vamos explicar mais à frente do que se trata, com detalhes.
O uso de duas ou mais listas sendo carregadas simultaneamente (Eager Loading) em um mesmo mapeamento não é permitido no Hibernate, até certo ponto. Sendo assim, neste artigo explicaremos o porquê este erro ocorre e como corrigi-lo de forma adequada.
Como ocorre o erro de “Multiple Bags”
Primeiro é importante entender que o termo “bag” é uma associação à java.util.List or java.util.Collection. Vamos abaixo explicar como o erro ocorre através de um exemplo simples, assim fica fácil de assimilar o problema.
Digamos que temos uma classe chamada Parent e 2 subclasses chamadas de Child1 e Child2. Ambas as subclasses Child1 e Child2 tem um bag da classe Parent, assim como mostra o código da Listagem 1.
Listagem 1. Mapeamento da classe Parent
@OneToMany(mappedBy="parent",cascade=CascadeType.ALL, fetch=FetchType.EAGER)
List<Child1> child1s = new LinkedList<Child1>();
@OneToMany(mappedBy="parent",cascade=CascadeType.ALL, fetch=FetchType.EAGER)
List<Child2> child2s= new LinkedList<Child2>(); Perceba que na Listagem 1 ambos os Lists possuem a “FetchType.EAGER” o que explicitamente diz que ambos dever ser carregados juntamente com sua classe Parent. Ao realizar uma busca do nosso objeto Parent no banco de dados, usando o Hibernate, teremos a saída da Listagem 2 do SQL gerado.
Listagem 2. SQL Gerado pelo Hibernate
select
parent0_.id as p_id, parent0_.name as p_name, child1s1_.parent_id as c1_p_id,
child1s1_.id as c1_id, child1s1_.id as c1_id_1, child1s1_.parent_id as
c1_p_id_1, child1s1_.value as c1_val,child2s2_.parent_id as c2_p_id,
child2s2_.id as c2_id, child2s2_.id as c2_id_,
child2s2_.parent_id as c2_p_id_1, child2s2_.value as c2_val
from
PARENT parent0_ left outer join
CHILD1 child1s1_ on parent0_.id=child1s1_.parent_id left outer join
CHILD2 child2s2_ on parent0_.id=child2s2_.parent_id
where
parent0_.id=? Nessa listagem foram realizadas pequenas modificações apenas para tornar o código mais legível. Vamos entender como funciona o relacionamento entre Parent, Child1 e Child2.
Na Figura 1 temos a tabela Parent com um registro.
Figura 1. Tabela Parent
Temos agora, na Figura 2, a tabela Child1 com dois registros fazendo referência (chave estrangeira) para a tabela Parent no registro 122.
Figura 2. Tabela Child1
Por fim e não menos importante, temos a Tabela 3 também fazendo referência a tabela Parent, no registro 122.
Figura 3. Tabela Child2
Agora, executamos o SQL mostrado na Listagem 2 e teremos o resultado da Figura 4.
Figura 4. Resultado da Listagem 2
Vamos entender o que ocorreu na figura acima: você deve ter percebido que o Hibernate gerou um erro na tabela mostrada, pois o CHILD2-1 está se repetindo duas vezes, sendo uma na primeira linha e outra na segunda linha. Isso ocorre porque o Hibernate não consegue “ver” que o Child2, na verdade tem apenas uma linha, isso porque a associação da tabela Parent com Child1 e Chidl2 tendem a fazer isso. Veremos nas próximas seções como corrigir esse problema.
Solução do Problema
Dado o problema apresentado neste artigo, vamos agora trabalhar para resolver este problema.
Existem pelo menos três estratégias para a solução deste problema, são elas:
- Solução 1 – Usar LAZY Loading em todas as listas, assim evita-se o processo de “confusão” e erro do Hibernate, ou manter sempre uma lista apenas com Eager Loading, deixando todas as outras com azy. Veja como ficaria o exemplo da Listagem 3 aplicado a esta solução.
Listagem 3. Solução 1
@OneToMany(mappedBy="parent",cascade=CascadeType.ALL, fetch=FetchType.LAZY)
List<Child1> child1s = new LinkedList<Child1>();
@OneToMany(mappedBy="parent",cascade=CascadeType.ALL, fetch=FetchType.LAZY)
List<Child2> child2s= new LinkedList<Child2>(); O problema da Solução acima é que nunca poderemos carregar as duas listas ao mesmo tempo, sempre teremos que fazer uma por uma. Ao tentar realizar um HQL realizando JOIN FETCH em ambas as listas o problema voltará a ocorrer.
- Solução 2 – Mudar a Bag (List/Collection) para Set é uma outra solução viável e muito utilizada e simples. O conceito é trocar o tipo do seu objeto de List/Collection para o tipo Set. Você deve-se perguntar sempre: Eu preciso mesmo utilizar um List? Porque não utilizar Set? Na maioria dos casos o List é utilizado apenas porque estamos acostumados à fazê-lo. Observe a Listagem 4.
Listagem 4. Solução 2
@OneToMany(mappedBy="parent",cascade=CascadeType.ALL, fetch=FetchType.EAGER)
Set<Child1> child1s = new HashSet<Child1>();
@OneToMany(mappedBy="parent",cascade=CascadeType.ALL, fetch=FetchType.EAGER)
Set<Child2> child2s= new HashSet<Child2>(); - Solução 3 – Adicionar o @IndexColumn a sua bag. Iremos ver com mais detalhes na seção abaixo apenas para essa solução. Veja na Listagem 5 como ficará nossa solução após finalizada.
Listagem 5. Solução 3
@OneToMany(mappedBy="parent",cascade=CascadeType.ALL, fetch=FetchType.EAGER)
@IndexColumn(name="INDEX_COL")
List<Child1> child1s = new LinkedList<Child1>(); Usando @IndexColumn para usar Multiple Bags
O uso da anotação @IndexColumn diz ao Hibernate se o elemento já foi ou não carregado, sendo assim evita-se a duplicidade como mostrado nas seções anteriores.
Porém fique muito atento, pois o @IndexColumn não é gerenciado pelo Hibernate no “lado mais fraco do relacionamento”, ou seja, o lado inverso. O lado mais fraco do relacionamento é especificado com o atributo “mappedBy” e como nossa Classe Parent tem um “mappedBy='parent'” significa que ela é o lado mais fraco do relacionamento, então devemos retirar esse mappedBy para que o @IndexColumn funcione como desejamos. Veja como ficaria na Listagem 6.
Listagem 6. Usando @IndexColumn sem mappedBy
@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER) //mappedBy removido
@IndexColumn(name="INDEX_COL")
List<Child> childs = new LinkedList<Child>(); Acontece que ao usar o mappedBy e tornando o Parent o lado mais fraco da associação, o Hibernate não gerencia o index de forma automática, que é exatamente o que desejamos em nosso caso.
Certo, mas então você deve se perguntar: “Se eu não posso mudar a forma como meus objetos se relacionam, eu prefiro gerenciar de forma manual o index do que perder o meu mappedBy”.
No caso onde é necessário o uso do mappedBy juntamente com o @IndexColumn, você precisará gerenciar seu index de forma manual, vamos ver como.
Primeiramente o seu mapeamento deverá ficar como na Listagem 7, juntando o mappedBy e o @IndexColumn.
Listagem 7. @IndexColumn e mappedBy
@OneToMany(mappedBy="parent",cascade=CascadeType.ALL, fetch=FetchType.EAGER)
@IndexColumn(name="INDEX_COL")
List<Child> childs = new LinkedList<Child>(); Lembre-se que o “INDEX_COL” deve ser uma coluna criada no banco de dados, pois só assim será possível indexar os elementos de forma correta.
Vejamos na Listagem 8 como ficaria nossa classe com um index manual.
Listagem 8. Indexando de forma manual
@Column(name = “INDEX_COLUMN”)
private int position;
@ManyToOne
public Parent getParent() {
return parent;
}
public int getPosition() {
return parent.getChildren().indexOf(this);
}
public void setPosition(int index) {
}O que temos acima é um campo chamado “position” que tem como propósito a indexação manual de nossos elementos na lista.
Das soluções propostas é muito útil avaliar a solução 2, pois é o caso mais comum, onde não há necessidade do uso de um List. Deve-se migrar para o Set, afim de evitar tais erros. Como citamos nas seções anteriores, se você não sabe ou não tem um objetivo especifico para usar o List, use o Set.
Por outro lado, há soluções como o uso de @IndexColumn e Lazy Loadings quando há real necessidade do uso de duas ou mais listas no mesmo mapeamento. O problema de usar-se Lazy Loading é que estaremos sempre amarrados a carregar uma lista por vez, o que pode ser um tanto quanto oneroso em se tratando de grandes aplicações que necessitam de maior produtividade e maior facilidade para manutenção de código. Sendo assim, não nos resta outra solução (mostrada neste artigo) se não a @IndexColumn que nos permite o uso simultâneo de duas ou mais listas, sem a necessidade de mudança brusca de código ou mesmo da estrutura atual do sistema.
Esperamos que este artigo tenha sido proveitoso e útil para o entendimento do problema em questão e resolução do mesmo.
