Bom pessoal, vamos trabalhar com algo mais interessante agora, vamos criar um CRUD, para quem ainda não acostumou com o termo “Create(Criar), Read(Ler), Update(Alterar), Delete(Excluir)”, iremos implementar um cadastro de clientes. No desenvolvimento desse projeto vamos utilizar o NetBeans 7 com suporte a JSF 2.0(nada impede de se usar outra IDE, ou versão do Netbeans, fica a critério de cada um), Hibernate 3.6.4 Final, Primefaces 2.2.1 Final, para o banco de dados será o MySql 5.1 e também vamos utilizar as ferramentas para manipular o banco MySql Tools.

Vamos desenvolver um cadastro de clientes, para isso vamos utilizar o padrão MVC, esse modelo visa separa as classes de acordo com suas responsabilidades, para isso iremos criar pacotes  chamados de: Model, View e Controller para visualizarmos com mais facilidade o padrão na prática.  A princípio nosso cliente terá as seguintes informações: nome, cpf ou cnpj, endereço, número, telefone, estado, cidade.

Então crie um novo projeto web, selecione o framework JavaServer Faces 2.0,  se ainda tem dúvida veja esse post primeira aplicação em JSF 2.0, para nosso projeto dei  o nome de “Cliente”, fica a critério de vocês,  agora crie um diretório chamado views  na pasta “Páginas Web”,  e nos pacotes de códigos fonte crie pacotes chamados “br.com.cliente.models”, “br.com.cliente.controllers”, assim seu código fica padronizado e de fácil entendimento para qualquer desenvolvedor que venha a dar manutenção ao código, veja na figura 1.

imagem netbeans 1

imagem de um projeto no netbeans

No pacote models crie um nova “classe java” chamada “cliente” que será nossa entidade.

package br.com.cliente.models;

import java.io.Serializable;

/**
 *
 * @author Thiago Marques
 */
public class Cliente implements Serializable {
    private Long idCliente;
    private String nome;
    private String cpf;
    private String cnpj;
    private String endereco;
    private String numero;
    private String telefone;
    private String estado;
    private String municipio;

    public String getCnpj() {
        return cnpj;
    }

    public void setCnpj(String cnpj) {
        this.cnpj = cnpj;
    }

    public String getCpf() {
        return cpf;
    }

    public void setCpf(String cpf) {
        this.cpf = cpf;
    }

    public String getEndereco() {
        return endereco;
    }

    public void setEndereco(String endereco) {
        this.endereco = endereco;
    }

    public String getEstado() {
        return estado;
    }

    public void setEstado(String estado) {
        this.estado = estado;
    }

    public Long getIdCliente() {
        return idCliente;
    }

    public void setIdCliente(Long idCliente) {
        this.idCliente = idCliente;
    }

    public String getMunicipio() {
        return municipio;
    }

    public void setMunicipio(String municipio) {
        this.municipio = municipio;
    }

    public String getNome() {
        return nome;
    }

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

    public String getNumero() {
        return numero;
    }

    public void setNumero(String numero) {
        this.numero = numero;
    }

    public String getTelefone() {
        return telefone;
    }

    public void setTelefone(String telefone) {
        this.telefone = telefone;
    }
}

Vejam que a classe tem um algo a mais:

public class Cliente implements Serializable

Essa implementação tem por objetivo serializar do nosso objeto, para entender sobre serialização leia esse post.

Agora vamos a parte que preparamos a classe para criarmos nosso banco com o hibernate. O Hibernate é um framework de persistência de dados e realiza o mapeamento de objetos para o paradigma relacional, a principal vantagem é não precisamos criar SQL na mão, entre outras, lhe proporcionando mais produtividade, o framework trabalha com annotations para realizar o mapeamento e validações.

Em nossa classe vamos adicionar as annotations  para criar nosso banco, veja que está comentado qual a função principal de cada delas.

package br.com.cliente.models;

import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

/**
 *
 * @author Thiago Marques
 */
@Entity
public class Cliente implements Serializable { //Serialição do nosso objeto, é utilizado quando recuperamos um dados, será útil mas a frente que tivermos outras classes envolvidas.

    @Id //Define que a variavel abaixo será nosso ID no banco
    @GeneratedValue(strategy= GenerationType.IDENTITY) // Gera um id único para cada registro de cliente
    private Long idCliente;
    @Column(name="NOME", length=80) // define que o nome da coluna, e o tamanho que terá no banco
    private String nome;
    @Column(name="CPF", length=12)// define que o nome da coluna, e o tamanho que terá no banco
    private String cpf;
    @Column(name="CNPJ", length=14)// define que o nome da coluna, e o tamanho que terá no banco
    private String cnpj;
    @Column(name="ENDERECO", length=80)// define que o nome da coluna, e o tamanho que terá no banco
    private String endereco;
    @Column(name="NUMERO", length=20)// define que o nome da coluna, e o tamanho que terá no banco
    private String numero;
    @Column(name="TELEFONE", length=20)// define que o nome da coluna, e o tamanho que terá no banco
    private String telefone;
    @Column(name="ESTADO", length=80)// define que o nome da coluna, e o tamanho que terá no banco
    private String estado;
    @Column(name="MUNICIPIO", length=80)// define que o nome da coluna, e o tamanho que terá no banco
    private String municipio;

//getters e setter omitidos
}

Vamos criar mais outro pacote chamado utility, nesse pacote iremos armazenar nossos arquivos utilitários do hibernate e outros que venhamos precisar.

Para configuração do Hibernate vamos utilizar um arquivo chamado HibernateUtility, nele vamos definimos qual banco de dados será utilizar, sua senha e endereço, e quais classes serão como modelo para criação do nosso banco de dados.  Como foi definido no inicio do projeto iremos utilizar o banco MySql, e para administrar esse banco temos um pacote de utilitários chamado MySql Tools que possui ferramentas necessárias para manipular o banco manualmente se for necessário. Vou disponibilizar já pronto, mas com comentários nas partes mais importantes de configuração, o restante é padrão para nosso exemplo.

package br.com.clientes.utility;

import br.com.cliente.models.Cliente;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class HibernateUtility {

    private static final SessionFactory factory;
    private static final ThreadLocal sessionThread = new ThreadLocal();
    private static final ThreadLocal transactionThread = new ThreadLocal();

    public static Session getSession() {
        Session session = (Session) sessionThread.get();
        if ((session == null) || (!(session.isOpen()))) {
            session = factory.openSession();
            sessionThread.set(session);
        }
        return ((Session) sessionThread.get());
    }

    public static void closeSession() {
        Session session = (Session) sessionThread.get();
        if ((session != null) && (session.isOpen())) {
            sessionThread.set(null);
            session.close();
        }
    }

    public static void beginTransaction() {
        Transaction transaction = getSession().beginTransaction();
        transactionThread.set(transaction);
    }

    public static void commitTransaction() {
        Transaction transaction = (Transaction) transactionThread.get();
        if ((transaction != null) && (!(transaction.wasCommitted())) && (!(transaction.wasRolledBack()))) {
            transaction.commit();
            transactionThread.set(null);
        }
    }

    public static void rollbackTransaction() {
        Transaction transaction = (Transaction) transactionThread.get();
        if ((transaction != null) && (!(transaction.wasCommitted())) && (!(transaction.wasRolledBack()))) {
            transaction.rollback();
            transactionThread.set(null);
        }
    }

    static {
        try {
            factory = new Configuration()
//                    /***MYSQL***/
                    .setProperty("hibernate.dialect", "org.hibernate.dialect.MySQLInnoDBDialect") // tipo de dialeto do banco
                    .setProperty("hibernate.connection.driver_class", "com.mysql.jdbc.Driver") // driver do banco
                    .setProperty("hibernate.connection.url", "jdbc:mysql://localhost:3306/cliente") // endereço do banco de dados
                    .setProperty("hibernate.connection.username", "root")
                    .setProperty("hibernate.connection.password", "root")
                    .setProperty("hibernate.hbm2ddl.auto", "update")
                    .setProperty("hibernate.c3p0.max_size", "10")
                    .setProperty("hibernate.c3p0.min_size", "2")
                    .setProperty("hibernate.c3p0.timeout", "5000")
                    .setProperty("hibernate.c3p0.max_statements", "10")
                    .setProperty("hibernate.c3p0.idle_test_period", "3000")
                    .setProperty("hibernate.c3p0.acquire_increment", "2")
                    .setProperty("show_sql", "true")
                    .setProperty("use_outer_join", "true")
                    .setProperty("hibernate.generate_statistics", "true")
                    .setProperty("hibernate.use_sql_comments", "true")
                    .setProperty("hibernate.format_sql", "true")
                    //CADASTROS abaixo coloque todas classes que deseja ser modelo para criação do banco de dados
                    .addAnnotatedClass(Cliente.class)
                    //MOVIMENTOS
                    .buildSessionFactory();
        } catch (RuntimeException e) {
            e.printStackTrace();
            throw e;
        }
    }

    public static void main(String [] args) {

    }

}

Ressaltando veja que temos uma parte da em nosso arquivo HibernateUtility que tem “.addAnnotatedClass(Cliente.class)” , nessa parte é onde definimos quais classes serão modelo para nossas tabelas no banco de dados.

Bom repare que nossa classes HiberanteUtility está acusando alguns erros, o motivo é que não inserimos as bibliotecas do Hibernate e suas dependências, faça o download das bibliotecas e o “log4j.properties” que vai ser incluído no “classpath”, faça download e adicione no projeto.

Instale o pacote Mysql Tools, após isso execute a ferramenta “MySql Query Browser” crie o banco com o nome “cliente” no seu MySql(“create database cliente;”), após criar o banco de dados execute somente a classe HibernateUtility, e veja o resultado no console da IDE, temos o código de criação da nossa tabela. Agora que temos nosso banco de dados pronto para receber os dados do cadastro, a ser armazenados para futura consulta.

No próximo post vamos criar nosso ManagerBean caso não fique extenso já vamos partir para view.

Até o póximo post pessoal, qualquer sugestão e dúvidas postem estou a disposição..

Anúncios