Refactoring Java Spring Boot Code: Eliminating If-Else Statements for Cleaner, Extensible Logic

If-else statements, though ubiquitous, can lead to complex and hard-to-maintain code if overused. In this article, we’ll explore various strategies to reduce the use of if-else constructs in Java Spring Boot projects, focusing on making your code more modular, maintainable, and readable.

Pyramid of Doom, or “Haduken Code”

Strategies to Reduce If-Else Statements

• Strategy Pattern
• Enum Usage
• Polymorphism
• Lambda Expressions and Functional Interfaces
• Command Pattern
• Guard Clauses

Let’s dive into each strategy with examples.

1. Strategy Pattern

The Strategy Pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. This pattern is useful when you have multiple ways to perform a certain task.

Example: Payment Processing System

First, define a PaymentStrategy interface:

public interface PaymentStrategy {
    void pay(double amount);
}

Next, implement different payment strategies:

@Component
public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        // Credit card payment processing logic
        System.out.println("Paid " + amount + " using Credit Card.");
    }
}

@Component
public class PaypalPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        // PayPal payment processing logic
        System.out.println("Paid " + amount + " using PayPal.");
    }
}

Create a PaymentService that uses the strategy:

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

    public PaymentService(List<PaymentStrategy> strategies) {
        for (PaymentStrategy strategy : strategies) {
            paymentStrategies.put(strategy.getClass().getSimpleName(), strategy);
        }
    }

    public void processPayment(String strategyName, double amount) {
        PaymentStrategy strategy = paymentStrategies.get(strategyName);
        if (strategy != null) {
            strategy.pay(amount);
        } else {
            throw new IllegalArgumentException("No such payment strategy: " + strategyName);
        }
    }
}

2. Enum Usage

Enums can be used to represent a set of predefined constants and their associated behaviors.

Example: Order Status Management

Define an OrderStatus enum with different behaviors:

public enum OrderStatus {
    NEW {
        @Override
        public void handle() {
            System.out.println("Processing new order.");
        }
    },
    SHIPPED {
        @Override
        public void handle() {
            System.out.println("Order shipped.");
        }
    },
    DELIVERED {
        @Override
        public void handle() {
            System.out.println("Order delivered.");
        }
    };

    public abstract void handle();
}

Use this enum in a service:

@Service
public class OrderService {
    public void processOrder(OrderStatus status) {
        status.handle();
    }
}

3. Polymorphism

Polymorphism allows objects to be treated as instances of their parent class rather than their actual class. This enables you to invoke overridden methods of derived classes through a reference of the parent class.

Example: Notification System

Define a Notification interface and its implementations:

public interface Notification {
    void send(String message);
}

public class EmailNotification implements Notification {
    @Override
    public void send(String message) {
        // Email sending logic
        System.out.println("Sending email: " + message);
    }
}

public class SmsNotification implements Notification {
    @Override
    public void send(String message) {
        // SMS sending logic
        System.out.println("Sending SMS: " + message);
    }
}

Create a service that uses polymorphism:

@Service
public class NotificationService {
    private final List<Notification> notifications;

    public NotificationService(List<Notification> notifications) {
        this.notifications = notifications;
    }

    public void notifyAll(String message) {
        for (Notification notification : notifications) {
            notification.send(message);
        }
    }
}

4. Lambda Expressions and Functional Interfaces

Lambda expressions can simplify your code, especially when dealing with small, single-method interfaces.

Example: Discount Service

Define a discount service that uses lambda expressions:

import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

public class DiscountService {
    private Map<String, Function<Double, Double>> discountStrategies = new HashMap<>();

    public DiscountService() {
        discountStrategies.put("SUMMER_SALE", price -> price * 0.9);
        discountStrategies.put("WINTER_SALE", price -> price * 0.8);
    }

    public double applyDiscount(String discountCode, double price) {
        return discountStrategies.getOrDefault(discountCode, Function.identity()).apply(price);
    }
}

5. Command Pattern

The Command Pattern encapsulates a request as an object, thereby allowing you to parameterize clients with queues, requests, and operations.

Example: File Operations

Define a Command interface and concrete commands:

public interface Command {
    void execute();
}

public class OpenFileCommand implements Command {
    private FileSystemReceiver fileSystem;

    public OpenFileCommand(FileSystemReceiver fs) {
        this.fileSystem = fs;
    }

    @Override
    public void execute() {
        this.fileSystem.openFile();
    }
}

public class CloseFileCommand implements Command {
    private FileSystemReceiver fileSystem;

    public CloseFileCommand(FileSystemReceiver fs) {
        this.fileSystem = fs;
    }

    @Override
    public void execute() {
        this.fileSystem.closeFile();
    }
}

Define the FileSystemReceiver and Invoker:

public interface FileSystemReceiver {
    void openFile();
    void closeFile();
}

public class UnixFileSystemReceiver implements FileSystemReceiver {
    @Override
    public void openFile() {
        System.out.println("Opening file in Unix OS");
    }

    @Override
    public void closeFile() {
        System.out.println("Closing file in Unix OS");
    }
}

public class FileInvoker {
    private Command command;

    public FileInvoker(Command cmd) {
        this.command = cmd;
    }

    public void execute() {
        this.command.execute();
    }
}

6. Guard Clauses

Guard clauses provide a way to handle conditions early, making your code more readable by reducing nested structures.

Example: User Validation

Instead of nesting if-else statements to validate user input, use guard clauses to handle invalid cases upfront:

public class UserService {
    public void registerUser(User user) {
        if (user == null) {
            throw new IllegalArgumentException("User cannot be null");
        }
        if (user.getName() == null || user.getName().isEmpty()) {
            throw new IllegalArgumentException("User name cannot be empty");
        }
        if (user.getEmail() == null || user.getEmail().isEmpty()) {
            throw new IllegalArgumentException("User email cannot be empty");
        }
        // Proceed with registration
        System.out.println("Registering user: " + user.getName());
    }
}

This approach ensures that invalid conditions are handled early, and the main logic remains clean and easy to follow.

Conclusion

By applying these strategies, you can significantly reduce the use of if-else statements in your Java Spring Boot projects. This not only makes your code more readable but also enhances its maintainability and scalability. Embrace these patterns and practices to write cleaner, more efficient code.

References

1. Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley.
2. Bloch, J. (2018). Effective Java. Addison-Wesley.
3. Fowler, M. (2019). Refactoring: Improving the Design of Existing Code. Addison-Wesley.
4. Freeman, E., & Robson, E. (2020). Head First Design Patterns: Building Extensible and Maintainable Object-Oriented Software. O’Reilly Media.
5. Beck, K. (2003). Test Driven Development: By Example. Addison-Wesley.

Happy Coding! 👨‍💻👩‍💻

Check out the latest story => Spring Boot Common Mistakes with Code Examples