一、使用背景
在实际开发中，if 语句常常是控制流的核心，但它们的滥用可能会导致代码冗长、可读性差，甚至引发维护问题。如何减少 if 语句的使用，使得代码更具可读性、可维护性，并提高开发效率，是我们今天讨论的主题。
为了达到这一目标，我们将通过对比一个常见场景：在没有使用工具类的情况下写条件判断与使用工具类 BizExecutor 来优化代码，展示如何减少冗余的 if 语句，简化业务逻辑的处理。
1.1. 没有使用业务执行器工具类前的代码
在传统的开发方式中，我们通常通过多个 if 语句来进行条件判断和执行相应的操作。这种写法虽然简单直接，但当条件复杂或者需要在多个地方重复执行相似的操作时，代码容易变得冗长且难以维护。以下是一个典型的没有使用工具类的例子：
public void processBusinessLogic(Boolean condition, String object) {
if (condition != null && condition) {
// 条件成立，执行某些操作
log.info("Condition is true");
}
if (condition != null && !condition) {
// 条件不成立，执行另一些操作
log.info("Condition is false");
}
if (object != null) {
// 对象存在时执行操作
log.info("Object is present: " + object);
} else {
// 对象为空时执行失败操作
log.info("Object is absent");
}
if (condition != null && condition) {
// 如果条件满足，抛出异常
throw new BusinessException("Condition failed");
}
}
从上面的代码可以看到，if 语句被大量使用，尤其是同样的条件被反复判断。这种写法虽然能完成基本功能，但缺点也显而易见：
- 重复代码：相同的条件检查（如
if (condition != null && condition)）重复多次，代码变得冗长且容易出错。 - 可读性差：条件语句的分散使得代码的逻辑不清晰，难以一眼看出程序的执行流程。
- 维护成本高：当需要修改逻辑时，必须逐个修改每个判断条件，增加了修改和测试的复杂性。
1.2. 使用业务执行器工具类后的优化代码
为了提升代码的清晰度和可维护性，我们可以将条件判断封装到一个专门的工具类中。这样一来，业务逻辑的执行就不再依赖大量的 if 语句，而是通过清晰的方法调用来处理各种条件。我们设计了 BizExecutor 工具类，利用它来简化代码。
public void processBusinessLogic(Boolean condition, String object) {
// 使用 BizExecutor 简化条件判断
BizExecutor.ifTrue(condition, () -> log.info("Condition is true"));
BizExecutor.ifTrueElse(condition, () -> log.info("Condition is true"), () -> log.info("Condition is false"));
// 判断对象是否存在
BizExecutor.ifPresent(object, obj -> log.info("Object is present: " + obj));
BizExecutor.ifPresentElse(object, obj -> log.info("Object is present: " + obj), () -> log.info("Object is absent"));
// 使用 BizExecutor 处理异常
BizExecutor.ifTrueThrow(condition, () -> new BusinessException("Condition failed"));
}
通过 BizExecutor 工具类，我们大大减少了冗长的 if 语句，逻辑变得更加清晰和简洁。具体的优化效果如下：
- 代码复用性高：
BizExecutor将常见的条件判断逻辑封装成了可复用的方法，避免了重复代码。每个方法只需要关注单一的功能，减少了代码的重复性。 - 可读性更强：方法名直观地表达了其功能（如
ifTrue、ifTrueElse、ifPresentElse），使得代码逻辑一目了然。开发者可以更容易地理解和维护业务逻辑。 - 更少的错误：由于大部分判断逻辑被封装在工具类中，减少了人为错误的发生。例如，不需要再手动检查
null或重复编写if语句，降低了出错的概率。 - 维护成本低：当条件判断逻辑发生变化时，只需要修改工具类中的相关方法，而不必修改每个业务逻辑的判断代码，这样大大降低了维护的复杂度。
二、BizExecutor 工具类的设计理念
BizExecutor 工具类的核心思想是将条件判断与具体的业务逻辑解耦。它提供了多个方法来处理不同场景下的条件判断：
ifTrue：当条件为true时执行操作。ifTrueElse：当条件为true时执行成功操作，否则执行失败操作。ifPresent：判断对象是否存在并执行操作。ifTrueThrow：条件满足时抛出指定异常。
三、文章总结
通过对比传统的 if 语句写法和使用 BizExecutor 工具类优化后的写法，我们可以看到，减少冗长的 if 语句能够带来以下显著的好处：
- 提升代码的可读性：通过清晰的函数式接口表达业务逻辑，使得代码更加简洁易懂。
- 提高代码的可维护性：通过将条件判断封装到工具类中，减少了代码的重复性，便于维护和扩展。
- 降低出错的风险：减少了手动编写条件判断的机会，从而减少了因逻辑错误导致的 bug。
- 提高开发效率：通过封装常见的判断逻辑，开发者不再需要从头编写相同的代码，节省了时间和精力。
在未来的开发中，利用类似 BizExecutor 这样的工具类封装常见的条件判断，不仅可以让代码更加简洁，而且能让我们更专注于业务逻辑本身，从而提升代码的质量和开发效率。
如果你也想让代码更加简洁高效，不妨考虑将常见的条件判断封装成工具类，减少冗长的 if 语句，享受函数式编程带来的便利。
四、附上代码
/**
* @author: bdmcom
* @createTime: 2024/12/14 20:39
* @company: <a href="https://www.bdmcom.cn">本当迷博客</a>
* @description: 业务执行器工具类
*/
@Slf4j
public class BizExecutor {
private BizExecutor() {
}
/**
* 如果条件满足，执行指定的操作
*
* @param condition 条件
* @param action 满足条件时执行的操作
*/
public static void ifTrue(Boolean condition, Runnable action) {
if (Boolean.TRUE.equals(condition)) {
action.run();
}
}
/**
* 如果条件满足，执行指定的消费者操作，并传递上下文信息
*
* @param <T> 上下文的类型
* @param condition 条件
* @param context 上下文信息
* @param consumer 满足条件时执行的操作，接受上下文
*/
public static <T> void ifTrue(Boolean condition, T context, Consumer<T> consumer) {
if (Boolean.TRUE.equals(condition)) {
consumer.accept(context);
}
}
/**
* 如果条件满足，执行成功操作；否则执行失败操作
*
* @param condition 条件
* @param onSuccess 条件满足时执行的操作
* @param onFailure 条件不满足时执行的操作
*/
public static void ifTrueElse(Boolean condition, Runnable onSuccess, Runnable onFailure) {
if (Boolean.TRUE.equals(condition)) {
onSuccess.run();
} else {
onFailure.run();
}
}
/**
* 如果条件满足，执行成功消费者操作；否则执行失败消费者操作，并传递上下文信息
*
* @param <T> 上下文的类型
* @param condition 条件
* @param context 上下文信息
* @param onSuccess 条件满足时执行的操作，接受上下文
* @param onFailure 条件不满足时执行的操作，接受上下文
*/
public static <T> void ifTrueElse(Boolean condition, T context, Consumer<T> onSuccess, Consumer<T> onFailure) {
if (Boolean.TRUE.equals(condition)) {
onSuccess.accept(context);
} else {
onFailure.accept(context);
}
}
/**
* 如果条件满足，执行指定的操作
*
* @param condition 条件
* @param action 满足条件时执行的操作
*/
public static void ifCondition(Predicate<Void> condition, Runnable action) {
if (condition.test(null)) {
action.run();
}
}
/**
* 如果条件满足，执行指定的消费者操作，并传递上下文信息
*
* @param <T> 上下文的类型
* @param condition 条件
* @param context 上下文信息
* @param consumer 满足条件时执行的操作，接受上下文
*/
public static <T> void ifCondition(Predicate<T> condition, T context, Consumer<T> consumer) {
if (condition.test(context)) {
consumer.accept(context);
}
}
/**
* 如果条件满足，执行成功操作；否则执行失败操作
*
* @param condition 条件
* @param onSuccess 条件满足时执行的操作
* @param onFailure 条件不满足时执行的操作
*/
public static void ifConditionElse(Predicate<Void> condition, Runnable onSuccess, Runnable onFailure) {
if (condition.test(null)) {
onSuccess.run();
} else {
onFailure.run();
}
}
/**
* 如果条件满足，执行成功消费者操作；否则执行失败消费者操作，并传递上下文信息
*
* @param <T> 上下文的类型
* @param condition 条件
* @param context 上下文信息
* @param onSuccess 条件满足时执行的操作，接受上下文
* @param onFailure 条件不满足时执行的操作，接受上下文
*/
public static <T> void ifConditionElse(Predicate<T> condition, T context, Consumer<T> onSuccess, Consumer<T> onFailure) {
if (condition.test(context)) {
onSuccess.accept(context);
} else {
onFailure.accept(context);
}
}
/**
* 如果对象存在，执行指定的操作
*
* @param <T> 对象的类型
* @param object 包装的对象
* @param consumer 对象存在时执行的操作
*/
public static <T> void ifPresent(T object, Consumer<T> consumer) {
Optional<T> optional = Optional.ofNullable(object);
optional.ifPresent(consumer);
}
/**
* 如果对象存在，执行成功操作；否则执行失败操作
*
* @param <T> 对象的类型
* @param object 包装的对象
* @param onSuccess 对象存在时执行的操作
* @param onFailure 对象不存在时执行的操作
*/
public static <T> void ifPresentElse(T object, Consumer<T> onSuccess, Runnable onFailure) {
Optional<T> optional = Optional.ofNullable(object);
if (optional.isPresent()) {
onSuccess.accept(optional.get());
} else {
onFailure.run();
}
}
/**
* 如果条件满足，抛出指定异常
*
* @param condition 条件
* @param exceptionSupplier 异常供应者
*/
public static void ifTrueThrow(Boolean condition, Supplier<? extends RuntimeException> exceptionSupplier) {
if (Boolean.TRUE.equals(condition)) {
throw exceptionSupplier.get();
}
}
/**
* 如果条件满足，抛出指定异常
*
* @param <T> 上下文的类型
* @param condition 条件
* @param context 上下文信息
* @param exceptionSupplier 异常供应者
*/
public static <T> void ifTrueThrow(Boolean condition, T context, Function<T, ? extends RuntimeException> exceptionSupplier) {
if (Boolean.TRUE.equals(condition)) {
throw exceptionSupplier.apply(context);
}
}
public static void main(String[] args) {
BizExecutor.ifTrue(Boolean.TRUE, () -> log.info("true"));
BizExecutor.ifTrueElse(Boolean.FALSE, () -> log.info("false"), () -> log.info("true"));
BizExecutor.ifTrueThrow(Boolean.TRUE, () -> new BusinessException("条件错误"));
BizExecutor.ifTrueThrow(Boolean.TRUE, "为ture", context -> new BusinessException("条件错误"));
}
}
