Upload
hoangtu
View
234
Download
0
Embed Size (px)
Citation preview
Introdução ao Hibernate
Há dois mundos diferentes de software: um é o mundo Java, em que nada além de objetos são
conhecidos, enquanto o outro é o mundo do banco de dados relacional, em que os dados
reinam.
Os desenvolvedores Java sempre trabalham com objetos representando estados e
comportamentos que modelam problemas do mundo real. A persistência de objetos é um
requisito fundamental em aplicações Java. O estado é modelado de modo a ser persistente em
repositórios duradouros para que ele se torne permanente.
Um pequeno exemplo:
Suponha que estejamos fazendo o design de um sistema de Internet banking. Esperamos que o
banco mantenha uma cópia segura de nossas contas, dos detalhes pessoais, das preferências e
das transações. Isso significa que, para serem duradouros, os dados da aplicação devem ser
persistentes em um espaço de armazenamento permanente. No contexto dessa aplicação
bancária, por dados persistentes quero dizer o cliente.
Hibernate – Mapeamento com Anotação
Projeto Desktop Uma Classe
Objetivo
Este documento descreve uma introdução ao framework Hibernate empregando Anotações. É
um exemplo simples de mapeamento objeto relacional com anotações Hibernate através de
uma pequena aplicação Desktop. Tem também uma breve introdução sobre anotações.
Programas Utilizados
Java (jdk-1_6_0_02-windows-i586-p)
Eclipse 3.2 ()
Hibernate 3.02
MySql 5.0
Criando um novo Projeto
Abrir o Eclipse 3.2 e informar um WorkSpace (Teste).
Clicar em: File | New | Project... | Java | Java Project
Clicar em: Next
Informar o nome: "SeuProjeto"
O projeto deverá ter esta estrutura:
Importando os Arquivos JARs do Hibernate e do MySQL
Criar uma pasta de nome lib no projeto para importar os arquivos jar´s do Hibernate e do
MySQL.
A pasta lib criada fica como a seguir:
Vamos importar os arquivos jar´s para o projeto. Clicar com o botão direito na pasta lib e depois
em:
Import... | General | File System | Next
Clicar no botão Browse e selecione a pasta onde se encontram os arquivos jar´s do Hibernate
(pasta Hibernate_JAR). Fazer a mesma para importar o jar do MySQL (pasta MySQL)
Selecionar os arquivos e clicar em Finish.
Informando ao Projeto que existem novos JARs
“Colocar os jars no projeto ou referenciá-los externamente?
É uma boa prática sempre colocarmos os jars de dependência de nosso projeto no próprio
projeto e não deixá-los em outro lugar e referenciá-los externamente. Desta forma, cada
projeto pode ter sua própria versão e evitamos problemas de compatibilidade. Além disso,
nosso projeto é auto-contido e conseguimos transportá-lo facilmente para outras máquinas.”
(Caelum – Java e Orientação a Objeto)
Clicar com o botão direito do mouse no projeto e depois em:
Properties | Java Build Path | na aba Libraries | no botão ADD JARs
Abrir a pasta lib, selecionar todos os arquivos jar e clique em OK.
Por fim clique em Ok.
Agora os jar estão incorporados ao projeto.
Inserindo os arquivos hibernate.cfg.xml,
hibernate-configuration-3.0.dtd e
log4j.properties na pasta src (source) do projeto
Copiar também o arquivo hibernate.cfg.xml da pasta Hibernate_Postgress/Hibernate_CFG e
colar dentro da pasta src (source).
Copiar também o arquivo hibernate-configuration-3.0.dtd da pasta
Hibernate_Postgress/Hibernate_DTD e colar dentro da pasta do projeto.
Copiar o arquivo log4j.properties (pasta Hibernate_Postgres/Hibernate_Property) e colar na
pasta do projeto, no nosso caso SeuProjeto.
Para visualizar os arquivos na janela Package Explorer clicar em Refresh.
Criando a Classe Evento com o Mapeamento Anotação
Criar o arquivo conforme abaixo e salvar como Evento.java
package modelo;
import java.io.Serializable;
import java.util.Date;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="evento")
public class Evento implements Serializable{
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
//@Column(name="idEvento")
private Integer idEvento;
private String nome ;
private Date dataInicio;
private Date dataFim;
public Evento (){}
//... IMPORTANTE: colocar os métodos GETs e SETs...
}
Vamos criar a Classe DaoEvento, responsável pela acesso com a base de dados como indicada a
seguir. Salve-a com o DaoEvento.java
package dao;
import modelo.Evento;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
public class DaoEvento {
private SessionFactory fabrica;
public DaoEvento() throws Exception{
// Cria uma configuração
AnnotationConfiguration configuration =
new AnnotationConfiguration();
// Lê o arquivo hibernate.cfg.xml
configuration.configure("hibernate.cfg.xml");
// Cria o objeto fabrica responsável em criar os objetos Sessions
fabrica = configuration.buildSessionFactory();
}
public void incluir(Evento e) throws Exception {
Session sessao = fabrica.openSession();
Transaction transacao= sessao.beginTransaction();
sessao.save(e);
transacao.commit();
sessao.close();
}
public void alterar(Evento e) throws Exception {
Session sessao = fabrica.openSession();
Transaction transacao= sessao.beginTransaction();
sessao.update(e);
transacao.commit();
sessao.close();
}
public void excluir(Evento e) throws Exception {
Session sessao = fabrica.openSession();
Transaction transacao= sessao.beginTransaction();
sessao.delete(e);
transacao.commit();
sessao.close();
}
public Evento consultar(Evento e)throws Exception{
Evento ev;
Session sessao =fabrica.openSession();
Transaction transacao = sessao.beginTransaction();
ev = (Evento)sessao.load(modelo.Evento.class, e.getIdEvento());
transacao.commit();
sessao.close();
return ev;
}
}
Criando Referência para o Banco de Dados (MySQL)
Abrir o hibernate.cfg.xml com algum editor (Notepad) e alterar os parâmetros de conformidade
com a configuração da sua conexão com o banco MySQL.
Deve ficar parecido com isto:
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate Mapping 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.dialect">
org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.connection.url">
jdbc:mysql://localhost:3306/empresa
?createDatabaseIfNotExist=true</property>
<property name="hibernate.connection.username">aluno</property>
<property name="connection.password">aluno</property>
<property name="hibernate.hbm2ddl.auto">create</property>
<property name="hibernate.hbm2ddl.auto">update</property>
<property name="show_sql">true</property>
<property name="format_sql">true</property>
<mapping class="modelo.Evento"/>
</session-factory>
</hibernate-configuration>
Para testar criaremos uma classe Tela com o método main. Copiar o conteúdo indicado a
seguir:
package visao;
import java.util.Date;
import modelo.Evento;
import dao.DaoEvento;
public class Tela {
public static void main(String[] args) throws Exception {
try{
Date dataInicio = new Date();
Date dataFim = new Date();
DaoEvento dao = new DaoEvento();
Evento evento = new Evento();
evento.setNome("show");
evento.setDataInicio(dataInicio);
evento.setDataFim(dataFim);
dao.incluir(evento);
System.out.println("Registro inserido com sucesso!!!");
}catch(Exception e){
System.out.println("Não foi possível, Erro: " +
e.getMessage());
}
}
}
Execute o arquivo Tela.java com a opção de Run | Java Application. Se tudo estiver como
descrito, você terá inserido o primeiro registro numa base de dados utilizando o Hibernate.
Verificar no MySql se realmente foi criado o banco (empresa), a tabela (evento) e inserido
corretamente os dados indicados na classe Tela.
Resumo dos Arquivos Criados e seus Locais
SeuProjeto:
hibernate.cfg.xml
log4j.properties
hibernate-configuration-3.0.dtd
//todos os JARs do Hibernate e do PostgreSql
dao
DaoEvento.java
modelo
Evento.java
visao
Tela.java
Conceitos
Inicialmente, para que o Hibernate soubesse como carregar e armazenar objetos de classes persistentes
eram utilizados apenas arquivos de mapeamento XML. Dessa forma, era possível informar que tabela do
banco de dados se refere uma dada classe persistente e quais colunas na tabela são referentes a quais
atributos da classe. Com o surgimento das anotações no Java 5.0, tornou-se possível substituir os
arquivos XML para o mapeamento objeto relacional. Através do uso de um conjunto de anotações no
código fonte das classes mapeadas.
As anotações podem ser definidas como metadados que aparecem no código fonte e são ignorados pelo
compilador. Qualquer símbolo em um código Java que comece com uma @ (arroba) é uma anotação.
Em outras palavras, as anotações marcam partes de objetos de forma que tenham algum significado
especial.
Definindo a Classe Evento com Anotações Hibernate
A seguir é apresentada a classe Evento realizando o mapeamento com anotações. Dessa forma, é
informado ao Hibernate que tabela no banco de dados deve ser usada e quais atributos correspondem
as quais colunas desta tabela.
package modelo;
import java.io.Serializable;
import java.util.Date;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="evento")
public class Evento implements Serializable{
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
@Column(name="idEvento")// não é necessário por ser igual ao atributo
private Integer idEvento;
private String nome ;
private Date dataInicio;
private Date dataFim;
public Evento (){}
// métodos gets e sets
}
Definindo uma entidade:
@Entity: Torna a classe uma entidade visível ao EntityManager
@Table: Define a tabela de armazenamento, caso seja necessário.
Anotações que têm escopo de classe, mas não definem a entidade:
Definindo a identidade de uma entidade:
@Id: Identifica a propriedade que representa a chave primária da tabela.
@Column: Configura o nome da coluna em que será armazenada a propriedade.
@GenerationValue: Define a estratégia de geração de chave primária
Definindo a estratégia de geração de chaves: GenerationType
GenerationType.AUTO: Define a estratégia automaticamente de acordo com o banco utilizado.
GenerationType.IDENTITY: Suporta colunas de identidades do tipo long, short ou int para os
bancos DB2, MySQL, MS SQL Server, Sybase e HipersonicSQL.
GenerationType.SEQUENCE: Nos bancos PostgresSQL, DB2, Oracle ou SAP DB, uma
sequência é utilizada.
GenerationType.TABLE: Uma tabela é utilizada para guardar o ultimo valor de chave gerado.
Cada gerador é mapeado para uma linha dessa tabela.
Considerações:
Hibernate requer que toda classe persistente possua um construtor padrão sem argumentos, assim, o
Hibernate pode instanciá-la simplesmente chamando Construtor.newInstance();
Observe que a classe Evento apresenta métodos setters e getters para acessar ou retornar todos os
seus atributos. O Hibernate persiste as propriedades no estilo JavaBeans, utilizando esses métodos;
A classe Evento possui um atributo idEvento que é o seu identificador único. É importante que, ao
utilizar Hibernate, todos os objetos persistentes possuam um identificador e que eles sejam
independentes da lógica de negócio da aplicação.
Há necessidade de se criar um objeto SEQUENCE do banco PostgreSQL chamado
hiberente_sequence. Veja o comando create sequence no item a seguir.
Configurar as propriedades indicando o seu banco, o usuário e por fim a senha para a sua
aplicação.
<property name="hibernate.connection.url">
jdbc:mysql://localhost:3306/??????? </property>
<property name="hibernate.connection.username">?????????</property>
<property name="hibernate.connection.password">?????</property>
Por fim a Execução do Exemplo
Neste ponto temos o Hibernate configurado e no projeto temos os seguintes arquivos:
As classes modelo.Evento e dao.DaoEvento; O banco de dados empresa com a tabela evento; O hibernate.cfg.xml com o tipo, o nome, o usuário e a senha do banco; Os jar´s do Hibernate e do MySql, mais os arquivos log4j.properties e hibernate-
configuration-3.0.dtd.