重构Java Spring Boot代码，消除If-Else语句-51CTO.COM

尽管if-else语句随处可见，但如果过度使用，可能会导致代码复杂且难以维护。在本文中，我们将探索各种策略来减少Java Spring Boot项目中if-else结构的使用，重点关注如何使代码更加模块化、可维护和易读。

图片

“厄运之塔”或“波动拳代码”

减少If-Else语句的策略

策略模式
枚举的使用
多态
Lambda表达式和函数式接口
命令模式
Guard子句

让我们逐一深入探讨这些策略，并给出示例。

1. 策略模式

策略模式定义了一系列算法，封装了每一个算法，并使它们可以互相替换。当你有多种方式来执行某个特定任务时，这种模式就很有用。

示例：支付处理系统

首先，定义一个PaymentStrategy接口：

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

接下来，实现不同的支付策略：

@Component
public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        // 信用卡支付处理逻辑
        System.out.println("Paid " + amount + " using Credit Card.");
    }
}

@Component
public class PaypalPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        // PayPal支付处理逻辑
        System.out.println("Paid " + amount + " using PayPal.");
    }
}

创建一个使用该策略的PaymentService：

@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. 枚举的使用

枚举可用于表示一组预定义的常量及其相关行为。

示例：订单状态管理

定义一个OrderStatus枚举并赋予不同的行为：

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();
}

在服务中使用这个枚举：

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

3. 多态

多态允许对象被视为其父类的实例，而不是其实际类。这使你能够通过父类的引用调用派生类的重写方法。

示例：通知系统

定义一个Notification接口及其实现:

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

public class EmailNotification implements Notification {
    @Override
    public void send(String message) {
        // 发送电子邮件的逻辑
        System.out.println("Sending email: " + message);
    }
}

public class SmsNotification implements Notification {
    @Override
    public void send(String message) {
        // 发送短信的逻辑
        System.out.println("Sending SMS: " + message);
    }
}

创建一个使用多态的服务：

@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表达式和函数式接口

Lambda表达式可以简化你的代码，特别是在处理小型、单方法接口时。

示例：折扣服务

定义一个使用Lambda表达式的折扣服务：

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. 命令模式

命令模式将请求封装为一个对象，从而允许你使用队列、请求和操作对客户端进行参数化。

示例：文件操作

定义命令接口及其具体实现：

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();
    }
}

定义FileSystemReceiver和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子句

Guard子句提供了一种提前处理条件的方式，通过尽早处理无效条件，使你的代码更加易读，并减少嵌套结构。

示例：用户验证

在这里不嵌套if-else语句来验证用户输入，而是使用Guard子句来提前处理无效情况：

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());
    }
}

这种方法可确保及早处理无效条件，并使主要逻辑保持简洁易懂。

结论

通过应用这些策略，你可以大大减少在Java Spring Boot项目中使用if-else语句。这不仅使你的代码更可读，也提高了其可维护性和可扩展性。采用这些模式和实践来编写更简洁、更高效的代码吧。