How Enums Can Eliminate Messy if‑else Chains in Java Payment Logic

Why if‑else chains are problematic

Long if‑else statements for payment channel selection become hard to read, violate the Open/Closed Principle, and are difficult to test. Adding a new channel requires modifying existing code, leading to bugs.

if ("wechat".equals(channel)) {
    payWithWeChat(amount);
} else if ("alipay".equals(channel)) {
    payWithAlipay(amount);
} else if ("bankcard".equals(channel)) {
    payWithBankCard(amount);
} else if ("paypal".equals(channel)) {
    payWithPayPal(amount);
} else if ("applepay".equals(channel)) {
    payWithApplePay(amount);
} else {
    throw new UnsupportedPaymentException("Unsupported channel: " + channel);
}

Pain points of the if‑else chain

Readability : Logic is scattered and hard to see supported branches.

Extensibility : Adding a new type requires code changes, increasing bug risk.

Open/Closed Principle : The code is not closed for modification.

Testing : All logic is in one method, making unit tests cumbersome.

Enum + Strategy + Functional Programming as a solution

Java enums are full‑featured classes that can hold fields, constructors, methods, and behavior, making them ideal for encapsulating payment logic.

public enum PayChannel {
    WECHAT("wechat", amount -> System.out.println("Using WeChat Pay " + amount)),
    ALIPAY("alipay", amount -> System.out.println("Using Alipay " + amount)),
    BANKCARD("bankcard", amount -> System.out.println("Using Bank Card Pay " + amount)),
    PAYPAL("paypal", amount -> System.out.println("Using PayPal " + amount)),
    APPLEPAY("applepay", amount -> System.out.println("Using Apple Pay " + amount));

    private final String code;
    private final PayHandler handler;

    PayChannel(String code, PayHandler handler) {
        this.code = code;
        this.handler = handler;
    }

    public void pay(BigDecimal amount) {
        handler.pay(amount);
    }

    public static PayChannel fromCode(String code) {
        return Arrays.stream(values())
            .filter(c -> c.code.equals(code))
            .findFirst()
            .orElseThrow(() -> new IllegalArgumentException("Unsupported channel: " + code));
    }
}

Usage becomes a single clean call:

String channelCode = "alipay";
BigDecimal amount = new BigDecimal("99.99");
PayChannel channel = PayChannel.fromCode(channelCode);
channel.pay(amount);

Output:

Using Alipay 99.99

Advantages

Logic is centralized; adding a new channel only requires a new enum constant.

Complies with the Open/Closed Principle.

Easy to unit‑test each enum constant.

No if‑else statements remain.

Advanced: Integrating with Spring

When each payment method needs a Spring service, an enum can store the bean name and retrieve it from the application context.

@Component
public enum PayChannelServiceLocator {
    WECHAT("wechat", "weChatPayService"),
    ALIPAY("alipay", "alipayPayService"),
    BANKCARD("bankcard", "bankCardPayService");

    private final String code;
    private final String beanName;

    PayChannelServiceLocator(String code, String beanName) {
        this.code = code;
        this.beanName = beanName;
    }

    public void pay(BigDecimal amount, ApplicationContext ctx) {
        PaymentService service = ctx.getBean(beanName, PaymentService.class);
        service.pay(amount);
    }
}

A more flexible approach registers all PaymentService implementations in a map:

@Service
public class PayChannelStrategyService {
    private final Map<String, PaymentService> strategyMap = new HashMap<>();

    public PayChannelStrategyService(List<PaymentService> services) {
        services.forEach(s -> strategyMap.put(s.getSupportedChannel(), s));
    }

    public void pay(String channel, BigDecimal amount) {
        PaymentService service = strategyMap.get(channel);
        if (service == null) {
            throw new IllegalArgumentException("Unsupported channel: " + channel);
        }
        service.pay(amount);
    }
}

Best practice: JSON serialization of enums

@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public enum PayChannel {
    WECHAT("wechat", "WeChat Pay"),
    ALIPAY("alipay", "Alipay");

    private final String code;
    private final String desc;

    PayChannel(String code, String desc) {
        this.code = code;
        this.desc = desc;
    }
    // getters omitted
}

Serialized form:

{
  "code": "wechat",
  "desc": "WeChat Pay"
}

Key takeaways

Use enums to encapsulate behavior and eliminate simple branching.

Combine enums with Spring to achieve runtime strategy dispatch without coupling.

Design extensible business type systems so new features require no modifications to existing code.

Illustrations