Java 运行时异常与编译时异常以及异常是否会对数据库造成影响？

发布于：2025-09-10 ⋅ 阅读:(21) ⋅ 点赞:(0)

Java 运行时异常与编译时异常

Java JDK

关于异常的定义与初衷

Java 把“必须显式处理”的异常叫 checked（编译时）异常，把“可以不处理”的叫 unchecked（运行时）异常。

  • 编译时异常：Java语言设计者想强制程序员在 “业务可预期、调用方有能力恢复” 的场景下给出处理策略。
    • 设计目的：强制程序员预先考虑和处理那些在程序正常运行时可预见的、可能发生的问题。编译器会检查你是否处理了它（要么 try-catch，要么在方法上 throws），不处理就报错，无法编译。
    • 典型例子：IOException（文件找不到、无法读写）、SQLException（数据库访问异常）、ClassNotFoundException（类找不到）。
    • 比如说：我们进行写文件操作时，必须强制要求添加try-catch或者抛出异常，这段代码通常被认为是程序员有能力解决(处理报错)，并且料想到该处代码可能报错。
  • 运行时异常：同时在 “编程错误、系统故障” 场景下不强迫写无意义的 try-catch，从而得到 “可读、可维护、可恢复” 的代码。
    • 设计目的：代表程序中的编程错误或系统级的不可恢复错误。编译器不强制你处理它们。
    • 典型例子：NullPointerException（空指针）、ArrayIndexOutOfBoundsException（数组越界）、IllegalArgumentException（非法参数）。
    • 运行时异常是我们最常见碰到的，比如空指针异常、数组越界，我们忘记传递某个参数，忘记判空等常见bug。

语义中的定义

Java将异常分为运行时异常（RuntimeException） 和编译时异常（Checked Exception），主要是基于两种截然不同的错误处理哲学和设计目的。

简单来说，核心区别在于：编译器是否强制要求程序员进行处理。

Throwable
    ├── Error (系统错误，通常不可恢复)
    ├── Exception (异常)
        ├── RuntimeException (运行时异常)
        └── 其他Exception (编译时异常/受检异常)

编译时异常 (Checked Exception)

  • 定义：除了 RuntimeException 及其子类以外的所有 Exception 的子类都是编译时异常。
  • 特点：编译器会检查（Check）这些异常。这意味着如果一个方法可能抛出编译时异常，那么该方法必须使用 throws 关键字在声明中标记出来。调用该方法的代码也必须处理这个异常（使用 try-catch 块捕获并处理，或者继续向上 throws 抛出），否则代码将无法通过编译。
  • 典型例子：
    • IOException（文件未找到、读写错误）
    • SQLException（数据库操作错误）
    • ClassNotFoundException（找不到类定义）
  • 设计目的：
    • 强制可靠性：编译时异常代表的是程序外部、不可预测的错误，通常是和应用程序上下文（Context）无关的。例如，文件是否存在、网络是否通畅、数据库连接是否有效，这些都不是程序逻辑本身能保证的。
    • 契约精神：通过强制处理，它要求程序员必须显式地考虑并编写处理这些“预期可能发生”的意外情况的代码。这相当于在方法签名中形成了一个“契约”，明确告知调用者：“我可能会抛出这种异常，你必须做好应对准备”。
    • 提升代码健壮性：确保程序在遇到外部环境问题时，不会直接崩溃，而是能以一种可控的方式（如重试、记录日志、给用户友好提示等）进行处理。

简单比喻：就像你出门前，天气预报说可能会下雨（编译器提示有异常）。强制要求你必须考虑带伞（try-catch）或者改变计划（throws，让调用者决定），否则不让你出门（编译不通过）。

运行时异常 (Runtime Exception)

  • 定义：RuntimeException 类及其所有子类都是运行时异常。
  • 特点：编译器不强制要求处理。即使一个方法可能抛出运行时异常，也不需要在其声明中用 throws 子句标记。调用代码也可以选择不处理它。
  • 典型例子：
    • NullPointerException（空指针异常）
    • ArrayIndexOutOfBoundsException（数组越界异常）
    • ClassCastException（类型转换异常）
    • IllegalArgumentException（非法参数异常）
  • 设计目的：
    • 代表编程错误：运行时异常通常表示程序逻辑本身存在Bug，是程序员应该避免而不是处理的。比如，访问一个null引用、用错误的下标访问数组，这些都是代码写错了，应该通过代码审查和测试来修复，而不是指望在运行时去捕获和处理。
    • 避免代码冗余：如果强制要求处理每一个潜在的 NullPointerException，代码会被大量的 try-catch 块淹没，变得极其臃肿且可读性差，而实际上这些异常在正确编程的情况下本不该发生。
    • 给予程序员灵活性：将是否处理这些“错误”的决定权交给程序员。在某些上层框架中，可能会有一个统一的异常处理器来捕获所有未处理的运行时异常，并转换为用户友好的错误页面，这比在每个方法里处理要简洁得多。

简单比喻：就像你走路时因为看手机而撞到电线杆（代码有Bug）。没有人会强制要求你出门前做好“防撞电线杆”的计划（编译器不强制），因为这是你应该自己避免的事情。如果真的撞上了，那就很疼（程序崩溃），让你记住下次要改正。

对比

特性 编译时异常 (Checked Exception) 运行时异常 (Runtime Exception)
检查机制 编译器强制检查和处理 编译器不强制检查和处理
处理要求 必须用 try-catch 捕获或 throws 声明抛出 可处理可不处理
继承自 Exception 本身，但不是 RuntimeException 的子类 RuntimeException 及其子类
本质代表 程序外部、不可控的、预期可能发生的问题 程序内部、可控的、本应避免的编程错误
处理策略 恢复策略：尝试修复、重试、告知用户 调试策略：修复代码中的Bug
例子 IOException, SQLException NullPointerException, ArrayIndexOutOfBoundsException

代码示例

  • 一般情况下，编译时异常必须添加try-catch或者throws。

try-catch 捕获异常

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class CheckedExceptionExample {
    
    // 示例1：使用try-catch处理编译时异常
    public void readFileWithTryCatch(String filename) {
        try {
            FileReader reader = new FileReader(new File(filename));
            // 读取文件内容...
            reader.close();
        } catch (IOException e) { // IOException是编译时异常，必须捕获
            System.out.println("文件读取错误: " + e.getMessage());
        }
    }
}

throws 抛出异常

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class CheckedExceptionExample {
    // 示例2：使用throws声明抛出编译时异常
    public void readFileWithThrows(String filename) throws IOException {
        FileReader reader = new FileReader(new File(filename));
        // 读取文件内容...
        reader.close();
    }
    
    // 示例3：如果不处理编译时异常，编译会失败
    public void readFileWithoutHandling(String filename) {
        // 下面这行代码会导致编译错误，因为可能抛出IOException
        // FileReader reader = new FileReader(new File(filename));
    }
}

Spring 框架

核心原因：设计哲学与默认假设

Spring 团队在设计事务管理时，基于这样一个默认假设：

  • RuntimeException（运行时异常）：通常代表编程错误或不可预料的系统级故障。例如：NullPointerException（空指针）、ArrayIndexOutOfBoundsException（数组越界）、IllegalArgumentException（非法参数）。这些异常是不可恢复的（unrecoverable）。如果事务中发生了这种错误，说明程序处于一个非预期的状态，继续执行业务逻辑或提交事务是非常危险的，因此默认回滚是唯一安全的选择。

  • Exception（编译时异常，Checked Exception）：通常代表可预见的业务逻辑异常。例如：文件找不到（IOException）、数据库连接失败、用户重复注册等自定义业务异常。这些异常是可恢复的（recoverable） 或应在业务逻辑中处理的。框架默认认为你已经（或应该）在代码中捕获并处理了这些异常，并做出了相应的业务决策（也许这个决策是记录日志并继续执行其他逻辑，而不是回滚整个事务）。因此，Spring 默认不会主动回滚事务，把决定权交给开发者。

一句话总结：Spring 认为运行时异常是“系统出了幺蛾子”，必须回滚；而编译时异常是“业务上的小问题”，开发者你自己看着办。

如何让编译时异常触发回滚？

方法一：在 catch 块中重新抛出运行时异常

  • 捕获编译时异常
@Transactional
public void updateUser(User user) {
    try {
        userRepository.update(user);
        // 抛出编译时异常
        someMethodThatThrowsCheckedException();
        userRepository.logUpdate(user.getId());
        
    } catch (IOException e) {
        log.error("IO错误发生", e);
        // 将编译时异常包装成运行时异常重新抛出
        throw new RuntimeException("业务操作失败", e);
    }
}

方法二：使用 @Transactional 的 rollbackFor 属性

  • 抛出IOException编译时异常
@Transactional(rollbackFor = IOException.class)
public void updateUser(User user) throws IOException {
    // 不捕获异常，让它直接抛出
    userRepository.update(user);
    someMethodThatThrowsCheckedException();
    userRepository.logUpdate(user.getId());
}

总结说明

  • 被 try-catch 包裹的异常不会导致事务回滚，因为 Spring 的事务管理器根本不知道这些异常的存在。
  • Spring 只关注从 @Transactional 方法边界抛出的异常
  • 如果您希望某些编译时异常也能触发回滚，可以：
    1. 在 catch 块中重新抛出运行时异常
    2. 使用 @Transactional(rollbackFor = ...) 明确指定

两种异常在数据库层面有何区别？

这是一个关键点，需要明确：在数据库层面，这两种异常没有任何区别。

数据库服务器（如 MySQL, PostgreSQL, Oracle）根本不知道你的 Java 应用程序抛出的异常是 RuntimeException 还是 Exception。对数据库来说，它只关心来自应用程序连接（Connection）的指令。

  • 数据库完全不知道Java代码中发生了什么异常。事务回滚的实际过程指令：
  1. Spring 在捕获异常后，根据上述规则做出决策
  2. 如果决定回滚，Spring 会向数据库连接发送 ROLLBACK 命令
  3. 如果决定提交，Spring 会向数据库连接发送 COMMIT 命令
  4. 数据库只是简单地执行收到的命令，完全不知道这个决策背后的原因

事务回滚的机制是这样的：

  1. Spring 管理的事务：Spring 在使用 @Transactional 时，会为方法代理一个数据库连接（Connection），并在这个连接上调用 setAutoCommit(false)，开始一个事务。
  2. 异常发生：当方法中抛出异常时，Spring 的事务拦截器（Transaction Interceptor）会捕获到这个异常。
  3. Spring 的决策：就在这一刻，Spring 会根据规则（默认规则就是：遇到运行时异常和 Error 就回滚，遇到编译时异常就提交）做出决定。
  4. 指令下达给数据库：
    • 如果 Spring 决定回滚，它会向数据库连接发送 rollback() 指令。
    • 如果 Spring 决定提交，它会向数据库连接发送 commit() 指令。
  5. 数据库执行：数据库收到 rollback() 或 commit() 指令后，才会真正执行物理上的回滚或提交操作，撤销或确认之前的所有 SQL 执行结果。

结论：异常类型的区别和回滚的决策完全发生在 Spring 框架层面，数据库只是被动地接收和执行回滚或提交的指令。 下图清晰地展示了这一决策流程：

Spring异常处理逻辑
否
RuntimeException
或 Error
Checked Exception
是
检查异常类型
Spring捕获异常
决策: 回滚
决策: 提交
@Transactional方法开始
Spring代理: 获取连接, begin()
业务方法执行SQL
是否抛出异常?
Spring代理: commit()
Spring代理: rollback()
数据库执行物理提交
数据库执行物理回滚
事务结束

总结与最佳实践

方面 运行时异常 (RuntimeException) 编译时异常 (Checked Exception)
Spring 默认回滚行为 回滚 不回滚（提交）
设计寓意 系统级、不可恢复的错误 业务级、可恢复的异常
数据库层面区别 无区别。回滚决策由 Spring 做出，数据库只负责执行指令。 无区别。
开发建议 通常不需要捕获，让其自动回滚事务。 要么在方法内捕获并处理（决定是提交还是回滚），要么用 rollbackFor 属性声明需要回滚。
常见例子 NPE, ClassCastException, IllegalStateException IOException, SQLException, 自定义业务异常

更精确的说法：“编译时异常机制常用于处理业务逻辑中可预见的异常情况。因此，Spring 默认假设编译时异常是开发者已预料到并打算将其作为业务逻辑流的一部分来处理的，故而不会强制回滚事务。”

核心区别在于：

  • 运行时异常 -> 代表程序bug或系统故障 -> Spring认为必须回滚（安全措施）。
  • 编译时异常 -> 常代表可预见的业务规则问题 -> Spring认为你可能想自己处理，故默认不回滚（把决定权交给你）。

当然，你可以通过 @Transactional(rollbackFor = MyCheckedException.class) 来覆盖默认行为，告诉 Spring：“我这个编译时异常也是需要回滚的！”。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布