Hibernate Exception: Multiple Bags

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.

Hibernate Exception: Multiple Bags

Veja neste artigo como ocorre o erro do uso de Multiple Bags no Hibernate e como resolve-lo.

Como ocorre o erro de �Multiple Bags�

Soluç�o do Problema

Usando @IndexColumn para usar Multiple Bags

Artigos relacionados