CloudWare

cafelog-coffee

Desenvolvendo uma Simples Aplicação com o Hibernate - Parte 2/3

Terça, 27 Dezembro 2011

hibernate

Continuando com a segunda parte do nosso tutorial "Desenvolvendo uma Simples Aplicação com o Hibernate", iremos configurar o Hibernate e implementá-lo.

CONFIGURANDO O HIBERNATE

Agora iremos criar o pessoas.hbm.xml, o arquivo contendo o mapeamento da tabela pessoas com os tipos de dados do Hibernate e que também informa o POJO responsável pelo mapeamento, neste caso a classe Pessoas. O arquivo deve ficar desta forma:

<?xml version="1.0" encoding="UTF-8"?>
http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="Pessoas" table="pessoas">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="nome" type="string" length="50"/>
        <property name="idade" type="integer" length ="3"/>
        <property name="sexo" type="character" length ="1"/>
    </class>
</hibernate-mapping>

Feito isso, iremos criar o hibernate.cfg.xml, arquivo responsável pela conexão com o Banco de Dados e pelo comportamento geral do Hibernate. Iremos informar o Dialeto, Driver e URL do Banco de Dados, usuário, senha e habilitaremos as opções de mostrar o SQL no console da IDE com formatação (Apenas para facilitar o entendimento do código) e a geração de estatísticas.
Repare que no final deste arquivo indicamos o local do pessoas.hbm.xml na propriedade resource da Tag mapping.
O arquivo deve ficar da seguinte forma:
<?xml version="1.0" encoding="UTF-8"?>
http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hello_hibernate</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password"/>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>
        <property name="hibernate.generate_statistics">true</property>
            
        <!-- ARQUIVO DE MAPEAMENTO -->
        <mapping resource="pessoas.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

A CLASSE DA SESSÃO

A classe Sessao será responsável por ler o arquivo hibernate.cfg.xml e estabelecer a conexão com o Banco de Dados. Nela usaremos apenas três classes: Configuration, SessionFactory e Session.
A classe Configuration é responsável por ler o arquivo hibernate.cfg.xml e iniciar a sessão propriamente dita.
A classe SessionFactory possui um alto custo de criação, é deve ser criado uma única vez, no início da execução da aplicação, a partir da instância de uma Configuration.
Uma Session é um objeto de baixo custo de criação e deve ser usado uma vez, para uma única requisição e então deve ser descartada (sessao.close()).
Uma transação precisa ser o mais curta possível, para reduzir a disputa pelo bloqueio na Base de Dados. Transações longas impedirão que sua aplicação seja altamente concorrente.
A classe Sessao deve ficar da seguinte maneira:

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class Sessao {
    private static SessionFactory fabricaSessao;
    private static Configuration hibernateConfig;
    // Estrutura static para garantir que a SessionFactory seja iniciada apenas uma vez
    static {
        try {
            hibernateConfig = new Configuration().configure("hibernate.cfg.xml");
            fabricaSessao = hibernateConfig.buildSessionFactory();
            atualizarBD();
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    // Retorna a sessão
    public static Session getSessao(){
        return fabricaSessao.openSession();
    }

    // Atualiza o Schema do Banco de Dados
    private static void atualizarBD(){
        SchemaUpdate se = new SchemaUpdate(hibernateConfig);
        se.execute(true, true);
    }
}

O método atualizarBD irá ser chamado assim que a conexão com o Banco de Dados for efetuada. Ele irá garantir que o nosso mapeamento seja "refletido" no banco de dados.

A CLASSE DE PERSISTÊNCIA

Feita a classe Sessao iremos implementá-la na classe HibernateUtil junto com os métodos select, insertUpdate e delete.
Nesta classe precisaremos das classes Session, Transaction, Query e List.
A Session nos permite acessar a SessionFactory. A Transaction é quem iniciará a Session e execuratá a Query. Ao realizar o SELECT será retornado uma List.
Veja como deve ficar a classe:

import java.util.ArrayList;
import java.util.List;
import javax.swing.JOptionPane;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
public class HibernateUtil {
    private Session sessao;
    private Transaction transacao;
    private Query query;
    
    public List select(){
        List<Pessoas> lista = new ArrayList();
        try {
            this.sessao = Sessao.getSessao();
            transacao = sessao.beginTransaction();
            query = sessao.createQuery("from Pessoas");
            lista = query.list();
            sessao.close();
        } catch (HibernateException e) { 
            JOptionPane.showMessageDialog(null, "Erro ao realizar Select.\n"+e.getMessage(), null, JOptionPane.ERROR_MESSAGE);
           e.printStackTrace(); 
       }
       return lista;
   }
   
    public void insertUpdate(Pessoas pessoa){
        try{
            this.sessao = Sessao.getSessao();
            transacao = sessao.beginTransaction();
            sessao.saveOrUpdate(pessoa);
            transacao.commit();
            sessao.close();
            JOptionPane.showMessageDialog(null, "Registro salvo com sucesso!", null, JOptionPane.INFORMATION_MESSAGE);
        } catch (HibernateException e) { 
            JOptionPane.showMessageDialog(null, "Erro ao persistir os dados.\n"+e.getMessage(), null, JOptionPane.ERROR_MESSAGE);
            e.printStackTrace(); 
        }
    }
    
    public void delete(Pessoas pessoa){
        try{
            this.sessao = Sessao.getSessao();
            transacao = sessao.beginTransaction();
            sessao.delete(pessoa);
            transacao.commit();
            sessao.close();
            JOptionPane.showMessageDialog(null, "Registro deletado com sucesso!", null, JOptionPane.INFORMATION_MESSAGE);
        } catch (HibernateException e) { 
            JOptionPane.showMessageDialog(null, "Erro ao deletar registro.\n"+e.getMessage(), null, JOptionPane.ERROR_MESSAGE);
            e.printStackTrace(); 
        }
    }
}

Como você pode ver, criamos três métodos: select, insertUpdate e delete. Em select utilizamos o HQL para realizar uma consulta que retornará uma List. Em insertUpdate utilizamos o método saveOrUpdate() que realiza tanto o INSERT quanto o UPDATE (apenas se o atributo id já existir). Em delete utilizamos o método delete() para apagar determinado registro.
Note que tanto em insertUpdate e delete passamos por parâmetro o POJO Pessoas e no método select retornamos uma List<Pessoas>. Observe também que utilizamos o sessao.beginTransaction() para iniciar a sessão, em seguida executamos a query com o transacao.commit() e fechamos a sessão, sessao.close(). Isso é muito importante pois, como vimos anteriormente, uma transação tem que ser o mais curta possível.

IMPLEMENTANDO AS CLASSES

Agora vamos implementar o HibernateUtil e outros métodos na classe principal Main, tornando a aplicação funcional. Vamos começar com a declaração dos atributos e do método construtor Main.

private HibernateUtil hibernate;
private Pessoas pessoas;
private DefaultTableModel tblModel;
private int id;

public Main() {
    hibernate = new HibernateUtil();
    pessoas = new Pessoas();
    initComponents();
    setLocationRelativeTo(null);
    setListeners();
    atualizarTabela();
}

O que acabamos de fazer?

  • Instanciamos o HibernateUtil e o POJO Pessoas;
  • Iniciamos os componentes Swing;
  • Centralizamos a tela;
  • Adicionamos os listeners necessários (A seguir);
  • Atualizamos a tabela (A seguir).

Agora iremos criar os métodos limparCampos e validarCampos:

private void limparCampos(){
     id = 0;
     txtNome.setText("");
     spnIdade.setValue(0);
     grpSexo.clearSelection();
}

private boolean validarCampos(){
     if(txtNome.getText().isEmpty()){
          JOptionPane.showMessageDialog(null, "Informe o nome", null,    JOptionPane.WARNING_MESSAGE);
          return false;
     } else if((Integer)spnIdade.getValue() < 1){
          JOptionPane.showMessageDialog(null, "Informe uma idade válida", null,  JOptionPane.WARNING_MESSAGE);
          return false;
     } else if(!rdoF.isSelected() && !rdoM.isSelected()){
          JOptionPane.showMessageDialog(null, "Informe o sexo", null,    JOptionPane.WARNING_MESSAGE);
          return false;
     }
     return true;
}

Feito isso, o próximo passo é criar os métodos setPessoas (Que irá pegar os valores do formulário e setar no POJO) e atualizarTabela (Que chamará o método select do HibernateUtil e preencherá a tabela sempre que um evento for disparado).
private void setPessoas() {
     pessoas.setId(id);
     pessoas.setNome(txtNome.getText());
     pessoas.setIdade((Integer)spnIdade.getValue());
     if(rdoM.isSelected())
     pessoas.setSexo('M');
     else if(rdoF.isSelected())
    pessoas.setSexo('F');
}

private void atualizarTabela(){
     try {
          limparCampos();
          tblModel.getDataVector().clear();
          List<Pessoas> select = hibernate.select();
          if(!select.isEmpty()){
         for(Pessoas p : select)
                    tblModel.addRow(new Object[]{p.getId(), p.getNome(),  p.getIdade(), p.getSexo()});
          }
     } catch (Exception e) {
          JOptionPane.showMessageDialog(null, "Erro ao atualizar     tabela\n"+e.getMessage(), null, JOptionPane.ERROR_MESSAGE);
     }
}

Por último iremos adicionar os listeners nos botões e na tabela. Nos botões btnInserir, bntAtualizar e btnDeletar iremos adicionar um ActionListener que, primeiramente, realizará uma validação e caso a mesma seja positiva executará o setPessoas, depois o método do HibernateUtil (insertUpdade ou delete) e por último atualizará a tabela.
Na tabela adicionaremos um MouseListener e sobrescreveremos o método mouseClicked. Ao clicarmos em uma linha, os campos nome, idade e sexo serão preenchidos e o atributo id terá seu valor atualizado.
private void setListeners() {
btnInserir.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            if(validarCampos()){
                id = 0;
                setPessoas();
                hibernate.insertUpdate(pessoas);
                atualizarTabela();
            }
        }
    });
    btnAtualizar.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            if(validarCampos()){
                setPessoas();
                hibernate.insertUpdate(pessoas);
                atualizarTabela();
            }
        }
    });
    btnDeletar.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            if(id > 0){
                setPessoas();
                hibernate.delete(pessoas);
                atualizarTabela();
            }
        }
    });
    tblRegistros.addMouseListener(new MouseAdapter() {
        @Override
        public void mouseClicked(MouseEvent e) {
            int linha = tblRegistros.getSelectedRow();
            id = (Integer)tblRegistros.getModel().getValueAt(linha, 0);
            txtNome.setText(tblRegistros.getModel().getValueAt(linha,1)+"");
            spnIdade.setValue(tblRegistros.getModel().getValueAt(linha, 2));
            if((Character)tblRegistros.getModel().getValueAt(linha, 3)=='M')
                rdoM.setSelected(true);
            else if((Character)tblRegistros.getModel().getValueAt(linha, 3)=='F')
                rdoF.setSelected(true);
        }
    });
}

Com isso feito nossa aplicação já está pronta para ser testada. Na terceira e última parte do tutorial testaremos a aplicação e falaremos um pouco mais sobre o Hibernate.

 

Parte 1 | Parte 2 | Parte 3

Android

Java

Hibernate

Joomla!

CSS3

HTML5

Saia na Frente

html5 css3

Sobre Mim

sobre-foto-2Adriel Café é Web Master e Desenvolvedor Java. Ele incentiva o uso/estudo de Web Standards, Java e Android.

Saiba Mais

Encontre-me

facebook linkedin