Orienta��o a objetos e PDO no PHP

A orientaç�o a objetos (OO) � um padr�o de programaç�o em que um software n�o � composto por um grande bloco de c�digos espec�ficos, e sim de v�rios blocos de c�digos distantes e independentes, que juntos montam um sistema. O PHP faz parte de um grupo de linguagens que possuem suporte a OO, mas n�o � preso a ela.

Esse padr�o n�o possui um objetivo �nico e tem como objetivo:

Reutilizaç�o de c�digo (tempo economizado);
Escalabilidade (c�digo adicionado mais facilmente);
Manutenibilidade (manutenç�o mais f�cil);
Desenvolvimento mais r�pido.

A POO possui alguns conceitos fundamentais para seu desenvolvimento:

Abstraç�o: s�o tipos abstratos de dados;
Objetos: um objeto � uma entidade do mundo real, concreta ou abstrata, que seja aplic�vel ao sistema;
Classes: uma classe � a representaç�o de v�rios objetos que possuem as mesmas caracter�sticas e comportamentos;
Atributos / Propriedades: s�o as caracter�sticas de um determinado objeto.

Classes e Objetos

Algo que confunde bastante novos estudantes de OO � a diferença entre Classes e Objetos.

As classes definem as caracter�sticas e o comportamento dos seus objetos. Cada caracter�stica � representada por um atributo e cada comportamento � definido por um m�todo.

Ent�o uma classe n�o � um objeto e sim uma abstraç�o de sua estrutura, no qual podemos definir quantos objetos desejamos ter.

Para podermos entender melhor o funcionamento, vamos criar a nossa primeira classe e alguns objetos a partir dela, conforme a Listagem 1.


  <?php
    Class Conta {
    }
    $conta  = new Conta();
    $conta2 = new Conta();
    $conta3 = new Conta();
  ?>

Listagem 1. Nossa primeira Classe

Criamos uma classe vazia de uma conta junto com tr�s objetos que s�o dessa conta criada. Podemos dizer ent�o que os tr�s objetos s�o do tipo conta. E � dessa maneira que funciona todo objeto, seu tipo ser� sempre a classe a partir do qual ele � criado.

Atributos e M�todos

Uma classe � composta por atributos e m�todos, que juntos d�o funcionalidade a um objeto. Podemos ver na Listagem 2 uma classe composta por dois atributos e tr�s m�todos.


  <?php
   Class Conta {
     public $saldo = 500;
     public $titular;
   
     function sacar($valor){
   
     }
   
     function depositar($valor){
   
     }
   
     function verSaldo(){
   
     }
   }
                          
    $conta1 = new Conta();
    $conta1 ->depositar(500);
    $conta1->sacar(20);
   
    $conta2 = new Conta();
    $conta2->depositar(250);
    $conta2->verSaldo();
  ?>

Listagem 2. Atributos e M�todos

A classe Conta tem como atributos o saldo da conta e o titular. E como m�todos possui depositar(), sacar() e verSaldo().

Para acessarmos o m�todo depositar() do nosso objeto $conta1 precisamos utilizar uma seta(->). Seu nome � Operador de Acesso a Objetos e � atrav�s dessa seta que indicamos que estamos acessando um atributo ou m�todo de tal objeto.

Faremos agora uma codificaç�o mais completa em cima de nossa classe Conta, como mostra a Listagem 3.


  <?php
    Class Conta{
      public $saldo = 0;
      public $titular;
 
      function depositar($valor){
        $this->saldo += $valor;
      }
   
      function sacar($valor){
        if(($this->saldo > 0) && ($this->saldo >= $valor))
        {
          $this->saldo -= $valor;
        }else{
          echo "Saldo insuficiente";    
        }
      }
      
      function verSaldo(){
        echo "Saldo Atual:".$this->saldo. "<br>";
      }
    }
   
    $novaConta = new Conta();
    $novaConta->verSaldo();
    $novaConta->depositar(500);
    $novaConta->verSaldo();
    $novaConta->sacar(150);
    $novaConta->verSaldo();
  ?>

Listagem 3. Classe conta completa

Note que para acessarmos nossos atributos dentro dos m�todos utilizamos a vari�vel reservada $this. Se fosse preciso chamar algum m�todo da pr�pria classe dentro de um outro m�todo ter�amos de usar $this, que � usado para acessar atributos e m�todos da pr�pria classe e s� existe dentro deste escopo. No PHP ele � fundamental e obrigat�rio, j� em algumas outras linguagens de programaç�o $this � opcional.

Herança

Um dos conceitos fundamentais da OO � a herança de classes, pois permite que uma classe estenda outra e a classe filha vai herdar todos os atributos e m�todos da classe pai. Ela pode ent�o tanto possuir novos m�todos e atributos, quanto reescrever m�todos j� existentes, como mostra a Listagem 4.


  <?php
    class Conta{
      public $saldo = 0;
                          
      function depositar($valor) {
                                     
      }
                                     
      function sacar() {
                                     
      }
   }
   
      class ContaCorrente extends Conta {
        function transferir($contaDestino, $valor){
          $this->saldo -= $valor;
        }
      }         
     
   
    $novaConta = new ContaCorrente();
    $novaConta->transferir('xxx-xxx', 500);
    echo "Saldo:".$novaConta->saldo;                
  ?>

Listagem 4. Herança

Adicionamos um novo m�todo � classe ContaCorrente, onde nela h� uma refer�ncia ao atributo saldo da pr�pria classe ContaCorrente que acessamos usando $this. E ser� que esse atributo existe mesmo? Sim, graças a herança, a classe ContaCorrente herda da classe Conta todos os m�todos e atributos ali definidos. Sendo assim, o atributo saldo existe tanto em Conta quanto em ContaCorrente e em outras contas que n�s venhamos a estender a partir da nossa classe pai Conta. Para estendermos uma classe basta utilizar o termo extends e seguir a sintaxe apresentada em nosso exemplo.

� importante sabermos que o PHP n�o possui herança m�ltipla, ou seja, n�o � poss�vel que uma classe filha estenda de dois pais diferentes, ela s� pode possuir uma �nica classe pai.

Classes abstratas

Uma classe abstrata � uma classe que n�o pode ser instanciada como um objeto diretamente. Ela tem que ser estendida por alguma classe concreta, e quando um objeto desta classe for criado, ele herdar� m�todos e atributos da classe abstrata. Veja na Listagem 5.


  <?php
    abstract class Conta{
      public $saldo =0;
      public function sacar(){
      }
                                     
      public function depositar($valor){
      }
   
      class ContaPoupanca extends Conta{
        public function resgatar($valor) {
        }
      }
    }
   
    $conta1 = new ContaPoupanca();
    $conta1->depositar(500);
    $conta1->resgatar(250); 
  ?>

Listagem 5. Classe Abstrata

Note que a classe estendida faz uso dos m�todos declarados na classe abstrata, ou seja, em classes abstratas e concretas o conceito de herança � o mesmo.

Mas, para que serve uma classe abstrata? Vamos pensar no funcionamento de um banco, onde os clientes podem ter uma conta corrente e poupança: o funcionamento de uma conta segue um determinado padr�o, o que difere uma da outra s�o as aç�es (m�todos) que podemos executar.

M�todos abstratos

Podemos ter tamb�m m�todos abstratos em nossas classes, como mostra a Listagem 6.


  <?php
    abstract class Conta {

      public $saldo = 0;

      abstract function sacar();
      abstract function depositar($valor);
    }
   
    class ContaPoupanca extends Conta {
      
      public function sacar() {
      }

      public function depositar($valor) {
      }

      public function resgatar($valor){
      }
    }
   
    $conta1 = new ContaPoupanca();
    $conta1->depositar(500);
    $conta1->resgatar(250);
  ?>

Listagem 6. M�todos Abstratos

Todo m�todo abstrato precisa, obrigatoriamente, ser implementado na classe filha, ou seja, todas as contas, independentemente do tipo devem possuir as operaç�es b�sicas de saque, dep�sito, transfer�ncia e consulta. Por�m, contas de tipos diferentes podem tratar estas aç�es de formas diferentes. Por exemplo: um dep�sito em uma conta poupança gera um certo rendimento ao saldo aplicado - para este caso um m�todo abstrato � uma forma de garantir que este m�todo seja implementado na classe ContaPoupança e em todas as outras classes que estende�l�s.

Classes finais

Uma classe final � uma classe que n�o pode ser estendida por nenhuma outra classe, ou seja, a classe final n�o tem herdeiros, pois ela � a �ltima de sua hierarquia. Em nosso exemplo temos uma conta do tipo poupança que, pela regra de neg�cio de um banco, n�o possui uma derivaç�o, ou seja, n�o deve ser estendida. Para estes casos definimos a classe como final, ou seja, somente existir�o objetos da classe poupança e n�o filhos da mesma, pois o correto � que todas as contas estendam a nossa classe pai Conta e mais nenhuma outra, como mostra a Listagem 7.


  <?php
    final class ContaPoupanca {
     public function resgatar($valor){
   
     }
      public function verSaldo(){
   
      } 
    }
   
    $poupanca = new ContaPoupanca();
    $poupanca->resgatar(250);
  ?>

Listagem 7. Classes Finais

M�todos Finais

Tamb�m podemos ter m�todos finais que jamais podem ser reescritos nas classes filhas. Em nosso exemplo de ag�ncia banc�ria, podemos concluir que o m�todo sacar de uma Conta � padr�o para todas as Contas, independentemente de seu tipo. Quando temos uma situaç�o como esta podemos definir estes m�todos como final, impedindo assim que eles sejam reescritos e saiam do padr�o estabelecido na classe pai, como mostra a Listagem 8.


  <?php
    class Conta {
     public function depositar($valor){
   
      }
     final public function sacar($valor){ #m�todo final, n�o pode ser reescrito
   
      }
  }
   
  class ContaCorrente extends Conta{
    public function depositar(){
   
     }
  } 
  ?>

Listagem 8. M�todos Finais

Traits

Traits, a partir do PHP 5.4, nos proporcionam uma maneira simples e objetiva de reaproveitamento de c�digo, pois s�o como classes onde usamos a palavra reservada trait, ent�o escrevemos os m�todos que queremos. E para usarmos um trait em uma classe usamos a palavra USE, como mostra a Listagem 9.


<?php
  class Conta {
    public $saldo = 0;
    public function getSaldo() {
      echo "Saldo Atual: {$this->saldo}"; 
    }
  }
  trait Acoes {
    public function getSaldo(){
      echo "Saldo Disponivel: {$this->saldo}";
   
    }
    public function depositar($valor){
      $this->saldo += $valor;
    }         
    public function sacar($valor){
      if($this->saldo >= $valor){
        $this->saldo -= $valor;           
      }
    } 
  }
  class ContaCorrente extends Conta{
    use Acoes;
  } 
   
  $o = new ContaCorrente();
  $o->depositar(500);
  $o->sacar(200);
  $o->getSaldo();
              
  // Saldo Disponivel: 300
?>

Listagem 9. Uso de Traits

Note que o m�todo getSaldo() foi reescrito dentro do Trait, ou seja, sobrescrever� os m�todos da classe base (pai).

Podemos ainda usar m�ltiplos traits em nossas classes, como na Listagem 10.


<?php
  class Conta {
    public $saldo = 0;
    public function getSaldo(){
      echo "Saldo Atual: {$this->saldo}";
    }
  } 
   
  trait Acoes {
    public function depositar($valor){
      $this->saldo += $valor;
    }
    public function sacar($valor){
      if($this->saldo >= $valor){
        $this->saldo -= $valor;
      }
    }
  }
   
  trait consultaExtrato{
    public function getSaldo(){
      echo "Saldo Disponivel para saque:{$this->saldo}<br>";
    }
    public function gerarExtrato($periodo){
      echo "Gerando extrato per�odo $periodo aguarde...";
    }
  } 
   
  class ContaCorrente extends Conta{
    use Acoes, consultaExtrato;
  } 
   
  $o = new ContaCorrente();
  $o->depositar(500);
  $o->sacar(200);
  $o->getSaldo();
  $o->gerarExtrato('20/01/2013');
  ?>

Listagem 10. Uso de M�ltiplos Traits

Desta vez temos dois traits com nomes diferentes, e note que sobrescrevemos o m�todo getSaldo() novamente no trait consultaExtrato.

PHP Data Objects (PDO)

O PDO veio para solucionar a migraç�o de um banco de dados para outro, do MySQL para o PostgreSQL, por exemplo. O PDO � uma camada de abstraç�o de acesso a dados, onde os m�todos de manipulaç�o de dados s�o independentes do SGDB que voc� est� utilizando, ou seja, podemos usar as mesmas funç�es para executar queries e consultar dados.

O PDO veio no PHP 5.1 e d� suporte a v�rios sistemas gerenciadores de banco de dados, como MySQL, PostgreSQL, SQlite, Informix, Oracle, SQL Server, IBM e etc.

A conex�o com um banco de dados atrav�s do PDO se d� durante a criaç�o de um objeto da classe PDO, passando informaç�es de conex�o com o banco na forma de um DSN (Data Source Name), al�m das credencias de acesso, como mostra a Listagem 11.


  <?php
    // MySQL
    $db = new PDO("mysql:host=localhost;dbname=banco", "root", "senha");
                          
    // PostgreSQL
                          
    $db = new PDO("pgsql:host=localhost;dbname=banco", "root", "senha");
                          
    // SQLite
   
    $db = new PDO("sqlite:banco.sqlite");
  ?>

Listagem 11. Conex�o com PDO

Veja que criamos a $db que guarda um objeto da classe PDO e entre par�nteses passamos o host, nome do banco, usu�rio e senha. Uma vez que o objeto da classe PDO tenha sido instanciado, conectamos em nosso banco. Para desconectar, basta "matarmos" o objeto ou aguardar que ele seja morto automaticamente ao final de nosso script, como mostra a Listagem 12.


  <?php
    $db = new PDO("mysql:host=localhost;dbname=banco", "root", "");
    unset($db);
  ?>

Listagem 12. Encerrando conex�o

Veja que utilizamos o unset para encerrar a conex�o.

Executando comando

Depois de conectados temos a nossa disposiç�o uma s�rie de m�todos para lidar com o banco. Utilizando a linguagem SQL, vamos fazer o uso do m�todo exec, de acordo com o c�digo da Listagem 13.


  <?php  
  $db = new PDO("mysql:host=localhost;dbname=banco", "root", "");
   
  $db->exec("CREATE TABLE clientes(id INT AUTO_INCREMENT, 
     nome VARCHAR(255), email VARCHAR(255)) ");
  ?>

Listagem 13. Exec SQL

Veja que acessamos o m�todo exec atrav�s de nossa conex�o com o �->� e criamos uma tabela chamada clientes com os campos id, nome e email.

Fazendo consultas

Para fazer consultas usamos o m�todo query, que executa um comando SQL e traz para n�s linhas de um banco de dados. Veja um exemplo na Listagem 14.


  <?php
    $db = new PDO("mysql:host=localhost;dbname=banco", "root", "");
   
    $dados = $db->query("SELECT * FROM clientes");
  ?>

Listagem 14. Utilizando query

Veja que dentro da $dados � executada uma query que traz todos os dados da tabela clientes.

Podemos ainda acessar nossos dados atrav�s dos m�todos fetch e fetchAll.

O m�todo fetch retorna apenas um resultado para n�s, enquanto o fetchAll retornar� todos os resultados. Estes m�todos retornam tanto um array quando um objeto, dependendo dos par�metros especificados, como na Listagem 15.


  <?php
    $db = new PDO("mysql:host=localhost;dbname=banco", "root","");
    $dados = $db->query("SELECT * FROM clientes");
    $todos = $dados->fetchAll();
    $um = $dados->fetch();
   
    print_r($todos);
    print_r($um);
  ?>

Listagem 15. Retornando dados com fetch e fetchAll

Note que, por padr�o, os m�todos retornam �ndices associativos e num�ricos. Podemos fazer com que somente �ndices associativos sejam mostrados ou apenas num�ricos, como mostra o c�digo da Listagem 16.


  <?php
    $db = new PDO("mysql:host=localhost;dbname=banco", "root","");
    $dados = $db->query("SELECT * FROM clientes");
    $assoc = $dados->fetchAll(PDO::FETCH_ASSOC);
    $num = $dados->fetchAll(PDO::FETCH_NUM);
      print_r($assoc);
      print_r($num);
  ?>

Listagem 16. Retornando apenas um dos �ndices

Veja que na $assoc queremos que seja retornado resultados em �ndices associativos, enquanto na $num retorna apenas �ndices num�ricos.

Transaç�es

Transaç�es s�o uma sequ�ncia de operaç�es feitas em um sistema gerenciador de banco de dados. As transaç�es t�m o objetivo de proporcionar uma maneira de recuperar informaç�es a partir de um desastre. Uma transaç�o de banco de dados deve possuir atomicidade, consist�ncia, isolamento e durabilidade (ACID).

Imagine um sistema onde temos que inserir dados em tabelas de estoque, pedido, cliente e log�stica. O cliente pagou e tudo foi inserido aparentemente bem no sistema, mas n�o foi inserido o pedido de entrega na tabela de log�stica. Temos um problema agora, certo?!

As transaç�es evitam esse tipo de problema atrav�s do m�todo beginTransaction do PDO. Ap�s chamarmos o m�todo, todos os comandos feitos n�o ser�o automaticamente executados. O PDO esperar� pelo m�todo commit para efetivar os comandos no banco de dados, ou pelo comando rollback para anular os comandos e desfazer tudo que foi feito. Veja um exemplo na Listagem 17.


  <?php
    $db = new PDO("mysql:host=localhost;dbname=banco", "root", "");
    $db->beginTransaction();
   
    $db->exec("UPDATE pedidos SET compra = 5641");
    $db->exec("UPDATE clientes SET compra = 5641 ");
    $db->exec("INSERT INTO log�stica(compra) VALUES (5641)");
    // Caso tudo tenha dado certo
    $db->commit();
   
    // Caso n�o deu certo
    $db->rollback();

Listagem 17. Exemplo de transaç�o

Prepared Statements

Statements s�o comandos SQL pr�-constru�dos e garantem que nenhuma query que foi preparada sofra um ataque SQL injection, ou seja, um ataque baseado na manipulaç�o do c�digo SQL pela inserç�o de informaç�es em uma query.

Imagine a inserç�o de v�rios dados em uma tabela. As �nicas coisas que mudam s�o as informaç�es de cada registro, a tabela e as colunas n�o mudam. Um statement ent�o cria um INSERT onde vai inserir em tabela e colunas pr�-determinadas, j� que apenas as informaç�es mudar�o.

O PDO possui um m�todo chamado prepare que, ao utiliz�-lo, o comando n�o ser� executado, apenas preparado para ser executado depois. O m�todo prepare retorna um objeto da classe PDOStatement para que, quando utilizamos esse m�todo, precisamos criar placeholders que ser�o substitu�dos pelos valores que queremos que estejam naquela query.

Veja na Listagem 18 um exemplo


  <?php
    $db = new PDO("mysql:host=localhost;dbname=banco", "root", "");
   
    $statement = $db->prepare("INSERT INTO posts (titulo, conteudo) VALUES
     (?, ?)");

Listagem 18. Prepared Statements

Note que as interrogaç�es s�o nossos placeholders, que ser�o substitu�dos por vari�veis. Para executarmos as statements usamos o m�todo execute, passando como par�metro um array de vari�veis que substituir�o os placeholders, como mostra a Listagem 19.


  <?php
    $db = new PDO("mysql:host=localhost;dbname=banco", "root", "");
              
    $statement = $db->prepare("INSERT INTO posts (titulo, conteudo) VALUES
    (?, ?)");
              
    $statement->execute(array("Arroz", "Meu primeiro item!"));
    $statement->execute(array("Feij�o", "Meu segundo item!"));
    $statement->execute(array("Tomate", "Meu terceito item!"));

Listagem 19. Executando os placeholders

Note que temos apenas uma query, mas iremos executar tr�s vezes com tr�s valores diferentes. Estamos passando um array de informaç�es para o m�todo execute, que pegar� essas informaç�es e colocar� no lugar das interrogaç�es, ou seja, os placeholders.