解析和解决Java异常处理中的链式异常

原创谁践踏了优雅 2024-10-11 08:30 56阅读 0赞

在Java中，链式异常（Chain of Responsibility）是一种处理多个相关但不相容异常的模式。这种模式通常由一个或多个责任处理器（Handler）组成。

以下是一个简单的链式异常处理的例子：

```java
// 定义基础异常类
class BaseException extends RuntimeException {
    public BaseException(String message) {
        super(message);
    }
}

// 定义责任处理器接口
interface Handler {
    void handle(BaseException e);
}

// 实现责任处理器
class FirstHandler implements Handler {
    @Override
    public void handle(BaseException e) {
        // 处理第一个异常
        if (e.getMessage().contains("Error 1")) {
            System.out.println("Handling Error 1...");
            // 自定义处理逻辑，这里简单打印信息
        } else {
            System.out.println("Unable to handle error: " + e.getMessage());
        }
    }
}

// 实现第二个责任处理器
class SecondHandler implements Handler {
    @Override
    public void handle(BaseException e) {
        // 处理第二个异常
        if (e.getMessage().contains("Error 2")) {
            System.out.println("Handling Error 2...");
            // 自定义处理逻辑，这里简单打印信息
        } else {
            System.out.println("Unable to handle error: " + e.getMessage());
        }
    }
}

// 使用链式异常处理器
public class ExceptionHandlingDemo {
    public static void main(String[] args) {
        try {
            // 调用可能会抛出异常的方法
            doSomethingThatMayThrowException();

System.out.println("Normal execution reached.");
        } catch (BaseException e) {
            // 当捕获到基础异常时，根据链式处理规则选择合适的处理器进行处理
            if (e instanceof FirstHandler.HandleableError1) {
                System.out.println("Handling Error 1...");
                ((FirstHandler.HandleableError1) e).handle();
            } else if (e instanceof SecondHandler.HandleableError2) {
                System.out.println("Handling Error 2...");
                ((SecondHandler.HandleableError2) e).handle();
            } else {
                // 如果找不到合适的处理器，或者处理器无法处理，则直接打印异常信息
                System.out.println("Unable to handle error: " + e.getMessage());
            }
        } catch (Exception ex) {
            // 所有其他类型的异常都会被这里捕获并处理
            System.out.println("Unexpected exception occurred: " + ex.getMessage());
        }
    }

// 假设这是一个可能会抛出各种异常的公共方法
    public void doSomethingThatMayThrowException() throws Exception {
        // 这里是可能抛出异常的代码，比如网络操作、文件读写等
        // 注意：在实际应用中，这里的异常处理应该尽可能具体和详细，避免捕获到所有类型的异常
        // 例如：如果涉及到网络操作，可能会遇到各种类型的网络异常，这些都需要进行具体的捕获和处理
    }
}
```

在这个例子中，我们定义了一个基础的异常类`BaseException`，以及两个责任处理器`FirstHandler`和`SecondHandler`。

当尝试执行可能抛出异常的方法时，如果捕获到`BaseException`，我们就根据链式处理规则选择合适的处理器进行处理。如果找不到合适的处理器，或者处理器无法处理，则直接打印异常信息。对于其他类型的异常，我们统一捕获并打印异常信息。