Iniciando com Hibernate 3 utilizando Annotations

Posted on 17 March 2010

O Hibernate é um dos mais famosos frameworks de persistencia. Um framework de persistencia é uma ferramenta que ajudará a persistir, ou seja, salvar, os seus dados em algum local, um banco de dados por exemplo. O Hibernate faz o mapeamento das classes de sua aplicação em tabelas e colunas do banco de dados. Com isso é possível ler e salvar objetos no banco de forma transparente. Nesse tutorial aprenderemos a configurar um projeto básico com Hibernate e utilizaremos Annotations para fazer a configuração das classes.

O primeiro passo para fazermos um projeto com Hibernate, é definir qual é a estrutura de classes iremos utilizar. Depois, criaremos as tabelas de acordo com essas classes, e faremos o mapeamento no hibernate. Essas classes serão mapeadas em tabelas no banco de dados, o hibernate então fará a comunicação entre nossa aplicação e o banco de dados.

Iremos utilizar o hibernate para fazer o mapeamento de classes para tabelas em um banco de dados, então antes de trabalharmos na aplicação é necessário configurar algum SGBD para trabalhamos. Utilizaremos nesse tutorial o HSQLDB que é um banco de dados em memória escrito em Java e vai facilitar o nosso trabalho.

1. Baixando os pacotes necessários

Para esse tutorial precisaremos baixar vários arquivos:

  • Hibernate Core (3.3.2 GA): contém o núcleo do hibernate
  • Hibernate Annotations (3.4.0 GA): contém a API necessária para configurar as classes com annotations
  • SLF4J (1.5.x): sistema de log utilizado pelo hibernate
  • HSQLDB (2.0 RC 8): banco de dados que utilizaremos no nosso exemplo

Os arquivos podem ser baixados nas seguintes URLs

Hibernate Core:
http://sourceforge.net/projects/hibernate/files/hibernate3/3.3.2.GA/hibernate-distribution-3.3.2.GA-dist.zip/download

Hibernate Annotations:
http://sourceforge.net/projects/hibernate/files/hibernate-annotations/3.4.0.GA/hibernate-annotations-3.4.0.GA.zip/download

SLF4J:
http://www.slf4j.org/dist/slf4j-1.5.8.zip

HSQLDB:
http://sourceforge.net/projects/hsqldb/files/alpha_beta/hsqldb_2_0_0_rc8/hsqldb-2.0.0-rc8.zip/download

Se desejar baixar versões diferentes será necessário verificar a compatibilidade das versões das bibliotecas. No site do hibernate existe uma planilha com a compatibilidade de versões. A versão do HSQLDB não deve influenciar na compatibilidade. A versão do SLF4J deve ser a mesma do JAR contido no hibernate core.

Baixe todos os arquivos e extraia o conteúdo para uma pasta qualquer.

2. Executando o HSQLDB

O HSQLDB, também conhecido como HyperSQL, é um banco de dados bem simples e não necessita instalação. Utilizaremos ele apenas para ser possível experimentar o hibernate. Antes de executar a aplicação que iremos montar será necessário ligar o banco de dados. Para ligar o banco de dados basta executar o arquivo runServer.bat que está dentro da pasta /hsqldb/bin. Nenhuma configuração é necessária.

Caso o banco de dados não esteja rodando quando executar a sua aplicação, um erro como o seguinte será lançado:
java.sql.SQLTransientConnectionException: java.net.ConnectException: Connection refused: connect

3. Criando um projeto e configurando as bibliotecas na aplicação

Crie um projeto no seu ambiente de desenvolvimento, é importante que seja um projeto Java 1.5 ou superior pois utilizaremos annotations. Copie e adicione ao classpath as bibliotecas das seguintes pastas dos arquivos baixados anteriormente:

\hsqldb-2.0.0-rc8\hsqldb\lib

        hsqldb.jar

\hibernate-distribution-3.3.2.GA

        hibernate3.jar

\hibernate-distribution-3.3.2.GA\lib\required (todas as bibliotecas)

        antlr-2.7.6.jar
        commons-collections-3.1.jar
        dom4j-1.6.1.jar
        javassist-3.9.0.GA.jar
        jta-1.1.jar
        slf4j-api-1.5.8.jar

\hibernate-annotations-3.4.0.GA

        hibernate-annotations.jar

\hibernate-annotations-3.4.0.GA\lib

        ejb3-persistence.jar
        hibernate-commons-annotations.jar

\slf4j-1.5.8

        slf4j-simple-1.5.8.jar

Totalizando 12 arquivos JAR.

4. Definindo a estrutura

Vamos criar apenas uma classe nessa aplicação, para ver como o hibernate funciona. Crie uma classe Produto conforme o exemplo:

package org.javaframework.persistencia;

import static javax.persistence.GenerationType.*;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Produto {

    @Id @GeneratedValue(strategy=SEQUENCE)
    Integer id;
    String nome;

    public Produto(Integer id, String nome) {
        this.id = id;
        this.nome = nome;
    }
    public Produto(){
    }

    public Integer getId() {
        return id;
    }
    public String getNome() {
        return nome;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public void setNome(String nome) {
        this.nome = nome;
    }
}

Essa classe produto possui dois atributos. O primeiro é o id, o id será utilizado apenas como a chave primária do produto, não terá utilidade na nossa aplicação. Mas para o hibernate trabalhar, precisamos definir esse atributo na classe. Escolhemos a classe Integer para o atributo id, pois utilizaremos um sequencial numérico para os registros do banco. O outro atributo é o nome do produto. Repare que foi criado um construtor sem nenhum parâmetro, esse construtor é obrigatório (caso crie um outro construtor com vários argumentos, como no exemplo).

A configuração dessa classe está nas anotações que utilizamos. A anotação @Entity define uma entidade, e deve ser utilizada em todas as classes que forem mapeadas pelo hibernate. A anotação @Id define o campo que será o primary key no banco de dados. E a anotação @GeneratedValue indica que deve ser gerado um valor quando for salvar um novo produto a estratégia utilizada é a SEQUENCE, que criará um novo sequencial para cada produto. Dependendo do banco de dados utilizado podem ser utilizadas outras estratégias, consulte a documentação do hibernate para mais informações.

Atenção para o pacote da anotação @Entity, deve ser utilizado o pacote javax.persistence. Existe outra anotação com o mesmo nome no pacote org.hibernate.annotations mas não servirá para mapear a classe, apenas para adicionar informações extras. Se utilizar a anotação do pacote errado o hibernate lançará exceções dizendo que a classe não foi mapeada.

5. Configurando o hibernate

Existem duas formas de configurar o hibernate, através de um XML ou de um arquivo de properties. Por sem mais simples, utilizaremos o arquivo de properties. Crie um arquivo chamado hibernate.properties na sua aplicação, ele deve ficar na raiz dos fontes (SRC no eclipse por exemplo) e deve estar na raiz do classpath quando executar sua aplicação (se estiver utilizando um editor, basta colocar o arquivo na pasta raiz dos fontes). O arquivo deve ficar assim:

hibernate.connection.driver_class=org.hsqldb.jdbcDriver
hibernate.connection.url=jdbc:hsqldb:hsql://localhost
hibernate.connection.username=sa
hibernate.connection.password=

# Echo all executed SQL to stdout
hibernate.show_sql=true

# Drop and re-create the database schema on startup
hibernate.hbm2ddl.auto=update

Nesse arquivo temos nas quatro primeiras linhas as informações de conexão JDBC com o banco de dados. Configuramos também a exibição de queries e que o hibernate deve criar a estrutura do banco de dados automaticamente.

Com esse arquivo o Hibernate estará configurado. Caso você nao coloque o arquivo no lugar certo com o nome correto um erro como o seguinte pode acontecer: Exception in thread "main" org.hibernate.HibernateException: ‘hibernate.dialect’ must be set when no Connection avalable.

Vamos agora criar uma classe que utilizará o hibernate.

6. Executando um programa com o Hibernate

Crie na sua aplicação a seguinte classe para podermos testar o hibernate:

package org.javaframework.persistencia;

import java.util.List;

import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.classic.Session;

public class HelloWorldHibernate {

    public static void main(String[] args) {
        AnnotationConfiguration config = new AnnotationConfiguration();
        config.addAnnotatedClass(Produto.class);
        SessionFactory sessionFactory = config.buildSessionFactory();
        Session session = sessionFactory.openSession();
        inserirProduto(session);
        listarProdutos(session);
        session.close();
        sessionFactory.close();
    }

    private static void inserirProduto(Session session) {
        Produto produto = new Produto();
        produto.setNome("Shampoo");
        Transaction tx = session.beginTransaction();
        session.persist(produto);
        tx.commit();
        System.out.println("Produto inserido");
    }

    private static void listarProdutos(Session session) {
        List<Produto> produtos = session.createQuery("from Produto").list();
        for (Produto p: produtos) {
            System.out.printf("%4d \t %s %n", p.getId(), p.getNome());
        }
    }

}

A classe HelloWorldHibernate é apenas para efeito didádico, é interessante você estruturar a sua aplicação de maneira mais elegante.

Nesse código criamos um AnnotationConfiguration que permite a configuração de classes anotadas no Hibernate. Adicionamos a classe Produto para ser adicionada a configuração. O arquivo hibernate.properties será lido automaticamente. Com essa configuração construimos um SessionFactory. Um SessionFactory serve para criamos sessões do hibernate. Devemos ter apenas um SessionFactory na aplicação mas podemos ter vários Sessions (geralmente um para cada thread, ou um por requisição no caso de aplicações web). Um SessionFactory é como um DataSource e um Session é como um Connection.

Temos dois métodos bastante simples, um é o inserirProduto, que salva um novo produto no banco de dados, inclusive utilizando uma transação. E um método listarProdutos que lista todos os produtos encontrados no banco de dados.

Se executarmos o programa veremos algo semelhante ao seguinte:

Hibernate: call next value for hibernate_sequence
Hibernate: insert into Produto (nome, id) values (?, ?)
Produto salvo
Hibernate: select produto0_.id as id0_, produto0_.nome as nome0_ from Produto produto0_
  10      Shampoo

Pronto! Já pode agora utilizar o hibernate nos seus projetos. Veja a documentação de referencia no site http://www.hibernate.org para mais exemplos de consultas, operações e mapeamentos.


No responses yet. You could be the first!

Leave a Response

Recent Posts

Tag Cloud

advice annotations aop api aspect bean bytecode compilador configuração crosscuting eclipse framework ide jar java jdk jee jme join point jre jse máquina virtual netbeans pointcut produtividade spring weaving web

Meta

Java Framework Portal is proudly powered by WordPress and the SubtleFlux theme.

Copyright © Java Framework Portal