O que são padrões de design: por que usá-los, classificação, prós e contras

Na engenharia de software, os padrões de projeto são soluções ideais para problemas que comumente ocorrem no projeto de software.

Eles são como pré-projetosdefiferramentas limitadas e testadas que você pode personalizar para resolver um problema de design recorrente em seu código.

Tempo estimado de leitura: 6 minutos

O que é um padrão de design

Um padrão de projeto não é um código que podemos copiar e inserir em nosso programa, como podemos fazer com funções ou bibliotecas padrão. O padrão de projeto é um conceito geral capaz de resolver um problema específico. Basicamente um modelo cujos detalhes podemos seguir e implementar uma solução que se ajuste à realidade do nosso programa.

Os modelos são frequentemente confundidos com algoritmos, porque ambos os conceitos descrevem soluções típicas para alguns problemas conhecidos. Enquanto um algoritmo defiSe houver sempre um conjunto claro de ações que podem atingir um determinado objetivo, um modelo é uma descrição de nível superior de uma solução. O código do mesmo modelo aplicado a dois programas diferentes pode ser diferente.

Querendo fazer uma analogia, podemos pensar em uma receita culinária: ambas possuem passos claros para atingir um objetivo. Porém, um modelo é mais parecido com um projeto, do qual você pode ver qual é o resultado e suas características, mas a ordem exata de implementação depende de nós que escrevemos o código.

Do que é feito um padrão de design?

A maioria dos padrões é descrita de forma muito formal para que as pessoas possam reproduzi-los em muitos contextos. Vejamos a seguir os elementos que estão presentes na descrição de um modelo:

• A intenção do modelo descreve brevemente o problema e a solução.
• A motivação explica melhor o problema e a solução que o modelo torna possível.
• A estrutura de classes mostra cada parte do modelo e como elas estão relacionadas.
• O exemplo de código em uma das linguagens de programação mais populares torna mais fácil entender a ideia por trás do modelo.

Por que usá-los?

Um programador pode desenvolver software sem saber da existência de padrões de projeto. Muitos o fazem e, por esta razão, implementam alguns esquemas sem saber. Mas então por que deveríamos gastar tempo aprendendo-os?

• Os padrões de design são um kit de soluções experimentadas e testadas para problemas comuns em design de software. Mesmo que você nunca encontre esses problemas, conhecer os padrões ainda é útil porque ensina como resolver todos os tipos de problemas usando princípios de design orientado a objetos.
• Os modelos de design defiEles criam uma linguagem comum que você e sua equipe podem usar para se comunicar de forma mais eficaz. Você poderia dizer: “Ah, basta usar um Singleton para fazer isso” e todos entenderão a ideia por trás de sua sugestão. Não há necessidade de explicar o que é um singleton se você conhece o padrão e seu nome.

Classificação de padrões de design

Os padrões de projeto diferem em complexidade, nível de detalhe e escala de aplicabilidade em todo o sistema projetado.

Por analogia, podemos tornar um cruzamento mais seguro instalando alguns semáforos ou construindo um cruzamento completo de vários níveis com passagens subterrâneas para pedestres.

Os modelos mais básicos e de baixo nível são frequentemente chamados expressões idiomáticas . Eles geralmente se aplicam apenas a uma única linguagem de programação.

Os modelos mais universais e de alto nível são modelos arquitetônicos . Os desenvolvedores podem implementar esses padrões em praticamente qualquer linguagem. Ao contrário de outros padrões, eles podem ser usados ​​para projetar a arquitetura de uma aplicação inteira.

Além disso, todos os modelos podem ser classificados de acordo com sua tentou ou propósito. As três classes principais são:

• Modelos criacionais eles fornecem mecanismos de criação de objetos que aumentam a flexibilidade e a reutilização do código existente.
• Modelos estruturais eles explicam como montar objetos e classes em estruturas maiores, mantendo essas estruturas flexíveis e eficientes.
• Modelos comportamentais eles lidam com a comunicação eficaz e a atribuição de responsabilidades entre objetos.

Exemplo de padrão de design no Laravel: Fachada

fachada é um padrão de design estrutural que fornece uma interface simplificada para uma biblioteca, estrutura ou qualquer outro conjunto complexo de classes.

Problema

Vamos supor que precisamos fazer o software funcionar, baseado em um grande conjunto de objetos que pertencem a uma biblioteca ou framework sofisticado. Normalmente, precisaríamos inicializar todos esses objetos, controlar as dependências, executar métodos na ordem correta e assim por diante.

Como resultado, a lógica de negócios das classes ficaria fortemente acoplada aos detalhes de implementação de classes de terceiros, tornando-as difíceis de compreender e gerenciar.

solução

Uma facade é uma classe que fornece uma interface simples para um subsistema complexo que contém muitas partes móveis. A facade pode fornecer funcionalidade limitada em comparação ao trabalho direto com o subsistema. No entanto, inclui apenas os recursos que realmente interessam aos clientes.

Tenha um facade é útil quando precisamos integrar o aplicativo a uma biblioteca sofisticada que possui dezenas de recursos, mas precisamos apenas de uma pequena parte de sua funcionalidade.

Por exemplo, um aplicativo que carrega vídeos curtos e engraçados com gatos nas redes sociais poderia usar uma biblioteca profissional de conversão de vídeo. No entanto, tudo o que realmente precisamos é de uma classe com o método único encode(filename, format). Após criar tal classe e conectá-la à biblioteca de conversão de vídeo, teremos nossa primeira facade.

Por exemplo, a operadora telefônica de uma central de atendimento é como um facade. Na verdade, quando ligamos para o serviço telefônico de uma loja para fazer um pedido por telefone, uma operadora é nossa facade para todos os serviços e departamentos da loja. A operadora fornece uma interface de voz simples para o sistema de pedidos, gateways de pagamento e diversos serviços de entrega.

Exemplo real em PHP

Pense sobre fachada como um adaptador simples para alguns subsistemas complexos. Facade isola a complexidade dentro de uma única classe e permite que outro código de aplicativo use a interface simples.

Neste exemplo, Facade esconde a complexidade da API do YouTube e da biblioteca FFmpeg do código do cliente. Em vez de trabalhar com dezenas de classes, o cliente utiliza um método simples no Façade.

<?php

namespace RefactoringGuru\Facade\RealWorld;

/**
 * The Facade provides a single method for downloading videos from YouTube. This
 * method hides all the complexity of the PHP network layer, YouTube API and the
 * video conversion library (FFmpeg).
 */
class YouTubeDownloader
{
    protected $youtube;
    protected $ffmpeg;

    /**
     * It is handy when the Facade can manage the lifecycle of the subsystem it
     * uses.
     */
    public function __construct(string $youtubeApiKey)
    {
        $this->youtube = new YouTube($youtubeApiKey);
        $this->ffmpeg = new FFMpeg();
    }

    /**
     * The Facade provides a simple method for downloading video and encoding it
     * to a target format (for the sake of simplicity, the real-world code is
     * commented-out).
     */
    public function downloadVideo(string $url): void
    {
        echo "Fetching video metadata from youtube...\n";
        // $title = $this->youtube->fetchVideo($url)->getTitle();
        echo "Saving video file to a temporary file...\n";
        // $this->youtube->saveAs($url, "video.mpg");

        echo "Processing source video...\n";
        // $video = $this->ffmpeg->open('video.mpg');
        echo "Normalizing and resizing the video to smaller dimensions...\n";
        // $video
        //     ->filters()
        //     ->resize(new FFMpeg\Coordinate\Dimension(320, 240))
        //     ->synchronize();
        echo "Capturing preview image...\n";
        // $video
        //     ->frame(FFMpeg\Coordinate\TimeCode::fromSeconds(10))
        //     ->save($title . 'frame.jpg');
        echo "Saving video in target formats...\n";
        // $video
        //     ->save(new FFMpeg\Format\Video\X264(), $title . '.mp4')
        //     ->save(new FFMpeg\Format\Video\WMV(), $title . '.wmv')
        //     ->save(new FFMpeg\Format\Video\WebM(), $title . '.webm');
        echo "Done!\n";
    }
}

/**
 * The YouTube API subsystem.
 */
class YouTube
{
    public function fetchVideo(): string { /* ... */ }

    public function saveAs(string $path): void { /* ... */ }

    // ...more methods and classes...
}

/**
 * The FFmpeg subsystem (a complex video/audio conversion library).
 */
class FFMpeg
{
    public static function create(): FFMpeg { /* ... */ }

    public function open(string $video): void { /* ... */ }

    // ...more methods and classes... RU: ...дополнительные методы и классы...
}

class FFMpegVideo
{
    public function filters(): self { /* ... */ }

    public function resize(): self { /* ... */ }

    public function synchronize(): self { /* ... */ }

    public function frame(): self { /* ... */ }

    public function save(string $path): self { /* ... */ }

    // ...more methods and classes... RU: ...дополнительные методы и классы...
}


/**
 * The client code does not depend on any subsystem's classes. Any changes
 * inside the subsystem's code won't affect the client code. You will only need
 * to update the Facade.
 */
function clientCode(YouTubeDownloader $facade)
{
    // ...

    $facade->downloadVideo("https://www.youtube.com/watch?v=QH2-TGUlwu4");

    // ...
}

$facade = new YouTubeDownloader("APIKEY-XXXXXXXXX");
clientCode($facade);

Ercole Palmeri