Skip to content

Java 异常机制详解 ​

程序运行过程中,总会遇到意料之外的情况:文件不存在、网络断开、参数不合法、内存不足……如果没有一套妥善的处理机制,任何一个小问题都可能直接让程序崩溃。

Java 的异常机制就是用来解决这个问题的。它的核心目标是:

将正常业务逻辑与错误处理逻辑分离,避免程序出现问题时直接崩溃。

本文将从异常体系结构出发,逐步深入到处理方式、传播机制、常见陷阱和实际项目中的应用。

1. Java 异常体系 ​

Java 中所有异常和错误都继承自 Throwable,这是整个异常体系的根类:

text
Throwable
├── Error
└── Exception
    ├── RuntimeException
    └── 其他非运行时异常

下面分层来看。

Error ​

Error 表示 JVM 或系统层面的严重问题,通常程序无法正常处理,也不应该试图捕获:

  • OutOfMemoryError:内存溢出,比如创建了过多对象且无法回收
  • StackOverflowError:栈溢出,常见于递归没有正确终止
  • NoClassDefFoundError:运行时找不到类定义

一般来说,业务代码不需要关心 Error。即使捕获了,也通常无法恢复正常的运行状态。

Exception ​

Exception 表示程序运行中可以预见、可以处理的异常情况。它又分为两大类。

受检异常(Checked Exception) ​

编译器会强制要求处理——要么用 try-catch 捕获,要么在方法声明上用 throws 抛出。不处理就无法通过编译。

常见的受检异常:

java
IOException
SQLException
ClassNotFoundException

示例:

java
public void readFile() throws IOException {
    FileInputStream inputStream = new FileInputStream("test.txt");
}

如果不做任何处理,编译器会直接报错。

非受检异常(Unchecked Exception) ​

主要指 RuntimeException 及其子类,编译器不强制处理。它们通常由程序逻辑错误引起:

java
NullPointerException
IndexOutOfBoundsException
IllegalArgumentException
ArithmeticException

示例:

java
int result = 10 / 0; // 抛出 ArithmeticException

这类异常不需要显式捕获,但如果放任不管,程序会直接终止。所以虽然编译器不强制,良好的代码仍然要考虑是否需要在合适的地方处理它们。

2. 异常处理关键字 ​

Java 的异常处理机制围绕五个关键字展开:

text
try    catch    finally    throw    throws

try-catch:捕获并处理异常 ​

java
try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("除数不能为零");
}

当 try 块中的代码抛出异常,后面的代码不再执行,程序会跳转到匹配的 catch 块。如果没有找到匹配的 catch,异常会继续向上抛出。

finally:无论如何都要执行的代码 ​

finally 块中的代码通常都会执行,一般用于释放资源(关闭文件、数据库连接等):

java
FileInputStream inputStream = null;

try {
    inputStream = new FileInputStream("test.txt");
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (inputStream != null) {
        try {
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

不过现在更推荐使用 try-with-resources 语法,代码会简洁很多:

java
try (FileInputStream inputStream =
         new FileInputStream("test.txt")) {

    // 读取文件
} catch (IOException e) {
    e.printStackTrace();
}

只要资源实现了 AutoCloseable 接口(InputStream、OutputStream、Connection 等都属于此类),Java 就会在 try 块结束后自动关闭资源,不需要手动写 finally。

throw:主动抛出异常 ​

throw 用于在方法内部主动抛出一个异常对象。当业务逻辑发现非法状态或参数时,常用它中断当前流程:

java
public void register(int age) {
    if (age < 18) {
        throw new IllegalArgumentException("年龄不能小于18岁");
    }
}

抛出异常后,当前方法立即结束,异常沿调用栈向上传播。

throws:声明方法可能抛出的异常 ​

throws 用在方法声明上,表示当前方法不处理某种异常,而是交给调用者处理:

java
public void readFile() throws IOException {
    FileInputStream inputStream = new FileInputStream("test.txt");
}

调用 readFile() 的方法必须在它的调用链中处理 IOException,要么继续用 throws 向上抛。

3. throw 和 throws 的区别 ​

这两个关键字名字相似,但作用完全不同:

对比项throwthrows
位置方法体内部方法声明处
作用主动抛出一个异常对象声明方法可能抛出的异常
后面跟的内容一个异常对象一个或多个异常类型
示例throw new RuntimeException()throws IOException, SQLException

简单记忆:throw 是"干"(抛出异常),throws 是"说"(声明异常)。

4. 异常传播机制 ​

如果一个方法发生异常,但当前方法没有捕获处理,异常会沿着方法调用栈不断向上抛出。

java
public static void main(String[] args) {
    methodA();
}

public static void methodA() {
    methodB();
}

public static void methodB() {
    int result = 10 / 0;
}

异常传播过程如下:

text
methodB  ← 抛出 ArithmeticException
  ↓
methodA  ← 未捕获,继续上抛
  ↓
main     ← 未捕获,继续上抛
  ↓
JVM      ← 打印异常堆栈,终止线程

如果整个调用链都没有捕获异常,最终 JVM 会接手——打印完整的异常堆栈,并终止当前线程。

异常堆栈中通常包含:

  • 异常类型:知道发生了什么问题
  • 异常信息:具体的错误描述
  • 异常发生的位置:哪个文件的哪行代码
  • 方法调用链路:异常从哪个方法起源,经过哪些方法传播

线上排查问题时,应优先关注异常堆栈中的 Caused by 部分,以及最接近自己业务代码的位置——那里往往是问题的真正源头。

5. 多个 catch 的匹配规则 ​

一个 try 后面可以跟多个 catch 块,分别处理不同类型的异常:

java
try {
    // 业务代码
} catch (NullPointerException e) {
    // 处理空指针
} catch (RuntimeException e) {
    // 处理其他运行时异常
} catch (Exception e) {
    // 兜底处理
}

这里有一个重要的规则:

子类异常在前,父类异常在后。

如果把父类放在前面,子类 catch 永远不会被执行:

java
try {
    // ...
} catch (Exception e) {          // 先捕获了 Exception
    // ...
} catch (NullPointerException e) { // 无法到达的代码
    // ...
}

因为 NullPointerException 是 Exception 的子类,上面的 catch 已经全部拦截了。

6. finally 一定会执行吗 ​

通常会执行,但存在少数例外。

以下情况 finally 可能不会执行:

  • JVM 被强制退出:System.exit(0) 会直接终止 JVM
  • JVM 崩溃:比如底层系统错误
  • 进程被强制终止:kill -9 之类的操作
  • 线程永久阻塞:finally 前的代码导致线程无法继续
  • 机器断电:物理层面上已经没法执行了

除了这些极端情况,正常情况下 finally 都会执行。日常开发中需要特别注意的是前面提到的 try-with-resources,它在很多场景下可以替代 finally,让代码更清晰。

finally 中的 return 陷阱 ​

另一个容易被忽略的问题是:不要在 finally 中使用 return:

java
public int test() {
    try {
        return 1;
    } finally {
        return 2;
    }
}

最终返回的是 2。因为 finally 中的 return 会覆盖 try(或 catch)中的返回值,也会"吞掉"本应抛出的异常。

java
public int test() {
    try {
        throw new RuntimeException();
    } finally {
        return 0; // 异常被吞掉了
    }
}

调用方会得到 0,完全感知不到异常发生。这种问题在线上排查时极其隐蔽,所以 finally 块只应该做资源清理,不要返回值。

7. 自定义异常 ​

业务开发中,Java 内置的异常类型往往不足以表达业务语义。自定义异常是常见做法:

java
public class BusinessException extends RuntimeException {

    private final Integer code;

    public BusinessException(Integer code, String message) {
        super(message);
        this.code = code;
    }

    public Integer getCode() {
        return code;
    }
}

使用时:

java
if (user == null) {
    throw new BusinessException(404, "用户不存在");
}

自定义异常通常继承 RuntimeException(非受检异常),这样业务代码不需要在每个地方都声明 throws,使用更灵活。

8. Spring Boot 中的全局异常处理 ​

在 Spring Boot 项目中,如果每个 Controller 都写一遍 try-catch,会产生大量重复且难以维护的代码。

更好的方案是定义全局异常处理器,统一管理所有异常的响应格式:

java
@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(BusinessException.class)
    public Result<?> handleBusinessException(BusinessException e) {
        return Result.fail(e.getCode(), e.getMessage());
    }

    @ExceptionHandler(Exception.class)
    public Result<?> handleException(Exception e) {
        return Result.fail(500, "系统异常");
    }
}

这样业务代码的任务变得极其简单:在不符合条件的地方直接抛异常,异常处理器负责:

  • 记录日志:保留错误现场
  • 转换错误码:将内部异常映射为前端可读的错误码
  • 返回统一响应格式:保证 API 返回结构一致
  • 隐藏系统内部异常信息:避免将栈信息直接暴露给用户
java
@RestController
public class UserController {

    @GetMapping("/user/{id}")
    public Result<UserVO> getUser(@PathVariable Long id) {
        User user = userService.findById(id);
        if (user == null) {
            throw new BusinessException(404, "用户不存在");
        }
        return Result.ok(UserVO.from(user));
    }
}

不需要任何 try-catch,异常处理逻辑全部集中在 GlobalExceptionHandler 中。

9. 几个常见问题和建议 ​

异常捕获粒度 ​

不要捕获 Exception 后什么都不做,也不要捕获异常却不记录日志:

java
try {
    // ...
} catch (Exception e) {
    // 空 catch —— 异常被吞掉了,没人知道
}

最起码要打印日志。更好的做法是区分哪些异常可以恢复、哪些需要直接抛出。

不要用异常控制正常流程 ​

java
// 反例:用异常控制流程
try {
    // 尝试执行业务
} catch (SomeException e) {
    // 如果失败,执行备选流程
}

异常机制在性能上不如条件判断,而且会让代码逻辑变得难以理解。能用 if-else 判断的情况,不要用异常。

尽早抛出,延迟捕获 ​

  • 尽早抛出:在发现异常的地方直接抛出,不要在逻辑继续执行很久后才抛出——那时上下文信息可能已经丢失。
  • 延迟捕获:在有能力处理异常的地方再捕获。如果当前方法无法决定如何处理,就让异常向上传播。

异常信息要有意义 ​

java
// 模糊
throw new BusinessException("错误");

// 清晰
throw new BusinessException(400, "用户年龄不能小于18岁,当前年龄:" + age);

有价值的异常信息应包含:什么操作、什么原因、涉及的上下文数据。

总结 ​

Java 异常机制可以概括为几个关键点:

  1. Throwable 体系:Error(系统级错误,不处理)和 Exception(可处理的异常)。
  2. 受检 vs 非受检:受检异常编译器强制处理,非受检异常(RuntimeException)不强制但需要关注代码质量。
  3. 五个关键字:try-catch-finally 捕获处理、throw 主动抛出、throws 声明异常。
  4. 异常传播:未被捕获的异常沿调用栈向上传递,最终由 JVM 处理。
  5. finally 特性:通常必执行,但 System.exit() 等情况例外;不要在 finally 中写 return。
  6. 自定义异常 + 全局处理:在 Spring Boot 中通过 @RestControllerAdvice 统一管理,业务代码只负责抛异常。

理解异常机制,不只是为了通过面试——它直接关系到线上系统的稳定性和问题排查效率。

参考资料 ​

最后更新于: