Nos posts anteriores, exploramos dois métodos diferentes para lidar com o processamento de pagamentos no Laravel:

• ligações de serviço codificadas
• vinculação contextual.

Embora ambos os métodos sejam eficazes, eles têm suas limitações quando se trata de selecionar processadores de pagamento dinamicamente com base nas condições de tempo de execução (por exemplo, entrada do usuário, definições de configuração).

Nesta terceira e última parte, veremos uma abordagem mais flexível: usando o Factory Pattern. Este padrão de design nos permite escolher a implementação apropriada de PaymentProcessorInterface com base no contexto (por exemplo, selecionando entre Stripe ou PayPal dependendo da solicitação).

Implementando o Padrão de Fábrica

O Factory Pattern fornece uma solução escalável para resolver dinamicamente diferentes implementações em tempo de execução. Veja como configurá-lo passo a passo.

Etapa 1: Crie uma interface de fábrica

Primeiro, vamos definir um PaymentProcessorFactoryInterface que descreve como resolver diferentes processadores de pagamento.

Essa interface garante que qualquer fábrica que criarmos terá um método getProcessor, responsável por retornar o processador de pagamento apropriado com base no argumento fornecido (por exemplo, 'stripe' ou 'paypal').


  
  
  Etapa 2: Criar a Implementação de Fábrica


Em seguida, implementaremos a fábrica que resolve o processador de pagamento apropriado com base na entrada do provedor.


Esta fábrica seleciona dinamicamente o processador de pagamento correto com base na entrada fornecida em tempo de execução. Neste exemplo, retornamos diretamente novas instâncias de StripePaymentProcessor e PayPalPaymentProcessor. Se necessário, essas classes também podem ser resolvidas no contêiner de serviço do Laravel para melhor gerenciamento.


  
  
  Etapa 3: implementar processadores Stripe e PayPal


Certifique-se de ter as classes StripePaymentProcessor e PayPalPaymentProcessor que implementam o PaymentProcessorInterface.

Exemplo: StripePaymentProcessor


Exemplo: PayPalPaymentProcessor

Da mesma forma, implemente a classe PayPalPaymentProcessor, seguindo o mesmo padrão do StripePaymentProcessor.


  
  
  Etapa 4: vincular a fábrica ao contêiner de serviço


Para garantir que a fábrica esteja disponível em todo o seu aplicativo Laravel, você precisa vincular o PaymentProcessorFactory ao contêiner de serviço do Laravel. Você pode fazer isso no AppServiceProvider.

Em App\Providers\AppServiceProvider.php, adicione o seguinte dentro do método de registro:


public function register()
{
    $this->app->singleton(\App\Contracts\PaymentProcessorFactoryInterface::class, \App\Services\PaymentProcessorFactory::class);
}




Essa ligação diz ao Laravel para usar PaymentProcessorFactory sempre que PaymentProcessorFactoryInterface for solicitado, garantindo que haja apenas uma instância da fábrica em toda a aplicação.


  
  
  Etapa 5: usando o Factory em um controlador


Agora que a fábrica está configurada, você pode injetá-la em seus controladores para selecionar dinamicamente o processador de pagamento apropriado com base nos dados de tempo de execução, como a entrada da solicitação.

Exemplo: PaymentController


paymentProcessorFactory = $paymentProcessorFactory;
    }

    public function makePayment(Request $request)
    {
        $provider = $request->input('provider'); // E.g., 'stripe' or 'paypal'
        $amount = $request->input('amount');
        $currency = $request->input('currency');
        $paymentDetails = $request->input('details');

        // Get the appropriate payment processor based on the provider
        $paymentProcessor = $this->paymentProcessorFactory->getProcessor($provider);

        // Use the selected payment processor to create a payment
        $response = $paymentProcessor->createPayment($amount, $currency, $paymentDetails);

        return response()->json($response);
    }
}




Neste controlador, injetamos PaymentProcessorFactoryInterface por meio de injeção de dependência. Quando um pagamento é solicitado, determinamos o provedor de pagamento (por exemplo, Stripe ou PayPal) a partir da solicitação, passamos para a fábrica e resolvemos dinamicamente o processador de pagamento apropriado.


  
  
  Etapa 6: Lidar com diferentes provedores de pagamento


Nesta configuração, o controlador agora pode lidar dinamicamente com diferentes provedores de pagamento simplesmente trocando o nome do provedor na solicitação. Este método é particularmente poderoso quando você precisa lidar com vários gateways de pagamento sem duplicar a lógica ou acoplar firmemente seu código a implementações específicas.


  
  
  Conclusão


Usar o Factory Pattern no Laravel 11 oferece uma abordagem altamente flexível para selecionar diferentes processadores de pagamento em tempo de execução. Aqui está um resumo das etapas que abordamos:

• Interface e implementação de fábrica: criou uma fábrica que resolve dinamicamente o processador de pagamento correto com base em uma entrada de string.
• Implementações de processador: garantia de que as classes StripePaymentProcessor e PayPalPaymentProcessor implementem PaymentProcessorInterface.
• Encadernação do contêiner de serviço: vincula a fábrica ao contêiner de serviço para permitir fácil injeção em toda a aplicação. Seleção dinâmica em controladores: usou a fábrica dentro de um controlador para selecionar e usar dinamicamente o processador de pagamento apropriado com base nos dados de tempo de execução.

Princípios e padrões de design de software

Começamos este tutorial de 3 partes usando um único processador de pagamento, com uma seleção codificada, depois estávamos usando uma configuração in code ("tempo de compilação") usando Laravel Service Container Binding, então nesta parte continuamos refatorando com design princípios e padrões de design em mente, o que nos permitiu refatorar o código, alcançando:

• Flexibilidade Dinâmica: O Factory Pattern permite a seleção de diferentes processadores de pagamento em tempo de execução, tornando sua aplicação mais flexível e escalável.
• Acoplamento fraco: Ao injetar a fábrica, seus controladores ficam fracamente acoplados aos processadores de pagamento, facilitando a adição ou substituição de gateways de pagamento no futuro.
• Manutenção: Esta abordagem fornece uma base de código mais limpa e de fácil manutenção, especialmente ao lidar com múltiplas opções de pagamento.

Com esta configuração, agora temos um sistema poderoso e flexível para lidar com pagamentos no Laravel. Se precisarmos oferecer suporte a processadores adicionais, podemos facilmente estender a fábrica para oferecer suporte e modificar a lógica de seleção de provedores e lidar com diferentes cenários de lógica de negócios.