在许多业务场景中，我们可能需要按顺序执行一系列命令或操作。如果其中任何一个操作返回了特定的结果（例如，一个非零的错误码），我们希望立即停止后续操作并返回该结果，否则继续执行下一个操作。传统的做法可能涉及大量的if-else语句，导致代码冗长且难以维护。java 8引入的optional类型为处理可能缺失的值提供了优雅的解决方案，但直接在optional.ifpresent()的lambda表达式中尝试返回外部方法的返回值是无效的，因为lambda无法控制外部方法的执行流程。
例如，以下代码尝试在ifPresent中返回一个值，但这在Java中是不允许的：
public class CommandExecutor {
public int topMethod() {
int cr = execCmds();
// ... 对 cr 进行后续处理 ...
return cr;
}
private int execCmds() {
// 这里的 'return cr' 在 ifPresent lambda中是无效的
// executeCmd("my command").ifPresent(cr -> return cr);
// executeCmd("my next command").ifPresent(cr -> return cr);
// ...
return 0; // 默认成功返回0
}
// 假设 executeCmd 返回 Optional.of(errorCode) 表示失败，Optional.empty() 表示成功
private Optional<Integer> executeCmd(String command) {
// 模拟命令执行
System.out.println("Executing: " + command);
if (command.contains("fail")) {
return Optional.of(1); // 模拟失败返回错误码 1
}
return Optional.empty(); // 模拟成功
}
}为了解决这个问题，我们可以利用Optional提供的更高级的组合操作。
1. 利用 Optional.or() 实现链式提前退出 (JDK 9+)
Optional.or() 方法是JDK 9引入的一个强大功能，它允许我们链式地尝试获取一个Optional值。如果当前Optional为空，它会调用一个Supplier来生成另一个Optional并返回。如果当前Optional非空，则直接返回当前Optional，而Supplier则不会被执行（惰性求值）。这非常适合我们按顺序执行命令并在第一个失败时提前退出的场景。
核心思想：
立即学习“Java免费学习笔记（深入）”；
- executeCmd方法在成功时返回Optional.empty()，在失败时返回Optional.of(errorCode)。
- 通过or()方法将多个executeCmd调用串联起来。
- 链的末尾使用orElse(0)来指定所有命令都成功时的默认返回值（例如0）。
示例代码：
import java.util.Optional;
import java.util.function.Supplier;
public class CommandExecutorWithOr {
public int topMethod() {
int cr = execCmds();
System.out.println("Final return code: " + cr);
// ... 对 cr 进行后续处理 ...
return cr;
}
private int execCmds() {
// 使用 or() 方法链式调用命令
return executeCmd("command 1") // 尝试执行第一个命令
.or(() -> executeCmd("command 2")) // 如果第一个失败，尝试执行第二个
.or(() -> executeCmd("command 3 fail")) // 如果第二个失败，尝试执行第三个（这里会失败）
.or(() -> executeCmd("command 4")) // 如果第三个失败，尝试执行第四个 (不会被执行)
.orElse(0); // 如果所有命令都成功 (Optional.empty())，则返回0
}
/**
* 模拟命令执行。
* @param command 命令字符串
* @return 如果命令执行失败，返回包含错误码的 Optional；如果成功，返回 Optional.empty()。
*/
private Optional<Integer> executeCmd(String command) {
System.out.println("Executing: " + command);
// 模拟一个命令可能失败的逻辑
if (command.contains("fail")) {
System.out.println("Command '" + command + "' FAILED.");
return Optional.of(1); // 模拟失败，返回错误码 1
}
System.out.println("Command '" + command + "' SUCCEEDED.");
return Optional.empty(); // 模拟成功
}
public static void main(String[] args) {
CommandExecutorWithOr executor = new CommandExecutorWithOr();
executor.topMethod();
}
}运行输出示例：
Executing: command 1 Command 'command 1' SUCCEEDED. Executing: command 2 Command 'command 2' SUCCEEDED. Executing: command 3 fail Command 'command 3 fail' FAILED. Final return code: 1
优点：
- 简洁性： 代码非常紧凑，表达意图清晰。
- 惰性求值： 只有当前一个Optional为空时，or()的Supplier才会被调用，有效避免了不必要的命令执行。
- 可读性： 链式调用使得命令执行顺序和条件返回逻辑一目了然。
注意事项：
- 此方法要求Java 9或更高版本。
- executeCmd方法必须遵循约定：成功返回Optional.empty()，失败返回Optional.of(errorCode)。
2. 使用 Supplier 流实现链式提前退出 (JDK 8 兼容)
如果您的项目仍在使用JDK 8，或者您需要处理OptionalInt（它没有or()方法），可以通过创建Supplier流的方式来达到类似的效果。这种方法也利用了惰性求值的特性。
核心思想：
立即学习“Java免费学习笔记（深入）”；
- 创建一个Supplier<OptionalInt>（或Supplier<Optional<Integer>>）的流。
- 每个Supplier负责调用一个executeCmd方法。
- 使用流操作按顺序获取每个OptionalInt，并筛选出第一个非空的OptionalInt。
示例代码：
import java.util.OptionalInt;
import java.util.function.Supplier;
import java.util.stream.Stream;
public class CommandExecutorWithStream {
public int topMethod() {
int cr = execCmds();
System.out.println("Final return code: " + cr);
// ... 对 cr 进行后续处理 ...
return cr;
}
private int execCmds() {
return Stream.<Supplier<OptionalInt>>of(
() -> executeCmd("command A"),
() -> executeCmd("command B fail"), // 这里会失败
() -> executeCmd("command C"), // 不会被执行
() -> executeCmd("command D") // 不会被执行
)
.map(Supplier::get) // 执行Supplier，得到 Stream<OptionalInt>
.filter(OptionalInt::isPresent) // 过滤掉空的 OptionalInt，只保留有值的
.mapToInt(OptionalInt::getAsInt) // 将 OptionalInt 转换为 IntStream
.findFirst() // 找到第一个有值的 OptionalInt
.orElse(0); // 如果所有 OptionalInt 都为空，则返回0
}
/**
* 模拟命令执行。
* @param command 命令字符串
* @return 如果命令执行失败，返回包含错误码的 OptionalInt；如果成功，返回 OptionalInt.empty()。
*/
private OptionalInt executeCmd(String command) {
System.out.println("Executing: " + command);
// 模拟一个命令可能失败的逻辑
if (command.contains("fail")) {
System.out.println("Command '" + command + "' FAILED.");
return OptionalInt.of(2); // 模拟失败，返回错误码 2
}
System.out.println("Command '" + command + "' SUCCEEDED.");
return OptionalInt.empty(); // 模拟成功
}
public static void main(String[] args) {
CommandExecutorWithStream executor = new CommandExecutorWithStream();
executor.topMethod();
}
}运行输出示例：
Executing: command A Command 'command A' SUCCEEDED. Executing: command B fail Command 'command B fail' FAILED. Final return code: 2
优点：
- JDK 8 兼容： 可以在旧版本的Java环境中使用。
- 灵活性： 适用于OptionalInt等没有or()方法的特殊Optional类型。
- 惰性求值： map(Supplier::get)结合findFirst()确保只有在需要时才执行命令。
注意事项：
- 相比Optional.or()，代码稍微冗长一些，需要理解流的各个操作。
- 同样要求executeCmd方法遵循约定：成功返回OptionalInt.empty()，失败返回OptionalInt.of(errorCode)。
总结
在Java中处理链式命令执行并实现条件性提前退出时，我们有两种主要且优雅的解决方案：
- 对于JDK 9及更高版本，推荐使用Optional.or()方法。它提供了最简洁、最直观的链式调用语法，并且天然支持惰性求值，使得代码高度可读和高效。
- 对于JDK 8环境或需要处理OptionalInt等特定Optional类型时，可以采用Supplier流的方式。虽然代码略显复杂，但它同样实现了惰性求值和提前退出，提供了良好的兼容性和灵活性。
无论选择哪种方法，关键在于定义一个统一的executeCmd辅助方法，使其在成功时返回一个空的Optional（或OptionalInt），在失败时返回一个包含错误码的非空Optional。这样，您就可以避免繁琐的if-else结构，使代码更加模块化、紧凑和易于维护。
