Utilizando interface no PHP

Ao trabalhar com Orientação a Objeto, algo que se espera é a confiabilidade de seus participantes. E uma das formas de garantir essa confiabilidade é a utilização de Interface.

A Interface permite definir um “contrato” na qual as classes que vão implementá-las terão que ter os métodos definidos pela interface.

Vamos ver algo mais prático para melhorar esta compreensão.

Você precisará desenvolver um projeto no qual o gerenciador do banco de dados será o MySQL e no decorrer do projeto você é informado que terá que usar o PostgreSQL.

E a agora? Como garantir que o projeto trabalhará com PostgreSQL sem precisar ir em todos os arquivos e efetuar contínuas mudanças?

Definiremos uma Interface que terão os métodos que irão trabalhar com as operações do banco de dados.

DataBase.php

<?php

interface DataBase{
	public function connect();
	public function insert($data);
	public function update($data, $where);
	public function select($columns='*', array $filters=null);
	public function delete($where);
	public function close();
	public function setTableName($name);
}

Criamos uma interface onde definimos as operações comuns com banco de dados, que é conectar, inserir, alterar, selecionar, excluir, fechar e também a definição do nome da tabela.

Quem for utilizar essa interface precisará ter esses métodos, mas a forma que eles irão implementar dependerá de cada classe que irá utilizar.

Agora podemos criar nossas classes que irão implementar.

Vamos criar para o MySQL:

MySQLDataBase.php

<?php
 
class MySQLDataBase implements DataBase{
 
	public function __construct($host, $user, $pass, $dbname){
	 
	}
	 
	public function connect(){
	//Implementa a conexão
	}
	 
	public function insert($data){
	//Implementação do Insert usando MySQL
	}
	 
	public function update($data, $where){
	//Implementação do update usando MySQL
	}
	 
	public function select($columns='*', array $filters=null){
	//Implementação do SELECT usando MySQL
	}
	public function delete($where){
	//Implementação do DELETE usando MySQL
	}
	 
	public function close(){
	//Fecha a conexão
	}
	 
	public function setTableName($name){
	//define nome da tabela
	}
}

Repare que todos os métodos que definimos na Interface foram implementados, só que como a classe vai implementar isso, vai depender de cada banco de dados.

Vamos fazer outro exemplo:

PostgreSQLDataBase.php

<?php
 
class PostgreSQLDataBase implements DataBase{
 
	public function __construct($host, $user, $pass, $dbname){
	 
	}
	 
	public function connect(){
	//Implementa a conexão
	}
	 
	public function insert($data){
	//Implementação do Insert usando Postgre
	}
	 
	public function update($data, $where){
	//Implementação do update usando Postgre
	}
	 
	public function select($columns='*', array $filters=null){
	//Implementação do SELECT usando Postgre
	}
	public function delete($where){
	//Implementação do DELETE usando Postgre
	}
	 
	public function close(){
	//Fecha a conexão
	}
	 
	public function setTableName($name){
	//define nome da tabela
	}
}

Veja que fiz a mesma coisa, mas a forma de implementar a instruções de conectar, inserir, etc, vai depender da classe, mas a única coisa que sei mesmo é que eles terão que ter esses métodos.

Agora criaremos uma nova classe a qual trabalhará com essas classes que vão abstrair.

DataAccessObject.php

<?php
 
class DataAccessObject implements DataBase{
	protected $adapter;
	 
	public function __construct(DataBase $object){
		$this->adapter = $object;
		$this->connect();
	}
	 
	public function setTableName($name){
		$this->adapter->setTableName($name);
	}
	 
	public function connect(){
		$this->adapter->connect();
	}
	 
	public function insert($data){
		$this->adapter->insert($data);
	}
	 
	public function update($data, $where){
		$this->adapter->update($data, $where);
	}
	 
	public function delete($where){
		$this->adapter->delete($where);
	}
	 
	public function close(){
		$this->adapter->close();
	}
}

Veja que criei uma classe que também implementa a Interface DataBase. Só que agora ela tem um atributo chamado adapter, que vai ser responsável por guardar a instância da classe do banco de dados que irei utilizar.

Veja que no construtor é informado que objeto passado tem que ter implementado a interface DataBase. Isso me garante que saberei quais métodos irei utilizar. Mas veja que não falei se será MySQL, PostgreSQL etc, pois não precisa.

O que preciso saber é se ele tem a Interface implementada pra pode utilizar nesta classe.

//Inclui as classes
require_once "Db/DataBase.php";
require_once "Db/MySQLDataBase.php";
require_once "Db/DataAccessObject.php";
 
//Instancia classe que abstrairá as ações do MySQL
$database = new MySQLDataBase($host, $user, $pass, $dbname);
 
//Instancio a classe que fará as operações, dizendo que banco de dados irei utilizar
$dao = new DataAccessObject($database);
 
//Definir o nome da tabela
$dao->setTableName('produtos');
 
//faço uma operação
$dao->delete('idProduto = 1');

Agora vamos dizer que precisamos usar o PostgreSQL. Simples, apenas instanciamos a classe do PostgreSQL e passamos para classe DataAccessObject.

//Inclui as classes
require_once "Db/DataBase.php";
require_once "Db/PostgreSQLDataBase.php";
require_once "Db/DataAccessObject.php";
 
//Instancia classe que abstrairá as ações do PostgreSQL
$database = new PostgreSQLDataBase($host, $user, $pass, $dbname);
 
//Instancio a classe que fará as operações, dizendo que banco de dados irei utilizar
$dao = new DataAccessObject($database);
 
//Definir o nome da tabela
$dao->setTableName('produtos');
 
//faço uma operação
$dao->delete('idProduto = 1');