Livre-se do SQL

Introdução

Hibernate é um mecanismo bem simples e poderoso que permite a persistência de objetos em banco de dados relacionais de maneira transparente e para qualquer tipo de aplicação Java (seja ela web-based ou desktop-based). Ou seja, ao invés de perder tempo escrevendo SQL, misturando estas consultas no meio do seu código Java e ficar mapeando o resultado de suas consultas para objetos, com o Hibernate você vai precisar se preocupar somente com seus objetos. Além disso, o processo de desenvolvimento usando Hibernate é muito mais simples do que usar JDBC puro. Com Hibernate, você só tem estes 5 passos:

criar a tabela no seu banco de dados onde os objetos vão persistir;

criar o objeto cujo estado vai ser persistido;

criar um XML, que relaciona as propriedades do objeto aos campos na tabela

criar um arquivo contendo as propriedades para que o Hibernate se conecte ao bando de dados

criar a classe DAO que vai persistir seu objeto; Simples? Muito. Então vamos por nossos dedos para trabalhar um pouco. Para o exemplo deste tutorial, estarei usando o como banco de dados o MySQL, mas pode ser substituído por qualquer um da sua preferência. O Hibernate pode ser encontrado no endereço http://hibernate.sf.net; A versão usada neste exemplo é a 1.2.4

Criando a tabela e a classe

Vamos começar definindo uma tabela simples no banco de dados.

CREATE TABLE 'amigos'(
'nome' varchar(40) NOT NULL DEFAULT '',
'endereco' varchar(60) NOT NULL DEFAULT '',
'fone' varchar(11) DEFAULT NULL,
'cel' varchar(11) DEFAULT NULL,
'email' varchar(70) DEFAULT NULL,
'nascimento' datetime DEFAULT NULL,
PRIMARY KEY  (`nome`)
);

nota: esse passo pode ser pulado, se você utilizar as ferramentas que acompanham o Hibernate, que já geram o código de criação das tabelas (SchemaExport). Pronto. Uma tabela para que eu possa guardar os dados dos meus amigos, como se fosse uma agenda. Agora vamos para o próximo passo, que é a reprensentação disso em forma de objeto em Java. Como o Hibernate trabalha através de reflexão para fazer o mapeamento, temos que "beanificar" nosso objeto. Assim:

public class Amigo {
private String nome;
private String endereco;
private String telefone;
private String celular;
private String email;
private java.util.Date nascimento;
 
public Amigo() {
}
 
public String getNome(){
return nome;
}
 
public void setNome(String nome){
this.nome = nome;
}
 
// os outros métodos get/set vão aqui...
 
public java.util.Date getNascimento(){
return nascimento;
}
 
public void setNascimento(java.util.Date nascimento){
this.nascimento = nascimento;
}
 
}

Nada muito complicado até aqui, certo? Criamos uma tabela e um bean que "representa" o esquema desta nossa tabela. Então nos falta informar ao Hibernate como juntar os dois. Para fazermos isso, é preciso criar um arquivo de mapeamento, cujo nome deve ser sempre "NomeDoObjeto.hbm.xml" (no nosso caso, "Amigo.hbm.xml"); cada objeto a ser persistido tem seu próprio arquivo de mapeamento.

O XML que faz o mapeamento
O modelo para o nosso Amigo.hbm.xml segue abaixo:

Coisas para as quais deve se ter atenção:

o atributo "name", da tag "class" - o valor de "name" inclui o nome completo do objeto, incluindo seu package (ou seja, x.y.z.MeuObjeto). É nesta tag que dizemos qual tabela se relaciona com qual objeto (através do atributo "table");

a tag "property" - o atributo "name" se refere à propriedade no nosso Bean, enquanto o atributo "column" se refere à coluna no nosso banco de dados (este última é opcional: se você deixá-la em branco, o Hibernate vai procurar por uma coluna cujo nome seja igual ao da propriedade do seu bean). O atributo "type" também é opcional e se refere ao tipo de dado da propriedade do seu bean;

a tag ID - sim, tem a ver com o mapeamento da chave primária da sua tabela. E o mapeamento é semelhante ao feito nas tags "property"; Agora, vamos criar o arquivo de configuração para que o Hibernate possa se conectar ao banco de dados. Este arquivo é um arquivo .properties bem comum, com os seguintes campos:

hibernate.connection.driver_class = org.gjt.mm.mysql.Driver # o driver
hibernate.connection.url = jdbc:mysql://localhost:3306/agenda # a url
hibernate.connection.username = daniel # o username
hibernate.connection.password = senha # a senha

Dê a ele o nome que você quiser (agenda.properties, por exemplo). Porém, se você der a este arquivo o nome de hibernate.properties e colocá-lo no seu classpath, o Hibernate irá carregá-lo automaticamente durante a início do programa. Até aqui temos:

uma tabela no banco de dados chamada Amigos;

um simples objeto que queremos persistir, chamado Amigo;

um arquivo para relacionar nosso objeto Amigo com a tabela Amigos;

as propriedades para que o Hibernate possa se conectar ao banco de dados;

Manipulando os dados

Agora vamos brincar de persistir, criando nosso DAO!!!

import cirrus.hibernate.*;
import java.util.Date;
 
public class AmigoDAO{
 
 private SessionFactory factory;
 
 public AmigoDAO() throws Exception{
  Datastore datastore = Hibernate.createDatastore();
  datastore.storeClass(Amigo.class);
  factory = datastore.buildSessionFactory();
 }
 
 public void insert(Amigo amigo) throws Exception{
  Session session = factory.openSession();
  session.save(amigo);
  session.flush();
  session.close();
 }
 
 public java.util.List getList(String condicao) throws Exception{
  Session session = factory.openSession();
  List amigos = session.find(condicao);
  session.flush();
  session.close();
  return amigos;
 }
 
 public Amigo retrieve(String pk) throws Exception{
  Session session = factory.openSession();
  Amigo amigo = (Amigo)session.load(Amigo.class, pk);
  session.flush();
  session.close();
  return amigo;
 }
 
 public void delete(Amigo amigo) throws Exception{
  Session session = factory.openSession();
  session.delete(amigo);
  session.flush();
  session.close();
 }
}

Bom, algumas coisas acima tem que ser ressaltadas:

em datastore.storeClass(Amigo.class);, o Hibernate assume que o arquivo de mapeamento está no mesmo diretório e possui o mesmo nome da classe Amigo. Caso algum destes requisitos não for atendido, use "datastore.storeClass();";

factory = datastore.buildSessionFactory();, aqui o Hibernate novamente assume que há um arquivo hibernate.properties no seu classpath. Senão for o caso, forneça um objeto do tipo java.util.Properties como parâmetro, contendo os dados necessários para que o Hibernate possa montar sua conexão;

session.find(condicao);: a condição é uma String que possui uma estrutura muito semelhante ao SQL e serve para que o Hibernate consiga identificar uma lista de objetos que cumpram suas exigências. A estrutura é esta:

from  in class  where

O Hibernate possui uma query language própria, orientada a objetos. Bom, este é quase um "hello world" para se trabalhar com o Hibernate. Algumas coisas, como controle de transação e foreign keys, não foram abordadas e vão ficar para um próximo tutorial. A finalidade deste aqui é só a de mostrar uma alternativa ao "JDBC puro" na construção de sistemas que precisem de banco de dados como meio de persistência. Dúvidas, críticas, erros, usem o nosso fórum. p.s.: Devido ao fato de muitos estarem usando a versão 2 do Hibernate, é preciso se atentar às mudanças entre as duas versões, como a alteração do nome dos pacotes (de cirrus.hibernate.* para net.sf.hibernate), entre outras coisas. Para maiores informações sobre como portar suas aplicações da versão 1.x.x do Hibernate para a versão 2.x.x, visite: http://hibernate.org/68.html.

Fonte: http://guj.com.br/

Vitor Yudi Hansen