À medida que avançamos em um projeto, perdidos em blocos if-else, lutando com condições complexas e código repetitivo, procuramos uma solução. Mas por que deveríamos ficar presos em blocos if-else? Neste artigo, vamos descobrir como se livrar da confusão if-else junto com os padrões de estratégia e fábrica.

Problema: confusão If-Else

Digamos que você esteja desenvolvendo um aplicativo de comércio eletrônico e precise oferecer suporte a diferentes métodos de pagamento, como cartão de crédito, cartão de débito e criptomoeda. Você começa com blocos if-else para processar pagamentos:

public class PaymentService {

    public void processPayment(String paymentType) {
        if (paymentType.equals("CREDIT_CARD")) {
            System.out.println("Processing credit card payment...");
        } else if (paymentType.equals("DEBIT_CARD")) {
            System.out.println("Processing debit card payment...");
        } else if (paymentType.equals("CRYPTO")) {
            System.out.println("Processing crypto payment...");
        } else {
            throw new IllegalArgumentException("Invalid payment type");
        }
    }
}

Embora possa parecer simples à primeira vista, à medida que os métodos de pagamento aumentam, também aumenta a complexidade do if-else. Um novo método de pagamento significa adicionar uma nova condição. O resultado é uma pilha de código difícil de gerenciar. E este método é contrário ao Princípio Aberto-Fechado.

Mas, podemos usar os padrões Estratégia e Fábrica para resolver esse problema.

Primeiro, vamos criar uma enumeração:

public enum PaymentType {
    CREDIT_CARD,
    DEBIT_CARD,
    CRYPTO
}

Solução: Limpeza com Padrão de Estratégia

public interface PaymentStrategy {
    void pay(PaymentRequest request);
}

public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(PaymentRequest request) {
        System.out.println("Processing $type payment".replace("$type", String.valueOf(request.getPaymentType())));
    }
}

public class DebitCardPayment implements PaymentStrategy {
    @Override
    public void pay(PaymentRequest request) {
        System.out.println("Processing $type payment".replace("$type", String.valueOf(request.getPaymentType())));
    }
}

public class CryptoPayment implements PaymentStrategy {
    @Override
    public void pay(PaymentRequest request) {
        System.out.println("Processing $type payment".replace("$type", String.valueOf(request.getPaymentType())));
    }
}

Nesta fase, uma estratégia separada para cada método de pagamento é implementada a partir de uma interface comum. Agora, com o Factory Pattern, decidiremos qual estratégia escolher.

Passo 2: Escolhendo Estratégia com Padrão de Fábrica

Nesta etapa, podemos tornar o Factory Pattern mais limpo e otimizado com EnumMap.

public class PaymentFactory {
    private static final Map strategies = new EnumMap(PaymentType.class);

    static {
        strategies.put(PaymentType.CREDIT_CARD, new CreditCardPayment());
        strategies.put(PaymentType.DEBIT_CARD, new DebitCardPayment());
        strategies.put(PaymentType.CRYPTO, new CryptoPayment());
    }

    public static PaymentStrategy getPaymentStrategy(PaymentType paymentType) {
        PaymentStrategy strategy = strategies.get(paymentType);

        if (Objects.isNull(strategy))
            throw new IllegalArgumentException("Strategy not found");

        return strategy;
    }
}

Última etapa: reorganização da classe de serviço

Agora, vamos usar o que fizemos.

public class PaymentService {

    public void processPayment(PaymentRequest request) {
        // Don't forget to check objects if null!
        if (Objects.isNull(request) || Objects.isNull(request.getPaymentType())
            throw new IllegalArgumentException("Request can not be null!");
        PaymentStrategy strategy = PaymentFactory.getPaymentStrategy(request.getPaymentType());

        strategy.pay(request);
    }
}

Do jeito que está, não precisamos de nenhum bloco if-else para processamento de pagamentos. Graças à Estratégia e aos Padrões de Fábrica, nosso código é mais limpo, modular e extensível.

Por que devemos usar esses padrões?

1. Extensibilidade: Adicionar uma nova forma de pagamento requer apenas uma nova classe e algumas linhas de código.
2. Legibilidade: Ao usar estratégias e fábrica em vez de blocos if-else, você torna seu código mais compreensível e gerenciável.
3. Capacidade de manutenção: Com a estratégia e o padrão de fábrica, alterações no código podem ser feitas sem afetar outras partes do código.

Conclusão: da confusão à clareza

Se você estiver trabalhando em um projeto em crescimento, não deve usar blocos if-else. Os padrões de estratégia e fábrica são soluções perfeitas para tornar seu código mais limpo, modular e de fácil manutenção.

Como você pode ver neste artigo, usar padrões de design em vez de blocos if-else para gerenciar transações de pagamento torna o projeto mais desenvolvível e melhora a legibilidade do código. Experimente esses padrões em seu próximo projeto em vez de usar blocos if-else.

...

Obrigado por ler meu artigo! Se você tiver alguma dúvida, feedback ou opinião que gostaria de compartilhar, adoraria ouvi-los nos comentários.

Você pode me seguir em dev.to para obter mais informações sobre este tópico e minhas outras postagens.

Obrigado??

Para me seguir no LinkedIn: https://www.linkedin.com/in/tamerardal/
Médio: não use mais blocos if-else! Use estratégia e padrão de fábrica juntos