Introdu��o ao Hibernate 3.5

O Hibernate � uma implementaç�o do padr�o Java Persistence API (JPA). Existem soluç�es em que usar um ORM (Object-Relational Mapping) como Hibernate � apropriado, no entanto, algumas vezes � mais apropriado usarmos o tradicional JDBC.

Abaixo ilustraremos alguns exemplos onde � mais apropriado o uso de Hibernate e contrastaremos com o tradicional JDBC. Tamb�m veremos exemplos de como utilizar Hibernate.

Plain Old Java Objects (POJOs)

No mundo ideal da programaç�o seria maravilhoso se tiv�ssemos um objeto Java simples sem nenhuma depend�ncia com bibliotecas externas e pud�ssemos armazenar este objeto na nossa Base de Dados sem nenhum esforço e nenhum problema de performance, como ilustrado abaixo:


ObjetoJavaPOJO pojo = new ObjetoJavaPOJO();
FrameworkORM orm = FrameworkORM.getInstance();
orm.save(pojo);

O Hibernate faz exatamente isso, no entanto, como nem tudo � perfeito temos que criar e configurar alguns arquivos de configuraç�o e considerar algumas quest�es de performance. Dessa forma, o Hibernate permite que possamos armazenar POJOs diretamente na nossa Base de Dados.

Um termo comumente usado � o de Mapeamento Objeto-relacional, isto �, o mapeamento de objetos em Java diretamente para entidades relacionais na base de dados.

Origens do Hibernate e Mapeamento Objeto-Relacional

Quando usamos JDBC temos um consider�vel n�mero de c�digos e v�rias regras que devem ser cuidadosamente observadas para assegurar que a nossa aplicaç�o n�o est� desperdiçando recursos.

Segue abaixo um exemplo de uma aplicaç�o usando JDBC para listar os tipos de assunto de alguns artigos de uma base de dados.


package br.com.artigos.dao;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import javax.faces.bean.ManagedBean;
import br.com..artigos.TpAssuntoVO;

public class TipoAssuntoDAO {
 
	public TpAssuntoVO consulta(Integer nroIntTpAssunto) {
	    
	    TpAssuntoVO tpAssuntoVO = null;
	    Connection con = null;
	    Statement st = null;
	    ResultSet rs = null;
	
	    String url = "jdbc:postgresql://pgsql01.redehost.com.br:5432/bd";
	    String user = "userdefault";
	    String password = "passwddefault";
	
	    try {
	    	 Class.forName("org.postgresql.Driver");
	        con = DriverManager.getConnection(url, user, password);
	        st = con.createStatement();
	        rs = st.executeQuery("select \"NRO_INT_TP_ASSUNTO\", \"ASSUNTO\" from public.tipoassunto " +
	        		" where \"NRO_INT_TP_ASSUNTO\" = " + nroIntTpAssunto);

	        if (rs.next()) {
	        	tpAssuntoVO = new TpAssuntoVO();
	        	tpAssuntoVO.setNroIntTpAssunto(rs.getInt("NRO_INT_TP_ASSUNTO"));
	        	tpAssuntoVO.setNome(rs.getString("ASSUNTO"));
	        }
	    } catch (SQLException ex) {
	    	System.out.println("Problem: " + ex.toString());
	    } catch (Exception ex) {
	    	System.out.println("Problem: " + ex.toString());
	    } finally {
	        try {
	            if (rs != null) {
	                rs.close();
	            }
	            if (st != null) {
	                st.close();
	            }
	            if (con != null) {
	                con.close();
	            }
	
	        } catch (SQLException ex) {
	        }
	    }
	        
	    return tpAssuntoVO;
	}

}

Listagem 1. Exemplo de Aplicaç�o usando JDBC

Podemos notar que essa t�cnica manual possui diversas situaç�es que devem ser gerenciadas pelo desenvolvedor, e a chance de ocorrerem problemas � realmente muito grande. Existem algumas t�cnicas para diminuir a chance de erro e o grande n�mero de c�digos necess�rios, mas mesmo assim muitas coisas ainda precisam ser gerenciadas manualmente e quanto maior fica o c�digo maior � a chance de ocorrerem problemas.

Esse � um momento oportuno para relatar o quanto essa t�cnica manual usando diretamente JDBC � problem�tica. Na minha empresa cada vez que um novo programador entra na equipe temos problemas com as conex�es, isso ocorre porque infelizmente o novo programador n�o dedicou total atenç�o para algumas situaç�es que usar JDBC diretamente requer, e �s vezes esquecer de fechar alguma conex�o ou esquecer de um finally, ou caso aconteça um erro inesperado e ele n�o seja tratado corretamente podem causar at� mesmo um estouro na pilha de conex�es levando o servidor de aplicaç�o a ficar inoperante. Muitas vezes at� os programadores mais experientes esquecem de detalhes que acabaram levando ao caos no dia seguinte. Mas felizmente hoje temos alternativas que nos permitem salvar muitas dores de cabeça.

Usando Hibernate Para Solucionar os Problemas

O Hibernate soluciona grande parte desses pontos ou no m�nimo alivia alguns desses problemas.

Com Hibernate podemos armazenar POJOs diretamente nas bases de dados e definir relacionamentos entre as classes, representando o Banco de dados.

Uma vantagem do Hibernate � que ele n�o tem requisitos para servidores de aplicaç�o J2EE ou qualquer outro ambiente. Portanto, Hibernate pode ser utilizado para aplicaç�es de linha de comandos, aplicaç�es do lado cliente, e outros ambientes de desenvolvimento onde um servidor J2EE n�o est� imediatamente dispon�vel.

A vantagem do Hibernate � que ele usa POJOs que podem ser facilmente port�veis para qualquer aplicaç�o. N�o h� qualquer depend�ncia entre os POJOs e o Hibernate, portanto os POJOs ainda podem ser utilizados para qualquer outra coisa que n�o requeira persist�ncia. Dessa forma, usar Hibernate � uma escolha natural para sobrepor m�todos ad hoc.

Abaixo segue um exemplo de como recuperar os tipos de assuntos da base de dados, o mesmo que foi feito anteriormente, mas agora utilizando Hibernate:


public static List getTpAssunto(int nroIntTpAssunto) throws MessageException
{
	SessionFactory sessions = new AnnotationConfiguration().configure().buildSessionFactory();
	Session session = sessions.openSession();
	
	Transaction tx = null;
	
	try {
		tx = session.beginTransaction();
		List list = session.createQuery("from TpAssuntoVO").list();
		tx.commit();
		tx = null;
		return list;
	} catch ( HibernateException e ) {
		if ( tx != null ) tx.rollback();
		throw new MotdException("Failed to retrieve message from the database.",e);
	} finally {
		session.close();
	}
}

Listagem 2. Recuperando tipos de assuntos da base de dados

Podemos notar inicialmente a quantidade de c�digo a menos que temos em relaç�o ao c�digo anterior utilizando JDBC. Tamb�m n�o temos nenhum tipo de configuraç�o em relaç�o a Base de Dados, tudo est� separado num arquivo de configuraç�o e n�o temos que se preocupar em converter resultados da base de dados para o nosso objeto Java.

Mapeamento

O Hibernate precisa de alguma forma dizer quais tabelas est�o relacionadas com quais objetos. Isto � chamado de mapeamento. Mapeamentos podem ou ser providenciados atrav�s de anotaç�es Java, ou atrav�s de um arquivo de mapeamento em XML. As nossas classes Java POJO ser�o anotadas diretamente. A maioria dos desenvolvedores preferem anotar diretamente as classes, pois isso d� um vis�o mais clara do que estamos tentando fazer com a classe.

Segue abaixo um exemplo de uma classe Java POJO anotada:


package entidades;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="usuario_bd")
public class Usuario {
	
	@Id
	Integer nroIntUsuario;
	String nome;
	String email;
	String usuario;
	String senha;

	
	
	public Usuario(String nome, String email, String usuario, String senha) {
		this.nome = nome;
		this.email = email;
		this.usuario = usuario;
		this.senha = senha;
	}
	
	public Usuario() {
	}

	
	

	public Integer getNroIntUsuario() {
		return nroIntUsuario;
	}

	public void setNroIntUsuario(Integer nroIntUsuario) {
		this.nroIntUsuario = nroIntUsuario;
	}

	public String getNome() {
		return nome;
	}

	public void setNome(String nome) {
		this.nome = nome;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public String getUsuario() {
		return usuario;
	}

	public void setUsuario(String usuario) {
		this.usuario = usuario;
	}

	public String getSenha() {
		return senha;
	}

	public void setSenha(String senha) {
		this.senha = senha;
	}
	
}

Listagem 3. Classe Java POJO Anotada

No exemplo acima temos uma classe POJO bem simples que j� demonstra alguns mapeamentos e caracter�sticas necess�rias para o Hibernate poder armazenar ou manipular essa classe. Podemos notar que nesse exemplo temos a anotaç�o @Entity que diz que essa classe � uma entidade, @Table que identifica o nome da tabela que ser� mapeada, @Id que identifica a chave prim�ria da tabela.

Tamb�m podemos notar a presença de um construtor default que � obrigat�rio. Muitas outras anotaç�es e configuraç�es s�o poss�veis como veremos nos pr�ximos artigos.

Conclus�o

Neste artigo estudamos o que � o Hibernate, quais s�o algumas de suas caracter�sticas e quais as suas vantagens em relaç�o a outros m�todos tradicionais como JDBC. Tamb�m vimos alguns exemplos pr�ticos de como usar Hibernate e manipular classes POJOs.

Bibliografia:

Jeff Linwood and Dave Minter. An introduction to persistence using Hibernate 3.5, Second Edition. Apress.
Steve Perkins. Hibernate Search by Example: Explore the Hibernate Search system and use its extraordinary search features in your own applications. Packt Publishing.