No entanto, aqueles que acompanham o PHP a algum tempo, sabe o que os frameworks fizeram pela linguagem. “Padrão” de código só para começar, além de difundir técnicas de desenvolvimento mais modernas, além dos design patterns mais comuns: MVC, singleton e factory.

E por que você deve conhecer um framework? Porque o mercado exige. Simples assim. Recentemente procurei um desenvolvedor para um projeto freelancer, recebi inumeros curriculos, todos eles apontando um ou mais frameworks de PHP, com varíos níveis diferentes de domínio. O interessante disso foi ouvir comentários como: “Eu uso o Cake, porque é mais rápido, não precisa ficar criando varias classezinhas, ele já faz tudo” ou “Eu faço com Zend, pois já estou acostumado”. Todos os selecionados, sem exceção, não cogitaram a possibilidade de desenvolver o projeto sem um framework.

Claro que isso não exime você de conhecer profundamente a linguagem, e sua arquitetura, porém, o que o mercado tem aceito como um bom programador PHP é aquele que usa e domina um framework comercial.

Só para constar, eu prefiro minhas “classezinhas”.

E você o que acha desse tema?

$pdo = new PDO(
    ‘mysql:host=localhost;dbname=nomedobanco’,
    "user",
    "pass",
    array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8"));

O último parametro do construtor do PDO é um array com as opções específicas do driver, no caso, do driver od MySQL. Este parametro é alimentado no velho estilo "array" chave=>valor.

Observem que o parametro (PDO::MYSQL_ATTR_INIT_COMMAND) não se trata de uma configuração de charset, mas sim de um comando que é executado todas as vezes que você conecta no banco. Neste caso, todas as vezes que ele se conecta no banco, ele executa a query "SET NAMES utf8" (acho que é específica do MySQL) que diz para o MySQL utilizar UTF-8 como charset para nossa conexão.

Para saber mais:

• PDO e BEAN no PHP
• MySQL “Connection Character Sets and Collation” documentation
• PDO constructor documentation
• PDO MySQL driver documentation

Fonte:
http://www.laszlo.nu/post/34159352/how-to-use-utf-8-with-mysql-and-php-data-objects-pdo

Tags BlogBlogs: php, pdo, mysql, utf8, unicode

Não é novidade, mas vale o registro. O PHP 5, possui uma funcionalidade bem interessante, similar a outras linguagens orientadas a objeto, Exceção. Quando algo altera o fluxo de execução do sistema ele dispara uma Exceção. Uma exceção pode ser disparada ou capturada, depende do que você pretende. Você pode customizar um série de tratamentos de erros que irão facilitar o desenvolvimento do seu sistema, com essa custimização você pode saber exatamente o que está sendo tratado e se algo fugir desse controle é algo anormal e fica mais facil a rastreabilidade.

Dentro de uma exceção, você pode disparar um log, ou um alert, ou registrar algo no banco, é um fluxo de erro sob controle.

Eu costumo tratar as exceções para tudo, campo em branco, tipo de dado inválido, e-mail inválido, ou se alguma fórmula não foi validada. Para isso uso um conjunto de classes que constituem as mensagens e os testes para que as exceções sejam disparadas:

Uma classe Main para controlar as requisições de Exception:

MainException.php:

<?PHP
    /**
    * Declaração da classe para tratamento de erros
    * A classe deve ser extendida da classe Exception do PHP
    * Ela irá realizar a sobrescrita da classe Exception do PHP
    */
    class MainException extends Exception {
        //Faço a declaração das variávis que vou utilizar no corpo da classe
        private    $cod          = 0;
        private    $msg          = "";
        private    $erromsg      = "";

        /**
        * Aqui faço a declaração do método construtor de classe
        * Esse método recebe os seguintes parametros:
        * @param $cod – Código de erro
        * @param $msg – Uma mensagem de erro personalizada
        * @param $erromsg – Uma mensagem de erro padrão
        */

        public function __construct( $cod = 0 , $msg = "" , $erromsg = "" ) {
 
            //Sobreescrevo as propiedades da classe passando os parametros
            $this->cod = $cod;
            $this->msg = "Ocorreu um erro não identificado";
            $this->erromsg = $erromsg;
 
            //Aqui eu chamo o construtor da classe pai 
            parent::__construct( $this->msg , $this->cod );        
 
        }
 
 
        /**
        * Este método irá salvar nossos erros em um log
        */
        public function _Log() {

            //Define o arquivo que será criado ou gravado caso exista, o nome do arquivo irá ser o nome da classe
 
            $log = __CLASS__ . "_log_" . date("dmY") . "txt";
 
            //Se não existe arquivo, cria
            if( !file_exists($log)){
 
                $msg = "/************************************************** " .
                " * Arquivo de log " .
                " * " .
                " * ClassName: " . __CLASS__ . " " .
                " * Data Criação: " . date("d/m/Y H:i") . " " .
                " *************************************************/ " .
                "——————————————————————- ";
 
            }else
                $msg = "";
 
                //Abre o arquivo
                if($fp = fopen( $txt , "a+")) {
 
                //Arquivo
                $msg .=    __CLASS__ . " hora: ".date("H:i") . " " .
                "Erro [ {$this->cod} ]: linha ( {$this->line} ) " .
                "{$this->msg} " .
                "{$this->erromsg} " .
                "——————————————————————- ";
 
                //Grava
                fwrite($fp, $msg);
                fclose($fp);
            }
 
        }
 
    }
?>

A classe abaixo estende MainException e a customiza para Exceções de texto:

textException.php:

<?PHP
/**
 * Esta classe é responsável por disparar exceções relacionadas a texto
 */
 class textException extends MainException {
 
      public function __construct(  ) {
          //Sobrescrita do construtor de MainException, com os valores que queremos
          parent::__construct( 1, "Tipo de caracter inválido", PHPSELF);
         
          $this->_Log();
                       
      }
          
 }
?>

A classe abaixo faz a verificação do texto e dispara a exceção:

verificaTexto.php:

<?PHP
 
class verificaTexto
{
    public function __construct($texto)
    {
        if(!is_int($texto))
        {
            echo $texto;
        }
        else
        {
            throw new textException();
        }
    }
 
}
 
?>

A classe abaixo faz o teste para números e caso falhe, dispara MainException, ou seja sem customizar o tipo de exceção que será disparada, então irá enviar a mensagem padrão:

verificaValor.php:

<?PHP
 
class verificaValor
{
    public function __construct($val)
    {
        if($val == 1)
        {
            echo $val;
        }
        else
        {
            throw new MainException();
        }
    }
 
}
 
?>

Apenas para teste:

<?PHP
 
include ("autoload.php");
 
try
{
 
    //$b = new verificaTexto(1);
    $b1 = new verificaValor(1123);
 
}
Catch(textException $te)
{
    echo $te->getMessage();
}
catch(Exception $e)
{
    echo $e->getMessage();
}
 
 
?>

E o autoload se alguém quiser:

<?PHP
 
function __autoload($class_name) {
    require_once $class_name . ‘.php’;
}
 
?>

Como podem ver, a classe MainException é que faz todo o trabalho, nela temos o método principal que realiza o disparo das exceptions, em textException, sobrespcrevemos a classe MainException e fazemos ela se comportar como queremos para disparar apenas uma mensagem de erro para textos.

Ainda existe a possibilidade de disparar uma Exception genérica, caso nosso tratamento não seja para textos. Se observarem com calma verão que se trata apenas de sobrescritas de métodos algo que seria perfeitamente possível sem Exception, porém desta forma temos mais controle (fora a elegancia do código).

Bom é isso, qualquer dúvida comentem.

Para saber mais:

• Exceptions no manual: http://www.php.net/manual/en/language.exceptions.php
• Classe MainException original de José Roberto Gomes da Silva: http://www.plugmasters.com.br/sys/materias/914/1/Exception-com-php

Tags BlogBlogs: php, exception, oo

Diferente do ano passado, o evento será realizado em São Paulo (ainda bem, porque Osasco é longe demais) na faculdade FIAP que fica na Av. Lins de Vasconcelos, 1264, bairro Aclimação, nos dias 18 e 19 de outubro. Os valores vão (iam) de R$ 30,00 à R$ 100,00 se você deixar para o último dia.

Mais uma vez, como no ano passado, a programação das palestras ainda não foi divulgada (pelo menos não até a data deste post), e quem esteve esperando para ver se valia a pena ir ao evento pelo conteúdo, não poderá mais aproveitar o preço de abertura, ou seja, os organizadores apostam que todos dêem um tiro no escuro para se inscrever em um evento que não se sabe a programção… well wathever…

As palestras internacionais já estão definidas, teremos Andrei Zmievski, que falará sobre o Unicode do PHP6 (exatamente a mesma coisa que o Lucas Smith veio falar ano passado) e o meu bom amigo Cesar Rodas que irá falar sobre seu projeto  no GSoC2008 para o worpress.

Não alimento grande expectativa para esse evento… mas vamos aguardar, talvez a organização venha com alguma surpresa
 

Tags BlogBlogs: php, conaphp, php conference, conisli

Hoje, chega ao fim a versão 4 do PHP, foram 4 longos anos desde o lançamento da versão 5 e agora encerrada oficialmente.

Para aqueles que veem isso com um certo temor, não se preocupem, o PHP5 não é um bicho de 7 cabeças e as melhorias implementadas nele não serão dificil de serem absorvidas pelos novatos… a diferença estará apenas na orientação a objetos.

Tags BlogBlogs: php

Criar Webservices no PHP é uma tarefa realtivamente simples, a grande dificuldade esta em gerar WSDL´s. Isso acontece porque apesar do PHP5 trazer grandes funcionalidades nesse campo, ele não gera o WSDL. Para ajudar, criar WSDL´s é extremamente complexo, com todas as suas variações e opções.

Quando disposnibilizamos um webservice para a plataforma PHP é facil e muito rápido de ser feito, apenas algumas linhas de código para o server e para o client são suficientes para realizar a transação.

Exemplo1:

server.php:

<?php

 
      /*
       * Função utilizada para autenticar o usuário na rede.
      */
    function Auth($login, $senha){
   
      if(trim($login) == NULL){
          return 0;
      }
   
      $dbconn = pg_connect("host=10.0.0.1 port=5432 dbname=database user=master password=master");
      $query = "select count(*) from usuarios where login=’".$login."’ and pass=’".$senha."’";
   
      $result =  pg_query($dbconn, $query);
   
      return $row[0]; // retorna 1 se validar, retorna 0 se não validar
   
   
    } 
 
  $server = new SoapServer(null, array(’uri’ => ‘http://auth.localhost.com.br/ws_auth/’)); // cria o ambiente para servir o webservice

  $server->addFunction("Auth"); // adiciona a função de autenticação ao escopo

  $server->handle();

 
?>
 

cliente.php:

<?php

    /**
     * Cria uma instancia do webservice
     */

    $client = new SoapClient(null,array(
    ‘location’ => ‘http://auth.localhost.com.br/ws_auth/server.php’,
    ‘uri’ => ‘http://auth.localhost.com.br/ws_auth/’,
    ‘trace’ => 1));

    /**
     * Para charmar a autenticação deve-se passar o login e a senha que ser quer validar como segue
     *
     * $result = $client->Auth(’login’,’senha’);
     *
     */
   
       $result = $client->Auth(’usuario’,’senha’);
    
      
       /**
        * resultado da autenticação
     *
     */
    print_r($result);
 
?>
 

E pronto, muito simples não? O problema é que esse tipo de webservice não é processado por outras plataformas por não gerar WSDL. Plataformas como .NET, JAVA e RUBY precisa de um WSDL para seguir o modelo do objeto que será gerado. Para resolver isso, você pode criar um WSDL seguindo as especificações do W3C (http://www.w3.org/TR/wsdl) ou usar alguma classe de terceiro.

Temos:

• NuSOAP (http://sourceforge.net/projects/nusoap/)
• PEAR::SOAP
• Ctrx_SOAP_AutoDiscover ( http://crtx.org/index.php?area=Main&page=CrtxSoapAutoDiscover)
• Webservice Helper tool (http://www.jool.nl/new/index.php?file_id=1)
• WSDL_Gen (http://www.schlossnagle.org/~george/php/WSDL_Gen.tgz)

Eu já trabalhei com NuSOAP mas deixei de lado, pois ela possui um nome que entra em conflito com uma função nativa do PHP, e para evitar dores de cabeça na distribuição eu resolvi optar por outra classe. Eu escolhi a Webservice Helper tool, por sua facilidade de uso. Todas as classes acima são utilizadas em ambiente de produção, basta escolher a que se adeque melhor ao seu uso.

A Webservice Helper tool consegue criar WSDL com PHP de uma maneira muito fácil e direta. Basicamente se escreve uma classe, adiciona essa classe ao escopo e pronto, o WSDL está pronto para usar, não vou por um exemplo completo aqui para não ficar com o post muito longo, caso tenha alguma dúvida me mande um e-mail. A classe é bem explicada e possui um exemplo muito bom. Você pode baixa-la aqui.

Tags BlogBlogs: php, wsdl no php, wsdl, webservice, webservice com php

"Programming is about expressing complex ideas in the simplest way possible. It’s important to eliminate all unnecessary clutter, polishing and honing until code is as clear as possible." – Noel Darlow (http://michaelkimsal.com/blog/php-groovy-and-language-evolution/)

De acordo.

Alterar o php.ini :

session.cookie_domain = .meudominio.com.br

Porém isso nem sempre é possível, para tanto podemos setar a configuração direto dentro do nosso php:

Antes do session_start() e antes de qualquer cookie:

ini_set(”session.cookie_domain”, “.meudominio.com.br”);

Pronto, bem simples.

Implementa cache de query em nível de código (o mesmo que o bind do oracle) e permite uma flexibilidade na manipulação dos resultados tanto como arrays ou objetos.

Por se tratar de uma feature relativamente nova, ela não esta completamente finalizada pelo time do PHP e algumas funções estão disponíveis apenas no cvs.

Um pequeno exemplo de como utilizar o PDO:

1
2
3
4
5
6
7
8

prepare("select contenttype, imagedata from images where id=?");
  $stmt->execute(array($_GET['id']));
  $stmt->bindColumn(1, $type, PDO::PARAM_STR, 256);
  $stmt->bindColumn(2, $lob, PDO::PARAM_LOB);
  $stmt->fetch(PDO::FETCH_BOUND);
 
  header("Content-Type: $type");
?>

Eu tenho utilizado PDO com grande sucesso em meus projetos e cada vez mais me acostumo a utiliza-la no lugar de ADODB/MDB2, tenho trabalhado 100% orientado a objetos no padrão BEAN igual ao do java (gosto de manter os dados protegidos dentro do meu código).

Abaixo um pequeno exemplo de como utilizao PDO em meus projetos. O código está comentado, porém se surgirem dúvidas me mande um e-mail ou comente abaixo que eu dou uma força.

Conexao.php:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

persistencia = true; }
  }
 
  public function getConnection(){
    try{
      $this->con = new PDO(
          $this->dbType.":host=".$this->host.";
          dbname=".$this->db,$this->user,
          $this->pass,
          array(PDO::ATTR_PERSISTENT=> $this->persistencia)
          );
 
      /*ESTA PROPRIEDADE INDICA COMO O PDO VAI RETORNAR OS
        ERROS SQL NO MODO PDO::ERRMODE_WARNING O RETORNO DO
        ERRO É IGUAL AO QUE VEMOS SEM A UTILIZAÇÃO DO PDO*/
    $this->con->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING);
      return $this->con;
    }catch(PDOException $ex){
      echo "ERRO:".$ex->getMessage();
    }
  }
 
  public function Close(){
    if($this->con != NULL){
      $this->con = NULL;
    }
  }
}
?>

cliente.php:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

id_cliente = $id_cliente;
  }
 
  public function getIdCliente(){
    return $this->id_cliente;
  }
 
  public function setEmail($email){
    $this->email = $email;
  }
 
  public function getEmail(){
    return $this->email;
  }
 
  public function setTelefone($telefone){
    $this->telefone = $telefone;
  }
 
  public function getTelefone(){
    return $this->telefone;
  }
}
?>

clienteModel.php:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

con = Conexao::getConnection();
  }  
 
  public function Insert($cliente){
    $query = "insert into cliente (id_cliente, nome, email, telefone)
	          values (:id_cliente,:nome,:email,:telefone)";
    try{
      $stmt = $this->con->prepare($query);
      $stmt->bindValue(':id_cliente',$cliente->getIdCliente());
      $stmt->bindValue(':nome',$cliente->getNome());
      $stmt->bindValue(':email',$cliente->getEmail());
      $stmt->bindValue(':telefone',$cliente->getTelefone());
      return $stmt->execute();
    }catch(PDOException $ex){
      echo $ex->getMessage();
    }
  }
 
  public function Update($cliente){
    $query = "update users set nome=:nome, email=:email,
	          telefone=:telefone where id_cliente=:id_cliente";
    try{
      $stmt = $this->con->prepare($query);
      $stmt->bindValue(':nome',$user->getNome());
      $stmt->bindValue(':email',$user->getEmail());
      $stmt->bindValue(':telefone',$user->getTelefone());
      $stmt->bindValue(':id_cliente',$user->getIdCliente());
      $stmt->execute();
    }catch(PDOException $ex){
      echo $ex->getMessage();
    }
  }
 
  public function Select($query = NULL){
 
    if(trim($query) == NULL){
      $query = "select * from clientes";
      try{
        $stmt = $this->con->prepare($query);
        $stmt->execute();
 
        /*
          ESSE AQUI É O PULO DO GATO: fetchObject(nome_da_classe)
          COM fetchObject COLOCAMOS O RETORNO DO BANCO DE DADOS EM
		  UMA CLASSE COM O NOME ESPECIFICADO NO PARAMETRO
          NO ARQUIVO EM QUE UTILIZAMOS A CONSULTA, TEMOS UM INCLUDE
		  DO ARQUIVO cliente.php QUE POSSUI A DEFINIÇÃO
          DA CLASSE cliente. LOGO, QUANDO A QUERY FOR EXECUTADA,
		  TEREMOS COMO RETORNO UMA CLASSE cliente COM TODOS OS
          ATRIBUTOS PREENCHIDOS PODENDO UTILIZAR OS SET´S E GET´S AUTOMATICAMENTE.
        */
 
        $stmt->fetchObject('cliente');
 
      }catch(PDOException $ex){
        echo $ex->getMessage();
      }
    }else{
      try{
        $stmt = $this->con->prepare($query);
        $stmt->setFetchMode(PDO::FETCH_CLASS, 'cliente');
        $stmt->execute();
 
        /*
          AQUI TEMOS UMA IMPLEMENTAÇÃO DIFERENTE, NÃO TEMOS COMO GARANTIR QUE
		  A QUERY PASSADA RETORNARÁ EXATAMENTE OS ATRIBUTOS DA CLASSE cliente,
		  PORTANTO, SETAMOS O RETORNO PARA A CLASSE cliente, SE O RESULTADO
		  PREENCHER OS ATRIBUTOS, TEREMOS UMA CLASSE cliente COM OS
		  ATRIBUTOS PREENCHIDOS E PODENDO SER MANIPULADA PELOS GET´S E SET´S
		  CASO NÃO, ELE RETORNA UMA CLASSE ONDE OS DADOS PODEM SER
		  ACESSADOS COMO ATRIBUTOS.
        */
 
      return $users = $stmt->fetch(PDO::FETCH_CLASS);  
 
      }catch(PDOException $ex){
        echo $ex->getMessage();
      }
    }
  }
}
?>

operacao.php:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

clienteValid();
 
  //CONSULTA
 
  $query = "select * from cliente where id_cliente=".$_REQUEST['cliente'];
  $cliente = $clienteModel->Select($query);
 
  echo $cliente->getNome();
  echo $cliente->getEmail();
 
  //ATUALIZAÇÃO
 
  $cliente->setIdCliente($cliente->getIdCliente());
  $cliente->setNome($cliente->getNome());
  $cliente->setEmail($cliente->getEmail());
  $cliente->setTelefone($_REQUEST['telefone']);
 
  $clienteModel->Update($cliente);
 
  //INSERT
 
  $cliente->setNome($_REQUEST['nome']);
  $cliente->setEmail($_REQUEST['email']);
  $cliente->setTelefone($_REQUEST['telefone']);
 
  $clienteModel->Insert($cliente);
?>

Este código é bem simples, mas é o que tenho utilizado, ele vêm evoluindo com o tmepo, e para minhas necessidades é bem eficiente. O PDO2 está por vir e promente melhorar muito toda essa interface e suporte a outra bancos.

Algumas referências que me ajudaram a entender a utilização do PDO:

• http://www.htmlstaff.org/ver.php?id=8117
• http://www.htmlstaff.org/ver.php?id=9527
• http://php.net/pdo

Qualquer sugestão me mande, ainda estou aprendendo a trabalhar com PDO.

Edit

Conforme as observações do Dimas Gomez, acertei o código exibido e aproveito para disponibilizar os fontes aqui.

Quanto ao erro “could not find driver” você pode deve habilitar o driver para seu banco de dados em seu php.ini. Como fazer isso está bem descrito no manual do php em http://php.net/pdo.

Tags BlogBlogs: php, pdo, php5, oo