PHP e MySQL :: CRUD – Create, Read, Update, Delete

CRUD EM PHP UTILIZANDO DAO.

Nível Intermediário.

Neste artigo vamos criar umas classes que irão trabalhar com as quatro operações de Banco, utilizando um padrão comum. Em geral procura-se utilizar uma camada intermediária entre código que se refere à estrutura de negócio e o banco de dados. Caso esteja procurando um Design Pattern não deixe de conferir meu artigo sobre Table Data Gateway.

Antes de prosseguir, se o que você espera, seja um artigo de nível básico, sem criação de classes e também não necessita neste momento de nenhum exemplo com orientação a objetos, talvez o que você esteja procurando está neste outro artigo bem abrangente e de forma simples do CRUD em PHP: PHP:: PDO – CRUD COMPLETO

Conforme a Wikipedia:
CRUD (acrônimo de Create, Read, Update e Delete na língua Inglesa) para as quatro operações básicas utilizadas em bases de dados relacionais (RDBMS) ou em interface para utilizadores para criação, consulta, atualização e destruição de dados.

Hoje, sabemos muito bem que os bancos de dados são utilizados para armazenar diversos tipos de informações pelo mundo todo e de fato, não conseguimos imaginar nenhum sistema de informação sem eles.

Hoje em dia cada vez mais se tem procurado desenvolver padrões de projetos de forma eficaz, onde não apenas o desenvolvimento seja prático, mas também a sua manutenção. Além disso, como regras de negócios tem se tornado cada vez mais complexas, se faz necessário desenvolver métodos onde seja possível abstrair ao máximo em camadas as lógicas, cada parte de um projeto, as que se referem às regras de negócios e as partes mecânicas da aplicação, sendo mais específica a persistência de dados e visualização das informações geradas com os dados.

Enfim, CRUD em padrões de projetos tais como o MVC, tem sido utilizado para criar uma camada de abstração que interage com a parte lógica de controle do Sistema que contém as regras de negócio e os sistemas de bancos de dados. Utilizando Orientação a Objetos, costuma-se utilizar o CRUD dentro de objetos DAO gerados por classes DAO (Data Access Object) para criar a “interface” entre a parte de Controle e os dados persistentes no sistema de banco de Dados. Inclusive a parte de persistência de dados, no MVC faz parte da camada Modelo.
Neste post, vamos ver como funciona um CRUD utilizado a classe PDO. Esta classe provê uma interface padrão de comunicação entre o PHP e os sistemas de bancos de dados.

Vamos criar um aplicativo de cadastro de contatos bem simples , visando apresentar as quatro operações concentradas na ideia CRUD.

Primeiramente vamos criar o banco de dados simples para persistência dos dados de contatos:

CREATE DATABASE exemplocrud;

CREATE TABLE contatos (
   ID INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
   NOME VARCHAR(45) NOT NULL,
   EMAIL VARCHAR(45) NOT NULL,
   TELEFONE VARCHAR(15)
);

Agora vamos criar a classe que gera objetos para manipulação de contatos. O objeto deverá refletir um no formato da tabela para que a nossa futura classe DAO que atuará como CRUD, possa traduzir os objetos para dados persistentes e vice-versa.

1. class Contato {

2.     private $id = null;

3.     private $nome;

4.     private $email;

5.     private $telefone;

7.     public function __construct($nome, $emal, $telefone) {

8.        $this->nome = $nome;

9.        $this->emal = $email;

10.        $this->telefone = $telefone;

11.     }

13.     public function getId() {

14.        return $this->id;

15.     }

17.     public function getNome() {

18.        return $this->nome;

19.     }

21.     public function getEmal() {

22.        return $this->emal;

23.     }

25.     public function getTelefone() {

26.        return $this->telefone;

27.     }

29.     public function setId($id) {

30.        $this->id = $id;

31.     }

33.     public function setNome($nome) {

34.        $this->nome = $nome;

35.     }

37.     public function setEmal($emal) {

38.        $this->email = $email;

39.     }

41.     public function setTelefone($telefone) {

42.        $this->telefone = $telefone;

43.     }

44. }

Agora vamos criar uma classe que gera uma conexão com banco de dados. Esta classe não precisa construir objetos e seguindo o padrão Singleton, só pode ser instanciada de dentro para fora. Por isso você nota que o método construtor, de clonagem e o de serializar, possuem uma restrição máxima “private” impedindo seu acesso. Além disso, como único meio de acesso público a classe, usará um método estático getInstancia(). Este método se encarrega de verificar se já existe uma instância de conexão ativa e se houver, apenas retorna esta instância. Caso contrário instancia um novo objeto de conexão PDO e retorna este. Faz sentido usar este método de conexão que sempre certificará se já existe uma instância de conexão ativa com o banco de dados e talvez você já esteja imaginando porque. Em geral, não precisamos de uma nova conexão com o banco de dados a cada operação realizada com o banco. Assim, este projeto Singleton, visa resolver este tipo de problema, quando só precisamos de uma única instância de um determinado objeto durante a execução da aplicação.

1. /**

2. * Description of PdoConexao – Singleton pattern

3. *

4. * @author Alexandre Bezerra Barbosa

5. */

7. class PdoConexao {

8.     private static $instancia;

9.    

10.     // Impedir instanciação

11.     private function __construct() { }

13.     // Impedir clonar

14.     private function __clone() { }

15.    

16.     //Impedir utilização do Unserialize

17.     private function __wakeup() { }

18.    

19.     /**

20.     *

21.     * @return object PDO connection

22.     *

23.     */

25.     public static function getInstancia() {

26.         if(!isset(self::$instancia)) {

27.              try {

28.                  $dsn = “mysql:host=localhost;dbname=exemplocrud”;

29.                  $usuario = “root”;

30.                  $senha = “”; // Preencha aqui com a senha do seu servidor de banco de dados.

31.                  

32.                  // Instânciado um novo objeto PDO informando o DSN e parâmetros de Array

33.                  self::$instancia = new PDO( $dsn, $usuario, $senha );

34.                  

35.                  // Gerando um excessão do tipo PDOException com o código de erro

36.                  self::$instancia->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );

37.              

38.              } catch ( PDOException $excecao ){

39.                  echo $excecao->getMessage();

40.                  // Encerra aplicativo

41.                  exit();

42.              }

43.          }

44.          return self::$instancia;

45.         }

46.    }

Já vimos que com essa classe é possível instanciar um objeto de conexão, mas ela em si não serve para nada se não houver a interface da aplicação com o banco de dados. Vamos criar então a classe DaoContatos que refletirá as quatro operações do banco e será o script que comunica a aplicação com o banco de dados.

Conforme a Wikipedia:
Objeto de acesso a dados (ou simplesmente DAO, acrônimo de Data Access Object), é um padrão para persistência de dados que permite separar regras de negócio das regras de acesso a banco de dados. Podemos até dizer que é uma camada intermediária entre código de estrutura de negócios e o banco de dados. Numa aplicação que utilize a arquitetura MVC, todas as funcionalidades de bancos de dados, tais como obter as conexões, mapear objetos Java para tipos de dados SQL ou executar comandos SQL, devem ser feitas por classes DAO.
(https://pt.wikipedia.org/wiki/Objeto_de_acesso_a_dados – Acesso em 11/01/2016)

Claro que ali apenas foi mencionada a linguagem de programação Java, mas podemos dizer que todas as linguagens de programação que são orientadas a objeto ou dão suporte a este paradigma, suportam o objeto DAO. Vamos então criar a nossa classe DAO, mas para seguir o padrão a risca, criaremos antes uma interface que reflete a ideia deste post, impondo os métodos para nos ajudar chegar ao nosso objetivo. Talvez nesse momento, usar uma interface não parece necessário, mas em um artigo posterior, vou detalhar mais motivos ao usar estas mesmas classes.

1. interface iDaoModeCrud {
2.     public function create( $object );
3.     public function read( $param );
4.     public function update( $object );
5.     public function delete( $param );
6. }

Pronto, então vamos criar a classe de persistência implementando a interface iDaiModeCrud para criar cada um dos métodos declarados nela. A nova classe precisa sempre gerar um novo objeto DAO para cada execução da aplicação. Isso faz sentido existir dessa forma porque imagine por um momento, quando você construir uma aplicação que conecte com muitos usuários simultaneamente, se todos estes utilizarem um único objeto instanciado para fazer interface com o banco? Diversas inconsistências poderiam ocorrer, então cada sessão deve ter seu próprio objeto DAO. Além disso para cada contexto de um sistema que vou me referir como um “tipo de módulo” que interage com o banco, precisaremos de uma classe DAO específica. Módulo? Sim, por exemplo um módulo de cadastro de clientes, um outro de cadastro de produtos, um outro para operações de vendas, etc. Estando claro isso e seguindo com nosso objetivo de criar um cadastro de contatos, segue nossa classe Dao:

1. class DaoContato implements iDaoModeCrud {

2.    

3.     private $instanciaConexaoPdoAtiva;

4.     private $tabela;

5.    

6.     public function __construct() {

7.        $this->instanciaConexaoPdoAtiva = PdoConexao::getInstancia();

8.        $this->tabela = “contatos”;

9.     }

11.     /**

12.     *

13.     * create: Insere informações no banco de dados

14.     *

15.     * @param object $objeto

16.     * @return boolean

17.     */

18.     public function create( $objeto ) {

19.        $id = $this->getNewIdContato();

20.        $nome = $objeto->getNome();

21.        $email = $objeto->getEmail();

22.        $telefone = $objeto->getTelefone();

23.        $sqlStmt = “INSERT INTO {$this->tabela} (ID, NOME, EMAIL, TELEFONE) VALUES (:id, :nome, :email, :telefone)”;

24.        try {

25.           $operacao = $this->instanciaConexaoPdoAtiva->prepare($sqlStmt);

26.           $operacao->bindValue(“:id”, $id, PDO::PARAM_INT);

27.           $operacao->bindValue(“:nome”, $nome, PDO::PARAM_STR);

28.           $operacao->bindValue(“:email”, $email, PDO::PARAM_STR);

29.           $operacao->bindValue(“:telefone”, $telefone, PDO::PARAM_STR);

30.           if($operacao->execute()){

31.                 if($operacao->rowCount() > 0) {

32.                    $objeto->setID($id);

33.                    return true;

34.                 } else {

35.                    return false;

36.                 }

37.              } else {

38.                 return false;

39.           }

40.        } catch( PDOException $excecao ) {

41.              echo $excecao->getMessage();

42.        }

43.     }

45.     /**

46.     *

47.     * read: Retorna um objeto refletindo um contato

48.     *

49.     * @param int $id

50.     * @return object

51.     */

52.     public function read( $id ) {

53.        $sqlStmt = “SELECT * from {$this->tabela} WHERE ID=:id”;

54.        try {

55.           $operacao = $this->instanciaConexaoPdoAtiva->prepare($sqlStmt);

56.           $operacao->bindValue(“:id”, $id, PDO::PARAM_INT);

57.           $operacao->execute();

58.           $getRow = $operacao->fetch(PDO::FETCH_OBJ);

59.           $nome = $getRow->NOME;

60.           $email = $getRow->EMAIL;

61.           $telefone = $getRow->TELEFONE;

62.           $objeto = new Contato( $nome, $email, $telefone );

63.           $objeto->setId($id);

64.           return $objeto;

65.        } catch( PDOException $excecao ){

66.           echo $excecao->getMessage();

67.        }

68.     }

69.    

70.     /**

71.     *

72.     * update: atualiza um contato

73.     *

74.     * @param object $objeto

75.     * @return boolean

76.     */

77.     public function update( $objeto ) {

78.        $id = $objeto->getId();

79.        $nome = $objeto->getNome();

80.        $email = $objeto->getEmail();

81.        $telefone = $objeto->getTelefone();

82.        $sqlStmt = “UPDATE {$this->tabela} SET NOME=:nome, EMAIL=:email, TELEFONE=:telefone WHERE ID=:id”;

83.        try {

84.           $operacao = $this->instanciaConexaoPdoAtiva->prepare($sqlStmt);

85.           $operacao->bindValue(“:id”, $id, PDO::PARAM_INT);

86.           $operacao->bindValue(“:nome”, $nome, PDO::PARAM_STR);

87.           $operacao->bindValue(“:email”, $email, PDO::PARAM_STR);

88.           $operacao->bindValue(“:telefone”, $telefone, PDO::PARAM_STR);

89.           if($operacao->execute()){

90.              if($operacao->rowCount() > 0){

91.                 return true;

92.              } else {

93.                 return false;

94.              }

95.           } else {

96.              return false;

97.           }

98.        } catch ( PDOException $excecao ) {

99.           echo $excecao->getMessage();

100.        }

101.     }

103.     /**

104.     *

105.     * DELETE exclui um contato no banco de dados conforme informado por id

106.     *

107.     * @param int $id

108.     * @return boolean

109.     */

110.     public function delete( $id ) {

111.         $sqlStmt = “DELETE FROM {$this->tabela} WHERE ID=:id”;

112.        try {

113.           $operacao = $this->instanciaConexaoPdoAtiva->prepare($sqlStmt);

114.           $operacao->bindValue(“:id”, $id, PDO::PARAM_INT);

115.           if($operacao->execute()){

116.              if($operacao->rowCount() > 0) {

117.                    return true;

118.              } else {

119.                    return false;

120.              }

121.           } else {

122.              return false;

123.           }

124.        } catch ( PDOException $excecao ) {

125.           echo $excecao->getMessage();

126.        }

127.     }

128.    

129.     /**

130.     *

131.     * getNewIdContato retorna um novo Id para novos registros

132.     *

133.     * @return int

134.     * @throws Exception

135.     */

136.     private function getNewIdContato(){

137.           $sqlStmt = “SELECT MAX(ID) AS ID FROM {$this->tabela}”;

138.           try {

139.              $operacao = $this->instanciaConexaoPdoAtiva->prepare($sqlStmt);

140.              if($operacao->execute()) {

141.                 if($operacao->rowCount() > 0){

142.                    $getRow = $operacao->fetch(PDO::FETCH_OBJ);

143.                    $idReturn = (int) $getRow->ID + 1;

144.                    return $idReturn;

145.                 } else {

146.                    throw new Exception(“Ocorreu um problema com o banco de dados”);

147.                    exit();

148.                 }

149.              } else {

150.                 throw new Exception(“Ocorreu um problema com o banco de dados”);

151.                 exit();

152.               }

153.           } catch (PDOException $excecao) {

154.              echo $excecao->getMessage();

155.           }

156.        }

157.     }

As classes funcionais estão prontas! Agora podemos criar um novo arquivo php para realizar alguns testes. Por exemplo, abaixo criei um arquivo php com uma função de auto loader para classes que se encontram no mesmo caminho (OBS: Salvar arquivos de bibliotecas de classes no mesmo diretório da aplicação principal não é uma prática recomendada, está sendo usado aqui apenas para fins didáticos), note as explicações acima de cada linha definido como comentário:

1. header(“Content-Type: text/html; charset=utf-8”,true);
3. function __autoload( $classe ){
5. if(file_exists( “{$classe}.php” )) {
6.           include_once “{$classe}.php”;
7.        } else {
8.           echo “O arquivo {$classe}.php da classe {$classe} não foi encontrado”;
9.        }
10.     }
11.    
12. // Nesta etapa criamos um objeto de contato e logo em seguida vamos fazer destes dados persistentes no banco de dados
13. $contato1 = new Contato( “Alexandre Barbosa”, “teste@teste.com.br”, “11999999999”);
15. // Então primeiro criamos um novo objeto DAO
16. $PersitenciaContato1 = new DaoContato();
18. // Para persistencia de dados do objeto contato, usamos o método create passando o nosso objeto de contato como parâmetro
19. if($PersitenciaContato1->create($contato1)){
20.        echo ‘Inseridos no banco com Êxito’;
21. }
23. // Agora podemos testar outra funcionalidade, recuperar os dados persistidos no dados no banco para um novo objeto de contatos, usamos o método read do nosso DAO. O
24. var_dump está sendo usado apenas para facilitar a visualização do objeto sem precisar inserir mais códigos
25. var_dump($PersitenciaContato1->read(1));
27. //Note que poderíamos criar um novo objeto com os dados de contato apenas desta forma:
28. $contato2 = $PersitenciaContato1->read(1);
30. // O número 1, indica o ID do registro no banco de dados.
31. //Agora para atualizar os dados, primeiro “setamos” os novos valores no objeto de contato com os dados carregados. Vamos usar o primeiro objeto identificado como $contato1:
32. $contato1->setNome(“João Silva”);
33. $contato1->setEmail(“joao@teste.com.br”);
35. // Então chamamos o método de update do nosso DAO passando o objeto de contato.
36. if($PersitenciaContato1->update($contato1)){
37.        echo ‘Atualizado no banco com Êxito’;
38. }
40. //Vamos conferir a atualização realizada com o método read do nosso DAO
41. var_dump($PersitenciaContato1->read(1));
43. // E para excluirmos? usamos o método delete do nosso DAO, informando o ID como parâmetro
44. if($PersitenciaContato1->delete(1)){
45.     echo ‘Excluído do banco com Êxito’;
46. }

Note que não precisamos mais agora nos preocupar como obter ou inserir dados no banco de dados porque todo processo será realizado pela classe de persistência. Precisamos apenas saber que temos quatro métodos de operação e quais são os parâmetros necessários para invocar estes métodos, uma vez que instanciamos um objeto DAO.

Este post já ficou bem extenso. Então vou encerrar por aqui. Mas estou preparando um novo artigo separado em que criamos um pequeno aplicativo usando estas classes junto com as classes (com algumas melhorias) criadas em um post anterior sobre o Factory Pattern.

Reconheço que o layout do meu blog ainda não está ajudando muito para área de desenvolvimento e estou trabalhando nisso. Mas eu gostaria que você me ajuda-se curtindo este post caso você tenha gostado. Alguns me enviam e-mails parabenizando, e não há problema, mas a sua “curtida aqui” é muito importante para que eu possa continuar meu trabalho.
[]’s