【一步一步了解Java系列】：认识异常类

逆舟
15 阅读10分钟

引言

在本章中，我们将深入探讨Java异常处理的重要性以及JDK 8中异常处理的新特性。

JDK 8中异常处理的重要性

异常处理是任何稳健的Java应用程序的关键组成部分。它允许程序在发生错误时优雅地恢复，而不是导致整个程序崩溃。

示例：没有异常处理的后果

public class Application {
    public static void main(String[] args) {
        int divisor = 0;
        int result = 10 / divisor; // 这里将抛出ArithmeticException
    }
}

如果没有适当的异常处理，上述代码将导致程序因ArithmeticException而异常终止。

JDK 8异常处理的新特性

JDK 8为Java异常处理带来了一些重要的改进，使得异常处理更加强大和易于管理。

1. try-with-resources语句

try-with-resources语句自动管理资源，确保每个资源在语句结束时关闭。

示例：使用try-with-resources

try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} // reader自动关闭

2. 多重异常捕获（Multi-catch）

多重异常捕获允许我们在同一个catch块中处理多个异常类型。

示例：多重异常捕获

try {
    // 可能抛出IOException或SQLException的代码
} catch (IOException | SQLException e) {
    System.err.println("I/O or SQL Error: " + e.getMessage());
}

3. 接口方法的默认实现

允许我们为接口方法提供默认实现，这在异常处理中非常有用。

示例：接口方法的默认实现

@FunctionalInterface
interface Service {
    void performTask() throws ServiceException;

    default void checkService() {
        try {
            performTask();
        } catch (ServiceException e) {
            handleException(e);
        }
    }

    default void handleException(ServiceException e) {
        // 异常处理逻辑
    }
}

Java异常体系结构

Java异常层次结构为异常和错误提供了一个清晰的组织架构，使得开发者能够更精确地处理各种异常情况。

Throwable类介绍

所有异常或错误的超类都是java.lang.Throwable类的子类。Throwable类有两个主要子类：Error和Exception。

示例：Throwable的子类

try {
    // 模拟一个错误
    throw new Throwable("A throwable occurred");
} catch (Throwable t) {
    System.out.println(t.toString());
}

异常与错误的区分

  • 异常（Exception）：程序本身可以处理的问题，比如文件未找到或网络连接失败。
  • 错误（Error）：通常是程序无法处理的严重问题，如OutOfMemoryError。

示例：错误与异常的捕获

try {
    // 模拟一个错误
    throw new OutOfMemoryError("Not enough memory!");
} catch (Error e) {
    // 通常不会捕获Error，除非是做一些清理工作
    System.out.println("A serious error occurred: " + e.getMessage());
}

检查型异常与非检查型异常

  • 检查型异常（Checked Exceptions）：编译器强制要求处理的异常，通常是外部因素引起的，如IOException。
  • 非检查型异常（Unchecked Exceptions）：编译器不强制要求处理的异常，通常是编程错误导致的，如NullPointerException。

示例：检查型与非检查型异常

public void readFile(String path) throws IOException {
    try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
        // 读取文件内容
    } catch (FileNotFoundException e) {
        throw new IllegalArgumentException("File not found: " + path, e);
    }
}

异常处理机制

Java提供了一套完整的异常处理机制，允许开发者捕获和处理程序运行时出现的错误情况。

try、catch和finally的使用

在Java中，try块用来包含可能抛出异常的代码，catch块用来捕获并处理异常，而finally块则用于执行无论是否发生异常都需要执行的清理工作。

示例：基本的异常处理

try {
    // 尝试执行可能抛出异常的代码
    int result = 10 / 0;
} catch (ArithmeticException e) {
    // 处理异常
    System.out.println("Cannot divide by zero: " + e.getMessage());
} finally {
    // 清理工作，如关闭文件流
    System.out.println("Execution completed.");
}

异常的传播

在Java中，可以在方法中通过throws关键字声明抛出异常，然后将异常的控制权交给上层调用者。

示例：异常的传播

public void riskyMethod() throws IOException {
    if (Math.random() > 0.5) {
        throw new IOException("Randomly generated IOException");
    }
}

public static void main(String[] args) {
    try {
        new Application().riskyMethod();
    } catch (IOException e) {
        System.out.println("An I/O error occurred: " + e.getMessage());
    }
}

异常链

当一个异常的处理过程中又抛出了另一个异常时，可以通过异常链将这两个异常联系起来，这有助于调试和日志记录。

示例：异常链

public void handleFile() {
    try {
        // 可能抛出FileNotFoundException
    } catch (FileNotFoundException e) {
        try {
            // 进行一些恢复操作，但可能抛出其他异常
        } catch (Exception e) {
            throw new RuntimeException("Error during recovery", e);
        }
    }
}

自定义异常

在Java中，除了使用标准异常库提供的异常类外，还可以创建自定义异常类来更精确地表达特定的错误情况。

定义自定义异常类

自定义异常通常是现有异常类的子类。推荐继承Exception类或其子类，以表示它是一个检查型异常或非检查型异常。

示例：创建自定义检查型异常

public class MyCustomException extends Exception {
    public MyCustomException(String message) {
        super(message);
    }

    // 可以添加其他构造器或方法
}

示例：创建自定义非检查型异常

public class MyUncheckedException extends RuntimeException {
    public MyUncheckedException(String message) {
        super(message);
    }
}

使用自定义异常

自定义异常可以在方法中抛出，并在调用栈的上层被捕获和处理。

示例：抛出自定义检查型异常

public void checkValue(int value) throws MyCustomException {
    if (value < 0) {
        throw new MyCustomException("Value cannot be negative.");
    }
}

示例：捕获自定义检查型异常

public static void main(String[] args) {
    try {
        new Application().checkValue(-10);
    } catch (MyCustomException e) {
        System.out.println(e.getMessage());
    }
}

自定义异常的序列化

如果自定义异常类需要跨越网络传输或存储到文件中，应确保它实现了Serializable接口。

示例：使自定义异常可序列化

public class MySerializableException extends Exception implements Serializable {
    private static final long serialVersionUID = 1L;

    public MySerializableException(String message) {
        super(message);
    }
}

自定义异常的最佳实践

  • 仅当标准异常不足以表达错误情况时，才定义新的异常类。
  • 自定义异常应提供额外的上下文信息，以帮助诊断问题。
  • 考虑异常的检查型与非检查型特性，以及它们对调用者的影响。

异常处理的最佳实践

在本章中，我们将探讨一些在Java异常处理中应遵循的最佳实践，以确保代码的健壮性和可维护性。

避免过度使用异常

异常处理不应该被用作常规的程序控制流程。异常应该仅用于处理异常情况。

示例：避免使用异常控制流程

// 错误的做法：使用异常进行循环退出
for (int i = 0; i < 10; i++) {
    try {
        if (someCondition()) {
            throw new Exception("Exit loop");
        }
    } catch (Exception e) {
        break;
    }
}

避免捕获过于宽泛的异常

避免捕获Exception类或Throwable类，因为这会掩盖潜在的问题，并且可能隐藏程序中的错误。

示例：避免捕获过于宽泛的异常

try {
    // 可能抛出多种异常的代码
} catch (Exception e) { // 错误的做法：捕获所有异常
    System.out.println("An error occurred.");
}

资源清理和try-with-resources语句

使用try-with-resources语句自动管理资源，确保每个资源在语句结束时关闭。

示例：使用try-with-resources

try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} // reader自动关闭

异常的文档记录

在方法的文档注释中记录可能抛出的异常，使用@throws标签为每个检查型异常提供说明。

示例：异常的文档记录

/**
 * Performs a risky operation that could throw an exception.
 * @throws MyCustomException if the operation fails
 */
public void riskyOperation() throws MyCustomException {
    // ...
}

使用异常链

当捕获并处理异常时，考虑使用异常链来保留原始异常的信息。

示例：使用异常链

try {
    // 可能抛出IOException的代码
} catch (IOException e) {
    throw new RuntimeException("Failed to perform operation", e);
}

Java 8的异常处理增强

Java 8在异常处理方面引入了一些新特性，这些特性使得异常处理更加简洁和高效。

多重异常捕获（Multi-catch）

Java 8允许在catch块中捕获多个异常类型，只要这些异常类型都与catch块中的变量类型兼容。

示例：多重异常捕获

try {
    // 可能抛出IOException或SQLException的代码
} catch (IOException | SQLException e) {
    System.err.println("An I/O or SQL error occurred: " + e.getMessage());
}

try-with-resources语句

Java 7开始引入的try-with-resources语句在Java 8中得到了进一步的增强，现在可以用于自动关闭实现了AutoCloseable接口的所有资源。

示例：使用try-with-resources自动管理资源

try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} // reader自动关闭

接口方法的默认实现

Java 8允许在接口中为方法提供默认实现，这可以在异常处理中提供更灵活的实现方式。

示例：接口方法的默认实现

interface Service {
    default void execute() {
        try {
            // 执行一些操作
        } catch (Exception e) {
            System.err.println("Service execution failed: " + e.getMessage());
        }
    }
}

异常处理的Lambda表达式

Java 8的Lambda表达式可以用于简化异常处理代码，尤其是在使用try-with-resources语句时。

示例：Lambda表达式简化异常处理

try (Resource resource = new Resource()) {
    resource.performAction(() -> {
        // 执行操作
    });
} catch (Exception e) {
    System.err.println("An error occurred: " + e.getMessage());
}

处理并发编程中的异常

在并发编程中，异常处理变得更加复杂。本章将探讨在多线程环境下处理异常的策略和技巧。

线程与异常

在多线程环境中，每个线程都可能抛出异常。正确地处理这些异常对于防止线程终止和应用程序崩溃至关重要。

示例：线程中的异常

new Thread(() -> {
    try {
        // 可能抛出异常的代码
    } catch (Exception e) {
        System.err.println("Exception in thread: " + e.getMessage());
    }
}).start();

异常的传播

在并发任务中，异常可能需要从工作线程传播到管理线程或调用者。

示例：异常的传播

Future<?> future = Executors.submit(() -> {
    // 可能抛出异常的代码
});

try {
    future.get(); // 等待任务完成，并捕获异常
} catch (ExecutionException e) {
    Throwable cause = e.getCause();
    if (cause instanceof Exception) {
        System.err.println("Task failed with exception: " + cause.getMessage());
    }
} catch (InterruptedException e) {
    Thread.currentThread().interrupt(); // 处理中断
}

使用Callable代替Runnable

Callable接口允许任务返回结果和抛出异常，而Runnable接口则不能。

示例：使用Callable接口

Future<Integer> future = Executors.submit(() -> {
    if (someCondition()) {
        throw new RuntimeException("Error occurred");
    }
    return 42; // 返回结果
});

try {
    Integer result = future.get();
    System.out.println("Task result: " + result);
} catch (ExecutionException e) {
    System.err.println("Task failed with exception: " + e.getCause().getMessage());
}

线程局部异常处理

在某些情况下，线程的异常可能需要局部处理，而不是传播到主线程。

示例：线程局部异常处理

Thread thread = new Thread(() -> {
    try {
        // 可能抛出异常的代码
    } catch (Exception e) {
        System.err.println("Thread-local exception handled: " + e.getMessage());
    }
});
thread.setUncaughtExceptionHandler((thread1, e) -> {
    System.err.println("Thread " + thread1.getName() + " failed with exception: " + e.getMessage());
});
thread.start();

实际案例分析

在本章中，我们将通过实际案例来分析日常开发中的异常处理模式与策略。

案例一：Web应用程序中的异常处理

Web应用程序需要处理来自用户的输入错误、资源访问问题等。

示例：Web应用程序中的异常处理

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(IllegalArgumentException.class)
    public ResponseEntity<String> handleBadRequest(Exception e) {
        return ResponseEntity.badRequest().body(e.getMessage());
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleException(Exception e) {
        return ResponseEntity.internalServerError().body("Internal server error");
    }
}

案例二：数据库访问中的异常处理

数据库访问代码可能抛出各种异常，需要适当地捕获并处理。

示例：数据库访问中的异常处理

public void processDatabase() {
    DataSource dataSource = getDataSource();
    String sql = "SELECT * FROM users";
    try (Connection conn = dataSource.getConnection();
         PreparedStatement stmt = conn.prepareStatement(sql)) {
        // 执行数据库操作
    } catch (SQLException e) {
        logger.error("Database access error", e);
        throw new DataAccessException("Error accessing the database", e);
    }
}

案例三：并发任务中的异常处理

并发任务可能在多个线程中抛出异常，需要特别注意异常的捕获和传播。

示例：并发任务中的异常处理

ExecutorService executor = Executors.newFixedThreadPool(10);
executor.submit(() -> {
    try {
        // 可能抛出异常的任务代码
    } catch (Exception e) {
        executor.shutdownNow(); // 异常情况下尝试关闭线程池
    }
});

案例四：资源密集型应用中的异常处理

资源密集型应用可能需要处理与资源获取和释放相关的异常。

示例：资源密集型应用中的异常处理

public void processResource() {
    try (Resource resource = acquireResource()) {
        // 使用资源
    } catch (ResourceAcquisitionException e) {
        logger.error("Failed to acquire resource", e);
    } finally {
        releaseResources(); // 确保资源被释放
    }
}
avatar
文章
阅读
粉丝