PHP

PDO DAO SELECT INSERT UPDATE DELETE LIST em PHP

Bene Silva Júnior Bene Silva Júnior 04/12/2021

Receba grátis o e-book Como Formatar um PC em 5 Minutos

Receba grátis o e-book Como Formatar um PC em 5 Minutos
Não enviamos spam. Seu e-mail está 100% seguro!

No desenvolvimento de aplicações PHP, manipular bancos de dados é uma tarefa recorrente. Para fazer isso de forma segura e eficiente, usamos o PDO (PHP Data Objects) para realizar operações de SELECT, INSERT, UPDATE, DELETE. Além disso, a implementação de um padrão DAO (Data Access Object) ajuda a organizar o código e separar a lógica de acesso aos dados da lógica da aplicação. Neste post, vou te mostrar PDO DAO SELECT INSERT UPDATE DELETE LIST em PHP.

O que é PDO?

O PDO é uma extensão nativa do PHP que permite acessar bancos de dados de forma segura, utilizando consultas preparadas que ajudam a evitar ataques de SQL Injection. Ele suporta diversos tipos de bancos de dados, como MySQL, PostgreSQL, SQLite, entre outros.

O que é DAO?

O DAO (Data Access Object) é um padrão de design que encapsula as operações de acesso ao banco de dados, facilitando a manutenção e a escalabilidade do código. Em vez de escrever consultas diretamente em todas as partes do código, você cria uma camada de acesso aos dados centralizada.

Configurando a conexão com o banco de dados

O primeiro passo é criar uma classe para a conexão com o banco de dados usando PDO. Aqui está um exemplo de como isso pode ser feito:

<?php
class Database {
    private $host = "localhost";
    private $db_name = "meu_banco";
    private $username = "root";
    private $password = "";
    public $conn;

    // Função para obter a conexão com o banco
    public function getConnection() {
        $this->conn = null;
        try {
            $this->conn = new PDO("mysql:host=" . $this->host . ";dbname=" . $this->db_name, $this->username, $this->password);
            $this->conn->exec("set names utf8");
        } catch(PDOException $exception) {
            echo "Erro na conexão: " . $exception->getMessage();
        }

        return $this->conn;
    }
}
?>

Criando a classe DAO

Agora, vamos criar uma classe DAO para manipular as operações de SELECT, INSERT, UPDATE, DELETE no banco de dados. Aqui, usaremos uma entidade chamada Usuario como exemplo.

Estrutura da tabela usuarios:

CREATE TABLE usuarios (
    id INT PRIMARY KEY AUTO_INCREMENT,
    nome VARCHAR(100),
    email VARCHAR(100)
);

Classe UsuarioDAO:

<?php
class UsuarioDAO {
    private $conn;
    private $table_name = "usuarios";

    public function __construct($db) {
        $this->conn = $db;
    }

    // Método para inserir um novo usuário
    public function insert($nome, $email) {
        $query = "INSERT INTO " . $this->table_name . " (nome, email) VALUES (:nome, :email)";
        $stmt = $this->conn->prepare($query);

        // Limpar dados
        $nome = htmlspecialchars(strip_tags($nome));
        $email = htmlspecialchars(strip_tags($email));

        // Bind de parâmetros
        $stmt->bindParam(":nome", $nome);
        $stmt->bindParam(":email", $email);

        if($stmt->execute()) {
            return true;
        }
        return false;
    }

    // Método para listar todos os usuários
    public function list() {
        $query = "SELECT * FROM " . $this->table_name;
        $stmt = $this->conn->prepare($query);
        $stmt->execute();
        return $stmt;
    }

    // Método para buscar um usuário por ID
    public function select($id) {
        $query = "SELECT * FROM " . $this->table_name . " WHERE id = :id";
        $stmt = $this->conn->prepare($query);

        $stmt->bindParam(":id", $id);
        $stmt->execute();

        return $stmt->fetch(PDO::FETCH_ASSOC);
    }

    // Método para atualizar um usuário
    public function update($id, $nome, $email) {
        $query = "UPDATE " . $this->table_name . " SET nome = :nome, email = :email WHERE id = :id";
        $stmt = $this->conn->prepare($query);

        $nome = htmlspecialchars(strip_tags($nome));
        $email = htmlspecialchars(strip_tags($email));

        $stmt->bindParam(":id", $id);
        $stmt->bindParam(":nome", $nome);
        $stmt->bindParam(":email", $email);

        if($stmt->execute()) {
            return true;
        }
        return false;
    }

    // Método para deletar um usuário
    public function delete($id) {
        $query = "DELETE FROM " . $this->table_name . " WHERE id = :id";
        $stmt = $this->conn->prepare($query);

        $stmt->bindParam(":id", $id);

        if($stmt->execute()) {
            return true;
        }
        return false;
    }
}
?>

Exemplo de uso do DAO

Aqui está como você pode usar a classe UsuarioDAO para realizar operações de CRUD:

<?php
// Inclui o arquivo da classe Database e UsuarioDAO
include_once 'Database.php';
include_once 'UsuarioDAO.php';

// Obtém a conexão com o banco de dados
$database = new Database();
$db = $database->getConnection();

// Cria uma instância do UsuarioDAO
$usuarioDAO = new UsuarioDAO($db);

// Inserir um novo usuário
$usuarioDAO->insert("João da Silva", "joao@email.com");

// Listar todos os usuários
$stmt = $usuarioDAO->list();
while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
    extract($row);
    echo "ID: $id - Nome: $nome - Email: $email\n";
}

// Atualizar um usuário
$usuarioDAO->update(1, "João Atualizado", "joaoatualizado@email.com");

// Deletar um usuário
$usuarioDAO->delete(2);
?>

Outros exemplos

Para podermos fazer um SELECT, INSERT, UPDATE, DELETE e LIST utilizando o PDO-DAO podemos utilizar um arquivo de configuração para carregarmos as classes do projeto e chamá-lo através da função require_once().

Arquivo Sql.php (classe Sql):

 //Extende da classe nativa PDO
 class Sql extends PDO {
  
  private $conn;
  
  //Método construtor para que, quando a classe for instanciada, a conexão seja feita automaticamente
  public function __construct() {
	
  //Faz a conexão com o banco mySQL 	  
  $this->conn = new PDO("mysql:host=localhost;dbname=meuBanco", "meuUsuario", "minhaSenha");     
  }
  
  //Função para associar os parâmetros (bind) ao comando prepare
  private function setParams($statement, $parameters = array()) {
   foreach ($parameters as $key => $value) {
    $this->setParam($statement, $key, $value);
   }
  }
  
  //Método para fazer o bind de um parâmetro apenas
  private function setParam($statement, $key, $value) {
   $statement->bindParam($key, $value);   
  }
  
  /* Função para executar os comandos SQL 
  ($rawQuery: comando SQL; $params: dados que serão recebidos e armazenados em um array */
  public function query($rawQuery, $params = array()) {
   
   //Statement que prepara o comando
   $stmt = $this->conn->prepare($rawQuery);
	
   //Associa os parâmetros ao comando prepare	
   $this->setParams($stmt, $params);
	 
   $stmt->execute();	 
    return $stmt;
   }
	
  public function select($rawQuery, $params = array()):array{
	 
  $stmt = $this->query($rawQuery, $params);	
   //Array com todos os dados 
   return $stmt->fetchAll(PDO:: FETCH_ASSOC); //FETCH_ASSOC: Mostra os dados associativos (sem os indexes)
   }	
 }

Arquivo Usuario.php (classe Usuario):

 class Usuario {
	 
  private $idusuario;
  private $deslogin;
  private $dessenha;
  private $dtcadastro;
	 
 //Funções get set
  public function getIdusuario() {
   return $this->idusuario;
  }
	 
  public function setIdusuario($value) {
   $this->idusuario = $value;
  }
	 
  public function getDeslogin() {
   return $this->deslogin;
  }
	 
  public function setDeslogin($value) {
   $this->deslogin = $value;
  }
	 
  public function getDessenha() {
   return $this->dessenha;
  }
	 
  public function setDessenha($value) {
   $this->dessenha = $value;
  }
	 
  public function getDtcadastro() {
   return $this->dtcadastro;
  }
	 
  public function setDtcadastro($value) {
   $this->dtcadastro = $value;
  }
	 
  public function loadById($id) {
	 
  $sql = new Sql();
	  
  //Instrução SQL levando em conta o Id recebido pelo parâmetro loadById()
  $results = $sql->select("SELECT * FROM tb_usuarios WHERE idusuario = :ID", array(
  ":ID"=>$id
  ));
	  
  //Se o resultado a consulta for maior que zero...
  if(count($results) > 0) {
   $this->setData($results[0]);	  
  }	 
 }
 
 //Método que traz uma lista de usuários
  public static function getList(){
   $sql = new Sql();
  return $sql->select("SELECT * FROM tb_usuarios ORDER BY deslogin");
 }
 
 //Método para pesquisar usuários com base em uma letra ou palavra
  public static function search($login){
   $sql = new Sql();
   return $sql->select("SELECT * FROM tb_usuarios WHERE deslogin LIKE :SEARCH ORDER BY deslogin", array(
   ':SEARCH'=>"%".$login."%"
  ));  
 }
 
  //Traz os dados do usuário com base no login e senha do mesmo
  public function login($login, $password){
 
 $sql = new Sql();
	  
 $results = $sql->select("SELECT * FROM tb_usuarios WHERE deslogin = :LOGIN AND dessenha = :PASSWORD", array(
  ":LOGIN"=>$login,
  ":PASSWORD"=>$password
 ));
	  
 if(count($results) > 0) {
  $this->setData($results[0]);  
  } else {
   throw new Exception ("Login e/ou senha inválidos!"); 
  }
 }
 
  //Função para setar dados
  public function setData($data) {
   $this->setIdusuario($data['idusuario']);
   $this->setDeslogin($data['deslogin']);
   $this->setDessenha($data['dessenha']);
   $this->setDtcadastro(new DateTime($data['dtcadastro'])); 
  } 
 
  //Método INSERT para criar usuários novos a partir da classe Usuario
 public function insert() {
  $sql = new Sql();
  
  //Chama uma procedure para inserir dados no banco
  $results = $sql->select("CALL sp_usuarios_insert(:LOGIN, :PASSWORD)", array(
  ':LOGIN'=>$this->getDeslogin(),
  ':PASSWORD'=>$this->getDessenha()
  ));
  
  if(count($results)>0){
   $this->setData($results[0]);
  }
 }
 
  //Método UPDATE para atualizar os registros
  public function update($login, $password) {

  $this->setDeslogin($login);
  $this->setDessenha($password);
  	 
  $sql = new Sql();
  $sql->query("UPDATE tb_usuarios SET deslogin = :LOGIN, dessenha = :PASSWORD WHERE idusuario = :ID", array (
  ':LOGIN'=>$this->getDeslogin(),
  ':PASSWORD'=>$this->getDessenha(),
  ':ID'=>$this->getIdusuario()
  ));
 }
 
 //Método para apagar registros
  public function delete() {
  
   $sql = new Sql();
   $sql->query("DELETE FROM tb_usuarios WHERE idusuario = :ID", array(
   ':ID'=>$this->getIdusuario()
   ));
  
  //Atualiza o objeto após a exclusão do registro  
   $this->setIdusuario(0);
   $this->setDeslogin("");
   $this->setDessenha("");
   $this->setDtcadastro(new DateTime());  
 }
 
  /* Método construtor para  receber o login e senha do usuário. 
  Caso os parâmetros não sejam passados, a classe será alimentada com nulos 
  (não será obrigatório o recebimento dos parâmetros) */
  
 public function __construct($login = "", $password = "") {
  $this->setDeslogin($login);
  $this->setDessenha($password);
 }
 
 //Método para mostrar as informações na tela ao solicitar ao objeto (echo)
 public function __toString() {
  return json_encode(array(
   "idusuario"=>$this->getIdusuario(),
   "deslogin"=>$this->getDeslogin(),
   "dessenha"=>$this->getDessenha(),
   "dtcadastro"=>$this->getDtcadastro()->format("d/m/Y H:i:s")
   ));
  } 
 }

Arquivo Config.php (arquivo de configuração):

 //Auto load
 spl_autoload_register(function($nameClass) {
 $nameClass = str_replace('\\', '/', $nameClass);
 
 //Pasta das classes
 $dirClass = "class";
 
  //Caminho do arquivo de classe a ser carregado
 $filename = $dirClass . DIRECTORY_SEPARATOR . $nameClass . ".php";

 if (file_exists($filename)) {
    require_once($filename);
 } 
});

Arquivo Index.php (arquivo do qual serão chamados o arquivo de configuração e as classes e métodos para manipulação do banco):

  require_once("config.php"); 
 
  $root = new Usuario();  
  $root->loadbyId(7); //Chama o método loadbyId() passando o Id 7 para a instrução SQL
  
  //Chama o método __toString()
  echo $root;  
  
  //Mostra lista de usuários
  $lista = Usuario::getList();
  echo json_encode($lista);
  
  //Carrega lista de usuários com base em uma ou mais letras
  $search = Usuario::search("ne");//Neste caso nome de usuários que contenham "ne"
  echo json_encode($search);
  
  //Carrega usuário com base no login e senha
  $usuario = new Usuario();
  $usuario->login("bene","123");
  
  //Atualiza os dados com base no ID
  $usuario = new Usuario();
  $usuario->loadById(5); //Carrega usuário
  $usuario->update("programador","676%$#");
  
  //Exclui registros com base no ID
  $usuario = new Usuario();
  $usuario->loadById(30);//Exclui o registro referente ao ID 30
  $usuario->delete();
  
  echo $usuario;

Procedure criada:

 CREATE DEFINER=`root`@`localhost` PROCEDURE `sp_usuarios_insert`(
   pdeslogin VARCHAR(64),
   pdessenha VARCHAR(256)
 )
 BEGIN
  INSERT INTO tb_usuarios (deslogin, dessenha) VALUES (pdeslogin, pdessenha);
  SELECT * FROM tb_usuarios WHERE idusuario = last_insert_id();
 END

Os arquivos do projeto em questão estão organizados da seguinte forma:

Pasta DAO (raiz):

config.php
index.php

Pasta DAO/class:

Sql.php
Usuario.php

Usar PDO junto com o padrão DAO em PHP ajuda a organizar e proteger o código, especialmente quando se trata de manipular bancos de dados. O PDO garante segurança contra SQL Injection e facilita a transição entre diferentes tipos de bancos de dados, enquanto o DAO separa a lógica de acesso a dados, deixando o código mais limpo e fácil de manter.

QUER APRENDER PHP ORIENTADO A OBJETOS OU APERFEIÇOAR O QUE JÁ SABE?

Então conheça o curso online que já ajudou milhares de pessoas a aprender a programar e desenvolver seus próprios projetos do ZERO e usando orientação a objetos de uma forma fácil de entender.

CLIQUE NA IMAGEM ABAIXO E SAIBA MAIS:

CLIQUE AQUI E SAIBA MAIS

Dúvidas ou sugestões? Deixem nos comentários! Para mais dicas, acesse o nosso canal no YouTube:
https://youtube.com/criandobits

Tags: |

Quer receber GRÁTIS o e-book "Como Formatar um Computador em 5 Minutos"?

Não enviamos spam. Seu e-mail está 100% seguro!

Artigos Relacionados

Hibernate Hibernate
Como debugar códigos no Visual Studio Como debugar códigos no Visual Studio
Destructuring em Java Script Destructuring em Java Script
AJAX AJAX

Sobre o Autor

Bene Silva Júnior
Bene Silva Júnior

Bacharel em Sistemas de Informação pelo Instituto Paulista de Pesquisa e Ensino IPEP. Apaixonado por tecnologias e games do tempo da vovó!

0 Comentários

Deixe um comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Assine a nossa Newsletter

Seja avisado sobre as novidades do site e não perca nenhuma dica!

Não enviamos spam. Seu e-mail está 100% seguro!