Olá,
pessoal!

Neste
artigo, veremos como usar JPA para seus projetos JEE, tendo como
provider o Hibernate, e como
view o JSF. Aplicação
será bem simples, apenas cadastrar um cliente. Limitamos os dados do
form, pois o objetivo é mostrar como criar um ambiente para
desenvolvimento tendo
JPA nos seus projetos.

Let’s go…

Posts relacionados

• JPA
  com Jboss tools

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 elas 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 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,
aqui chamaremos de sistemas e clientes,
respectivamente.

Monte uma estrutura conforme a imagem acima.

Como sempre, 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.
Essa classe extends
a classe DAO, para conseguirmos pegar um 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 o no velho e querido face-config.xml

< face-config.xml>

Criando o arquivo persistence.xml

1. O arquivo que vamos precisar para conectar ao banco de dados é
   parecido com o arquivo hibernate.cfg.xml que temos quando usamos
   Hibernate puro (sem JPA).

2. Observe
   o name da
   persistence-unit. É ele que usamos no nosso DAO.java.

1. Não
   se esqueça que você terá de criar um folder META-INF em
   JavaSource e
   colocar o persistence.xml nesse
   folder, não dentro do META-INF de WebContent.
   Alguns programadores acabam confundido isso, e geram as velhas
   exceções, ficam estressados etc 🙂

Criando as pages JSF

Agora criamos duas páginas .jsp com JSF, uma será o index, que
redireciona para cadastro.jsf, e a outra mostra apenas uma mensagem
dizendo que o cadastrado foi feito 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 e espero que tenham gostado!

JPA com JEE usando o framework JSF.

Abraços, see ya! 🙂