PDO (PHP Data Objects)

Reuso e a segurança
PDO é uma classe desenvolvida para trabalhar com procedimentos relacionados a Banco
de Dados. PDO oferece segurança extra.

Os recursos oferecidos são suficiente para trabalhar implementando toda nossa aplicação
sem nos preocuparmos com qual banco estamos utilizando, e que uma mudança posterior
na escolha do banco não trará grandes mudanças na aplicação.

É necessário implementar um padrão de projeto que implemente o conceito de

multicamadas, onde o principal objetivo é separar a camada de dados do restante da
aplicação. Separando a aplicação em camadas, e utilizando o PDO adequadamente,
teremos a receita perfeita de uma aplicação bem estruturada.

Configurando o PDO
Listagem 1: Habilitando PDO no Linux

extension=pdo.so
extension=pdo_mysql.so
extension=pdo_pgsql.so
extension=pdo_sqlite.so

Listagem 2: Habilitando PDO no Windows

extension=php_pdo.dll
extension=php_pdo_mysql.dll
extension=php_pdo_pgsql.dll
extension=php_pdo_sqlite.dll
Os exemplos que se seguem utilizam o padrão de projeto MVC (Model View Controller), que

separa a camada de apresentação (view), a camada de controle/regra de negócios

(controller) e a camada de dados (model, onde ficam os comandos SQL).

Um arquivo de conexão com o banco em PDO será o ponto de conexão da aplicação com o

banco.

Listagem 3: Arquivo conexao.php

<?php

class Conexao {

public static $instance;

private function __construct() {

//
}

public static function getInstance() {

if (!isset(self::$instance)) {
self::$instance = new
PDO('mysql:host=localhost;dbname=minhabasededados', 'root', 'vertrigo',
array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8"));
self::$instance->setAttribute(PDO::ATTR_ERRMODE,
PDO::ERRMODE_EXCEPTION);
self::$instance->setAttribute(PDO::ATTR_ORACLE_NULLS,
PDO::NULL_EMPTY_STRING);
}

return self::$instance;
}

?>

POJO é o “espelho” da tabela em objetos.

Listagem 4: Classe POJO Usuário

<?php

class PojoUsuario {

private $cod_usuario;
private $nome;
private $email;
private $senha;
private $ativo;
private $perfil;
 public function getCod_usuario() {
return $this->cod_usuario;
}

public function setCod_usuario($cod_usuario) {

$this->cod_usuario = $cod_usuario;
}

public function getNome() {

return $this->nome;
}

public function setNome($nome) {

$this->nome = $nome;
}

public function getEmail() {

return $this->email;
}

public function setEmail($email) {

$this->email = strtolower($email);
}

public function getSenha() {

return $this->senha;
}

public function setSenha($senha) {

$this->senha = strtolower($senha);
}

public function getAtivo() {

return $this->ativo;
}

public function setAtivo($ativo) {

$this->ativo = strtolower($ativo);
}

public function getPerfil() {

return $this->perfil;
}

public function setPerfil($perfil) {

$this->perfil = $perfil;
}

?>

A classe DAO será responsável por realizar as consultas, inserções, deleções e edições no

banco. O DAO é responsável por realizar processos no banco e retornar POJOs (se

necessários) para a camada de controle. O nosso DAO implementa um padrão de projetos

chamado Singleton, que em resumo faz que com que o objeto seja criado apenas uma vez

na memória.
Listagem 5: DAO para a Classe Usuario
<?php

require_once CAMINHO_RAIZ . "admin/conexao.php";

require_once CAMINHO_RAIZ . "admin/geralog.php";
require_once CAMINHO_RAIZ . "admin/entity/perfil/controller_perfil.php";
require_once "pojo_usuario.php";

class DaoUsuario {

public static $instance;

private function __construct() {

//
}

public static function getInstance() {

if (!isset(self::$instance))
self::$instance = new DaoUsuario();

return self::$instance;
}

public function Inserir(PojoUsuario $usuario) {

try {
$sql = "INSERT INTO usuario (
nome,
email,
senha,
ativo,
cod_perfil)
VALUES (
:nome,
:email,
:senha,
:ativo,
:cod_perfil)";

$p_sql = Conexao::getInstance()->prepare($sql);

$p_sql->bindValue(":nome", $usuario->getNome());
$p_sql->bindValue(":email", $usuario->getEmail());
$p_sql->bindValue(":senha", $usuario->getSenha());
$p_sql->bindValue(":ativo", $usuario->getAtivo());
$p_sql->bindValue(":cod_perfil", $usuario->getPerfil()-
>getCod_perfil());

return $p_sql->execute();
} catch (Exception $e) {
print "Ocorreu um erro ao tentar executar esta ação, foi gerado
um LOG do mesmo, tente novamente mais tarde.";
GeraLog::getInstance()->inserirLog("Erro: Código: " .
$e->getCode() . " Mensagem: " . $e->getMessage());
}
}

public function Editar(PojoUsuario $usuario) {

try {
$sql = "UPDATE usuario set
nome = :nome,
 email = :email,
senha = :senha,
ativo = :ativo,
cod_perfil = :cod_perfil WHERE cod_usuario = :cod_usuario";

$p_sql = Conexao::getInstance()->prepare($sql);

$p_sql->bindValue(":nome", $usuario->getNome());
$p_sql->bindValue(":email", $usuario->getEmail());
$p_sql->bindValue(":senha", $usuario->getSenha());
$p_sql->bindValue(":ativo", $usuario->getAtivo());
$p_sql->bindValue(":cod_perfil", $usuario->getPerfil()->
getCod_perfil());
$p_sql->bindValue(":cod_usuario", $usuario->getCod_usuario());

return $p_sql->execute();
} catch (Exception $e) {
print "Ocorreu um erro ao tentar executar esta ação, foi gerado
um LOG do mesmo, tente novamente mais tarde.";
GeraLog::getInstance()->inserirLog("Erro: Código: " . $e->
getCode() . " Mensagem: " . $e->getMessage());
}
}

public function Deletar($cod) {

try {
$sql = "DELETE FROM usuario WHERE cod_usuario = :cod";
$p_sql = Conexao::getInstance()->prepare($sql);
$p_sql->bindValue(":cod", $cod);

return $p_sql->execute();
} catch (Exception $e) {
print "Ocorreu um erro ao tentar executar esta ação, foi gerado
um LOG do mesmo, tente novamente mais tarde.";
GeraLog::getInstance()->inserirLog("Erro: Código: " . $e->
getCode() . " Mensagem: " . $e->getMessage());
}
}

public function BuscarPorCOD($cod) {

try {
$sql = "SELECT * FROM usuario WHERE cod_usuario = :cod";
$p_sql = Conexao::getInstance()->prepare($sql);
$p_sql->bindValue(":cod", $cod);
$p_sql->execute();
return $this->populaUsuario($p_sql->fetch(PDO::FETCH_ASSOC));
} catch (Exception $e) {
print "Ocorreu um erro ao tentar executar esta ação, foi gerado
um LOG do mesmo, tente novamente mais tarde.";
GeraLog::getInstance()->inserirLog("Erro: Código: " . $e->
getCode() . " Mensagem: " . $e->getMessage());
}
}
private function populaUsuario($row) {
$pojo = new PojoUsuario;
$pojo->setCod_usuario($row['cod_usuario']);
$pojo->setNome($row['nome']);
$pojo->setEmail($row['email']);
$pojo->setSenha($row['senha']);
$pojo->setAtivo($row['ativo']);
$pojo->setPerfil(ControllerPerfil::getInstance()-
>BuscarPorCOD($row['cod_perfil']));
return $pojo;
}
}

?>

Listagem 6: Método DELETAR

public function Deletar($cod) {
try {
$sql = "DELETE FROM usuario WHERE cod_usuario = :cod";
$p_sql = Conexao::getInstance()->prepare($sql);
$p_sql->bindValue(":cod", $cod);

return $p_sql->execute();
} catch (Exception $e) {
print "Ocorreu um erro ao tentar executar esta ação, foi gerado
um LOG do mesmo, tente novamente mais tarde.";
GeraLog::getInstance()->inserirLog("Erro: Código: " . $e->
getCode() . " Mensagem: " . $e->getMessage());
}
}

O PDO é criado no arquivo conexao.php, por isso utilizamos o código

“Conexao::getInstance()->prepare($sql”), é nesta linha que ao mesmo tempo que

capturamos a instância do PDO da memória, já passamos a ele o SQL a ser preparado. O

PDO irá pegar sua SQL e implementar os escapes necessários e segurança necessária. A

única coisa que é necessário fazer é passar os parâmetros definidos no SQL com o método

“bindValue” e executar a Query com o método “execute()”.