08-PHP com PDO

Prévia do material em texto

PHP com PDO
PHP com PDO
 
Antes de falarmos especificamente do PDO precisamos entender uma
coisa muito importante: O PHP é e, ao mesmo tempo, não é orientado à
objetos. Sim, apesar de parecer estranho isso, não é difícil de entender os
motivos.
Originalmente o PHP nasceu e evoluiu sendo uma linguagem de scripts,
interpretada pelo servidor que o hospeda, entretanto o paradigma de
orientação a objetos passou a ser considerado na linguagem a partir de
sua versão 6 (embora na versão 5 já tenhamos o aparecimento de alguns
indícios), mas na versão 8 é que a orientação a objetos realmente ganhou
notoriedade no motor do PHP. Portanto, o PHP é uma linguagem que não
é orientada a objetos, mas com suporte a tal e, por isso, podemos dizer
que o PHP é e não é Orientado à Objetos.
Agora que esclarecemos um importante conceito da linguagem, podemos
voltar a falar do PDO, que significa PHP Data Object (Objeto de Dados
PHP) e é uma classe pronta com diversos recursos de acesso e
manipulação à bancos de dados e o mais legal e interessante: com
suporte aos principais bancos de dados relacionais do mercado (MySQL,
MariaDB, SQLServer, PostgreSQL, Oracle, SQLite etc.) de forma nativa,
ou seja, sem a necessidade de utilização de nenhuma biblioteca externa.
Para exemplificar o uso do PHP com PDO nada melhor do que
desenvolvemos um pequeno projeto. Vamos desenvolver um pequeno
sistema de ToDo (lista de tarefas).
Para começarmos este projeto, que será orientado a objetos, vamos
desenvolver nossa classe que representará uma tarefa (task). Seu
desenvolvimento pode ser visto abaixo, já com seu devido
encapsulamento dos atributos com os “métodos mágicos” (apenas um set
e apenas um get para todos os atributos).
<?php
 class Task {
 private $taskId;
 private $task;
 private $date;
 
 // Métodos "mágicos" de encapsulamento do PHP
 public function __get($atrib){
 return $this->$atrib;
 }
 
 public function __set($atrib, $value){
 $this->$atrib = $value;
 }
 }
?>
É natural que nossas tarefas fiquem armazenas no banco de dados e, por
isso, vamos utilizar uma única tabela para armazenar estes, devido à
simplicidade do contexto. O quadro abaixo mostra o script de criação da
tabela de tarefas. Repare que que há três colunas nessa tabela: a do
identificador único de cada tarefa, incremental e automático, o texto da
tarefa e um campo de hora, que usaremos para ordenar as tarefas
cronologicamente. Este campo possui um valor default, ou seja, padrão se
não informado, que utiliza a hora do servidor. Faça algumas inserções
manualmente, também, para já termos um banco preenchido para
testarmos a listagem.
CREATE TABLE tasks (
 taskId INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
 task VARCHAR(300) NOT NULL,
 date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
Agora podemos criar nossa classe de conexão com o banco de dados
para realizar as devidas manipulações. O quadro abaixo mostra o script
de como fazer isso utilizando a classe PDO do PHP. Apenas observe que
o nome do banco de dados pode variar caso a caso. O script em questão
mostra como o desenvolvido em aula.
<?php
 class Connection {
 private $serv = 'localhost'; //servidor
 private $db = 'aula_php_temp'; //nome do banco
 private $user = 'root'; //usuário do banco
 private $pass = ''; //senha do banco
 public function connect(){
 try{
 $conn = new PDO(
 "mysql:host=$this->serv;dbname=$this->db",
 "$this->user",
 "$this->pass"
 );
 return $conn;
 } catch(PDOException $e){
 echo $e->getMessage();
 }
 }
 }
?>
Pronto, agora que já temos nossa classe que representa uma tarefa no
sistema, nossa conexão e nosso banco de dados pronto, basta
começarmos a desenvolver o CRUD (Create, Read, Update, Delete –
Criar, Ler, Atualizar, Deletar). Para isso vamos criar dois scripts: Um que
será capaz de realizar todas as manipulações necessárias no banco de
dados (script de serviço – service) e outro que que recebe as requisições
do frontend e direciona para o backend (script de controle – controller). O
quadro abaixo mostra o script “taks_service.php”:
<?php
 class TaskService{
 private $conn; //conexão
 private $task; //tarefa
 //construtor da classe
 public function __construct(Connection $conn, Task $task){
 $this->conn = $conn->connect();
 $this->task = $task;
 }
 public function addTask(){
 $query = 'INSERT INTO tasks(task) VALUES(:task)'; //query
 $stm = $this->conn->prepare($query); //prepara a query
 $stm->bindValue(':task', $this->task->__get('task')); //substitui o
parâmetro
 $stm->execute(); //executa a query
 if($stm->rowCount() > 0){ 
 return true; //se inseriu, o rowCount do resultado é 1
 }
 return false; //caso cotrário, emcontramos um erro
 }
 public function getTasks() {
 $query = 'SELECT t.taskId, t.task, t.date
 FROM tasks as t
 ORDER BY t.date DESC'; //query
 $stm = $this->conn->prepare($query); //prepara
 $stm->execute(); //executa
 return $stm->fetchAll(PDO::FETCH_ASSOC); //retorna os dados
em um resultset
 //FETCH_ASSOC o array é indexado com os mesmos nomes das
colunas
 }
 public function deleteTask() {
 $query = "DELETE FROM tasks WHERE taskId = :taskId"; //query
 $stm = $this->conn->prepare($query); //prepara
 $stm->bindValue(':taskId', $this->task->__get('taskId')); //substitui o
id na query
 return $stm->execute(); //executa
 }
 }
?>
Agora o quadro abaixo mostra o script responsável por direcionar o as
requisições do frontend para o backend, baseado no tipo de acionamento
que ele recebe. O processo é bastante simples, feito com um “switch,
case” baseado no tipo de ação recebida. 
Neste projeto estamos tratando apenas três ações: Criação, listagem e
deleção. Sinta-se desafiado para criar a atualização de uma tarefa.
<?php
 //inclusão dos scripts necessários:
 require_once "task_model.php";
 require_once "task_service.php";
 require_once "connection.php";
 //verifica se o "act" está setado na requisição ou via variável
 $action = isset($_GET['act']) ? $_GET['act'] : $action;
 switch($action) {
 case 'getTasks': //dispara o evento de listar as tarefas
 $conn = new Connection();
 $taskService = new TaskService($conn, new Task());
 $tasks = $taskService->getTasks();
 break;
 case 'addTask': //dispara o evento de nova tarefa
 $task = new Task();
 $conn = new Connection();
 $task->__set('task', $_POST['task']);
 $taskService = new TaskService($conn, $task);
 if($taskService->addTask()) {
 echo 'Inseriu';
 header('Location: index.php');
 } else {
 echo 'Erro'; //apenas mostra que deu erro
 }
 break; 
 case 'deleteTask': //dispara o evento de deleção
 $conn = new Connection();
 $task = new Task();
 $task->__set('taskId', $_GET['taskId']);
 $taskService = new TaskService($conn, $task);
 if($taskService->deleteTask()) {
 header('Location: index.php');
 } else {
 echo 'Erro'; //apenas mostra que deu erro
 }
 break;
 default:
 header('Location: index.php');
 break;
 }
?>
Agora, finalmente podemos criar nosso frontend único, que é capas de
criar, listar e deletar tarefas, com um simplesformulário. O bloco abaixo
mostra o corpo do “index.php”. o cabeçalho (head) do arquivo é o padrão
de um arquivo html com Bootstrap, conforme o vídeo dessa aula mostra.
<body>
 <header>
 <nav class="navbar navbar-dark bg-primary">
 <a class="navbar-brand" href="index.php">
 <!-- ícone de: https://icons.getbootstrap.com/icons/card-checklist/
-->
 <svg xmlns="http://www.w3.org/2000/svg" width="32"
height="32" fill="currentColor" class="bi bi-card-checklist" viewBox="0 0 16
16">
 <path d="M14.5 3a.5.5 0 0 1 .5.5v9a.5.5 0 0 1-.5.5h-13a.5.5 0
0 1-.5-.5v-9a.5.5 0 0 1 .5-.5h13zm-13-1A1.5 1.5 0 0 0 0 3.5v9A1.5 1.5 0 0
0 1.5 14h13a1.5 1.5 0 0 0 1.5-1.5v-9A1.5 1.5 0 0 0 14.5 2h-13z"/>
 <path d="M7 5.5a.5.5 0 0 1 .5-.5h5a.5.5 0 0 1 0 1h-5a.5.5 0 0
1-.5-.5zm-1.496-.854a.5.5 0 0 1 0 .708l-1.5 1.5a.5.5 0 0 1-.708
0l-.5-.5a.5.5 0 1 1 .708-.708l.146.147 1.146-1.147a.5.5 0 0 1 .708 0zM7
9.5a.5.5 0 0 1 .5-.5h5a.5.5 0 0 1 0 1h-5a.5.5 0 0 1-.5-.5zm-1.496-.854a.5.5
0 0 1 0 .708l-1.5 1.5a.5.5 0 0 1-.708 0l-.5-.5a.5.5 0 0 1 .708-.708l.146.147
1.146-1.147a.5.5 0 0 1 .708 0z"/>
 </svg>
 ToDo List
 </a>
 </nav>
 </header>
 <main>
 <div class="container pt-5">
 <h5>Incluir tarefa:</h5>
 <form method="POST" action="task_controller.php?
act=addTask">
 <div class="input-group">
 <input type="text" name="task" required class="form-control"
autofocus placeholder="Nova tarefa...">
 <div class="input-group-append">
 <button class="btn btn-primary"
type="submit">Adicionar</button>
 </div>
 </div>
 </form>
 <hr>
 <h2>Sua lita de tarefas:</h2>
 <?php foreach($tasks as $t) : ?>
 <ul>
 <li><?= $t["task"] ?> - <a href="task_controller.php?
act=deleteTask&taskId=<?=$t["taskId"]?>" class="btn btn-sm btn-
success">Concluir</a></li>
 </ul>
 <?php endforeach ?>
 </div>
 </main>
</body>
Prontinho. Terminamos de desenvolver nosso projeto completo com o
PHP com PDO. Não deixe de tentar melhorar este projeto e se aprofundar
em novos conceitos.
 
 
Atividade extra
Tente terminar o projeto desenvolvido nesta aula, incluindo a edição de
uma tarefa. Pode ser desenvolvida uma nova página para isso, onde a
tarefa é carregada em um campo de texto ou utilizar algo mais avançado,
como AJAX para que a edição ocorra na mesma tela inicial.
 
 
Referência Bibliográfica
Flatschart, F., HTML5 – Embarque imediato, Editora Brasport, 1ª Ed., 2011
Frain, B., Responsive Web Design with HTML5 and CSS, Editora Packt
Publishing, 3ª Ed., 2020
Libby, A., Gupta G., Talesra A., Responsive Web Design with HTML5 and
CSS3 Essentials, Editora Packt Publishing, 1ª Ed., 2016
Twitter Inc., Bootstrap, site oficial, disponível em
https://getbootstrap.com.br/, acessado em 16 de fevereiro de 2021
PHP, site oficial, disponível em http://www.php.net, acessado em 16 de
fevereiro de 2021
Ir para questão
https://getbootstrap.com.br/
http://www.php.net/