Interface em CRUD - S.O.L.I.D

[paulodsn 1]

Fala pessoal,

 

Estou com uma dúvida, comecei a estudar sobre design partners e acabei me deparando com as regras S.O.L.I.D. Assistir alguns debates entretanto fiquei com uma dúvida que é:

• sempre devo usar uma interface em um controller?
• Em um CRUD é necessário o uso de interface? 
• Quando usar interface?

 

Obrigado desde já.

[Don Benatti 28]

Olá amigo, linguagens como PHP não desfrutam de todo pode que uma interface oferece, nesta linguagem você consegue burlar tudo, criar hacks para as coisas, etc. veja alguns hacks abaixo:

$class_name = "StdClass";
new $class_name;
$object->{"nomeDoMetodo"}($a, $b, $c);
// Entre outras "gambiarras"

Interfaces não são o que são por iniciar seu design com a palavra interface, na verdade é possível criar interfaces em qualquer linguagem, mesmo que está não ofereça uma "keyword" chamada "Interface", pra ser mais especifico, é possível criar uma interface usando uma classe concreta, eu sei que essa pode ter doído um pouco, mas você entenderá assim que conseguir "ficar de pé na prancha".

 

Veja um exemplo:

interface Crud
{
    public function create(/* [args...] */);
    
    public function read(/* [args...] */);
    
    public function update(/* [args...] */);
    
    public function delete(/* [args...] */);
}

Vamos implementar esta interface onde quisermos

class MySql implements Crud
{}

class SQLite implements Crud
{}

class XML implements Crud
{}

class JSON implements Crud
{}

class TextPlain implements Crud
{}

class Etc implements Crud
{}

Dessa maneira a única instancia que nosso sistema vai esperar será a de "Crud" e não a de MySql, SQLite ou outro.

class UmaClasseQueFazAlgo
{
    /**
    * @var Crud
    */
    private $instanciaDeCrud;
    
    /**
    * @param Crud $crud
    */
    public function __construct(Crud $crud)
    {
        $this->instanciaDeCrud = $crud;
    }
    
    public function facaAlgo()
    {
        /*
        Dessa maneira você poderá mudar internamente de MySql 
        para JSON que não afetará em nada aqui
        */
        $this->instanciaDeCrud->create(/* [args...] */);
    }
}

(new UmaClasseQueFazAlgo())->facaAlgo();

 

[paulodsn 1]

Opa! Don Banatti sua explicação me ajudou muito. Junto com esse vídeo (https://www.asolucoesweb.com.br/aula/php-orientado-a-objetos-interfaces-quando-usar), pude perceber quando se deve usar interface. 

[Matheus Tavares 167]

Olá @paulodsn.

 

5 minutos atrás, paulodsn disse:

sempre devo usar uma interface em um controller?

Honestamente, não entendi muito bem essa dúvida.

O que é um controller pra você? Um dos 3 pilares do MVC? Se sim, quem fornece esse controller à você?

Digo, qual biblioteca ou framework? Phalcon? ZF? Yii? Laravel?

Esse monte de questões é pelo fato de que depende. Depende de quem projetou/desenhou a ferramenta que você está utilizando.

Eu particularmente nunca vi uma framework que ofereça uma interface (não abrangendo classes abstratas aqui) para um Controller, mas nada impede de haver, pois isso é um mero detalhe da implementação do projeto.

 

12 minutos atrás, paulodsn disse:

Em um CRUD é necessário o uso de interface? 

De novo, depende do projeto. Vamos supor que você queira criar uma lib para auxiliar nos métodos de resposta para um CRUD, beleza... daí você pode criar uma interface, que nada mais é do que um contrato entre as partes do sistema que se relacionam de alguma forma, pelo ponto que tange o uso dessa interface (seus métodos/declaração). Exemplo:

<?php
interface CrudInterface {
    
    public function create();
    public function read();
    public function update();
    public function delete();
    
}

Agora quem implementar essa interface deve implementar seus métodos. Por isso é um contrato. Todos sabem que a classe que implementa essa interface segue um padrão de comportamento e pode fazer uma ou mais tarefas.

 

Então temos um controller para as notícias do sistema que implementa essa interface, pois sabemos que ele deve respeitar as respostas dos 4 métodos que definimos:

class Noticias implements CrudInterface {
    public function create()
    {
        //lógica para criar uma notícia
    }
    
    public function read()
    {
        //lógica para ler notícias
    }
    
    public function update()
    {
        //lógica para atualizar uma notícia
    }
    
    public function delete() {
        //lógica para excluir uma notícia
    }
}

 

Isso facilita a organização do código, pois dá limites à ele. Expõe as intenções de um pacote sem precisar necessariamente explicar sobre isso.

 

Tudo é muito conceitual, eu sei. Passei pelas mesmas dúvidas que você. É fato ainda que muitas vezes podemos utilizar classes abstratas ao invés de interfaces e isso nos confunde ainda mais, certo?

Mas a verdade é que interfaces são meras definições comportamentais. Ela diz: essa classe FAZ alguma coisa, enquanto uma classe abstrata indica que a classe filha É alguma coisa.

 

Veja:

- Temos um Funcionário em uma empresa (uma pessoa, genérica, mas com atribuições que lhe colocam em um grupo específico).

- Temos o comportamento de Dirigir (algo que pessoas fazem, mas não todas).

 

Então podemos criar uma pessoa concreta seguindo o raciocínio:

class Pessoa {}
interface CarDriver {
    public function turnLeft();
    public function turnRight();
	public function moveForward();
    //outras possíveis ações no manuseio de um carro
}
class Funcionario extends Pessoa {}

//observe a composição de classes e "contratos de ações" (interfaces)
//Joao deve implementar sua forma de dirigir por si só. Cada um dirige de uma forma.
class Joao extends Pessoa implements CarDriver {
   //implementações....
}

 

O problema é que esses exemplos, apesar de verdadeiros, não nos auxiliam no entendimento para a prática no desenvolvimento web. Então vamos pegar o exemplo do nosso pequeno módulo de Noticias com CRUD e bolar um exemplo prático. Vou colocar arquivo por arquivo. Leia linha-a-linha, pois fiz comentários para ajudar no entendimento.

 

CrudInterface

/**
 * Cada recurso da nossa pequena API REST deve implementar essa interface se quiser
 * declarar ao sistema que respeita os métodos de uma CRUD comum
 */
interface CrudInterface
{
    public function create(array $data);
    public function read(int $id = null);//Se id informado, apenas ele, senão todos
    public function update(array $data, int $id);
    public function delete(int $id);//argumento tipado disponível somente no PHP 7.0.0 em diante
}

 

News (uma implementação concreta de CRUD)

class News implements CrudInterface
{
    
    /**
     * Isso seria responsabilidade de outra lib, mas vamos armazenar as noticias aqui para fins didáticos.
     * Vamos preencher com dados por padrão para exemplificar.
     */
    private $news = [
        [
            'id'     => 1,//como em um banco de dados, vamos começar o id por 1 e não 0
            'titulo' => 'Girafas agora podem voar!',
            'texto'  => 'Lorem ipsum dolor sit amet...',
        ],
        [
            'id'     => 2,
            'titulo' => 'iMasters eleito o maior portal de TI do Brasil novamente!',
            'texto'  => 'Lorem ipsum dolor sit amet...',
        ],
    ];
    
    public function create(array $data)
    {
        $this->news[] = [
            'id'     => $this->getLastId() + 1,
            'titulo' => $data[ 'titulo' ],//seria interessante validar...
            'texto'  => $data[ 'texto' ],
        ];
    }
    
    public function read(int $id = null)
    {
        if ( $id === null ) {
            return print_r( $this->news, true );//leitura de um registro específico
        }
        
        return print_r( $this->news[ $this->getIndexById( $id ) ], true );//leitura de todos os registros
    }
    
    public function update(array $data, int $id)
    {
        $registro =& $this->news[ $this->getIndexById( $id ) ];
        
        if ( isset( $data[ 'titulo' ] ) ) {
            $registro[ 'titulo' ] = $data[ 'titulo' ];
        }
        
        if ( isset( $data[ 'texto' ] ) ) {
            $registro[ 'texto' ] = $data[ 'texto' ];
        }
    }
    
    public function delete(int $id)
    {
        unset( $this->news[ $this->getIndexById( $id ) ] );
    }
    
    /**
     * Os métodos abaixo fazem parte da nossa implementação somente.
     * Não faz parte do contrato, mas precisamos desses métodos para ajudar a satisfazer o propósito da classe
     */
    private function getIndexById(int $id)
    {
        foreach ( $this->news as $i => $noticia ) {
            if ( $noticia[ 'id' ] === $id ) {
                return $i;
            }
        }
        
        throw new Exception( 'ID inexistente.' );
    }
    
    private function getLastId()
    {
        return max( array_column( $this->news, 'id' ) );
    }
    
}

 

AddressParser - Apenas um auxiliar para a classe responsável pelas Rotas

class PatternNotSatisfied extends Exception
{
}

/**
 * Essa classe não segue os princípios da Clean Code / S.O.L.I.D.
 * Muita responsabilidade em cima de cada método, mas para não aumentarmos a quantidade de classes,
 * fiz uma implementação bem primitiva propositalmente. Ela é apenas uma auxiliar do Router,
 * mas podia ser desmembrada para ficar melhor.
 */
class AddressParser
{
    
    private $address;
    private $params = [];
    
    public function __construct($actual_address)
    {
        $this->address = trim( $actual_address, '/' );
    }
    
    public function getFirstSuitablePattern($options)
    {
        $address_chunks = explode( '/', $this->address );
        
        foreach ( $options as $pattern ) {
            $this->params = [];
            $pattern_chunks = explode( '/', trim( $pattern, '/' ) );
            $address_chunks_copy = $address_chunks;
            
            try {
                while ( $pattern_chunk = array_shift( $pattern_chunks ) ) {
                    $this->parseAndTestChunks( $pattern_chunk, array_shift( $address_chunks_copy ) );
                }
                
                return $pattern;//se não encontrou exceções, pode ser utilizada como padrão para a URL requisitada
                
            } catch ( PatternNotSatisfied $e ) {
            }
        }
        
        return end( $options );
    }
    
    private function parseAndTestChunks($pattern_chunk, $address_chunk = null)
    {
        //Trata-se de um parâmetro
        if ( $pattern_chunk[ 0 ] === ':' ) {
            
            //O parâmetro é obrigatório
            if ( $pattern_chunk[ 1 ] !== '[' && !$address_chunk ) {
                throw new PatternNotSatisfied();
            }
            
            //O parâmetro é opcional
            if ( $address_chunk ) {
                $this->params[] = $address_chunk;
            }
            
            return;
        }
        
        if ( $pattern_chunk === $address_chunk ) {
            return;
        }
        
        throw new PatternNotSatisfied();
    }
    
    public function getParamsFromLastParsing()
    {
        return $this->params;
    }
    
}

 

Router

/**
 * Implementação da Router desconsiderando a REQUEST e RESPONSE
 *
 * Além disso trabalharemos apenas com métodos para tratar as calls, ignorando a possibilidade
 * do uso de Closures, por exemplo.
 */
class Router
{
    
    private $methods = [];
    
    /**
     * Os exemplos serão feitos "na mão", via código mesmo. Por isso precisamos de um método para invocar
     * nossas requisições, simulando uma ação externa, como em uma pequena API REST
     */
    public function request($http_method, $actual_address, array $params = null)
    {
        $parser = new AddressParser( $actual_address );
        $possible_methods = array_keys( $this->methods[ $http_method ] );
        $address_pattern = $parser->getFirstSuitablePattern( $possible_methods );
        $handler = $this->methods[ $http_method ][ $address_pattern ];
        
        $params = array_merge( (array)$params, (array)$parser->getParamsFromLastParsing() );
        
        return call_user_func_array( $handler, $params );
    }
    
    /**
     * O que é $controller? Um objeto Controller? Não importa!
     * handleCrud() espera apenas que o objeto seja capaz de responder por uma CRUD
     *
     * As requisições devem respeitar as seguintes regras:
     * 1 - Quantas partes (controller, action, etc) quiser para compor a URL
     * 2 - Parametros começam com :
     * 3 - Parâmetros opcionais ficam dentro de [ ]
     */
    public function handleCrud(CrudInterface $controller)
    {
        $resource_name = mb_strtolower( get_class( $controller ) );//apenas o nome da classe minúsculo. No caso, "news"
        
        $this->get( "/{$resource_name}/:[id]", [ $controller, 'read' ] );
        $this->post( "/{$resource_name}/:id", [ $controller, 'update' ] );
        $this->put( "/{$resource_name}", [ $controller, 'create' ] );
        $this->delete( "/{$resource_name}/:[id]", [ $controller, 'delete' ] );
    }
    
    /**
     * Na nossa limitada implementação, $handler deve representar um array com o par "objeto-nome do método"
     */
    public function get($address, array $handler)
    {
        $this->methods[ 'GET' ][ $address ] = $handler;
    }
    
    public function post($address, array $handler)
    {
        $this->methods[ 'POST' ][ $address ] = $handler;
    }
    
    public function put($address, array $handler)
    {
        $this->methods[ 'PUT' ][ $address ] = $handler;
    }
    
    public function delete($address, array $handler)
    {
        $this->methods[ 'DELETE' ][ $address ] = $handler;
    }
    
}

 

 

E agora unimos tudo e usamos a ferramenta:

$router = new Router;
$app = new News;

/**
 * É aqui que a mágica acontece.
 * Veja a implementação de Router e notará que ele nem sequer conhece uma notícia (News).
 * Ele apenas oferece um método adicional (além de get, put, etc...) para tratar especificamente CRUDs.
 * E como ele sabe quem pode tratar uma CRUD?
 * Pela imposição feita sobre o tipo do parâmetro desse método (CrudInterface).
 */
$router->handleCrud( $app );

/**
 * Vamos simular algumas requisições.
 * Note o uso de [[]]. Isso é pelo fato de este parâmetro gera uma lista chave-valor de parâmetros para o objecto,
 * onde o primeiro parâmetro da lista seria $data com o array de dados.
 *
 * Caso fosse um único array, estaríamos dizendo que queríamos passar $titulo e $texto como parâmetro,
 * enquanto na verdade queremos passar um array de dados.
 */
$router->request( 'PUT', '/news', [ [ 'titulo' => 'TESTANDO', 'texto' => 'bla bla bla bla' ] ] );
$router->request( 'POST', '/news/3', [ [ 'titulo' => 'Este novo título é muito melhor :)' ] ] );
$router->request( 'DELETE', '/news/1' );

//exibimos o resultado final
echo nl2br( $router->request( 'GET', '/news' ) );

 

Resultado:

Array
(
[1] => Array
(
[id] => 2
[titulo] => iMasters eleito o maior portal de TI do Brasil novamente!
[texto] => Lorem ipsum dolor sit amet...
)

[2] => Array
(
[id] => 3
[titulo] => Este novo título é muito melhor :)
[texto] => bla bla bla bla
)

)

 

[paulodsn 1]

@Matheus Tavares Muito obrigado pela explicação, reforçou mais a ideia, onde eu posso sim ter uma interface em meu controller ( MVC - Laravel). Porém vai depender para que eu quero utiliza-lo e se realmente é preciso a interface, no seu exemplo é uma obrigação a existência de uma interface pois na parte:

    public function handleCrud(CrudInterface $controller)
    {
        $resource_name = mb_strtolower( get_class( $controller ) );//apenas o nome da classe minúsculo. No caso, "news"
        
        $this->get( "/{$resource_name}/:[id]", [ $controller, 'read' ] );
        $this->post( "/{$resource_name}/:id", [ $controller, 'update' ] );
        $this->put( "/{$resource_name}", [ $controller, 'create' ] );
        $this->delete( "/{$resource_name}/:[id]", [ $controller, 'delete' ] );
    }
    

 

Você utiliza os métodos no qual foram definidos através do "contrato". Além disso você não precisa especificar qual class está sendo passada para ele, apenas sendo necessário que a class passada tenha o "contrato".

[Matheus Tavares 167]

Perfeito, @paulodsn. Excelente observação.

 

37 minutos atrás, paulodsn disse:

no seu exemplo é uma obrigação a existência de uma interface

Apenas é bom reforçar a diferença que expliquei no post (entre interfaces x classes abstratas), em relação a isso que você disse.

 

O código obriga sim uma interface para declarar as regras de comportamento da classe, que serão utilizadas pelo Router.

Mas essa interface poderia ser feita utilizando uma classe abstrata também.

 

Bastaria que para isso tornássemos CrudInterface uma classe abstrata e seus métodos fossem abstract.

 

Aí vai da sua necessidade e do seu projeto.

O método handleCrud() poderia funcionar exatamente da mesma forma, se ao invés da interface ele definisse que o tipo fosse uma classe abstrata.

 

É interessante ver os exemplos do próprio PHP: http://php.net/manual/pt_BR/reserved.interfaces.php

Observe que interfaces geralmente possuem nomes como "FAZEDOR" (sufixo "or") de alguma coisa ou "CAPAZ" (able) de fazer algo.

Exemplo: "Traversable" => "Capaz de atravessar / (Percorrível)"

Outro: "Throwable" => "Capaz de arremessar/disparar (uma exceção, no caso)"

 

Já uma classe, mesmo abstrata, ela sempre SERÁ alguma coisa. "Animal" é o abstrato de Cachorro (que é concreto)...

 

Enfim... mas que bom que o código te ajudou. Os conceitos confundem mesmo, por isso quis trazer algo mais "prático". Geralmente é mais eficiente no aprendizado.