Java 异常机制详解
程序运行过程中,总会遇到意料之外的情况:文件不存在、网络断开、参数不合法、内存不足……如果没有一套妥善的处理机制,任何一个小问题都可能直接让程序崩溃。
Java 的异常机制就是用来解决这个问题的。它的核心目标是:
将正常业务逻辑与错误处理逻辑分离,避免程序出现问题时直接崩溃。
本文将从异常体系结构出发,逐步深入到处理方式、传播机制、常见陷阱和实际项目中的应用。
1. Java 异常体系
Java 中所有异常和错误都继承自 Throwable,这是整个异常体系的根类:
Throwable
├── Error
└── Exception
├── RuntimeException
└── 其他非运行时异常下面分层来看。
Error
Error 表示 JVM 或系统层面的严重问题,通常程序无法正常处理,也不应该试图捕获:
OutOfMemoryError:内存溢出,比如创建了过多对象且无法回收StackOverflowError:栈溢出,常见于递归没有正确终止NoClassDefFoundError:运行时找不到类定义
一般来说,业务代码不需要关心 Error。即使捕获了,也通常无法恢复正常的运行状态。
Exception
Exception 表示程序运行中可以预见、可以处理的异常情况。它又分为两大类。
受检异常(Checked Exception)
编译器会强制要求处理——要么用 try-catch 捕获,要么在方法声明上用 throws 抛出。不处理就无法通过编译。
常见的受检异常:
IOException
SQLException
ClassNotFoundException示例:
public void readFile() throws IOException {
FileInputStream inputStream = new FileInputStream("test.txt");
}如果不做任何处理,编译器会直接报错。
非受检异常(Unchecked Exception)
主要指 RuntimeException 及其子类,编译器不强制处理。它们通常由程序逻辑错误引起:
NullPointerException
IndexOutOfBoundsException
IllegalArgumentException
ArithmeticException示例:
int result = 10 / 0; // 抛出 ArithmeticException这类异常不需要显式捕获,但如果放任不管,程序会直接终止。所以虽然编译器不强制,良好的代码仍然要考虑是否需要在合适的地方处理它们。
2. 异常处理关键字
Java 的异常处理机制围绕五个关键字展开:
try catch finally throw throwstry-catch:捕获并处理异常
try {
int result = 10 / 0;
} catch (ArithmeticException e) {
System.out.println("除数不能为零");
}当 try 块中的代码抛出异常,后面的代码不再执行,程序会跳转到匹配的 catch 块。如果没有找到匹配的 catch,异常会继续向上抛出。
finally:无论如何都要执行的代码
finally 块中的代码通常都会执行,一般用于释放资源(关闭文件、数据库连接等):
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 语法,代码会简洁很多:
try (FileInputStream inputStream =
new FileInputStream("test.txt")) {
// 读取文件
} catch (IOException e) {
e.printStackTrace();
}只要资源实现了 AutoCloseable 接口(InputStream、OutputStream、Connection 等都属于此类),Java 就会在 try 块结束后自动关闭资源,不需要手动写 finally。
throw:主动抛出异常
throw 用于在方法内部主动抛出一个异常对象。当业务逻辑发现非法状态或参数时,常用它中断当前流程:
public void register(int age) {
if (age < 18) {
throw new IllegalArgumentException("年龄不能小于18岁");
}
}抛出异常后,当前方法立即结束,异常沿调用栈向上传播。
throws:声明方法可能抛出的异常
throws 用在方法声明上,表示当前方法不处理某种异常,而是交给调用者处理:
public void readFile() throws IOException {
FileInputStream inputStream = new FileInputStream("test.txt");
}调用 readFile() 的方法必须在它的调用链中处理 IOException,要么继续用 throws 向上抛。
3. throw 和 throws 的区别
这两个关键字名字相似,但作用完全不同:
| 对比项 | throw | throws |
|---|---|---|
| 位置 | 方法体内部 | 方法声明处 |
| 作用 | 主动抛出一个异常对象 | 声明方法可能抛出的异常 |
| 后面跟的内容 | 一个异常对象 | 一个或多个异常类型 |
| 示例 | throw new RuntimeException() | throws IOException, SQLException |
简单记忆:throw 是"干"(抛出异常),throws 是"说"(声明异常)。
4. 异常传播机制
如果一个方法发生异常,但当前方法没有捕获处理,异常会沿着方法调用栈不断向上抛出。
public static void main(String[] args) {
methodA();
}
public static void methodA() {
methodB();
}
public static void methodB() {
int result = 10 / 0;
}异常传播过程如下:
methodB ← 抛出 ArithmeticException
↓
methodA ← 未捕获,继续上抛
↓
main ← 未捕获,继续上抛
↓
JVM ← 打印异常堆栈,终止线程如果整个调用链都没有捕获异常,最终 JVM 会接手——打印完整的异常堆栈,并终止当前线程。
异常堆栈中通常包含:
- 异常类型:知道发生了什么问题
- 异常信息:具体的错误描述
- 异常发生的位置:哪个文件的哪行代码
- 方法调用链路:异常从哪个方法起源,经过哪些方法传播
线上排查问题时,应优先关注异常堆栈中的 Caused by 部分,以及最接近自己业务代码的位置——那里往往是问题的真正源头。
5. 多个 catch 的匹配规则
一个 try 后面可以跟多个 catch 块,分别处理不同类型的异常:
try {
// 业务代码
} catch (NullPointerException e) {
// 处理空指针
} catch (RuntimeException e) {
// 处理其他运行时异常
} catch (Exception e) {
// 兜底处理
}这里有一个重要的规则:
子类异常在前,父类异常在后。
如果把父类放在前面,子类 catch 永远不会被执行:
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:
public int test() {
try {
return 1;
} finally {
return 2;
}
}最终返回的是 2。因为 finally 中的 return 会覆盖 try(或 catch)中的返回值,也会"吞掉"本应抛出的异常。
public int test() {
try {
throw new RuntimeException();
} finally {
return 0; // 异常被吞掉了
}
}调用方会得到 0,完全感知不到异常发生。这种问题在线上排查时极其隐蔽,所以 finally 块只应该做资源清理,不要返回值。
7. 自定义异常
业务开发中,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;
}
}使用时:
if (user == null) {
throw new BusinessException(404, "用户不存在");
}自定义异常通常继承 RuntimeException(非受检异常),这样业务代码不需要在每个地方都声明 throws,使用更灵活。
8. Spring Boot 中的全局异常处理
在 Spring Boot 项目中,如果每个 Controller 都写一遍 try-catch,会产生大量重复且难以维护的代码。
更好的方案是定义全局异常处理器,统一管理所有异常的响应格式:
@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 返回结构一致
- 隐藏系统内部异常信息:避免将栈信息直接暴露给用户
@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 后什么都不做,也不要捕获异常却不记录日志:
try {
// ...
} catch (Exception e) {
// 空 catch —— 异常被吞掉了,没人知道
}最起码要打印日志。更好的做法是区分哪些异常可以恢复、哪些需要直接抛出。
不要用异常控制正常流程
// 反例:用异常控制流程
try {
// 尝试执行业务
} catch (SomeException e) {
// 如果失败,执行备选流程
}异常机制在性能上不如条件判断,而且会让代码逻辑变得难以理解。能用 if-else 判断的情况,不要用异常。
尽早抛出,延迟捕获
- 尽早抛出:在发现异常的地方直接抛出,不要在逻辑继续执行很久后才抛出——那时上下文信息可能已经丢失。
- 延迟捕获:在有能力处理异常的地方再捕获。如果当前方法无法决定如何处理,就让异常向上传播。
异常信息要有意义
// 模糊
throw new BusinessException("错误");
// 清晰
throw new BusinessException(400, "用户年龄不能小于18岁,当前年龄:" + age);有价值的异常信息应包含:什么操作、什么原因、涉及的上下文数据。
总结
Java 异常机制可以概括为几个关键点:
- Throwable 体系:
Error(系统级错误,不处理)和Exception(可处理的异常)。 - 受检 vs 非受检:受检异常编译器强制处理,非受检异常(
RuntimeException)不强制但需要关注代码质量。 - 五个关键字:
try-catch-finally捕获处理、throw主动抛出、throws声明异常。 - 异常传播:未被捕获的异常沿调用栈向上传递,最终由 JVM 处理。
- finally 特性:通常必执行,但
System.exit()等情况例外;不要在finally中写return。 - 自定义异常 + 全局处理:在 Spring Boot 中通过
@RestControllerAdvice统一管理,业务代码只负责抛异常。
理解异常机制,不只是为了通过面试——它直接关系到线上系统的稳定性和问题排查效率。