详解Java异常处理和链式抛出案例

原创曾经终败给现在 2024-09-12 02:21 82阅读 0赞

Java异常处理是程序在执行过程中遇到的问题，导致程序不能正常运行时的一种机制。Java提供了try-catch-finally语句来实现异常处理。

链式抛出（Chained Throwing）是在Java 8引入的`throwables`包中的一个概念，它允许你在一个位置抛出多个异常，并让这些异常按照特定的顺序进行捕获。

下面是一个简单的链式抛出案例：

```java
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class ChainedThrowingExample {

public void chainExceptions() {
        try {
            // 首先模拟一个可能抛出异常的操作
            Future<Integer> future = compute();
            if (future != null) {
                // 如果操作成功，但结果可能失败（例如：计算错误）
                int result = future.get();
                if (result < 0) {
                    // 最后，当所有条件满足时，抛出一个链式异常
                    throw new NegativeResultException("Computational error with negative result", new ExecutionException(new RuntimeException("Simulated exception")))));
                }
            } else {
                // 如果操作失败，直接抛出一个基础异常
                throw new FailedComputeException("Failed to compute", new ExecutionException(new RuntimeException("Simulated exception")))))));
            }
        } catch (NegativeResultException e) {
            // 当链式异常被捕获时，处理其中的异常信息
            System.out.println("Handling negative result: " + e.getMessage());
            e.printStackTrace(); // 打印堆栈跟踪，便于排查问题
        } catch (FailedComputeException e) {
            // 处理基础异常
            System.out.println("Handling failed computation: " + e.getMessage());
            e.printStackTrace();
        }
    }

// 假设有一个计算方法
    private Future<Integer> compute() {
        // 这里是一个模拟计算失败的示例
        if (Math.random() > 0.5) {
            throw new RuntimeException("Simulated exception in computation");
        }
        try {
            Thread.sleep(200); // 模拟计算需要时间
            return Executors.newSingleThreadExecutor().submit(() -> {
                // 这里是一个模拟成功的计算示例
                System.out.println("Computational successful: " + (Math.random() * 10) + "\n");
                return Math.random() * 10; // 返回一个随机的计算结果
            })).get(); // 获取计算结果，模拟计算需要时间
        } catch (InterruptedException | ExecutionException e) {
            System.out.println("Error occurred during computation: " + e.getMessage());
            e.printStackTrace();
        }
    }

public static void main(String[] args) throws NegativeResultException, FailedComputeException {
        ChainedThrowingExample example = new ChainedThrowingExample();
        try {
            // 调用链式抛出示例方法
            example.chainExceptions();
        } catch (NegativeResultException e) {
            // 当链式异常被捕获时，处理其中的异常信息
            System.out.println("Handling negative result exception: " + e.getMessage());
            e.printStackTrace(); // 打印堆栈跟踪，便于排查问题
        } catch (FailedComputeException e) {
            // 处理基础异常
            System.out.println("Handling failed computation exception: " + e.getMessage());
            e.printStackTrace();
        }
    }
}
```

在这个例子中，我们首先定义了一个`chainExceptions`方法，这个方法模拟了可能会抛出多个异常的场景。

然后在`main`方法中，我们调用这个方法并捕获可能抛出的异常。根据链式抛出的特点，不同类型的异常按照它们被添加到链中的顺序进行处理。