Pular para o conteúdo

Design Patterns em PHP na prática (com Laravel)

Brayan Monteiro Brayan Monteiro
Atualizado em 20/11/2026 15 min de leitura
O que é Design Patterns (Padrões de Design)?
Compartilhar:

Se você trabalha com PHP, provavelmente já encontrou alguma classe que começou pequena e, com o passar do tempo, virou um amontoado de condicionais, responsabilidades e dependências. Uma alteração simples acaba afetando várias partes do sistema, e manter o código se torna cada vez mais trabalhoso.

É justamente nesse tipo de situação que os Design Patterns (padrões de projeto) podem ajudar. Eles oferecem soluções conhecidas para problemas recorrentes no desenvolvimento de software, ajudando a organizar o código e facilitar sua manutenção.

Mas existe um detalhe importante: conhecer padrões de projeto não significa que você precisa aplicar um em cada classe do seu sistema. Na verdade, saber quando não utilizar um padrão é tão importante quanto conhecer sua implementação.

Neste artigo, vamos conhecer quatro Design Patterns e entender como aplicá-los em situações reais com PHP: Strategy, Observer, Decorator e Adapter. Também veremos como alguns desses conceitos aparecem naturalmente no Laravel.

O que são Design Patterns?

Design Patterns são soluções reutilizáveis para problemas comuns encontrados durante o desenvolvimento de software. Eles não são bibliotecas, frameworks ou códigos prontos que você simplesmente copia para dentro do projeto. São modelos de organização que podem ser adaptados de acordo com a necessidade de cada aplicação.

A ideia ganhou bastante popularidade em 1994, com a publicação do livro Design Patterns: Elements of Reusable Object-Oriented Software, escrito por Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides, conhecidos como Gang of Four (GoF).

O livro documentou 23 padrões de projeto, organizados em três categorias:

  • Criacionais: relacionados à criação de objetos, como Factory Method, Abstract Factory e Singleton.
  • Estruturais: ajudam a organizar e relacionar classes e objetos, como Adapter, Decorator e Facade.
  • Comportamentais: tratam da comunicação e distribuição de responsabilidades entre objetos, como Strategy, Observer e Command.

Esses padrões não foram criados para serem seguidos como regras obrigatórias. São soluções que surgiram da experiência de desenvolvedores ao lidar com problemas recorrentes em sistemas orientados a objetos.

Na prática, um padrão de projeto ajuda a estabelecer uma estrutura conhecida para resolver determinado problema. Isso também facilita a comunicação entre desenvolvedores, já que mencionar Strategy ou Observer pode ser suficiente para explicar uma abordagem de implementação.

Quando utilizar Design Patterns?

Antes de conhecer os exemplos, vale entender que nem todo problema precisa de um padrão de projeto.

Imagine que você tenha uma aplicação que realiza um cálculo simples de frete. Se existe apenas uma regra e não há previsão de mudanças, criar cinco interfaces e várias classes para resolver isso provavelmente vai complicar mais do que ajudar.

Agora imagine que a aplicação passe a trabalhar com diferentes transportadoras, cada uma com suas próprias regras de cálculo, integração e condições de entrega. Nesse cenário, uma estrutura que permita substituir essas implementações pode fazer bastante sentido.

Algumas situações em que Design Patterns podem ajudar:

  • Quando uma classe começa a acumular muitas responsabilidades.
  • Quando diferentes partes do sistema precisam executar a mesma operação de maneiras diferentes.
  • Quando existe muito acoplamento entre componentes.
  • Quando você precisa integrar bibliotecas ou serviços com interfaces diferentes.
  • Quando novas funcionalidades precisam ser adicionadas sem modificar constantemente o código existente.

Por outro lado, evite aplicar padrões apenas porque eles são conhecidos ou aparecem em livros de arquitetura de software.

Um bom código não é aquele que utiliza mais padrões, mas aquele que resolve o problema com a menor complexidade possível.

1. Strategy Pattern: diferentes formas de executar uma operação

O Strategy é um padrão comportamental que permite definir diferentes maneiras de executar uma operação, deixando que a aplicação escolha qual implementação utilizar.

Vamos imaginar um sistema de vendas que oferece diferentes tipos de desconto. Inicialmente, existe apenas um desconto de 10%, mas futuramente podem surgir descontos para clientes VIP, campanhas promocionais e cupons.

Uma implementação inicial poderia ser algo assim:

class DiscountCalculator
{
    public function calculate(float $price, string $type): float
    {
        if ($type === 'percentage') {
            return $price * 0.90;
        }

        if ($type === 'fixed') {
            return $price - 20;
        }

        return $price;
    }
}

O problema começa quando novas regras aparecem. A classe passa a acumular condicionais e precisa ser modificada sempre que um novo tipo de desconto é criado.

Com o Strategy, podemos separar cada regra em sua própria implementação.

Primeiro, criamos um contrato:

interface DiscountStrategy
{
    public function calculate(float $price): float;
}

Agora, cada estratégia implementa esse contrato:

final class PercentageDiscount implements DiscountStrategy
{
    public function calculate(float $price): float
    {
        return $price * 0.90;
    }
}
final class FixedDiscount implements DiscountStrategy
{
    public function calculate(float $price): float
    {
        return max(0, $price - 20);
    }
}

Podemos adicionar quantas estratégias forem necessárias, sem precisar alterar as implementações existentes.

A classe responsável pelo cálculo recebe a estratégia por injeção de dependência:

final class DiscountCalculator
{
    public function __construct(
        private DiscountStrategy $strategy
    ) {}

    public function calculate(float $price): float
    {
        return $this->strategy->calculate($price);
    }
}

Na utilização, basta fornecer a implementação desejada:

$calculator = new DiscountCalculator(
    new PercentageDiscount()
);

echo $calculator->calculate(100);

Se quisermos utilizar o desconto fixo, podemos trocar a estratégia:

$calculator = new DiscountCalculator(
    new FixedDiscount()
);

echo $calculator->calculate(100);

A classe DiscountCalculator não precisa conhecer os detalhes de cada regra. Ela simplesmente utiliza o contrato definido pela interface.

Quando utilizar?

  • Quando existem diferentes formas de executar uma mesma operação.
  • Quando as regras de negócio podem mudar ou crescer.
  • Quando você quer substituir implementações sem alterar a classe que utiliza o comportamento.

Quando evitar?

Se existe apenas uma implementação simples e não há necessidade real de substituição, criar uma interface e várias classes pode ser desnecessário.

Outro detalhe: no exemplo utilizamos float apenas para simplificar a demonstração. Em sistemas financeiros reais, prefira trabalhar com valores monetários em unidades inteiras, como centavos, ou utilizar uma biblioteca apropriada para operações financeiras.

2. Observer Pattern: reagindo a eventos sem acoplamento

O Observer é um padrão comportamental que permite que diferentes componentes sejam notificados quando determinado acontecimento ocorre.

Imagine um sistema de vendas. Quando um pedido é concluído, algumas ações precisam acontecer:

  • Enviar um e-mail para o cliente.
  • Registrar uma notificação.
  • Atualizar informações de outros serviços.
  • Gerar algum registro para acompanhamento.

Uma implementação muito acoplada poderia colocar todas essas responsabilidades dentro da própria classe de pedidos.

O problema é que, conforme novas funcionalidades aparecem, a classe responsável pelo pedido começa a conhecer cada vez mais componentes do sistema.

O Observer resolve isso permitindo que outros componentes acompanhem acontecimentos sem precisar estar diretamente conectados à implementação que os dispara.

No Laravel, temos uma implementação desse conceito por meio de Events e Listeners.

Vamos começar criando um evento:

php artisan make:event OrderCompleted

Na classe OrderCompleted, podemos receber o pedido que acabou de ser concluído:

namespace App\Events;

use App\Models\Order;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;

class OrderCompleted
{
    use Dispatchable;
    use SerializesModels;

    public function __construct(
        public Order $order
    ) {}
}

Agora podemos criar um Listener responsável por enviar o e-mail:

php artisan make:listener SendOrderConfirmation
namespace App\Listeners;

use App\Events\OrderCompleted;
use Illuminate\Contracts\Queue\ShouldQueue;

class SendOrderConfirmation implements ShouldQueue
{
    public function handle(OrderCompleted $event): void
    {
        $order = $event->order;

        // Enviar e-mail de confirmação do pedido.
    }
}

Também podemos criar outro Listener para registrar uma notificação:

php artisan make:listener RegisterOrderNotification
namespace App\Listeners;

use App\Events\OrderCompleted;

class RegisterOrderNotification
{
    public function handle(OrderCompleted $event): void
    {
        // Registrar notificação para o cliente.
    }
}

Com os componentes criados, basta disparar o evento quando o pedido for concluído:

use App\Events\OrderCompleted;

OrderCompleted::dispatch($order);

Os dois Listeners podem reagir ao mesmo evento, cada um executando sua própria responsabilidade.

A classe responsável por concluir o pedido não precisa saber que existe um serviço de e-mail ou um sistema de notificações.

No Laravel, os eventos e seus respectivos listeners podem ser registrados automaticamente ou configurados conforme a estrutura da aplicação. Consulte a documentação da versão utilizada para verificar o mecanismo de descoberta e registro.

Quando utilizar?

  • Quando diferentes partes do sistema precisam reagir ao mesmo acontecimento.
  • Quando você quer separar efeitos colaterais da lógica principal.
  • Quando novas ações podem ser adicionadas sem modificar o componente que dispara o evento.

Quando evitar?

Não transforme qualquer chamada de método em um evento. Se uma operação depende diretamente do resultado de outra e precisa acontecer de maneira sequencial, uma chamada explícita pode ser muito mais simples.

Também tenha atenção ao processamento assíncrono: quando um Listener utiliza filas, sua execução acontece posteriormente e exige o gerenciamento adequado das filas e das possíveis falhas.

3. Decorator Pattern: adicionando comportamentos sem modificar a classe original

O Decorator é um padrão estrutural que permite adicionar funcionalidades a um objeto sem precisar modificar sua implementação original.

Imagine que você desenvolveu um serviço de notificações por e-mail. Com o tempo, surge a necessidade de registrar logs sempre que uma mensagem for enviada.

Uma alternativa seria modificar a classe original e colocar a lógica de logging dentro dela. Mas isso mistura responsabilidades e pode dificultar a evolução do serviço.

Com o Decorator, podemos envolver o objeto original em outra implementação que adiciona esse comportamento.

Primeiro, definimos um contrato para as notificações:

interface Notifier
{
    public function send(string $message): void;
}

Criamos a implementação original:

final class EmailNotifier implements Notifier
{
    public function send(string $message): void
    {
        // Enviar e-mail.
    }
}

Agora, criamos um Decorator que recebe outro objeto do mesmo tipo e adiciona o registro de logs:

use Psr\Log\LoggerInterface;

final class LoggingNotifier implements Notifier
{
    public function __construct(
        private Notifier $notifier,
        private LoggerInterface $logger
    ) {}

    public function send(string $message): void
    {
        $this->notifier->send($message);

        $this->logger->info(
            'Notificação enviada.',
            ['message' => $message]
        );
    }
}

Observe que LoggingNotifier também implementa Notifier, mas recebe outra implementação desse mesmo contrato.

Isso permite utilizar o Decorator como se fosse o serviço original:

$notifier = new LoggingNotifier(
    new EmailNotifier(),
    $logger
);

$notifier->send('Seu pedido foi confirmado!');

A mensagem é enviada pelo EmailNotifier e, em seguida, o Decorator registra a operação.

Podemos criar outros Decorators para adicionar métricas, auditoria ou outras funcionalidades, combinando diferentes comportamentos sem modificar a classe original.

Quando utilizar?

  • Quando você precisa adicionar funcionalidades a um objeto sem modificar sua implementação.
  • Quando deseja combinar comportamentos de maneira flexível.
  • Quando herança não é uma boa alternativa para estender uma funcionalidade.

Quando evitar?

Se o comportamento adicional é simples e não existe necessidade de composição, criar várias camadas de Decorators pode dificultar o entendimento do fluxo de execução.

Também é importante não confundir Decorator com qualquer classe que simplesmente encapsula outra. Para caracterizar o padrão, o objeto decorador deve preservar o contrato do componente original e acrescentar um comportamento.

4. Adapter Pattern: integrando serviços com interfaces diferentes

O Adapter é um padrão estrutural utilizado quando precisamos integrar componentes que possuem interfaces incompatíveis.

Esse cenário é bastante comum em sistemas que trabalham com APIs externas, gateways de pagamento e bibliotecas de terceiros.

Imagine que sua aplicação utiliza um serviço de pagamento que recebe valores em centavos e espera um método chamado charge(). Agora você precisa integrar outro gateway que possui um método diferente, chamado createPayment(), e recebe os valores em outro formato.

Modificar toda a aplicação para atender à interface do novo serviço seria uma péssima ideia.

Em vez disso, podemos criar um Adapter responsável por traduzir a comunicação entre os dois componentes.

Primeiro, definimos o contrato que nossa aplicação espera:

interface PaymentGateway
{
    public function pay(
        int $amountInCents,
        string $currency
    ): string;
}

Agora imagine que uma biblioteca externa disponibiliza a seguinte classe:

final class ExternalPaymentSdk
{
    public function createPayment(
        float $amount,
        string $currencyCode
    ): array {
        // Comunicação com o gateway externo.

        return [
            'transaction_id' => 'TX-12345',
            'status' => 'approved',
        ];
    }
}

Não precisamos modificar essa biblioteca. Criamos uma classe adaptadora que implementa o contrato da nossa aplicação:

final class ExternalPaymentAdapter implements PaymentGateway
{
    public function __construct(
        private ExternalPaymentSdk $sdk
    ) {}

    public function pay(
        int $amountInCents,
        string $currency
    ): string {
        $response = $this->sdk->createPayment(
            $amountInCents / 100,
            $currency
        );

        return $response['transaction_id'];
    }
}

Agora, qualquer componente da aplicação pode trabalhar com a interface PaymentGateway, sem conhecer os detalhes da biblioteca externa.

final class CheckoutService
{
    public function __construct(
        private PaymentGateway $gateway
    ) {}

    public function checkout(int $amountInCents): string
    {
        return $this->gateway->pay(
            $amountInCents,
            'BRL'
        );
    }
}

Se amanhã você precisar substituir o gateway, basta criar outro Adapter que implemente o mesmo contrato.

A lógica principal do checkout continua funcionando sem precisar conhecer as particularidades de cada fornecedor.

Quando utilizar?

  • Quando precisa integrar bibliotecas ou APIs com interfaces diferentes.
  • Quando trabalha com sistemas antigos que não podem ser modificados.
  • Quando deseja manter a aplicação independente dos detalhes de um fornecedor externo.

Quando evitar?

Se a integração é simples e não existe incompatibilidade relevante entre as interfaces, criar uma camada adicional pode ser desnecessário.

O Adapter deve resolver um problema de compatibilidade, não servir apenas como intermediário sem responsabilidade real.

Design Patterns já fazem parte do Laravel

Uma coisa interessante é que você não precisa implementar todos esses padrões manualmente para aproveitar seus benefícios. Frameworks como Laravel já utilizam conceitos de orientação a objetos e padrões de projeto em sua própria arquitetura.

Alguns exemplos:

Observer com Events e Listeners

Como vimos anteriormente, o sistema de eventos do Laravel oferece uma implementação do padrão Observer. Um evento pode ser recebido por diferentes listeners, permitindo separar responsabilidades dentro da aplicação.

Injeção de dependências com Service Container

O Service Container do Laravel gerencia dependências e permite injetar implementações nos componentes que precisam delas.

Isso facilita bastante a utilização de interfaces e diferentes estratégias dentro da aplicação.

Por exemplo, podemos registrar uma implementação de PaymentGateway em um Service Provider:

use App\Contracts\PaymentGateway;
use App\Services\ExternalPaymentAdapter;

public function register(): void
{
    $this->app->bind(
        PaymentGateway::class,
        ExternalPaymentAdapter::class
    );
}

Assim, quando uma classe precisar de PaymentGateway, o Laravel poderá fornecer a implementação registrada automaticamente.

Essa abordagem é especialmente útil quando trabalhamos com diferentes serviços, integrações e implementações de regras de negócio.

Vale lembrar que injeção de dependências é um princípio e uma técnica de organização de código, não um Design Pattern GoF por si só.

Vale a pena utilizar Design Patterns em todos os projetos?

Não. E é importante entender isso antes de sair criando interfaces e classes para qualquer funcionalidade.

Design Patterns são ferramentas para resolver problemas de arquitetura e organização de código. Eles ajudam a reduzir acoplamento, separar responsabilidades e facilitar mudanças, mas também podem aumentar a quantidade de abstrações e a complexidade de uma aplicação.

Em projetos PHP e Laravel, por exemplo, é bastante comum encontrar aplicações com uma quantidade exagerada de interfaces, repositories, factories e services que não acrescentam nenhuma funcionalidade relevante.

O problema não está em utilizar esses recursos, mas em utilizá-los sem uma necessidade concreta.

Antes de aplicar um padrão, procure entender:

  • Qual problema estou tentando resolver?
  • Essa estrutura realmente facilita futuras alterações?
  • Existe uma necessidade de substituir ou combinar implementações?
  • A solução está ficando mais simples ou apenas ganhou mais classes?

Se você consegue responder essas perguntas e percebe que a estrutura proposta resolve um problema real, provavelmente está no caminho certo.

Conclusão

Aprender Design Patterns é uma etapa importante para quem deseja evoluir na programação orientada a objetos e desenvolver aplicações mais organizadas e fáceis de manter.

Neste artigo, vimos quatro padrões que podem ser bastante úteis no desenvolvimento com PHP: Strategy, Observer, Decorator e Adapter. Cada um resolve um tipo diferente de problema, desde a substituição de regras de negócio até a integração de serviços externos.

O mais importante é entender que padrões de projeto não são receitas obrigatórias. São soluções que você pode utilizar quando encontrar situações nas quais elas realmente fazem sentido.

Com o tempo e a experiência, você começa a reconhecer esses problemas naturalmente e percebe que muitos conceitos já estão presentes nos frameworks e ferramentas que utiliza no dia a dia.

Não programe pensando em aplicar Design Patterns. Programe pensando em resolver problemas. Os padrões devem ser consequência de boas decisões de arquitetura, não um objetivo por si só.

Referências

Leia também: Algoritmos e Lógica de Programação para Iniciantes

Palavras-chave:

#Design Patterns #Padrões de Projetos

Sobre o autor

Brayan Monteiro

Brayan Monteiro

Bacharel em Sistemas de Informação pela Faculdade Maurício de Nassau e desenvolvedor de software. Produzo conteúdo e gerencio blogs. Sou especialista em desenvolvimento web e SEO de sites.

Continue lendo

Postagens relacionadas

Discussão

Comentários

Nenhum comentário ainda. Seja o primeiro a comentar.