Java脚本如何实现全局异常处理，消除冗余try/catch并维持循环？

我有一个处理百万级数据的Java程序，部分损坏数据会导致依赖的不可修改框架抛出异常。现在每次调用框架函数都要加try/catch块，大量的try/catch让代码可读性极差，想移除这些块，把异常处理和业务代码分离。

想要实现类似Spring、Jersey这类Web框架的全局异常处理机制：框架抛出异常时自动捕获并记录日志，同时让数据处理循环继续执行。试过Thread.UncaughtExceptionHandler，但它会在异常发生时终止进程，满足不了需求。

当前代码：

public static void main(String[] args)  throws FrameworkException {
    List<Element> elements = new ArrayList<>(); //百万级数据
    processItems(elements);
}

public void processItems(List<Element> items) throws FrameworkException{
    for (int i = 0; i < elements.size(); i++) {
        try{
            framework.doSomething(elements.get(i));
        }
        catch(FrameworkException e){
            // 处理异常
        }

        // ...

        try{
            framework.doDifferentThing(elements.get(i));
        }
        catch(FrameworkException e){
            // 处理异常
        }

        // ...
    }

    System.out.println("Processing completed.");
}

期望的理想代码（异常由全局处理）：

public void processItems(List<Element> items) throws FrameworkException{
    for (int i = 0; i < elements.size(); i++) {
            framework.doSomething(elements.get(i));

            // ...

            framework.doDifferentThing(elements.get(i));

             // ...
    }
    System.out.println("Processing completed.");
}

1. 封装框架调用为工具方法 #

把框架的每个调用封装到工具类的方法里，集中处理异常，业务代码只需要调用工具方法即可。

示例代码：

// 框架调用封装工具类
public class FrameworkWrapper {
    private static final Logger logger = LoggerFactory.getLogger(FrameworkWrapper.class);
    private final Framework framework;

    public FrameworkWrapper(Framework framework) {
        this.framework = framework;
    }

    public void doSomething(Element element) {
        try {
            framework.doSomething(element);
        } catch (FrameworkException e) {
            logger.error("执行doSomething失败，元素信息: {}", element, e);
            // 统一处理逻辑，比如标记错误数据、上报监控等
        }
    }

    public void doDifferentThing(Element element) {
        try {
            framework.doDifferentThing(element);
        } catch (FrameworkException e) {
            logger.error("执行doDifferentThing失败，元素信息: {}", element, e);
        }
    }
}

修改后的业务代码：

public void processItems(List<Element> items) {
    FrameworkWrapper wrapper = new FrameworkWrapper(framework);
    for (Element element : items) {
        wrapper.doSomething(element);
        // ...
        wrapper.doDifferentThing(element);
        // ...
    }
    System.out.println("Processing completed.");
}

这种方式将异常处理逻辑统一维护在工具类中，业务代码变得简洁易读。

2. 函数式接口实现通用异常处理 #

如果框架方法数量较多，逐个封装太繁琐，可以用函数式接口做通用异常处理模板，适配不同的框架方法。

示例代码：

// 通用异常处理工具类
public class ExceptionHandlerUtil {
    private static final Logger logger = LoggerFactory.getLogger(ExceptionHandlerUtil.class);

    // 处理无返回值的框架调用
    public static <T> void handleFrameworkAction(Consumer<T> action, T param, String operationName) {
        try {
            action.accept(param);
        } catch (FrameworkException e) {
            logger.error("{}执行失败，参数信息: {}", operationName, param, e);
        }
    }

    // 处理有返回值的框架调用（按需使用）
    public static <T, R> R handleFrameworkFunction(Function<T, R> function, T param, String operationName) {
        try {
            return function.apply(param);
        } catch (FrameworkException e) {
            logger.error("{}执行失败，参数信息: {}", operationName, param, e);
            return null; // 或返回业务默认值
        }
    }
}

业务代码使用示例：

public void processItems(List<Element> items) {
    for (Element element : items) {
        ExceptionHandlerUtil.handleFrameworkAction(framework::doSomething, element, "doSomething");
        // ...
        ExceptionHandlerUtil.handleFrameworkAction(framework::doDifferentThing, element, "doDifferentThing");
        // ...
    }
    System.out.println("Processing completed.");
}

这种方式灵活性更高，不管框架有多少方法，都能通过同一个工具方法完成异常处理。

3. Stream流结合局部封装（适合批量数据） #

如果用Stream处理数据，可以将异常处理逻辑嵌入流操作中，同时保持业务代码结构清晰。

示例代码：

public void processItems(List<Element> items) {
    items.stream()
         .peek(this::processDoSomething)
         .peek(this::processDoDifferentThing)
         .count(); // 触发流执行

    System.out.println("Processing completed.");
}

private void processDoSomething(Element element) {
    try {
        framework.doSomething(element);
    } catch (FrameworkException e) {
        logger.error("处理doSomething失败", e);
    }
}

private void processDoDifferentThing(Element element) {
    try {
        framework.doDifferentThing(element);
    } catch (FrameworkException e) {
        logger.error("处理doDifferentThing失败", e);
    }
}

本质是把try/catch提取到单独的方法中，流操作只负责调用业务逻辑，代码可读性同样能得到提升。

Thread.UncaughtExceptionHandler是用来处理线程中未被捕获的顶层异常，一旦触发，线程会直接终止，无法满足"异常发生后继续处理后续数据"的需求。上面的方案都是通过局部捕获+封装的方式，实现了异常处理与业务代码的分离，同时保证循环能继续执行。

内容的提问来源于stack exchange，提问作者Kaan Ateşel