Hibernate para iniciantes

Pessoal, neste post vamos demonstrar os passos necessários para utilizar o Hibernate.

O Hibernate é um framework de ORM (Mapeamento objeto-relacional), basicamente é uma maneira de se mapear as tabelas de uma base de dados em objetos no seu programa.

Neste tutorial eu usei o MySQL como base de dados e o Maven para baixar as dependências do projeto, não entrarei em detalhes da instalação do MySQL, sobre o Maven você pode checar o post anterior caso tenha dúvidas.

Primeiramente abra o seu terminal navegue até o diretório onde deseja criar seu projeto e digite o seguinte.

mvn archetype:generate -DgroupId=com.blogspot.runnerdtalks.hibernatetutorial -DartifactId=HibernateTutorial -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Isso irá criar o esqueleto de um projeto Java, dentro do seu diretório HibernateTutorial que foi criado no comando acima você encontrará o seguinte

Agora abra o arquivo pom.xml e vamos adicionar as dependências do hibernate como no trecho abaixo.

<dependencies>
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.16</version>
</dependency>

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.4.2</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.18</version>
</dependency>

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>3.3.0.SP1</version>
</dependency>

<dependency>
    <groupId>org.hibernate</groupId>
   <artifactId>hibernate-annotations</artifactId>
    <version>3.4.0.GA</version>
    </dependency>

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-entitymanager</artifactId>
    <version>3.4.0.GA</version>
</dependency>
</dependencies>

Volte ao seu terminal de digita o seguinte:

mvn install

mvn eclipse:eclipse

O primeiro comando irá baixar as dependências e o segundo irá criar os arquivos necessários para transforma-lo em um projeto eclipse.

Abra seu Eclipse e vá em File>Import>Existing Projects into Workspace e de Next.
Clique em Browse e navegue até o diretório onde você mandou o Maven criar o seu projeto, e finalize a importação.

Se esta é a primeira vez que você usa o Maven para criar um projeto no Eclipse será necessário resolver alguns problemas no seu Build Path. 

Clique com o botão direito no projeto, e escolha Properties, escolha Java Build Path>Libraries>Add Variable>Configure Variables... > New...

Em Name coloque M2_REPO

Em Path deve ser o caminho do diretório onde o Maven baixa as dependências, isso varia dependendo do sistema operacional que você usa mas, em sistemas como o Linux e OSX é ~/.m2/repository para Windows fica em C:\Document and Settings\username\.m2 (pode variar dependendo da versão do Windows)

Dê ok em todos os diálogos que estavam abertos, caso seu projeto ainda de erros de compilação vá em Projects>Clean... para forçar a recompilação

No diretório src/res o arquivo hibernate.cfg.xml, esse xml é o responsável por configurar para o hibernate o caminho do banco de dados, usuário senha e etc.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
  "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
 <session-factory>

  <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
  <property name="hibernate.connection.password">tutorial</property>
  <property name="hibernate.connection.username">username</property>
  <property name="hibernate.connection.url">jdbc:mysql://localhost/hibernateTutorial</property>
  <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

  <property name="hibernate.show_sql">true</property>
  <property name="hibernate.format_sql">true</property>
  <property name="hbm2ddl.auto">create</property>

  <mapping class="com.blogspot.runnerdtalks.hibernatetutorial.entity.User"/>
 </session-factory>
</hibernate-configuration>

Veja que já estamos com uma Entity mapeada, no caso a entity User, deixei ela aí já para nos poupar um passo mas é importante lembrar da necessidade de colocar esse mapeamento no XML.
Lembre-se de fazer as devidas alterações nos campos de conexão, como usuário e senha.

Crie também o arquivo log4j.properties no mesmo diretório como abaixo.

log4j.logger.org.hibernate = info, CONSOLE
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n

Será necessário colocar os arquivos no seu classpath, clique com o botão direito em seu projeto vá em Properties>Java Build Path>Source>Add Folder... adicione o diretório res e clique em ok.

Agora vamos criar a nossa entity User, como já definimos ela no Hibernate.cfg.xml é importante cria-lá no mesmo pacote: com.blogspot.runnerdtalks.hibernatetutorial.entity


Sua entity vai ficar como a seguinte

package com.blogspot.runnerdtalks.hibernatetutorial.entity;

//imports

@Entity
public class User {

 @Id
 @GeneratedValue
 private Long id; 

 private String name;

 private String password;

 //adicione aqui seus getters e setters

}

Veja que a classe esta anotada com @Entity que identifica que essa é uma Entity do Hibernate, e que temos um membro da classse anotado com @Id e @GeneratedValue

• @ID identifica que ela é a chave primária de sua tabela
• @GeneratedValue é para o próprio hibernate atribuir os valores para ela automaticamente.

Os outros membros não possuem anotação, mas mesmo assim eles serão automagicamente mapeados para colunas na tabela.

Para sua entity isto é o suficiente

Perceba que temos nossa entity mapeada para uma base de dados que não tem nada criado! É porque agora vamos fazer o Hibernate gerar as tabelas da base de dados baseado em nossa entity.

Conecte no mysql com o comando

mysql -u user -p

Dentro do console do mysql vamos criar a base de dados.

create database hibernateTutorial;

Selecione a base de dados recém criada.

use hibernateTutorial

E execute o seguinte para mostrar as tabelas

show tables;

Seu resultado será algo como o seguinte

Crie uma nova classe no pacote com.blogspot.runnerdtalks.hibernatetutorial.main chamada GenerateSchema.

public class GenerateSchema {

    public static void main( String[] args ) {

     //Le o hibernate.cfg.xml

     AnnotationConfiguration annotationConfiguration = new AnnotationConfiguration();
     annotationConfiguration.configure();

     SchemaExport se = new SchemaExport(annotationConfiguration);
     se.create(true, true);
    }
}

E execute...

O console do eclipse irá mostrar para você diversos detalhes do hibernate se conectando a base de dados e também aparecerá um comando SQL.

Volte ao terminal que você está conectado ao MySQL e execute novamente

show tables;

O resultado deverá mostrar agora a table User, uma tabela não é nada sem dados correto? Então vamos criar uma nova classe chamada CreateNewUser no mesmo pacote do GenerateSchema.

public class CreateNewUser {

 public static void main(String[] args) {

  AnnotationConfiguration annotationConfiguration = new AnnotationConfiguration();
  annotationConfiguration.configure();

  SessionFactory sessionFactory = annotationConfiguration
    .buildSessionFactory();
  Session session = sessionFactory.openSession();

  User user = new User();
  user.setName("root");
  user.setPassword("raquel");

  Transaction transaction = session.beginTransaction();
  session.save(user);
  transaction.commit();
 }
}

Volte ao MySQL e execute

select * from User;

Seu terminal irá exibir o recém criado usuário na tabela.

Caso tenha percebido que sua tabela esteja sendo recriado toda vez que executa o código é por culpa dessa linha no xml.

<property name="hbm2ddl.auto">create</property>

Comente-a e a execução do código não fará mais sua tabela ser recriada.

Código Fonte no GitHub

Valeu!