Criando um projeto JEE usando JPA com Hibernate, JSF e MySQL

Olá,
pessoal!

Veremos
hoje como como usar JPA para seus projetos JEE, tendo como provider
o Hibernate e usando o JSF para o view.
Vamos fazer uma aplicação para cadastrar um cliente. Limitamos os
dados do form, pois o objetivo é mostrar como criar um ambiente para
development tendo JPA
nos seus projetos.

Let’s
go…

Requisitos:

• MySQL 5.0.x

• TomCat
  6

• Hibernate
  – Download
  .jars

• JSF
  1.2 – Download
  .jars

Iniciando

Na
imagem a seguir você tem toda a estrutura do projeto. Observe que já
criei as bibliotecas para o projeto e estas foram adicionadas. Se
não quiser adicionar as bibliotecas ao projeto, copie os .jars para
a pasta lib e pronto. Lembre-se de que ao adicionar uma biblioteca ao
projeto, o stupid Eclipse
não copia os .jars para a pasta lib. (ao contrário do netbeans!).

Não
se esqueça também de criar um schema
e uma table no MySQL,
que aqui chamaremos de sistemas e clientes respectivamente.

Monte uma estrutura conforme a imagem acima. Boa parte das
explanações estão dentro do código, no formato de comentário,
lado a lado para facilitar a compreensão.

Desenvolvimento

O primeiro passo é criar o bean e fazer as devidas anotações.
Veja abaixo como está o nosso cliente bean:

package br.com.bean;
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="cliente")//caso o nome da tabela seja diferente informe aqui
public class Cliente {
        @Column(name="nome")
        private String nome;

        @Id
        @GeneratedValue(strategy=GenerationType.IDENTITY)
        //anotação acima indica que o campo será gerado automaticamente pelo BD
        @Column(name="id")
        private int id;
        @Column(name="sobrenome")
        private String sobrenome;
        @Column(name="cidade")
        private String cidade; 

        public Cliente() {
                // TODO Auto-generated constructor stub
        }

        public String getNome() {
                return nome;
        }

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

        public int getId() {
                return id;
        }

        public void setId(int id) {
                this.id = id;
        }

        public String getSobrenome() {
                return sobrenome;
        }

        public void setSobrenome(String sobrenome) {
                this.sobrenome = sobrenome;
        }

        public String getCidade() {
                return cidade;
        }

        public void setCidade(String cidade) {
                this.cidade = cidade;
        }

}

Agora vamos
partir para criar o nosso DAO; nele teremos a nossa fábrica de
conexão. Poderíamos ter métodos genéricos como salvar, deletar,
atualizar etc., mas não vamos implementar todos.

package br.com.dao;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class DAO {

        private EntityManagerFactory emf; 

        /* se vc já está acostumado com Hibernate
         * a ideia é a mesma do método de fabrica que
         * criamos para os Session que vem do SessionFactory
         * Aqui temos apenas nomeclatura diferente, pense assim.
         */
        public EntityManager getEntityManager(){

                //responsavel pela persistencia
                return emf.createEntityManager();
        }
        public DAO() {
                //chamo ele de reprodutor da instância
                emf = Persistence.createEntityManagerFactory("sistemas");

                /* o nome passado vem do arquivo persistence.xml que contém as configs
                 * para conexão com o BD.
                 */
        }}

Agora vamos criar a classe que vai
fazer a persistência com os dados do cliente. É a ClienteDAO.java,
que estende
a classe DAO, para conseguirmos pegar um objeto objeto EntityManager
que é responsável pelas inclusões, exclusões e
atualizações.

package br.com.dao;

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.Query;

import br.com.bean.Cliente;

public class ClienteDAO extends DAO {

        public void salvar(Cliente cliente){
                //obtendo o EntityManager
                EntityManager em = getEntityManager();
                try{
                        //inicia o processo de transacao
                        em.getTransaction().begin();
                        //faz a persistencia
                        em.persist(cliente);
                        //manda bala para o BD
                        em.getTransaction().commit();
                }catch (Exception e) {
                        //se der algo de errado vem parar aqui, onde eh cancelado
                        em.getTransaction().rollback();
                }
        }

        public List exibir(){
                EntityManager em = getEntityManager();
                try{
                        Query q = em.createQuery("select object(c) from Cliente as c");

                return q.getResultList();}
                finally{
                        em.close();
                }
        }}

Agora
criaremos a classe ClienteController, que
terá a responsabilidade de direcionar a comunicação do JSF, pegar
o que foi digitado no form e persistir.

package br.com.controller;
import javax.faces.model.DataModel;
import javax.faces.model.ListDataModel;
import br.com.bean.Cliente;
import br.com.dao.ClienteDAO;
public class ClienteController {
        private Cliente cliente;
        private DataModel model;
        public ClienteController() {
                cliente = new Cliente();
        }

        public Cliente getCliente() {
                return cliente;
        }
        public void setCliente(Cliente cliente) {
                this.cliente = cliente;
        }

        public String salvar(){
                ClienteDAO clientedao = new ClienteDAO();
                        clientedao.salvar(cliente);
                return "salvar";
        }
        public DataModel getTodos(){
                        ClienteDAO clientedao = new ClienteDAO();
                        model = new ListDataModel(clientedao.exibir());
                return model;
        }}

Vamos configurar no velho e querido face-config.xml.

Criando arquivo persistence.xml

O arquivo que vamos precisar para conectar ao banco de dados é
parecido como hibernate.cfg.xml, já que tem a mesma função
(conectar ao BD).

Observe
o name da
persistence-unit pois, é ele que usamos no nosso DAO.java.

Não
esqueça que terá que criar um folder META-INF em
JavaSource e colocar o
persistence.xml neste
folder, não dentro do META-INF de WebContent.
Alguns programadores acabam confundido e daí recebem as velhas
exceções…

Criando as pages JSF

Agora criamos três páginas .jsp com JSF, uma será o index, que
redireciona para cadastro.jsf, e a outra é somente uma mensagem
dizendo que foi cadastrado com sucesso.

Index.jsp

< jsp:forward page="cadastro.jsf" />

cadastro.jsp

Testando

1. Mande executar seu projeto. Clique nele e vá em Run ==> Run as
   ==> Run on Server
2. Cadastre um cliente
3. E depois verifique se ele está realmente no BD. Veja abaixo meus
   prints:

Fico por aqui, espero que tenham gostado do
artigo.

Abraços, see you! 🙂