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.

Validação no JavaScript

      //
        function validate() {   //nome
            if (document.getElementById("<%=txtNome.ClientID%>").value == "") {
                alert("Informe o nome.");
                document.getElementById("<%=txtNome.ClientID%>").focus();
                return false;
            }
            //Alfanumerico e espaço(' '),nao aceita numeros e nem caracteres especiais min 5 e max 45 caracteres.
            var ck_nome = /^[A-Za-z ]{5,45}$/;
            var tempNome = document.getElementById("<%=txtNome.ClientID%>").value;
            var matchNome = tempNome.match(ck_nome);
            if (matchNome == null) {
                alert("Nome inválido : Não informe números,  ");
                document.getElementById("<%=txtNome.ClientID %>").focus();
                return false;
            }
            //fONE
            if (document.getElementById("<%=txtEmail.ClientID %>").value == "") {
                alert("O FONE não pode estar vazio");
                document.getElementById("<%=txtEmail.ClientID %>").focus();
                return false;
            }
       
            alert("Formulário enviado com sucesso");
            return true;
        }
//

Teste de Conexão ASP.Net

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data.SqlClient;
using System.Data;

namespace AvaliacaoKT
{
    public class Dados
    {
        public string sql = "Data Source=EDVANIATEODORO;Initial Catalog=Banco;Integrated Security=True";

        public const string srtInsert = "INSERT INTO TBAGENDA Values (@NOME,@FONE)";



        public void gravar(string nome, string fone)
        {

            using (SqlConnection objConexao = new SqlConnection(sql))
            {
                using (SqlCommand objComando = new SqlCommand(srtInsert, objConexao))
                {
                    objComando.Parameters.AddWithValue("NOME", nome);
                    objComando.Parameters.AddWithValue("FONE", fone);
               


                    objConexao.Open();

                    objComando.ExecuteNonQuery();

                    objConexao.Close();






                }




            }

        }
    }
}
   

Get e Set PHP OO

 class Cliente {

private $nome;
private $endereco;
private $cpf;
private $fone;

public function setNome($nome){
$this->nome=nome;
    }
public function getNome (){
return $this->nome;
}
public function setEndereco ($endereco){
$this->endereco=endereco;
}
public function getEndereco (){
return $this->endereco;
}

public function setCpf ($cpf){
$this->cpf=cpf;
}
public function getCpf (){
return $this->cpf;
}

public function setFone ($fone){
$this->fone=fone;
}
public function getFone () {
return $this->cpf;}



}




?>

Conexão PHP OO

/*************************************************
Classe de conexão com banco de dados
@author   Edson Gouveia de Brito
@date    31/03/2012
*************************************************/

class Conexao{

private $host = "localhost";
private $user= "root";
private $pass = "root";
private $db = "sapsa";
private $message_error = "Erro ao efetuar conexão com o bando de dados, entre em contato com o administrador do sistema";

private $dbc;
private $dbs;


   /*
   Metodos que trazem o conteudo da variavel desejada
   @return   $xxx = conteudo da variavel solicitada
        */
   protected function getHost(){return $this->host;}
   protected function getUser(){return $this->user;}
   protected function getPass(){return $this->pass;}
   protected function getDB(){  return $this->db;}
   protected function getMsg(){ return $this->message_error;}



   /*
   Metodo construtor do banco de dados
        */
   public function database(){
   }
   
   
   
   /*
   Metodo que cria a conexao com o banco de dados configurado
   @return   $dbc = contem a conexao com o banco
   @version   1.0
        */  
   public function connectionDB(){
      // conecta ao bando de dados e guarda a conexão
      $this->dbc = mysql_connect($this->getHost(),$this->getUser(),$this->getPass());
     
      //seleciona a base para ser usada
        $dbs = mysql_select_db($this->db,$this->dbc);
     
        return ($dbc);
   }
   


   /*
     Retorna o id da ultima query executada
     @return   $id_insert = id da ultima inserção
     @version   1.0
   */
   public function retornaID(){
      $id_insert = mysql_insert_id();
      return ($id_insert);
   }

   
   
   /*
   Metodo que fecha a conexao com o bando de dados
   @version   1.0
        */
   public function closeDB(){
      mysql_close($this->dbc);
   }
   
   

   
}



?>

Teste envio de E-mail pelo PHP

mail("dinho_gouveia@hotmail.com","Assunto","Minha Mensagem");


?>

Classe de Conexão PHP

     $db = mysql_connect('localhost','root','');
     $dados = mysql_select_db('primeiraconexao',$db);

?>

Texto motivacional

    Como já dizia Charles Chaplin: " A vida é uma peça de teatro que não permite ensaios, por isso cante, chore, dance, ria e viva intensamente, antes que a cortina se feche e a peça termine sem aplausos."

  
    Muitas pessoas se arrasta-se pela Vida sem Decidir algo para si mesmos, e é Justamente por essa falta de decisão que elas fracassam, a falta de auto-confiança e a falta em dizer:


"Eu Vou consegui, Por que Eu sou Capaz", 

  

 " Só existem dois dias do ano em que nada pode ser feito. Um se chama ontem e o outro se chama amanhã, portanto hoje é o dia certo para amar, acreditar, fazer e principalmente viver." Dalai Lama.

E assim vários pensadores apontavam a mesma idéia, o principal senão o único segredo da vida, viver o hoje como se fosse o último dia.

   

     A única coisa que nos prende ao caminho do fracasso somos nós mesmos, devido ao nosso medo de dar o primeiro passo. O pensamento negativo que atrai o negativo, como no livro "The Secret" : "Sua mente tem um poder de fabricar e realizar. O que você pensa, você sente, o que você sente, você vibra, o que você vibra atrai para si. Somos seres vibracionais que integram o universo."

   

      O medo do fracasso também nos prende a darmos o primeiro passo, por isso as pessoas optam pelo caminho mais fácil, o caminho do comodismo. A zona de conforto não é o melhor passo a seguir, devemos arriscar, temos que lutar com toda a força por nossos objetivos. Você tem um objetivo?

   
     Eu tenho e ele pulsa efervecente dentro de mim, me levanta e me motiva a cada dia, sinto-o vivo dentro de mim e estou lutando com toda a força para alcançá-lo.

Você vai deixar seu medo derrubar seu objetivo?

  
   Por isso Viva o Presente, Planeje o amanha, Dane-se o Passado esse é o segredo, tenha grandes objetivos, enfrente seus medos e coloque Deus acima de tudo.




Letra de Pitty - Semana que Vem ! ! !

              

Qual o verdadeiro papel do Analista ?

  O perfil dele deve ser de desenvolvedor como o mercado hoje exige, ou deve ser alguém totalmente independente de tecnologia e focada apenas no entendimento das regras de negócio?

                               


         
Segundo Philip, o autor deste artigo, o analista deve ser focado nas regras de negócio.


       "O analista deve trabalhar em conjunto com os stakeholders para gerar uma visão única do projeto (já que possivelmente cada stakeholder que uma coisa diferente) e transformar isso em algo que possa ser executado (histórias). No meio do caminho eles ajudam a eliminar desperdício, introduzir idéias novas, validar os pedidos, conferir viabilidade e tudo mais que não faz parte do papel de um desenvolvedor e sim de alguém que, de fato, entenda do negócio do cliente."


       "Note que o papel do analista de negócios não elimina a necessidade de termos um cliente presente. Não existe mapeamento de requisitos ou coisas do tipo, além de usar seu expertise naquele domínio em específico, o analista de negócios age como facilitador e não como ponte entre cliente e desenvolvedores. Ele também não é um tradutor, os termos de negocio e os processos devem ser entendidos por todos os envolvidos."


         Particularmente, eu sou de acordo com a idéia que o analista deve sim ser expert em entender a regra de negócio, ou ainda, ter perfil de negociador, isto é, alguém que sabe como fazer o cliente expor as informações chaves e necessárias para solução do problema dele, e principalmente para convencer o cliente do que ele realmente necessita. Pois o que temos hoje são equipes que possuem desenvolvedores que não entendem do negócio e clientes que não sabem exatamente o que necessitam, resultando em sistemas que vão ao ar não contendo "exatamente o que o cliente necessita, seja por falha de comunicação ou porque ele mudou de idéia e “esqueceu” de avisar aos desenvolvedores".


       Para uma metodologia mais ágil de gerenciamento de projetos, essa visão de analista seria muito mais eficaz, uma vez que o analista seria o facilitador para que a equipe pudesse trabalhar de forma mais objetiva e específica, atuando no problema bem definido e não na "lista interminável de desejos do cliente" que só descobre não serem necessários no final, quando já se gastou muito tempo e esforço para o seu desenvolvimento.


       Portanto é preciso avaliar cada cenário e diagnosticar qual será a verdadeira função de um analista dentro de cada cenário.