Utilizando Interface no PHP

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 a algo mais prático para melhor entender isso.

Você precisará desenvolver um projeto, o qual Gerenciador do Banco de Dados será o MySQL e no decorrer do projeto você é informado terá que usar o PostgreSQL. E a agora? Como garantir que o projeto trabalhará como PostgreSQL, sem precisar ir em todos os arquivos e efetuar contínuas mudanças?

Vamos definir uma interface, que terão os métodos que irão trabalhar com as operações do banco de dados.

DataBase.php

[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);
}
[/php]

Criamos uma interface onde definimos as operações comuns com banco de dados, que é conectar, inserir, alterar, selecionar, excluir, fechar, e também definição do nome da tabela. Quem for utilizar essa interface precisará ter esses métodos, mas a forma q 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]
<?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
}
}

[/php]

Repare que todos os métodos foram utilizados da interface, só que como a classe vai implementar isso, vai depender de cada banco de dados. Vamos fazer outro exemplo:

PostgreSQLDataBase.php

[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 PostgreSQL
}

public function update($data, $where){
//Implementação do update usando PostgreSQL
}

public function select($colums=’*’, array $filters=null){
//Implementação do SELECT usando PostgreSQL
}
public function delete($where){
//Implementação do DELETE usando PostgreSQL
}

public function close(){
//Fecha a Conexão
}

public function setTableName($name){
//define nome da tabela
}
}

[/php]

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 que coisa q sei mesmo q eles terão q ter esses métodos.

Agora criaremos uma nova classe, a qual trabalhará com essas classes, que vai abstrair pra gente:

DataAccessObject.php

[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();
}
}

[/php]

Veja que criei uma classe que também implementa a interface DataBase. Só que agora ela tem um atributo chamado adapter, q vai ser responsável por guardar a instancia da classe do banco de dados q irei utilizar. Veja que no construtor é informado q objeto passado tem q ter implementado a interface DataBase, isso me garante que saberei q métodos irei utilizar. Mas veja que não falei se será MySQL,PostgreSQL etc, porque não precisa, o que preciso saber que ele tem a interface implementado, pra pode utilizar nessa classe.

[php]
//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’);

[/php]

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

[php]
//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’);

[/php]

Veja que operação no banco de dados, continuará a mesma, a lógica da aplicação não vai mudar, porque sei que as classes que vão trabalhar com banco de dados terão a interface com as operações que foram definidas.

Então a ideia da interface é definir uma forma de trabalhar, mas como você vai trabalhar, vai depender de cada classe. Definimos q iremos trabalhar com as operações no banco de dados, todas as classes que implementarem a Interface, terão que ter esses métodos, caso precise mudar de banco de dados, não terei perda no sistema, porque sei que irão trabalhar da mesma forma, só a implementação que será diferente.

Espero que tenha ajudado.

E até a próxima.