27 jan 2014
CRUD usando a biblioteca PDO no PHP e MySQL
Hoje o tema será a construção de uma classe CRUD no PHP utilizando a biblioteca PDO para manipular registros no MySQL. O foco desse artigo não é HTML e CSS, por esse motivo irei trabalhar somente com scripts e códigos PHP, sem usar formulários, submissões e validações dos métodos GET e POST.
Mas alguns leitores podem se perguntar, “Afinal de contas o que é CRUD?”.
Create – Adicionar novo registro
Retrieve – Consultar registro
Update – Atualizar registro
Delete – Excluir registro
Nesse artigo vamos trabalhar com o seguinte cenário:
– MySQL 5.5.34
– MySQL Workbench 6.0
– PHP 5.5
– Banco de dados DB_BLOG
Para nossos exemplos vamos utilizar uma tabela ARTIGO bem simples com apenas 5 campos, sendo que o campo idArtigo é auto-incremento e o campo data tem como default TIMESTAMP do sistema, a tabela tem a seguinte estrutura:
|
1 2 3 4 5 6 7 8 |
CREATE TABLE `ARTIGO` ( `idArtigo` int(10) unsigned NOT NULL AUTO_INCREMENT, `categoria` varchar(30) NOT NULL, `titulo` varchar(50) NOT NULL, `autor` varchar(45) NOT NULL, `data` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, PRIMARY KEY (`idARTIGO`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8; |
Nossa classe CRUD vai precisar de conexão com o banco de dados, então vou utilizar uma classe de conexão PDO seguindo o padrão Singleton, a explicação das funcionalidades dessa classe estão nesse artigo que postei anteriormente.
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 30 31 32 33 34 35 36 37 38 39 40 41 |
<?php /* * Constantes de parâmetros para configuração da conexão */ define('HOST', 'localhost'); define('DBNAME', 'DB_BLOG'); define('CHARSET', 'utf8'); define('USER', 'root'); define('PASSWORD', '123456'); class Conexao { /* * Atributo estático para instância do PDO */ private static $pdo; /* * Escondendo o construtor da classe */ private function __construct() { // } /* * Método estático para retornar uma conexão válida * Verifica se já existe uma instância da conexão, caso não, configura uma nova conexão */ public static function getInstance() { if (!isset(self::$pdo)) { try { $opcoes = array(PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES UTF8', PDO::ATTR_PERSISTENT => TRUE); self::$pdo = new PDO("mysql:host=" . HOST . "; dbname=" . DBNAME . "; charset=" . CHARSET . ";", USER, PASSWORD, $opcoes); self::$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); } catch (PDOException $e) { print "Erro: " . $e->getMessage(); } } return self::$pdo; } } |
Classe CRUD
Nesse artigo vou usar uma classe CRUD também seguindo o padrão de projeto Singleton, dessa maneira vamos trabalhar orientado a objetos, pessoalmente gosto de trabalhar com esse tipo de classe, gera uma ecônomia de código principalmente no método de consulta que em certos casos é utilizado em várias páginas, dessa maneira não é necessário construir uma consulta em cada página com instruções SQL repetidas.
crudBlog.class.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 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 |
<?php /* * Classe para operações CRUD na tabela ARTIGO */ class crudBlog{ /* * Atributo para conexão com o banco de dados */ private $pdo = null; /* * Atributo estático para instância da própria classe */ private static $crudBlog = null; /* * Construtor da classe como private * @param $conexao - Conexão com o banco de dados */ private function __construct($conexao){ $this->pdo = $conexao; } /* * Método estático para retornar um objeto crudBlog * Verifica se já existe uma instância desse objeto, caso não, instância um novo * @param $conexao - Conexão com o banco de dados * @return $crudBlog - Instancia do objeto crudBlog */ public static function getInstance($conexao){ if (!isset(self::$crudBlog)): self::$crudBlog = new crudBlog($conexao); endif; return self::$crudBlog; } /* * Metodo para inclusão de novos registros * @param $categoria - Valor para o campo categoria * @param $titulo - Valor para o campo titulo * @param autor - Valor para o campo autor */ public function insert($categoria, $titulo, $autor){ if (!empty($categoria) && !empty($titulo) && !empty($autor)): try{ $sql = "INSERT INTO ARTIGO (categoria, titulo, autor) VALUES (?, ?, ?)"; $stm = $this->pdo->prepare($sql); $stm->bindValue(1, $categoria); $stm->bindValue(2, $titulo); $stm->bindValue(3, $autor); $stm->execute(); echo "<script>alert('Registro inserido com sucesso')</script>"; }catch(PDOException $erro){ echo "<script>alert('Erro na linha: {$erro->getLine()}')</script>"; } endif; } /* * Metodo para edição de registros * @param $categoria - Valor para o campo categoria * @param $titulo - Valor para o campo titulo * @param autor - Valor para o campo autor * @param id - Valor para o campo id */ public function update($categoria, $titulo, $autor, $id){ if (!empty($categoria) && !empty($titulo) && !empty($autor) && !empty($id)): try{ $sql = "UPDATE ARTIGO SET categoria=?, titulo=?, autor=? WHERE idArtigo=?"; $stm = $this->pdo->prepare($sql); $stm->bindValue(1, $categoria); $stm->bindValue(2, $titulo); $stm->bindValue(3, $autor); $stm->bindValue(4, $id); $stm->execute(); echo "<script>alert('Registro atualizado com sucesso')</script>"; }catch(PDOException $erro){ echo "<script>alert('Erro na linha: {$erro->getLine()}')</script>"; } endif; } /* * Metodo para exclusão de registros * @param id - Valor para o campo id */ public function delete($id){ if (!empty($id)): try{ $sql = "DELETE FROM ARTIGO WHERE idArtigo=?"; $stm = $this->pdo->prepare($sql); $stm->bindValue(1, $id); $stm->execute(); echo "<script>alert('Registro excluido com sucesso')</script>"; }catch(PDOException $erro){ echo "<script>alert('Erro na linha: {$erro->getLine()}')</script>"; } endif; } /* * Metodo para consulta de artigos * @return $dados - Array com os registros retornados pela consulta */ public function getAllArtigo(){ try{ $sql = "SELECT * FROM ARTIGO"; $stm = $this->pdo->prepare($sql); $stm->execute(); $dados = $stm->fetchAll(PDO::FETCH_OBJ); return $dados; }catch(PDOException $erro){ echo "<script>alert('Erro na linha: {$erro->getLine()}')</script>"; } } } |
O trabalho pesado está pronto, com a classe CRUD construída temos praticamente todas as funcionalidades prontas para trabalhar com a tabela ARTIGO, é interessante mencionar que pode ocorrer casos em que é necessário acrescentar métodos de consultas distintos, um exemplo seria a necessidade de se pesquisar por categoria, titulo e autor, outra situação seria adicionar um parâmetro para informar por qual campo seria ordenado a consulta e pode-se acrescentar validações antes da inclusão para não deixar repetir o mesmo cadastro, enfim a classe pode ser melhorada tudo depende da necessidade e da criatividade do programador.
Outra dica interessante para aperfeiçoar essa classe CRUD, geralmente as tabelas tem mais do que 3 campos para serem passados como parâmetro, esses métodos podem ser modificados para aceitar um array de dados contendo o valor para vários campos e na hora de passar os valores com o bindValue() usar um foreach() para percorrer o array.
A classe CRUD está bem comentada, com informações sobre os parâmetros de entrada e saída, os métodos de insert(), update() e delete() possuem retornos com mensagens de confirmação para o sucesso da operação, observem que todos os métodos possuem uma captura de exceção com um bloco try…catch, se ocorrer um erro será informado através de um alert() em qual linha foi disparada a PDOException.
|
1 2 3 4 5 |
try{ // Código }catch(PDOException $erro){ echo "<script>alert('Erro na linha: {$erro->getLine()}')</script>"; } |
Agora vamos aos testar nossa classe CRUD, inicialmente vamos atribuir uma instância dessa classe para uma variável $blog usando o método estático getInstance() da classe crudBlog, passar uma conexão como parâmetro para esse método e posteriormente incluir um registro com o método insert():
index.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 |
<?php // Testando classe CRUD /* * Require nos scripts necessários */ require_once "conexao.php"; require_once "crudBlog.class.php"; /* * Atribui uma instância da classe crudBlog * e passa uma conexão como parâmetro */ $blog = crudBlog::getInstance(Conexao::getInstance()); /* * Variáveis contendo os valores para serem inseridos no banco de dados */ $categoria = 'PHP'; $titulo = 'Classe CRUD com PDO'; $autor = 'William'; /* * Chama o método insert() e passa os parâmetros necessários */ $blog->insert($categoria, $titulo, $autor); |
Mensagem de retorno do método insert():
O próximo a ser testado é o método update(), vou alterar o registro inserido anteriormente passando o id:
index.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 |
<?php // Testando classe CRUD /* * Require nos scripts necessários */ require_once "conexao.php"; require_once "crudBlog.class.php"; /* * Atribui uma instância da classe crudBlog * e passa uma conexão como parâmetro */ $blog = crudBlog::getInstance(Conexao::getInstance()); /* * Variáveis contendo os valores para serem atulizados no banco de dados */ $categoria = 'PHP'; $titulo = 'Classe CRUD com PDO no PHP'; $autor = 'William'; $id = 1; /* * Chama o método update() e passa os parâmetros necessários */ $blog->update($categoria, $titulo, $autor, $id); |
Mensagem de retorno do método update():
Próximo método é o delete(), será excluído o registro que foi alterado passando o id:
index.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 |
<?php // Testando classe CRUD /* * Require nos scripts necessários */ require_once "conexao.php"; require_once "crudBlog.class.php"; /* * Atribui uma instância da classe crudBlog * e passa uma conexão como parâmetro */ $blog = crudBlog::getInstance(Conexao::getInstance()); /* * Variável contendo o id para exclusão do registro */ $id = 1; /* * Chama o método delete() e passa o parâmetro necessário */ $blog->delete($id); |
Mensagem de retorno do método delete():
E para finalizar será chamado o método getAllArtigo(), que vai retornar um array de objetos com todos os artigos cadastrados no banco de dados, basta utilizar um foreach para percorrer esse array e exibir os registros no navegador.
index.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 |
<?php // Testando classe CRUD /* * Require nos scripts necessários */ require_once "conexao.php"; require_once "crudBlog.class.php"; /* * Atribui uma instância da classe crudBlog * e passa uma conexão como parâmetro */ $blog = crudBlog::getInstance(Conexao::getInstance()); /* * Chama o método getAllArtigo() que retorna um array de objetos */ $dados = $blog->getAllArtigo(); /* * Loop foreach percorre a array para exibir os artigos */ foreach ($dados as $reg): echo "********************************************** "; echo "Id: " . $reg->idArtigo . " "; echo "Categoria: " . $reg->categoria . " "; echo "Titulo: " . $reg->titulo . " "; endforeach; |
Retorno da consulta sendo exibido no navegador:
Bom pessoal esse artigo acabou ficando um pouco mais extenso que os anteriores, mas era necessário devido a quantidade de informações e exemplos que deveriam ser passados, todos os métodos foram testados e com certeza essa classe CRUD pode gerar um reaproveitamento de código no dia a dia do programador PHP. Toda as operações que envolvem o básico de um CRUD foram adicionadas nessa classe, mas deixo aberto para o leitor customizá-la de acordo com sua necessidade.
Até a próxima ….
