Como Usar

Com o objetivo de demonstrar o JBC, será apresentado neste tópico dois exemplos de implementação da regra de negócio em Java, conforme as arquiteturas apresentadas na Figura 1.

Figura 1 - Modelo de implementação JBC 

Para implementação, iremos utilizar o banco de dados MySql, juntamente com a IDE Netbeans 7.0, porém qualquer outra IDE compatível Java pode ser utilizada, assim como qualquer outro banco de dados relacional.

No primeiro exemplo será apresentado o Modelo Tradicional e o segundo exemplo, usando o Modelo utilizando o Framework JBC, para isso será usado como base a implementação de uma entidade simples, vamos chama-la de Pessoa. Esta entidade terá apenas dois atributos, id e nome, e como vamos utilizar o framework Hibernate, vamos declarar a classe seguido de suas anotações.

@Entity

public class Pessoa implements Serializable {   

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="ID")
    private int id;   

    @Column(name="NOME", length=50, nullable=false)
    private String nome;

    public int getId() {
       return id;
    }

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

    public String getNome() {
       return nome;
    }

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

}

Não iremos entrar em detalhes sobre anotações neste momento.

Consequentemente se utilizamos Hibernate, precisamos adicionar as bibliotecas do Framework, como também o drive de conexão com o MySql, como na Figura 2.

Figura 2 - Importação das bibliotecas

Os seguintes Jars foram adicionados:

Figura 3 - Detalhamento das bibliotecas

Temos que utilizar por padrão os Jars da versão 3 do Hibernate, que é a mesma versão utilizada no desenvolvimento do JBC.

Se utilizamos anotações, precisamos ter o arquivo de configuração do Hibernate, que por padrão deve ficar na raiz do código fonte do projeto, como na Figura 4

.

Figura 4 - Arquivo de Configuração Hibernate na Raiz do Projeto

 

<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/nomedabasededados</property>

    <property name="hibernate.connection.username">root</property>

    <property name="hibernate.hbm2ddl.auto">update</property>  

    <property name="hibernate.connection.pool_size">1</property>

    <mapping class="nomedopacote.Pessoa"/>
  

 </session-factory>

</hibernate-configuration>

No arquivo de configuração acima, devem ser ajustado o nome da base de dados e o nome do pacote Java onde se encontra a classe Pessoa. Vale também lembrar, que precisamos criar a base de dados no MySql.

Os procedimentos realizados até aqui são necessários para os dois exemplos de arquitetura, tanto o Modelo Tradicional, quanto o Modelo JBC. Daqui pra frente, teremos as implementações individuais para cada Modelo.
Vale lembrar que o Modelo Tradicional é uma das formas de implementar MVC, existem várias outras alternativas no mercado. O objetivo deste exemplo não é dizer o que é certo, ou o que é errado, apenas apresentar o JBC


Modelo tradicional

No Modelo de desenvolvimento Tradicional MVC (Imagem 1), precisamos definir as seguintes entidade: Dao, Facade e Controller, como vemos a seguir:

import org.hibernate.Session;

import java.io.Serializable;

public class PessoaDao implements Serializable {

    private final Session session;

    public PessoaDao(Session session) {
       this.session = session;
    }

    public Boolean insert(Pessoa p) {

       this.session.merge(p);
       this.session.flush();
       this.session.evict(p);

       return true;

    }
}

import java.io.Serializable;

public class PessoaFacade implements Serializable {

    private Transaction factory;

    private PessoaDao dao;

    public PessoaFacade() {
       factory = Transaction.getInstance();
       dao = new PessoaDao(factory.getSession());
    }

    public Boolean insert(Pessoa p) {

       if (factory.hasTransaction()) {
           return dao.insert(p);
       } else {
           return false;
       }

    }
}

import java.io.Serializable;

public class PessoaController implements Serializable {

    private PessoaFacade facade;

    public PessoaController() {
       this.facade = new PessoaFacade();
    }

    public PessoaFacade getFacade() {
       return facade;
    }

    public Boolean insert(Pessoa p) throws Exception {

       try {

           Transaction.getInstance().beginTransaction();

           if (this.facade.insert(p)) {
               Transaction.getInstance().commit();
               return true;
           } else {
               Transaction.getInstance().rollback();
               return false;
           }

       } catch (Exception e) {
           Transaction.getInstance().rollback();
           throw e;
       }

    }

}

Levando em consideração que precisamos ter também uma classe utilitária Transaction, para controle de transação.

Consequemente, o código para inserir a Pessoa:

public class Main {
    
    public static void main(String[] args) {
        PessoaController controller = new PessoaController();
        Pessoa p = new Pessoa();
        p.setNome("Rodrigo Marconato");
        try {
            controller.insert(p);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

O Modelo Tradicional pode ser baixado aqui.

Modelo JBC

Neste segundo exemplo, iremos criar a outra aplicação, o Modelo JBC, que será definido a classe Pessoa e suas anotações, juntamente com o arquivo de configuração do Hibernate, como já vimos anteriormente, ou seja, todo o código mostrado no Modelo Tradicional é desnecessário. Com a aplicação criada, precisamos adicionar o JAR JBC na aplicação, que pode ser baixado aqui. Então para realizar a inserção do registro, não precisamos de nenhum dos códigos declarados na apresentação do Modelo Tradicional, basta utilizar uma instância da classe br.com.jbc.controller.Controller, e definir o tipo genérico como sendo a classe Pessoa, em seguida, chamar o método de acesso ao banco de dados necessário, neste caso o insert. Como no exemplo abaixo:

import br.com.jbc.controller.Controller;

public class Main {

   

    public static void main(String[] args) {

       Controller<Pessoa> controller = new Controller<Pessoa>();

       try {
            Pessoa p = new Pessoa();
            p.setNome("Rodrigo Marconato");
            controller.insert(p);

       } catch (Exception e) {
            e.printStackTrace();
       }

    }

}

O Modelo JBC pode ser baixado aqui.

Conclusão

Para desenvolver um sistema por completo, necessitamos de uma infinidade de operações de transação e consulta na camada de negócio, então imagine ter que desenvolver todas estas operações para cada entidade do seu negócio. Realmente é o que acontece em nosso meio, então a ideia do JBC foi generalizar todas essas operações através de um Framework que desse suporte para todo e qualquer tipo de negócio, indiferente de funcionalidades e regras, deixando com que o desenvolvedor dedique a maior parte de seu tempo com o desenvolvimento da camada de visualização, implementação que requer mais atenção e que tem grande variedade entre um sistema e outro.

O código fonte dos dois exemplos podem ser baixados aqui

O JBC exige que alguns requisitos sejam cumpridos, veja quais são eles