Melhorando a Legibilidade do Código com Design Patterns

Olá, pessoal! Hoje vamos explorar alguns Design Patterns e ver como eles podem ser aplicados em nossa rotina diária. Mas primeiro, o que são Design Patterns?

Design Patterns são padrões de código que se repetem ao longo da nossa vida. Eles não são exatamente um bloco de código ou algo bem específico, mas sim uma receita a ser seguida. São muito importantes para remover a duplicidade do nosso código e deixar o nosso código mais legível para outros humanos. Eles não melhoram o algoritmo em si, mas melhoram a nossa legibilidade do código.

Agora que sabemos o que são Design Patterns, vamos ver um exemplo simples e analisá-lo.

class Gateway:
  def __init__(self):
    pass

  def initialize_payment(self, payment):
    pass

class Payment:
  def __init__(self):
    pass

  def pay_by_credit_card(self):
    gateway = Gateway()
    gateway.initialize_payment(self)

  def pay_by_debit_card(self):
    gateway = Gateway()
    gateway.initialize_payment(self)

Podemos identificar alguns padrões de design nesse código? Vamos lá!

Programação orientada a objetos: Podemos ver que temos duas classes aqui, Gateway e Payment.
Dependência injection: A classe Payment está recebendo outra classe, Gateway, no método initialize_payment. Isso é chamado de dependência injection.
Código duplicado: Podemos ver que temos o mesmo código em ambos os métodos pay_by_credit_card e pay_by_debit_card. Isso pode ser resolvido usando o padrão de design conhecido como Factory Method.

O Factory Method serve para fatorar um código e inicializar um pedaço do código para você. No nosso caso, podemos ter uma função que inicializa as duas classes juntas, como mostrado abaixo:

def build_payment():
  gateway = Gateway()
  payment = Payment()
  gateway.initialize_payment(payment)
  return payment

payment = build_payment()
payment.pay_by_credit_card()
payment.pay_by_debit_card()

Agora, temos uma funçãozinha legal chamada payByOrderId que faz o mesmo que os métodos anteriores, mas de forma mais legível:

def payByOrderId(payment, orderId):
  payment.pay_by_credit_card()
  payment.pay_by_debit_card()
  # outras coisas que precisam ser feitas

payment = build_payment()
payByOrderId(payment, orderId)

E se surgir um novo gateway de pagamento? Não precisamos duplicar as classes, podemos usar um padrão chamado Abstract Factory. Criamos uma classe base chamada BasicGateway com o método interno getUrl que precisa ser implementado nas classes que extenderem essa classe base.

class BasicGateway:
  def getUrl(self):
    raise NotImplementedError

class GatewayA(BasicGateway):
  def getUrl(self):
    return 'process.tmp.api.gatewayA'

class GatewayB(BasicGateway):
  def getUrl(self):
    return 'process.tmp.api.gatewayB'

def build_payment():
  gateway = GatewayA() if process.tmp.api == 'gatewayA' else GatewayB()
  payment = Payment()
  gateway.initialize_payment(payment)
  return payment

E agora, temos um código mais legível e fácil de entender para quem está trabalhando com a gente. E isso é o que os Design Patterns servem: nos ajudam a economizar código e deixar nosso código bem mais legível.

Espero que tenham gostado desse vídeo! Não esqueçam de compartilhar com os amigos e se inscrever no canal. Tamo junto!

Referências:

Esse blog post foi escrito utilizando AI ( especificamente whisper-large ) com o projeto https://github.com/S4mpl3r/youtube2blog.

O vídeo abaixo foi transcrito e utilizado como base para gerar o texto:

Design Patterns (ai)

Melhorando a Legibilidade do Código com Design Patterns

Melhorando a Legibilidade do Código com Design Patterns