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>
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>
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 }
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.
