Hibernate Mapping: Mapeando Relacionamentos entre Entidades

Hibernate facilita o armazenamento e a recuperaç�o de objetos Java atrav�s do Mapeamento Objeto-Relacional (Object/Relational Mapping - ORM). O Hibernate oferece aos desenvolvedores a opç�o de criar mapeamentos entre modelos de base de dados e modelos de objetos atrav�s de duas formas: arquivos XML ou atrav�s de anotaç�es no c�digo fonte dos objetos. A opç�o prefer�vel � a segunda.

Quando utilizamos anotaç�es temos algumas vantagens como: c�digo mais intuitivo do que arquivos baseados em XML, menos detalhes para se preocupar, facilidade de visualizaç�o das configuraç�es, etc.

O Hibernate usa e suporta anotaç�es JPA 2 que por sua vez suportam o mapeamento entre entidades. JPA 2 suporta as associaç�es One-to-one (Um para Um), One-to-Many (Um para Muitos), Many-to-one (Muitos para Um) e Many-to-Many (Muitos para Muitos).

No restante do artigo estaremos estudando como podemos definir relacionamentos entre as nossas entidades.

1. Mapeando Associaç�es One-to-One Embutidas

Neste relacionamento teremos os atributos das entidades relacionadas que ser�o persistidas na mesma tabela. Por exemplo, uma classe Pessoa que tem um relacionamento One-to-One com a classe endereço, conforme exemplo da Listagem 1.

Listagem 1. Definindo uma tabela com uma anotaç�o @Embeddable


  @Entity
  public class Pessoa {
     @Id
     private long id;
     private String nome;
    @Embedded
     private Endereco endereco;
      //get's e set's
  }
  @Embeddable
  public class Endereco {
    private String logradouro;
    //get's e set's
  }

Nesse caso temos todos os campos de uma tabela mantidos dentro de uma mesma tabela como se fosse outra tabela. Os atributos @Embedded e @Embeddable s�o usados para gerenciar este relacionamento. Uma entidade embutida deve ser composta inteiramente de campos e atributos b�sicos. As entidades embutidas usam as anotaç�es @Basic, @Column, @Lob, @Temporal, e @Enumerated. Podemos observar que a chave-prim�ria n�o pode ser mantida pela classe embutida e sim na classe que cont�m ela. A anotaç�o @Embeddable n�o tem qualquer atributo adicional, ela � pura. A anotaç�o @Embedded � utilizada para marcar campos ou m�todos getter nas entidades que referencia a entidade embutida. A anotaç�o @Embedded nos permite sobrescrever colunas atrav�s das tags @AttributeOverride e @AttributeOverrides.

No exemplo da Listagem 2 demonstramos como utilizar @AttributeOverride e @AttributeOverrides para sobrescrever nomes de coluna endereco e pais com os atributos ENDER e PAIS.

Listagem 2. Utilizando @AttributeOverride e @AttributeOverrides


  @Embedded
  @AttributeOverrides({
    @AttributeOverride(name="endereco",column=@Column(name="ENDER") 
    ),
    @AttributeOverride(name="pais",column=@Column(name="PAIS"))
  })
  public Endereco getEndereco() {
    return this.endereco;
  }

Como uma �ltima dica, vale ressaltar que o Hibernate e JPA n�o suportam mapear um objeto embutido em mais de uma tabela.

2. Mapeando Associaç�es One-to-One Convencionais

A anotaç�o One-to-One � utilizada para associar duas entidades onde uma n�o � componente da outra, ao contr�rio da definiç�o acima. Numa associaç�o One-to-One tamb�m podemos ter um relacionamento bidirecional. Nesse caso, um dos lados precisar� ser o dono do relacionamento e ser respons�vel por atualizar uma coluna com uma chave estrangeira. Para mais informaç�es veja mais sobre o atributo mappedBy j� discutido em outro artigo.

A aplicaç�o do One-to-one � simples e possui apenas atributos opcionais. Na Listagem 3 temos um exemplo de como aplicar a anotaç�o.

Listagem 3. Utilizando a anotaç�o @OneToOne.


  @OneToOne
  public Endereco getEndereco() {
           return this.endereco;
  }

Os atributos opcionais s�o os seguintes:

- targetEntity: � a classe da entidade que � o destino da associaç�o. O default � o tipo do campo ou a propriedade que armazena a associaç�o.

- cascade: pode ser configurado para qualquer um dos membros da enumeraç�o javax.persistence.CascadeType.

- fetch: pode ser configurado para EAGER ou LAZY.

- optional: indica se o valor sendo mapeado pode ser null.

- orphanRemoval: indica que se o valor sendo mapeado � deletado, esta entidade tamb�m ser� deletada.

- mappedBy: indica que um relacionamento one-to-one bidirecional � apropriado pela entidade nomeada. O dono possui a chave-prim�ria da entidade subordinada.

3. Mapeando Associaç�es Many-to-One ou One-to-Many

A anotaç�o @OneToMany pode ser aplicada para um campo ou propriedade de uma coleç�o ou um array representando o "many" da associaç�o.

O atributo mappedBy � obrigat�rio numa associaç�o bidirecional e opcional numa associaç�o unidirecional. O atributo cascade tamb�m � opcional, possuindo um membro da enumeraç�o javax.persistence.CascadeType. O atributo targetEntity tamb�m � opcional. Por fim, fetch tamb�m � opcional permitindo LAZY ou EAGER. Segue na Listagem 4 um exemplo da utilizaç�o.

Listagem 4. Utilizando mappedBy e cascade na anotaç�o @OneToMany.


  @OneToMany(cascade = ALL, mappedBy = "publicador")
  public Set<Livro> getLivros() {
           return livros;
  }

A anotaç�o many-to-one deste relacionamento � expresso da mesma forma que a anotaç�o anterior, conforme mostrado na Listagem 5.

Listagem 5. Utilizando a anotaç�o @ManyToOne.


  @ManyToOne
  @JoinColumn(name = "publicador_id")
  public Publicador getPublicador() {
           return publicador;
  }

@JoinColumn � utilizado para nomearmos a coluna que possui a chave-estrangeira requerida pela associaç�o. Se nada for especificado, ser� utilizado o nome do campo.

Outra anotaç�o bastante importante e utilizada � a @JoinTable que tamb�m � encontrada nos relacionamentos @ManyToMany.

Para exemplificar melhor podemos imaginar que tenhamos Usuarios e Perfis, ou seja, temos duas tabelas na nossa base de dados, sendo que cada usu�rio poder� ter apenas um perfil. Dessa forma, temos al�m das duas tabelas (Usu�rio e Perfil) uma terceira tabela para o mapeamento dos perfis para os usu�rios. Essa �ltima tabela Usu�rios_Perfil � uma tabela intermedi�ria que possui duas chaves estrangeiras para cada uma das tabelas Usu�rio e Perfil. Para mapear essa situaç�o podemos usar o JoinTable. O exemplo da Listagem 6 mostra como ficaria uma classe Java mapeando o Usuario.

Listagem 6. Exemplificando a classe Usuario.


  @Entity  
  @Table(name="usuario")  
  public class Usuario {  
           @Id
           @GeneratedValue
           private Integer id;
           private String login;
           private String senha; 
           @OneToOne(cascade=CascadeType.ALL)
           @JoinTable(name="usuario_perfil",
                     joinColumns={@JoinColumn(name="usuario_id",  
                      referencedColumnName="id")},  
                     inverseJoinColumns={@JoinColumn(name="perfil_id",   
                      referencedColumnName="id")})  
           private Perfil perfil;
   
           //getters e setters
        
  }

Na Listagem 7 temos o mapeamento da classe Perfil.

Listagem 7. Exemplificando a classe Perfil.


  @Entity  
  @Table(name="perfil")  
  public class Perfil {  
    
           @Id
           @GeneratedValue
           private Integer id;
   
           private String nomePerfil;
   
           @OneToMany(cascade=CascadeType.ALL)  
           @JoinTable(name="usuario_perfil",  
                     joinColumns={@JoinColumn(name="perfil_id", 
                      referencedColumnName="id")},  
                     inverseJoinColumns={@JoinColumn(name="usuario_id", 
                       referencedColumnName="id")})  
           private List<Usuario> usuarioList;
   
           //getters e setters
        
  }

A anotaç�o @JoinTable indica que estamos interagindo com uma tabela intermedi�ria, neste caso a tabela usuario_perfil, e no exemplo acima tamb�m configuramos o relacionamento e o mapeamento de colunas. joinColumns � resposn�vel pelo mapeamento de colunas do lado que � o dono. O atributo name possui o nome da coluna da tabela intermedi�ria, referencedColumnName cont�m o nome da coluna chave-prim�ria do lado que � dono (no nosso caso a tabela usuario possui como chave-prim�ria id).

O atributo inverseJoinColumns � respons�vel por mapear colunas do lado inverso.

Para testar esse c�digo, siga o exemplo da Listagem 8.

Listagem 8. Testando os c�digos anteriores.

public class Teste { public static void main(String[] args) { SessionFactory sessionFactory = HibernateUtil.getSessionFactory(); Session session = sessionFactory.openSession(); session.beginTransaction(); Perfil perfil = (Perfil) session.get(Perfil.class, 2); Usuario usuario = new Usuario("testeuser", "senhaqualquer"); usuario.setPerfil(perfil); session.save(usuario); session.getTransaction().commit(); session.close(); } }

Para simplificar ainda mais as ideias as tabelas, temos o exemplo da Listagem 9.

Listagem 9. Sqls utilizados nos exemplos.


  CREATE TABLE `perfil` (  
           `id` int(6) NOT NULL AUTO_INCREMENT,  
           `perfil` varchar(20) NOT NULL,  
           PRIMARY KEY (`id`)  
  ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;  
        
  CREATE TABLE `usuario` (  
           `id` int(6) NOT NULL AUTO_INCREMENT,  
           `login` varchar(20) NOT NULL,  
           `senha` varchar(20) NOT NULL,  
           PRIMARY KEY (`id`)  
  ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;  
        
  CREATE TABLE `usuario_perfil` (  
           `usuario_id` int(6) NOT NULL,  
           `perfil_id` int(6) NOT NULL,  
           KEY `usuario` (`usuario_id`),  
           KEY `perfil` (`perfil_id`),  
           CONSTRAINT `usuario` FOREIGN KEY 
           (`usuario_id`) REFERENCES `usuario` (`id`) ON DELETE CASCADE 
            ON UPDATE CASCADE,  
           CONSTRAINT `perfil` FOREIGN KEY (`perfil_id`)
           REFERENCES `perfil` (`id`) ON DELETE CASCADE 
           ON UPDATE CASCADE  
  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

4. Mapeando Associaç�es Many-to-Many

A anotaç�o @ManyToMany tem os seguintes atributos:

- mappedBy: � o campo que indica o dono do relacionamento. Este atributo s� � necess�rio quando a associaç�o � bidirecional.

- targetEntity: � a classe da entidade que � o destino da associaç�o.

- cascade: indica o comportamento em cascata da associaç�o, o default � none (nenhum).

- fetch: indica o comportamento de busca da associaç�o, sendo que o default � LAZY.

O exemplo da Listagem 10 demonstra a utilizaç�o desta anotaç�o.

Listagem 10. Utilizando a anotaç�o @ManyToMany.


@ManyToMany(cascade = ALL)
public Set<Autor> getAutores() {
	return autores;
}

Conclus�o

Neste artigo vimos como mapear relacionamentos utilizando o Hibernate. Tamb�m vimos como omitir certos campos e quais s�o os principais e mais utilizados atributos para cada uma das anotaç�es vistas.

At� a pr�xima!

Bibliografia

[1]Hibernate - JBoss Community, dispon�vel em www.hibernate.org/

[2]Documentaç�o de Refer�ncia Hibernate, dispon�vel em https://docs.jboss.org/hibernate/core/3.6/reference/pt-BR/html/index.html

[3] Introduç�o ao Hibernate, dispon�vel em http://www.hibernate.org/hib_docs/v3/reference/en/html/queryhql.html

[4] Jeff Linwood and Dave Minter. An introduction to persistence using Hibernate 3.5, Second Edition. Apress.

[5] Steve Perkins. Hibernate Search by Example: Explore the Hibernate Search system and use its extraordinary search features in your own applications. Packt Publishing.