O padrão Fachada

     O Padrão Facade que é simples de ser aplicado e que traz grandes benefícios aos projetos é dito como sendo um padrão estrutural e está entre os 23 padrões de projeto do GoF (Gang of Four).

Entende-se por padrão estrutural todo padrão de projeto que trata da associação entre classes e objetos.

Como o nome sugere Facade, é realmente uma fachada, podemos fazer a seguinte analogia, quando caminhamos em frente a um prédio com uma bela fachada, vemos as belas janelas as paredes bem decoradas, ou seja um ambiente bem amigável, e ignoramos toda a complexidade por trás da obra, a quantidade de salas, todas as empresas que estão neste prédio, deste modo o Facade também age nos projetos de software, dentre seus benefícios, alguns são:

 - Reduz a complexidade de uma api, liberando acesso a métodos de alto nível encapsulando os demais.
 - Produz uma interface comum e simplificada.
 - Pode encapsular uma ou mais interfaces mal projetadas em uma mais concisa.

 - Reduz drasticamente o acoplamento entre as camadas do projeto.

Veja o Exemplo da Classe Fachada!

package Camadas;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
import Classes.Agenda;
import Classes.Cliente;
import Classes.Funcionario;
import Classes.Produto;
import Classes.Servico;
import Classes.Venda;
import java.util.ArrayList;

/**
 *
 * @author GOVEIA
 */
public class Fachada implements
     
        InterfaceAgenda,
        IntefaceCliente,
        InterfaceFuncionario,
        InterfaceProduto,
        InterfaceServico,
        InterfaceVenda{

    private NegocioCliente negocioCliente;
    private NegocioFuncionario negocioFuncionario;
    private NegocioProduto negocioProduto;
    private NegocioServico negocioServico;
    private NegocioAgenda negocioAgenda;
    private NegocioVenda negocioVenda;
         
    private static Fachada instancia;

    public static Fachada obterInstancia() {
     
        if (instancia == null) {
            instancia = new Fachada();
        }
        return instancia;
    }

    private Fachada() {

        this.negocioCliente = new NegocioCliente();
        this.negocioFuncionario = new NegocioFuncionario();
        this.negocioProduto = new NegocioProduto();
        this.negocioServico = new NegocioServico();
        this.negocioAgenda = new NegocioAgenda();
        this.negocioVenda = new NegocioVenda();

    }

    // Fachada Cliente
    @Override
    public void cadastrar(Cliente cliente) throws Exception {
        this.negocioCliente.cadastrar(cliente);

    }

    @Override
    public void remover(Cliente cliente) throws Exception {
        this.negocioCliente.remover(cliente);
    }

    @Override
    public void alterar(Cliente cliente) throws Exception {
        this.negocioCliente.alterar(cliente);
    }

    @Override
    public ArrayList listarCliente() throws Exception {
        return this.negocioCliente.listarCliente();

    }

   @Override
    public ArrayList consultar(Cliente cliente) throws Exception {
        return this.negocioCliente.consultar(cliente);
 
    }

 
    // Fachada Funcionario
 

    @Override
    public void cadastrar(Funcionario funcionario) throws Exception {
        this.negocioFuncionario.cadastrar(funcionario);
    }

    @Override
    public void remover(Funcionario funcionario) throws Exception {
        this.negocioFuncionario.remover(funcionario);
    }

    @Override
    public void alterar(Funcionario funcionario) throws Exception {
        this.negocioFuncionario.alterar(funcionario);
    }

    @Override
    public ArrayList listarFuncionario() throws Exception {
        return this.negocioFuncionario.listarFuncionario();
    }

    @Override
    public ArrayList consultar(Funcionario funcionario) throws Exception {
        return negocioFuncionario.consultar(funcionario);
    }

 
 
 
 
    @Override
    public void cadastrar(Agenda agenda) throws Exception {
       this.negocioAgenda.cadastrar(agenda);
    }

    @Override
    public void remover(Agenda agenda) throws Exception {
       this.negocioAgenda.remover(agenda);
    }

    @Override
    public void alterar(Agenda agenda) throws Exception {
        this.negocioAgenda.alterar(agenda);
    }

    @Override
    public ArrayList listarAgenda() throws Exception {
       return  this.negocioAgenda.listarAgenda();
    }

    @Override
    public ArrayList consultar(Agenda agenda) throws Exception {
       return   this.negocioAgenda.consultar(agenda);
    }

 
 
 
 
    @Override
    public void cadastrar(Produto produto) throws Exception {
      this.negocioProduto.cadastrar(produto);
    }

    @Override
    public void remover(Produto produto) throws Exception {
        this.negocioProduto.remover(produto);
    }

    @Override
    public void alterar(Produto produto) throws Exception {
        this.negocioProduto.remover(produto);
    }

    @Override
    public ArrayList listarProduto() throws Exception {
        return  this.negocioProduto.listarProduto();
    }


   
     @Override
    public void cadastrar(Servico servico) throws Exception {
       this.negocioServico.cadastrar(servico);
    }

    @Override
    public void remover(Servico servico) throws Exception {
        this.negocioServico.remover(servico);
    }

    @Override
    public void alterar(Servico servico) throws Exception {
       this.negocioServico.alterar(servico);
    }

    @Override
    public ArrayList listaServico() throws Exception {
       return  this.negocioServico.listaServico();
    }

   
     @Override
    public void lancarVenda(Venda venda) throws Exception {
       this.negocioVenda.lancarVenda(venda);
    }

    @Override
    public void remover(Venda venda) throws Exception {
       this.negocioVenda.remover(venda);
    }
 
    @Override
    public ArrayList HistorioVendas() throws Exception {
        return this.negocioVenda.HistorioVendas();
    }

    @Override
    public ArrayList consultar(Venda venda) throws Exception {
        return  this.negocioVenda.consultar(venda);
    }

    @Override
    public ArrayList consultar(Produto produto) throws Exception {
        return this.negocioProduto.consultar(produto);
    }

    @Override
    public ArrayList consultar(Servico servico) throws Exception {
       return  this.negocioServico.consultar(servico);
    }

 
 }
 
 
 



 
 
 
 

Conexão ODBC SQL Sever 2008

package ConexaoPostgres;

import java.sql.*;
import javax.swing.JOptionPane;

public class ConexaoOdbc {

    private Connection conexao;
    public Statement stmt;

     
    // conexao ao SQL Server 2008
   
    public Statement conexao() throws Exception{
        try {
            /* Tenta se conectar ao Driver */
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
         
            String nomeOdbc = "petshop";
            conexao  = DriverManager.getConnection("jdbc:odbc:"+nomeOdbc);// PostgreSQl35W
           
            stmt = conexao.createStatement();
         
        } catch (ClassNotFoundException e) {//capturando os erros da conexão
            JOptionPane.showMessageDialog(null, "Erro conectar ao banco de dados: " + e.getMessage());
        } catch (SQLException sqle) {
            JOptionPane.showMessageDialog(null, "Erro conectar ao banco de dados: " + sqle.getMessage());
        }
        return stmt;
    }

    public void desconectar() {
        try {
            conexao.close();
        } catch (SQLException sqle) {
        }
    }
}

Conexao JDBC Java

Ola, Povos e Povas! :)
       
         Para abrir uma conexão com um banco de dados, precisamos utilizar sempre um driver. A classe DriverManager é a responsável por se comunicar com todos os drivers que você deixou disponível.

         Para isso, invocamos o método estático getConnection com uma String que indica a qual banco desejamos nos conectar.

     Essas Strings - chamada de String de conexão JDBC - que utilizaremos para acessar o postgresql tem sempre a seguinte forma:


            // local
            String local = "localhost";
           
            //banco de dados a ser utilizado
            String banco = "PetShow";
            String usuario = "postgres";
            String senha = "edsongouveia";

// Passando as String de endereço da conexão! 
  this.conn = DriverManager.getConnection("jdbc:postgresql://"
                    + local + "/" + banco
                    + "?charSet=LATIN1", usuario, senha);
 

        Seguindo o exemplo da linha acima e tudo que foi dito até agora, seria possível rodar o exemplo abaixo e receber uma conexão para um banco postgresql, caso ele esteja rodando na mesma máquina:



package ConexaoPostgres;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author Edson Gouveia
 */
public class Conexao {



    private Connection conn;

    public Statement conexao() {
        Statement stmt = null;
        try {
            //classe referente ao banco de dados postgresql
            Class.forName("org.postgresql.Driver");
            //local do banco, neste caso o banco se encontra localmente
            String local = "localhost";
            //banco de dados a ser utilizado
            String banco = "PetShow";
            String usuario = "postgres";
            String senha = "edsongouveia";

            this.conn = DriverManager.getConnection("jdbc:postgresql://"
                    + local + "/" + banco
                    + "?charSet=LATIN1", usuario, senha);
            //codigo para execução de uma instrução sql
            stmt = this.conn.createStatement();
            //JOptionPane.showMessageDialog(null, "conectado");
        } catch (ClassNotFoundException e) {
            System.out.println("ClassNotFound: " + e.getMessage() + "...");
        } catch (SQLException e) {
            System.out.println("Open Exception: " + e.getMessage() + "...");
        }
        return stmt;
    }

    public void desconectar() {
        try {
            this.conn.close();
        } catch (SQLException ex) {
            System.out.println(ex.getMessage());
        }
    }
}


       Statement vai preparar um DML (que você passa como String) e mandar para o banco através do Connection, quando o banco processa o pedido, recebe o retorno.

       O ultimo método (desconectar) para fechar a conexão, dentro dele chamamos o método close(); ele é importantíssimo ser chamado dentro de um método apos abrir a conexão.


Espero ter Ajudado!
Que Deus abençoe todos vocês.