如何在try块遇异常时仍执行全部代码？无需嵌套try-catch

嘿，这问题问得挺实际的——很多人都碰到过这种不想因为某一步异常就中断后续操作的场景。不用嵌套一堆try-catch当然有办法，我给你几个实用的简便方案：

方案1：通用异常处理工具方法封装 #

核心思路是写一个复用的工具方法，把每一行可能抛出异常的操作单独包裹，同时收集异常（或直接处理），这样既保证所有步骤执行，又避免重复写try-catch。

先定义工具方法：

import java.util.List;

private static void safeExecute(Runnable task, List<Exception> exceptionList) {
    try {
        task.run();
    } catch (Exception e) {
        exceptionList.add(e); // 把异常收集起来，后续统一处理
    }
}

然后在业务代码里调用：

List<Exception> exceptions = new ArrayList<>();

// 逐个执行所有操作，异常会被收集但不中断后续步骤
safeExecute(() -> line1(), exceptions);
safeExecute(() -> line2(), exceptions);
safeExecute(() -> line3(), exceptions);
safeExecute(() -> line4(), exceptions);

// 统一处理所有收集到的异常
if (!exceptions.isEmpty()) {
    // 可选：抛出复合异常，或者逐个处理异常
    throw new RuntimeException("多个操作出现异常", exceptions.get(0));
    // 或者遍历exceptions逐个处理，比如打印日志
}

// 原来finally块里的剩余操作放在这里执行
执行剩余操作;

方案2：Stream流批量处理（Java 8+） #

如果你的操作较多，可以用Stream来批量执行并收集异常，写法更简洁：

import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

List<Runnable> operations = Arrays.asList(
    () -> line1(),
    () -> line2(),
    () -> line3(),
    () -> line4()
);

// 执行所有操作，过滤出非空的异常并收集
List<Exception> exceptions = operations.stream()
    .map(op -> {
        try {
            op.run();
            return null;
        } catch (Exception e) {
            return e;
        }
    })
    .filter(Objects::nonNull)
    .collect(Collectors.toList());

// 后续异常处理和剩余操作同方案1
if (!exceptions.isEmpty()) {
    // 处理逻辑
}
执行剩余操作;

方案3：单步异常直接处理（无需汇总） #

如果不需要汇总所有异常，只需要记录每个异常并继续执行，可以简化工具方法：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

private static final Logger log = LoggerFactory.getLogger(YourClass.class);

private static void safeExecute(Runnable task) {
    try {
        task.run();
    } catch (Exception e) {
        // 直接处理单个异常，比如打印日志
        log.error("执行操作失败", e);
    }
}

// 业务代码直接调用
safeExecute(() -> line1());
safeExecute(() -> line2());
safeExecute(() -> line3());
safeExecute(() -> line4());

执行剩余操作;

核心逻辑总结 #

这些方案的本质都是将每个可能抛出异常的操作独立包裹，但通过复用统一的异常处理逻辑，避免了重复编写try-catch块。不管某一步是否抛出异常，后续操作都会正常执行，最后你可以选择统一处理所有异常，或者逐个处理单步异常。

内容的提问来源于stack exchange，提问作者Abhijeet Raj