PDO em PHP Orientado a Objetos

Veja nesse artigo como usar o PDO em PHP orientado a objetos para conectar em um banco de dados.

por Gregory Monteiro

Nesse artigo vou mostrar como usar o PDO para conectar em um banco de dados em PHP orientado a objetos.

Nesse exemplo estou usando o banco de dados MySQL.

Vamos primeiramente criar um banco de dados chamado “teste”. Ver Listagem 1

Listagem 1: Código para criar um banco de dados no MySQL query

create database teste

Agora vamos criar a estrutura da classe de conexão. Para isso vamos criar um arquivo chamado conexao.php e criar a nossa classe database que será uma abstrata. Ver Listagem 2.

Listagem 2: Estrutura da classe database

<?php
abstract class database{
}
?>

Vamos então adicionar os métodos padrões para as classes abstratas que são o __construct, __clone e __destruct. Ver Listagem 3.

Os métodos __construct e __destruct.são padrões do php e são responsáveis por construir e destruir a instancia da nossa classe.

O método __clone evita que nossa classe seja clonada.

Listagem 3: Classe usuarios com os métodos __construct, __clone e __destruct

<?php
abstract class database{
	/*Método construtor do banco de dados*/
	private function __construct(){}
	
	/*Evita que a classe seja clonada*/
	private function __clone(){}
	
	/*Método que destroi a conexão com banco de dados e remove da memória todas as variáveis setadas*/
	public function __destruct() {
		foreach ($this as $key => $value) {
			unset($this->$key);
        }
	}
}
?>

Na listagem 3 o método __destruct remove da memória todas as variáveis que foram setadas pela nossa classe.

Agora vamos criar os métodos de conexão e fechar a conexão com o BD. Ver Listagem 4.

Listagem 4: Métodos connect e disconnect

<?php
abstract class database{
	/*Método construtor do banco de dados*/
	private function __construct(){}
	
	/*Evita que a classe seja clonada*/
	private function __clone(){}
	
	/*Método que destroi a conexão com banco de dados e remove da memória todas as variáveis setadas*/
	public function __destruct() {
		$this->disconnect();
		foreach ($this as $key => $value) {
			unset($this->$key);
        }
	}
	
	private static $dbtype   = "mysql";
	private static $host     = "localhost";
	private static $port     = "3306";
	private static $user     = "root";
	private static $password = "123";
	private static $db       = "teste";
	
	/*Metodos que trazem o conteudo da variavel desejada
	@return   $xxx = conteudo da variavel solicitada*/
	private function getDBType()  {return self::$dbtype;}
	private function getHost()    {return self::$host;}
	private function getPort()    {return self::$port;}
	private function getUser()    {return self::$user;}
	private function getPassword(){return self::$password;}
	private function getDB()      {return self::$db;}
	
	private function connect(){
		try
		{
			$this->conexao = new PDO($this->getDBType().":host=".$this->getHost().";port=".$this->getPort().";dbname=".$this->getDB(), $this->getUser(), $this->getPassword());
		}
		catch (PDOException $i)
		{
			//se houver exceção, exibe
			die("Erro: <code>" . $i->getMessage() . "</code>");
		}
		
		return ($this->conexao);
	}
	
	private function disconnect(){
		$this->conexao = null;
	}
}
?>

Veja a definição das variáveis privadas usadas para conexão na Listagem 4:

• dbtype - define uma string que informa qual a plataforma de banco de dados que estamos usando. Para o MySQL usamos a string “mysql” e para o SQL Server usamos a string “mssql”. Veja nesse link http://br.php.net/manual/en/pdo.drivers.php os drives de banco de dados suportados pelo PDO
• host - define o nome do host
• port - define a porta do host
• user - define o usuário de acesso ao banco de dados
• password - define a senha de acesso ao banco de dados
• db - define o nome do banco de dados

O método connect tenta se conectar com o banco de dados usando as informações passadas pelas variáveis privadas, caso não consiga retorna um erro.

O método disconnect finaliza a conexão com o banco de dados. Perceba que esse método está sendo chamado pelo método __destruct, ou seja, ele sempre será executado ao término da utilização da classe database.

Por fim vamos criar os métodos insert, select, update e delete para fazer o nosso CRUD. Ver Listagem 5.

Listagem 5: Métodos insert, select, update e delete

<?php
abstract class database{
	/*Método construtor do banco de dados*/
	private function __construct(){}
	
	/*Evita que a classe seja clonada*/
	private function __clone(){}
	
	/*Método que destroi a conexão com banco de dados e remove da memória todas as variáveis setadas*/
	public function __destruct() {
		$this->disconnect();
		foreach ($this as $key => $value) {
			unset($this->$key);
        }
	}
	
	private static $dbtype   = "mysql";
	private static $host     = "localhost";
	private static $port     = "3306";
	private static $user     = "root";
	private static $password = "123";
	private static $db       = "teste";
	
	/*Metodos que trazem o conteudo da variavel desejada
	@return   $xxx = conteudo da variavel solicitada*/
	private function getDBType()  {return self::$dbtype;}
	private function getHost()    {return self::$host;}
	private function getPort()    {return self::$port;}
	private function getUser()    {return self::$user;}
	private function getPassword(){return self::$password;}
	private function getDB()      {return self::$db;}
	
	private function connect(){
		try
		{
			$this->conexao = new PDO($this->getDBType().":host=".$this->getHost().";port=".$this->getPort().";dbname=".$this->getDB(), $this->getUser(), $this->getPassword());
		}
		catch (PDOException $i)
		{
			//se houver exceção, exibe
			die("Erro: <code>" . $i->getMessage() . "</code>");
		}
		
		return ($this->conexao);
	}
	
	private function disconnect(){
		$this->conexao = null;
	}
	
	/*Método select que retorna um VO ou um array de objetos*/
	public function selectDB($sql,$params=null,$class=null){
		$query=$this->connect()->prepare($sql);
		$query->execute($params);
		
		if(isset($class)){
			$rs = $query->fetchAll(PDO::FETCH_CLASS,$class) or die(print_r($query->errorInfo(), true));
		}else{
			$rs = $query->fetchAll(PDO::FETCH_OBJ) or die(print_r($query->errorInfo(), true));
		}
		self::__destruct();
		return $rs;
    }
	
	/*Método insert que insere valores no banco de dados e retorna o último id inserido*/
	public function insertDB($sql,$params=null){
		$conexao=$this->connect();
		$query=$conexao->prepare($sql);
		$query->execute($params);
		$rs = $conexao->lastInsertId() or die(print_r($query->errorInfo(), true));
		self::__destruct();
		return $rs;
    }
	
	/*Método update que altera valores do banco de dados e retorna o número de linhas afetadas*/
	public function updateDB($sql,$params=null){
		$query=$this->connect()->prepare($sql);
		$query->execute($params);
		$rs = $query->rowCount() or die(print_r($query->errorInfo(), true));
		self::__destruct();
		return $rs;
    }
	
	/*Método delete que excluí valores do banco de dados retorna o número de linhas afetadas*/
	public function deleteDB($sql,$params=null){
		$query=$this->connect()->prepare($sql);
		$query->execute($params);
		$rs = $query->rowCount() or die(print_r($query->errorInfo(), true));
		self::__destruct();
		return $rs;
    }
}
?>

Os métodos insert, update e delete tem quase a mesma codificação, eles recebem o comando SQL e e os parâmetros então o executa retornando o número de linhas afetadas. A diferença é que o método insert retorna o último id inserido na tabela.

Caso aconteça algum erro ao tentar executar o comando esses métodos retornam o erro.

O método select recebe o SQL, os parâmetros e o nome de uma classe para o qual o método transformará os dados da tabela em objetos. Para isso é necessário criar uma classe de mapeamento VO (Value Objects) que receberá esses dados.

Caso não seja passado o nome de uma classe ele retorna um array de objetos.

Assim como nos métodos insert, update e delete, se acontecer algum erro o método select retorna esse erro.

Ficamos por aqui, até o próximo artigo.