Hibernate PDF

Persistência Objeto/Relacional com
Hibernate Annotations
Prof. Alan Bruch

Persistência
• Define como guardar os dados em um
banco de dados.
• Todo sistema é persistente?
• Como é realizada atualmente?
Mapeamento Objeto Relacional(MOR)
• MOR é a persistência automatizada dos objetos em
uma aplicação Java para as tabelas em um banco de
dados relacional.
• Trabalha com a transformação(reversível) dos dados
de uma representação para outra.
• As tabelas do banco de dados são representadas
através de classes e os registros de cada tabela são
representados como instâncias das classes
correspondentes.
• Com esta técnica, o programador não precisa de se
preocupar com os comandos em linguagem SQL; irá
usar uma interface de programação simples que faz
todo o trabalho de persistência.
Mapeamento de um objeto
com tipos primitivos
• Mapeamento simples: objeto possui
apenas tipos de dados básicos.
Mapeamento de objetos que contém
uma coleção de objetos
• Um objeto possui um conjunto de
outros objetos.
Solução MOR
• Uma solução MOR consiste em:
– Fornecer uma API para realizar operações CRUD
– Uma linguagem ou API para especificar consultar
– Uma facilidade para especificar o metadado de
mapeamento
Hibernate
• O Hibernate é uma ferramenta MOR completa,

que fornece todos os benefícios de um MOR
citados.
• O Hibernate é um framework de mapeamento
objeto relacional para aplicações Java.
• Disponibiliza um poderoso mecanismo de
consulta de dados, permitindo uma redução
considerável no tempo de desenvolvimento da
aplicação.
• Portável para qualquer banco de dados
relacional.
Hibernate
• Hibernate Core
• Hibernate Annotations
• Hibernate EntityManager
• www.hibernate.org
Configurando Conexão NetBeans
Configurando Conexão Hibernate
Classes Persistentes
• As classes persistentes de uma aplicação

são aquelas que implementam as
entidades do negócio.
• O Hibernate trabalha associando cada
tabela do banco de dados a um POJO
(Plain Old Java Object).
• POJO´s são objetos Java que seguem a
estrutura de JavaBeans
• São criados sempre no pacote model.bean
Classes Persistentes
• Considerações:
– O Hibernate requer que toda classe
persistente possua um construtor padrão
sem argumentos.
– O Hibernate persiste as propriedades no
estilo JavaBeans utilizando os métodos
getters e setters.
– Todos os objetos persistentes devem
possuir um identificador.
Exemplo de um POJO ou BEAN
public class Pessoa {
private int idPessoa;
private String nome;
public Pessoa(){
}
public int getIdPessoa() {
return idPessoa;
}
private void setIdPessoa(int idPessoa) {
this.idPessoa = idPessoa;
}
public String getNome(){
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
}
Annotations
• O mapeamento objeto relacional

utilizando Hibernate pode ser feito a
partir de anotações.
• 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.
Annotations
• Este recurso foi introduzido na

linguagem Java a partir da versão Java
SE 5.0.
• Em outras palavras, as anotações
marcam partes de objetos de forma que
tenham algum significado especial.
• Inicialmente, para que o Hibernate

soubesse como carregar e armazenar
objetos de classes persistentes, eram
utilizados apenas arquivos de
mapeamentos XML.
• 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 através do uso de um
conjunto de anotações no código fonte
das classes mapeadas.
• Todas as classes persistentes mapeadas

com anotações são declaradas usando a
anotação @Entity.
• Exemplo:
@Entity
public class Pessoa{
...
}
• Quando o nome da classe é diferente do

nome da tabela para a qual é mapeada é
necessário informar na anotação @Table
qual o nome da tabela, usando o
atributo name.
• Exemplo:
@Entity
@Table(name=“pessoa”)
...
}
• A chave primária da tabela é mapeada

na classe através da anotação @Id.
• Exemplo:
@Entity
@Id
...
}
• Se o nome da coluna anotada com @Id for

diferente, é necessário utilizar a anotação
@Column informando o nome da coluna,
através do atributo name.
• Exemplo:
@Entity
@Id
@Column(name=“idpessoa”)
...
• Demais atributos da classe serão

anotados com @Column(name = “”)
somente quando o nome do atributo for
diferente do nome do campo.
Hibernate - Arquitetura
• Session (org.hibernate.Session)
– Possibilita a comunicação entre a aplicação e
a persistência, através de uma conexão
JDBC.
– É um objeto leve de ser criado.
– Com ele é possível criar, remover, atualizar e
recuperar objetos persistentes.
• SessionFactory
(org.hibernate.SessionFactory)
– Mantém o mapeamento objeto relacional em
memória.
– É um objeto pesado de ser criado.
– Permite a criação de objetos Session.
Hibernate - Arquitetura
• Configuration
(org.hibernate.Configuration)
– Utilizado para realizar as configurações de
inicialização do Hibernate:
• Driver do banco de dados.
• Usuário e senha do banco.
• Transaction (org.hibernate.Transaction)
– Utilizada para representar uma unidade
indivisível de uma operação de manipulação
de dados.
• Interfaces Criteria e Query
– Utilizadas para realizar consultas ao banco
de dados.
Abrindo uma sessão...
• SessionFactory sessionFactory =
new AnnotationConfiguration().
configure("hibernate.cfg.xml“).
buildSessionFactory();
• Session session = sessionFactory.openSession();
Persistindo Objeto
• Instancia objeto Pessoa:

– Pessoa pessoa = new Pessoa();
• Seta atributos:
– pessoa.setIdPessoa(1);
– pessoa.setNome(“Ronaldo!”);
• Abre uma transação:
– Transaction t = session.beginTransaction();
• Persiste o objeto:
– session.saveOrUpdate(pessoa);
• Aplica as alterações na base:
– t.commit();
• Fecha a sessão:
– session.close();
Persistindo Objeto
Classe AppPessoa.java
Persistindo Objeto
Persistindo Objeto
Consultando um Objeto
• Para recuperar um objeto da base de dados, é
preciso saber o valor do seu ID. O atributo
que o identifica é definido na classe Bean.
• Para consultar, executamos o seguinte
código:
– session.get(Classe, Valor ID);
– Onde, a Classe corresponde a classe que
queremos recuperar o valor do ID
informado.
• Exemplo:
– session.get(Pessoa.class, 1);
• Um objeto precisa receber o resultado da
consulta, então antes de executar a consulta,
instanciamos um objeto que irá receber o
resultado.
• Exemplo:
– Pessoa pessoa = new Pessoa();
– pessoa = (Pessoa)session.get(Pessoa.class, 1);
• Após executada a consulta, podemos mostrar

os dados recuperados usando os metodos
getters do bean, exemplo:
– JOptionPane.showMessageDialog(null,
pessoa.getNome());
Alterando um Objeto
• Para alterar um objeto, primeiro
precisamos recuperá-lo, como explicado
anteriormente. Para fazer isso,
precisamos saber qual o valor do ID
desse objeto.
• Após recuperado o objeto, passamos os
novos valores para os atributos que
desejamos alterar:
– pessoa.setNome(“Marciano”);
• E aplicamos a correção com o comando:
– session.saveOrUpdate(pessoa);
Alterando um Objeto
• Para salvar, também é preciso abrir a
transação, e após ter executado o
comando saveOrUpdate, deve ser feito o
commit:
Transaction t = session.beginTransaction();
session.saveOrUpdate(pessoa);
t.commit();
session.close();
Alterando um Objeto
Removendo um Objeto
• Para remover um objeto, primeiro
precisamos recuperá-lo. Para fazer isso,
precisamos saber qual o valor do ID
desse objeto.
• Após recuperado o objeto, basta removê-
lo:
– session.delete(pessoa);
Alterando um Objeto
• Para salvar, também é preciso abrir a
transação, e após ter executado o
comando delete, deve ser feito o commit:
Transaction t = session.beginTransaction();
session.delete(pessoa);
t.commit();
session.close();
Alterando um Objeto
Consultando todos Objetos
• Comando para retornar todos os objetos
de uma classe:
– session.createCriteria(Classe).list();
• Este método retorna uma lista, então
faremos com que o resultado seja
atribuído a uma lista.
• Utilizando a classe Pessoa como exemplo
temos:
– List<Pessoa> lista =
session.createCriteria(Pessoa.class).list();
• Para percorrer todos os objetos
retornados na lista faremos:
for (Pessoa pessoa : lista) {

JOptionPane.showMessageDialog(null,
pessoa.getNome());
}
• Para percorrer todos os objetos
retornados na lista faremos:
for (Pessoa pessoa : lista) {

JOptionPane.showMessageDialog(null,
pessoa.getNome());
}
Manipulando Dados
• Salvar ou Atualizar:
– session.saveOrUpdate(objeto);
• Remover:
– session.delete(objeto);
• Busca:
– session.get(Classe, Valor ID);
• Busca todos:
– session.createCriteria(Classe).list();
• Anotação @Temporal:
– TemporalType.DATE: usado para
mapear datas;
– TemporalType.TIME: usado para
mapear hora;
– TemporalType.TIMESTAMP: usado
para mapear datas e hora.
• Exercício: Criar uma classe para

persistir as seguintes informações:
Atributo Tipo Classe Campo Tipo BD
IDTipos Long idtipos numeric(18)
tipoInteiro Integer tipointeiro integer
tipoCaracter String tipocaracter text
tipoBooleano Boolean tipobooleano boolean
tipoCasaDecimal BigDecimal tipocasadecimal numeric(15,2)
tipoData Date tipodata date
tipoHora Date tipohora time without time
tipoDataHora Date zone
tipodatahora timestamp
without time zone
Organizando a aplicação
• Aplica-se o padrão de projeto

MVC(Model, View e Controler)
• Na camada View ficarão as interfaces
• Na camada Model ficarão os beans e os
DAOs
• Na camada Controler ficarão as classes
controladoras.
• Criar um pacote chamado Util, onde
todas as camadas poderão ter acesso.
• Até o momento...
– as interfaces foram criadas dentro da
camada View.
– os beans foram criados dentro da
camada Model
– a camada View está acessando
diretamente a Model para manipular
os dados, o que não é permitido no
padrão MVC.
• No padrão MVC:
– A View acessa solicita ao controler que
manipule os dados(inserir, alterar, remover,
consultar)
– O Controler por sua vez faz as modificações
solicitadas através das classes DAOs da
camada Model.
• Classes que deverão ser construídas:

– Camada View
• Todas as interfaces
– Camada Controler
• Classes com métodos para manipular os dados de
cada interface
– Camada Model
• Classes DAOs que manipulam os dados
diretamente no banco de dados
• Classes Beans
Pacote Util
• No pacote Util, deverá ser criada a

classe HibernateUtil.java, que terá um
método estático que retornará uma
session.
Pacote Util: classe HibernateUtil.java
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
public class HibernateUtil {

private static SessionFactory SESSIONFACTORY;
static{
AnnotationConfiguration cfg = new
AnnotationConfiguration();
SESSIONFACTORY = cfg.buildSessionFactory();
}
public static Session getSession(){

return SESSIONFACTORY.openSession();
}
}
Pacote Util: classe HibernateUtil.java
Camada Model
• As classes DAOs deverão ser criadas no

pacote dao, dentro de model:
Camada Model
• Primeira classe a criar neste pacote é a

DaoFactory.java que permitirá:
– Abrir uma transação
– Efetuar Commit
– Efetuar Rollback
– Fechar Sessão
– Retornar as classes DAO
DaoFactory.java
import br.com.faculdadeiguacu.tesi.util.HibernateUtil;
import org.hibernate.Transaction;
public class DaoFactory {

private final Session session;
private Transaction transaction;
public DaoFactory() {
this.session = HibernateUtil.getSession();
}
public void beginTransaction(){

this.transaction = this.session.beginTransaction();
}
DaoFactory.java
public void commit(){
this.transaction.commit();
this.transaction = null;
}
public boolean hasTransaction(){
return this.transaction != null;
}
public void rollback(){

this.transaction.rollback();
this.transaction = null;
}
public void close(){

this.session.close();
}
}
Classes DAO
• Neste mesmo pacote deverão ser criadas

as classes que fornecerão os métodos
para manipular os dados(Inserir,
Alterar, Excluir, Consultar) chamadas de
classes DAO.
• São construídas para cada bean da
aplicação.
• O nome da classe é formado pelo nome
do bean + a palavra Dao.
– Exemplo: PessoaDao
PessoaDao.java
PessoaDao.java
PessoaDao.java
PessoaDao.java
import br.com.faculdadeiguacu.tesi.model.bean.Pessoa;
import java.util.List;
public class PessoaDao {

private Session session;
public PessoaDao(Session session) {

this.session = session;
}
public void salvar(Pessoa Pessoa){

session.saveOrUpdate(Pessoa);
}
PessoaDao.java
public void remover(Pessoa Pessoa){

session.delete(Pessoa);
}
public Pessoa buscar(int id){

return (Pessoa)session.get(Pessoa.class, id);
}
public List<Pessoa> buscarTodos(){

return
session.createCriteria(Pessoa.class).list();
}
}
Modificação na classe
DaoFactory
• Para cada classe DAO criada, deverá ser
criado um método na classe DaoFactory que
retorne uma instância da classe DAO:
public PessoaDao getPessoaDao(){

return new PessoaDao(session);
}
Modificação na classe
DaoFactory
Camada Controler
• Nesta camada serão construídas as

classes que terão acesso aos métodos da
classes DAO.
• Normalmente são construídas para cada
interface, pois as interfaces terão acesso
a ela para executar suas operações
(inserir, atualizar, remover, consultar).
Camada Controler
• Nesta camada serão construídas as

classes que terão acesso aos métodos da
classes DAO.
• As classes controler deverão ser criadas
dentro do pacote controler.
Camada Controler
Classe PessoaControler.java
import br.com.faculdadeiguacu.tesi.model.bean.Pessoa;
import br.com.faculdadeiguacu.tesi.model.dao.DaoFactory;
import br.com.faculdadeiguacu.tesi.model.dao.PessoaDao;
import java.util.List;
public class PessoaControler {

private DaoFactory daoFactory;
private PessoaDao pessoaDao;
public PessoaControler() {
daoFactory = new DaoFactory();
pessoaDao = daoFactory.getPessoaDao();
}
public void salvar(Pessoa Pessoa){

daoFactory.beginTransaction();
pessoaDao.salvar(Pessoa);
daoFactory.commit();
}
public void remover(Pessoa Pessoa){

daoFactory.beginTransaction();
pessoaDao.remover(Pessoa);
daoFactory.commit();
}
public Pessoa buscar(int id){

return pessoaDao.buscar(id);
}
public List<Pessoa> buscarTodos(){

return pessoaDao.buscarTodos();
}
}
Associações
• O termo associação é utilizado para se

referir aos relacionamentos entre as
entidades.
• Os relacionamentos n-para-n, n-para-1 e
1-para-n são os mais comuns entre as
entidades de um banco de dados.
Associações
• Relacionamento entre Cidade

e Pessoa.
• Uma cidade possui um
conjunto de n pessoas e uma
pessoa está associada a
apenas uma única cidade.
• Precisamos definir as
associações para representar
os relacionamentos do banco
de dados.
Associações
• Para exemplificar as associações, crie:

– Tabela na base de dados chamada cidade,
com os atributos idcidade e nome; Criar
chave primária;
– Definir chave estrangeira na tabela pessoa;
Precisa criar o campo idcidade.
– Classe chamada Cidade e coloque os
atributos da tabela;
– Torne a classe persistente;
– Crie o Dao e o Controlador para a classe
Cidade.
– Incluir no DaoFactory o metodo
getDaoCidade.
Associações
Associações 1-n (one-to-many)
Classe Cidade.java
• Classe Cidade
– Incluir atributo chamado collPessoas do tipo
Collection<Pessoa> e utilizar a anotação
OneToMany:
@OneToMany(mappedBy=“cidade")
private Collection<Pessoas> collPessoas;
– Gerar os métodos getters e setters.

Associações 1-n (one-to-many)
Classe Cidade.java
Associações n-1 (many-to-one)
Classe Pessoa.java
• Classe Pessoa
– Incluir o atributo chamado cidade do tipo
Cidade com as anotações:
@ManyToOne
@JoinColumn(name="idcidade")
private Cidade cidade;
– Gerar metodos getters e setters.

– A anotação @JoinColumn é utilizada para
informar qual o nome da coluna que
corresponde à chave estrangeira do
relacionamento entre as tabelas cidade e
pessoa.
Associações n-1 (many-to-one)
Classe Pessoa.java
Associações
• Anotação Cascade:
– Serve para indicar com que ação em cascata o
relacionamento será tratado.
– Incluir a anotação @Cascade(CascadeType.ALL)
no atributo da classe Professor onde há
associação.
– Imports:
• import org.hibernate.annotations.Cascade;
• import org.hibernate.annotations.CascadeType;
Associações
• Atributo fetch:
– Indica quando o conteúdo do atributo anotado
será trazido da base de dados.
– Valores:
• FetchType.EAGER
• FetchType.LAZY
– Exemplo:
• @OneToMany(mappedBy=“professor", fetch =
FetchType.LAZY)
Exercício
• A partir do diagrama a seguir,

desenvolver as classes
persistentes, as tabelas no
banco de dados e uma classe
principal para inserir, remover
e consultar informações.
Associações n-n (many-to-many)
• Um relacionamento n-n implica em

existir uma nova tabela para mapear o
relacionamento no banco de dados.
• Relacionamento n-n entre Curso e
Departamento:
• Criar uma nova tabela chamada

departamento_curso.
• Em cada classe persistente, anotar o atributo

que faz referencia a outra classe:
– @ManyToMany
– @JoinTable
• A anotação JoinTable indica a tabela
intermediária da relação n-n. Devem ser
preenchidos os atributos:
– name: que é o nome da tabela intermediária;
– joinColumns: recebe como parametro @JoinColumn
que informa qual a coluna na tabela intermediária;
– inverseJoinColumns: recebe como parametro
@JoinColumn que informa a coluna que representa a
outra tabela no relacionamento;
• Classe Departamento:
– Atributo cursos:
@ManyToMany(fetch=FetchType.LAZY)
@JoinTable(name="departamento_curso",
joinColumns=@JoinColumn(name="id_departamento"),
inverseJoinColumns=@JoinColumn(name="id_curso"))
private Collection<Curso> cursos;
• Classe Curso:
– Atributo departamentos:
@ManyToMany(fetch=FetchType.LAZY)
@JoinTable(name="departamento_curso",
joinColumns=@JoinColumn(name="id_curso“),
inverseJoinColumns=@JoinColumn(name="id_departamento“))
private Collection<Departamento> departamentos;
• Exercício:
– Criar as classes persistentes para um sistema onde possui as
classes disciplinas e professores, onde um professor pode
ministrar várias disciplinas e uma disciplina pode ser
ministrada por vários professores.
Persistindo dados utilizando as
classes controladoras
• Na classe view, criar uma variável de classe referente a
classe controladora que se deseja utilizar.
• Por exemplo, na classe PessoaView, criar a seguinte
variável de classe:
PessoaControler pessoaControler = new PessoaControler();
• Criar dois métodos na classe:
– getDadosTela()
– setDadosTela(Pessoa pessoa)
• O primeiro passa os dados da tela para um

bean.
• O segundo passa os dados do bean para os
componentes da tela.
private Pessoa getDadosTela() {
Pessoa p = new Pessoa();
if (MyNumber.parseInt(jTfCodigo.getValue()) > 0){
p.setIdPessoa
(MyNumber.parseInt(jTfCodigo.getValue()));
}
p.setNome(jTfNome.getText());
return p;
}
private void setDadosTela(Pessoa p){
if (p.getIdPessoa() > 0){
jTfCodigo.setValue(p.getIdPessoa());
}
jTfNome.setText(p.getNome());
}
• Criar mais 5 métodos:
– salvar();
– remover();
– consultar();
– cancelar();
– fechar();
private void salvar(){
Pessoa p = getDadosTela();
pessoaControler.salvar(p);
}
private void remover() {
int id = MyNumber.parseInt(jTfCodigo.getValue());
if (id > 0) {
Pessoa p = pessoaControler.buscar(id);
pessoaControler.remover(p);
}
}
private void cancelar(){
jTfCodigo.setValue(0);
jTfNome.setText(“”);
}
private void consultar(){
//este método irá abrir uma tela de consulta que
//ira retornar um objeto do tipo pessoa.
}
Interface de Consulta
• Criar classe ConsultarPessoaView.java

• Adicionar:
– Jlabel: mudar texto para „Nome:‟
– JTextField: renomear para jTfNome
– JTable: renomear para jTblDados
– JButton: mudar texto para „Ok‟
– JButton: mudar texto para „Cancelar‟
• Criar a variável de classe:

private DefaultTableModel model = new DefaultTableModel();
Private PessoaControler pessoaControler = new PessoaControler();
• Criar dois métodos:

– carregaCabecalho();
– carregaDados();
private void carregaCabecalho(){

Vector<String> v = new Vector<String>();
v.add("Código");
v.add("Nome");
model.setDataVector(null, v);
carregaDados();
}
private void carregaDados(){

List<Pessoa> list = pessoaControler.buscarTodos();
for (Pessoa pessoa : list) {
model.addRow(new Object[]{
pessoa.getIdPessoa(),
pessoa.getNome()
});
}
}
• Criar variável de classe:

Pessoa pessoa = null;
• Criar métodos
– selecionar
– getPessoa
private void selecionar(){

Integer id =
(Integer)model.getValueAt(jTblDados.getSelectedRow(), 0);
pessoa = pessoaControler.buscar(id);
}
public Pessoa getPessoa() {

return pessoa;
}
• Chamar o método selecionar(); no botão „OK‟.

• No botão Cancelar colocar o código:
pessoa = null;
• Na classe PessoaView, no método consultar,

adicionar o seguinte código:
ConsultarPessoaView c =
new ConsultarPessoaView(null, true);
c.setVisible(true);
Pessoa p = c.getPessoa();
if (p != null){
setDadosTela(p);
}else{
cancelar();
}
• Ainda é preciso que a classe de consulta de

pessoas retorne as pessoas quando for
informado seu nome.
• Para que isso aconteça, é preciso criar uma
consulta na classe PessoaDao e fazer com que a
classe PessoaControle tenha acesso a ela.
• Classe PessoaDao:
– Adicionar a consulta que consulta por nome, incluindo o
seguinte método:
public List<Pessoa> buscarPorNome(String nome){

Query q = session.createQuery("from Pessoa p where
p.nome like ?");
q.setString(0, "%"+nome+"%");
return q.list();
}
• Classe PessoaControler:
– Adicionar um método que chama a consulta criada na
classe PessoaDao:
public List<Pessoa> buscarPorNome(String nome){

return pessoaDao.buscarPorNome(nome);
}
• Classe ConsultarPessoaView:
• Assim, quando qualquer tecla for pressionada,

será chamado o método de consulta, passando o
que foi digitado:
• A seguir é preciso modificar o método

carregaDados:
private void carregaDados(String nome){

int cont = model.getRowCount();
for(int i = 0; i < cont; i++){
model.removeRow(0);
}
List<Pessoa> list = pessoaControler.buscarPorNome(nome);
for (Pessoa p : list) {
model.addRow(new Object[]{
p.getIdPessoa(),
p.getNome()
});
}
}
Ajustando Interface de Cadastro
• Chamar o método salvar(); no botão salvar

• Chamar o método remover(); no botão apagar
• Chamar o método consultar(); no botão consultar
• Chamar o método cancelar(); no botão cancelar
• Colocar o código dispose(); no botão fechar
JComboBox com Dados do Banco
• Adicionar:
– JLabel, mudar texto para Cidade:
– JComboBox, renomear para jCmbCidade
• Tirar os dados da propriedade Model do

JComboBox
• Criar o método carregaCidade():
private void carregaCidade(){

CidadeControler cidadeControler = new CidadeControler();
List<Cidade> list = cidadeControler.buscarTodos();
jCmbCidade.removeAllItems();
for (Cidade cidade : list) {
jCmbCidade.addItem(cidade);
}
}
• No bean Cidade.java incluir os seguintes

métodos:
@Override
public String toString() {
return nome;
}
@Override
public boolean equals(Object obj) {
if (obj instanceof Cidade)
return this.getIdCidade() == ((Cidade)obj).getIdCidade();
else
return super.equals(obj);
}
• Acrescentar no método setDadosTela:

jCmbCidade.setSelectedItem(p.getCidade());
• Acrescentar no método getDadosTela:

p.setCidade((Cidade)jCmbCidade.getSelectedItem());
Estratégia para Atribuir Valor para
a Chave Primária
• O valor atribuído à chave primária pode ser dado tanto
pela aplicação quanto por um mecanismo do Hibernate
que o gere automaticamente.
• A anotação @GeneratedValue permite a definição
automática para o valor do identificador.
• O Hibernate apresenta vários mecanismos internos para
a geração dos valores da chave primária.
– Sequence: Mapeado em seqüências no DB2, PostgreSQL, Oracle,
Firebird;
– Auto: Utiliza uma sequence comum chamada hibernate_sequence.
– Identity: Utiliza Colunas de Identidades. Suportado nos bancos de
dados DB2, MySQL, MS SQL Server, Sybase e HypersonicSQL
– Table: O usuário define uma tabela que armazenará os valores das
sequences.
Estratégia para Atribuir Valor para
a Chave Primária
• Para definir a estratégia, deve ser passado por parâmetro
qual a escolhida:
I. @GeneratedValue(strategy = GenerationType.SEQUENCE).
II. @GeneratedValue(strategy = GenerationType.IDENTITY).
III.@GeneratedValue(strategy = GenerationType.AUTO).
IV. @GeneratedValue(strategy = GenerationType.TABLE).
• Para o caso I. e III. deve haver uma seqüência no banco de

dados chamada de “hibernate_sequence”.
• Para usar uma sequencia definida pelo usuário, deve usar a
anotação @SequenceGenerator definindo um nome para a
sequencia e qual o nome dela na base de dados:
@SequenceGenerator(name = "SEQ_CLIENTE",
sequenceName = "cliente_seq")
@GeneratedValue( strategy = GenerationType.SEQUENCE,
generator = "SEQ_CLIENTE")
Recuperação de dados
• Formas de recuperar objetos

– Pelo identificador
– Usando HQL
– Usando a API Criteria
– Usando SQL nativo
HQL
• Hibernate Query Language

– Não é uma linguagem de manipulação de
dados (como SQL); não serve para inserir,
remover, atualizar;
– É usada apenas para recuperação de objetos
– O query mais simples possível:
Query q1 = session.createQuery("from Universidade");
List result = q1.list();
Consultas HQL
• O query mais simples possível:

Query q1 = session.createQuery("from Universidade");
• Os resultados de um query podem ser lidos em

“páginas”
• O query abaixo lê 10 páginas, a partir da primeira
página:
Query query =
session.createQuery("from Centro c order by c.nome asc");
query.setFirstResult(0);
query.setMaxResults(10);
List results = query.list();
Consultas HQL - Parâmetros
• Parâmetros podem ser passados duas formas:

– Por nome de variável
String queryString = "from Centro centro where “
+ “centro.nome like :nomeBusca";
Query q = session.createQuery(queryString);
q.setString ("nomeBusca", "%L%");
– Por ordem
String queryString = "from Centro centro where “
+ “centro.nome like ?";
Query q = session.createQuery(queryString);
q.setString(0, “%L%”);
Consultas HQL – Queries Chamadas
pelo Nome
• Queries não precisam aparecer no código.
• Especifica o query no bean:
@Entity
@NamedQuery(name=“centro.findNome", query="from Centro
where nome like :nomeBusca")
• Para chamar um query pelo nome:

Query q = session.getNamedQuery(“centro.findNome");
• Mais de uma consulta no bean:

@NamedQueries({
@NamedQuery(name = "centro.findNome", query = "from
Centro where nome like :nomeBusca"),
@NamedQuery(name = "centro.todos", query = "from Centro")
})
Consultas HQL – Joins
• Joins (junções) são usados para combinar

dados de duas ou mais tabelas relacionadas
• Joins em HQL são bem mais simples que em
SQL
• Exemplo:
from Universidade un
inner join un.centro
• Retorna um array de Object;

• Incluir fecth para retornar as coleções
inicializadas.
Consultas HQL – Select
• Com SELECT é possível especificar quais os

atributos retornados do objeto
• Retorna um array de object;
Query query =
session.createQuery(“select un.nome, cen.nome from
Universidade un inner join un.centro cen ");
Iterator i = q.list().iterator();
while (i.hasNext()) {
Object[] row = (Object[]) i.next();
String nomeUn = (String) row[0];
String nomeCen = (String) row[1];
System.out.println(nomeUn + " ---- " + nomeCen);
}
Consultas HQL – Funções
Agregadas
• HQL suporta as seguintes funções na cláusula
select:
– count(), min(), max() – retorna Long
– sum() – Tipo definido para o atributo
– avg() – retorna Double
Long count = (Long)session.createQuery("select count(*)

from Centro").uniqueResult();
Object[] avgmax = (Object[]) session.createQuery("select

avg(c.idCentro), max(c.idCentro) from Centro
c").uniqueResult();
Double avg = (Double)avgmax[0];
Long max = (Long)avgmax[1];

Hibernate PDF

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Hibernate PDF

Caricato da

Copyright:

Formati disponibili

Persistência Objeto/Relacional com

Prof. Alan Bruch

• O Hibernate é uma ferramenta MOR completa,

• As classes persistentes de uma aplicação

• O mapeamento objeto relacional

• Este recurso foi introduzido na

• Inicialmente, para que o Hibernate

• Com o surgimento das anotações no

• Todas as classes persistentes mapeadas

• Quando o nome da classe é diferente do

• A chave primária da tabela é mapeada

• Se o nome da coluna anotada com @Id for

• Demais atributos da classe serão

• Instancia objeto Pessoa:

• Após executada a consulta, podemos mostrar

for (Pessoa pessoa : lista) {

for (Pessoa pessoa : lista) {

• Exercício: Criar uma classe para

• Aplica-se o padrão de projeto

• Classes que deverão ser construídas:

• No pacote Util, deverá ser criada a

public class HibernateUtil {

public static Session getSession(){

• As classes DAOs deverão ser criadas no

• Primeira classe a criar neste pacote é a

public class DaoFactory {

public void beginTransaction(){

public void rollback(){

public void close(){

• Neste mesmo pacote deverão ser criadas

public class PessoaDao {

public PessoaDao(Session session) {

public void salvar(Pessoa Pessoa){

public void remover(Pessoa Pessoa){

public Pessoa buscar(int id){

public List<Pessoa> buscarTodos(){

public PessoaDao getPessoaDao(){

• Nesta camada serão construídas as

• Nesta camada serão construídas as

public class PessoaControler {

public void salvar(Pessoa Pessoa){

public void remover(Pessoa Pessoa){

public Pessoa buscar(int id){

public List<Pessoa> buscarTodos(){

• O termo associação é utilizado para se

• Relacionamento entre Cidade

• Para exemplificar as associações, crie:

– Gerar os métodos getters e setters.

– Gerar metodos getters e setters.

• A partir do diagrama a seguir,

• Um relacionamento n-n implica em

• Criar uma nova tabela chamada

• Em cada classe persistente, anotar o atributo

• O primeiro passa os dados da tela para um

• Criar classe ConsultarPessoaView.java

• Criar a variável de classe:

• Criar dois métodos:

private void carregaCabecalho(){

private void carregaDados(){

• Criar variável de classe:

private void selecionar(){

public Pessoa getPessoa() {

• Chamar o método selecionar(); no botão „OK‟.