Guia Hibernate

Hibernate: Como configurar em um projeto

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (9)  (0)

Veja neste artigo como configurar o framework de mapeamento objeto-relacional Hibernate no seu projeto.

Motivação

O Hibernate é um framework ORM (Object/Relational Mapping), e como tal tem a função de mapear as tabelas de um banco de dados relacional para as classes de uma aplicação. A ideia por trás desse tipo de framework é que você possa persistir e consultar dados utilizando apenas classes e objetos Java, minimizando a necessidade de lidar diretamente com SQL.

Neste artigo veremos como adicionar o Hibernate a um projeto, configurando as devidas dependências, e um exemplo simples de mapeamento por meio de anotações.

Iniciando a configuração do Hibernate

Para adicionar o Hibernate a um projeto, assim como normalmente fazemos ao adicionar qualquer biblioteca, utilizaremos o Maven. No entanto, caso você não deseje fazer uso dessa ferramenta de gerenciamento de dependências, pode importar as bibliotecas desse framework diretamente no classpath do projeto. Na Listagem 1 temos um exemplo de como deve ficar o arquivo pom.xml, no qual registramos as dependências.

<!-- HIBERNATE -->
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>5.2.6.Final</version>
</dependency>
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-entitymanager</artifactId>
    <version>5.2.6.Final</version>
</dependency>
Listagem 1. Importando o Hibernate no arquivo pom.xml

Nele, importamos duas bibliotecas: hibernate-core e hibernate-entitymanager, ambas da versão 5.2.6.Final, a mais recente na data de publicação desse artigo. Ao realizar essas importações, conseguiremos fazer uso dos principais recursos do Hibernate.

Logo após, o próximo passo é criar o arquivo persistence.xml, que contém as principais configurações requeridas pela JPA para que seja possível realizar corretamente as ações de mapeamento e persistência de dados na aplicação. Na Listagem 2 podemos ver como esse arquivo pode ser definido. A partir daqui, passaremos a usar apenas recursos da JPA, pois a ideia é termos uma aplicação com baixo nível de acoplamento em relação aos recursos do Hibernate, ou seja, a qualquer momento poderemos substitui-lo pelo EclipseLink ou qualquer outro framework ORM que implemente a JPA sem muito impacto no código.

01 <?xml version="1.0" encoding="UTF-8"?>
02 <persistence version="2.0"
03    xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
04    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
05    <persistence-unit name="myPU">
<p dir="ltr">06       <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
07       <class>br.com.devmedia.Documento</class>
08       <properties>
09          <!-- Dados da conexão com o banco -->
10
11          <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5InnoDBDialect" />
12          <property name="hibernate.show_sql" value="true" />
13          <property name="hibernate.format_sql" value="false" />
14          <property name="hibernate.hbm2ddl.auto" value="update" />
15       </properties>
16    </persistence-unit>
17 </persistence>
Listagem 2. Arquivo persistence.xml

O arquivo persistence.xml, que deve ser criado no diretório /main/resources/META-INF/, é responsável por manter algumas configurações da JPA e da respectiva implementação dessa especificação; nesse caso, do Hibernate. O principal aspecto a ser notado aqui é que declaramos um <provider> da JPA, o org.hibernate.jpa.HibernatePersistenceProvider, visando, exatamente, reduzir a dependência do Hibernate. Por outro lado, a tag <properties> possui configurações específicas desse framework, e nesse ponto não há como evitá-las. Caso optemos por mudar o framework ORM, portanto, será necessário alterar todas as propriedades desse trecho. Esse impacto, porém, será pequeno, visto que nossas entidades normalmente não precisarão de alteração.

Mapeando uma entidade

Com o Hibernate/JPA configurado, podemos mapear as entidades utilizando as anotações da JPA, como mostra a Listagem 3. Tais anotações informarão ao Hibernate como persistir os objetos dessa classe no banco de dados. Por meio delas, podemos definir, por exemplo, a que tabela determinada classe corresponderá, qual atributo da classe representa a chave primária, entre outras opções.

  01 import javax.persistence.*;
  02 @Entity
  03 @Table(name = "documento")
  04 public class Documento {
  05         
  06     @Id
  07     @GeneratedValue
  08     private Long id;
  09        
  10     @Column(name=”tipo_documento”)
  11     private String tipoDocumento;        
  12
  13     public Long getId() {
  14         return id;
  15     }
  16     public void setId(Long id) {
  17         this.id = id;
  18     }
  19
  20      public String getTipoDocumento(){
  21         return tipoDocumento;
  22      }
  23
  24      public void setTipoDocumento(String tipoDocumento){
  25        this.tipoDocumento = tipoDocumento;
  26      }
  27 }
  
Listagem 3. Mapeando a classe Documento com anotações JPA

Linha 2: A anotação @Entity define que essa classe é uma entidade a ser mapeada pela JPA;

Linha 3: A anotação @Table permite definir o nome da tabela à qual essa entidade estará relacionada no banco de dados. Contudo, essa anotação é necessária apenas se houver diferença entre o nome da tabela e o nome da classe, como ocorre nesse caso;

Linha 6: Por meio da anotação @Id, indicamos que a propriedade codigo representa o identificador único na tabela do banco de dados;

Linha 7: Com a anotação @GeneratedValue informamos que os dados dessa chave serão criados pelo banco de dados;

Linha 10: Com @Column, informamos o nome da coluna no banco de dados que será mapeada ao atributo tipoDocumento. Caso esses nomes sejam iguais, essa anotação, de modo semelhante a @Table, se torna opcional.

Perceba que nesse exemplo utilizamos apenas JPA, fazendo com que a implementação do Hibernate seja um simples detalhe em nosso projeto, pelo menos quanto à parte do mapeamento objeto-relacional. Dessa forma, poderíamos substituir o framework ORM e não seria necessário alterar o código dessa classe.

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?