【Java基础：系统性学习指南】异常处理：从语法到架构思维

摘要：本文围绕 Java 异常处理展开，从基础的 checked 与 unchecked 异常的区别入手，深入剖析 JDBC 和 Spring 选择不同异常类型的原因，通过具体案例探讨异常丢失的问题，从字节码层面解析 finally 块中 return 覆盖 try 块返回值的现象，最后详细介绍全局异常处理器的设计以及 Spring 的 @ControllerAdvice 实现原理。通过丰富的实操

AI_DL_CODE

1134人浏览 · 2025-04-20 15:47:52

AI_DL_CODE · 2025-04-20 15:47:52 发布

摘要：本文围绕 Java 异常处理展开，从基础的 checked 与 unchecked 异常的区别入手，深入剖析 JDBC 和 Spring 选择不同异常类型的原因，通过具体案例探讨异常丢失的问题，从字节码层面解析 finally 块中 return 覆盖 try 块返回值的现象，最后详细介绍全局异常处理器的设计以及 Spring 的 @ControllerAdvice 实现原理。通过丰富的实操流程和完整代码，帮助开发者全面掌握 Java 异常处理的相关知识和架构思维。

文章目录

【Java基础：系统性学习】异常处理：从语法到架构思维

在这里插入图片描述

【Java基础：系统性学习】异常处理：从语法到架构思维

关键词

Java 异常处理；checked 异常；unchecked 异常；异常丢失；全局异常处理器；@ControllerAdvice

一、引言

在 Java 编程中，异常处理是一个至关重要的部分。它能够帮助开发者捕获和处理程序运行过程中出现的错误，保证程序的健壮性和稳定性。Java 中的异常分为 checked 异常和 unchecked 异常，不同的场景和框架会选择不同类型的异常进行处理。同时，异常处理过程中还可能会出现异常丢失等问题，需要开发者深入理解其原理并掌握相应的解决方法。此外，设计合理的全局异常处理器能够统一处理程序中的异常，提高代码的可维护性。本文将围绕这些核心内容，结合实际案例和代码，进行详细的阐述。

二、checked vs unchecked 异常

2.1 异常的基本概念

在 Java 中，异常是指程序在运行过程中出现的错误或意外情况。异常类继承自 Throwable 类，Throwable 有两个重要的子类：Error 和 Exception。Error 表示系统级的错误，通常是由 JVM 或硬件问题引起的，程序无法处理；Exception 表示程序可以处理的异常，又分为 checked 异常和 unchecked 异常。

2.2 checked 异常

checked 异常是指在编译时必须进行处理的异常，否则程序无法通过编译。这些异常通常表示程序外部的问题，如文件不存在、网络连接失败等。常见的 checked 异常包括 IOException、SQLException 等。

以下是一个简单的读取文件的示例，演示了 checked 异常的处理：

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

public class CheckedExceptionExample {
    public static void main(String[] args) {
        try {
            File file = new File("test.txt");
            FileReader reader = new FileReader(file);
            int data;
            while ((data = reader.read()) != -1) {
                System.out.print((char) data);
            }
            reader.close();
        } catch (IOException e) {
            System.out.println("读取文件时出现异常: " + e.getMessage());
        }
    }
}

在这个示例中，FileReader 的构造函数和 read 方法都可能抛出 IOException，这是一个 checked 异常。因此，在使用这些方法时，必须使用 try-catch 块捕获异常或者在方法签名中使用 throws 关键字声明抛出异常。

2.3 unchecked 异常

unchecked 异常是指在编译时不需要进行处理的异常，也称为运行时异常。这些异常通常是由程序的逻辑错误引起的，如空指针异常、数组越界异常等。RuntimeException 及其子类都属于 unchecked 异常，常见的 unchecked 异常包括 NullPointerException、ArrayIndexOutOfBoundsException 等。

以下是一个空指针异常的示例：

public class UncheckedExceptionExample {
    public static void main(String[] args) {
        String str = null;
        try {
            System.out.println(str.length());
        } catch (NullPointerException e) {
            System.out.println("出现空指针异常: " + e.getMessage());
        }
    }
}

在这个示例中，str 为 null，调用 length() 方法会抛出 NullPointerException，这是一个 unchecked 异常。虽然我们可以使用 try-catch 块捕获它，但在编译时并不强制要求。

2.4 checked 异常和 unchecked 异常的区别

编译时检查：checked 异常在编译时会被检查，必须进行处理；而 unchecked 异常在编译时不会被检查。
异常类型：checked 异常通常表示程序外部的问题，如文件操作、网络连接等；而 unchecked 异常通常表示程序的逻辑错误。
处理方式：对于 checked 异常，必须使用 try-catch 块捕获或者在方法签名中使用 throws 关键字声明抛出；对于 unchecked 异常，可以选择捕获处理，也可以不处理。

三、为什么 JDBC 用 checked 异常而 Spring 用 unchecked

3.1 JDBC 使用 checked 异常的原因

JDBC（Java Database Connectivity）是 Java 用于连接数据库的标准 API。JDBC 使用 checked 异常（如 SQLException）的主要原因如下：

明确错误处理：数据库操作涉及到外部资源，可能会出现各种错误，如数据库连接失败、SQL 语句执行错误等。使用 checked 异常可以强制开发者在代码中处理这些异常，确保程序能够正确地处理数据库操作中的错误。
异常传播：在企业级应用中，数据库操作通常是多个层次的，如 DAO 层、Service 层等。使用 checked 异常可以将异常向上传播，让上层调用者知道数据库操作出现了问题，并进行相应的处理。

以下是一个简单的 JDBC 查询示例：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class JdbcExample {
    public static void main(String[] args) {
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        try {
            // 加载数据库驱动
            Class.forName("com.mysql.cj.jdbc.Driver");
            // 建立数据库连接
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password");
            // 创建 Statement 对象
            statement = connection.createStatement();
            // 执行 SQL 查询
            resultSet = statement.executeQuery("SELECT * FROM users");
            // 处理查询结果
            while (resultSet.next()) {
                System.out.println(resultSet.getString("username"));
            }
        } catch (Exception e) {
            System.out.println("数据库操作出现异常: " + e.getMessage());
        } finally {
            // 关闭资源
            try {
                if (resultSet != null) resultSet.close();
                if (statement != null) statement.close();
                if (connection != null) connection.close();
            } catch (Exception e) {
                System.out.println("关闭资源时出现异常: " + e.getMessage());
            }
        }
    }
}

在这个示例中，Class.forName、DriverManager.getConnection、statement.executeQuery 等方法都可能抛出 SQLException 或其他 checked 异常，需要使用 try-catch 块进行处理。

3.2 Spring 使用 unchecked 异常的原因

Spring 是一个轻量级的 Java 开发框架，它提倡使用 unchecked 异常（如 DataAccessException 及其子类），主要原因如下：

简化代码：使用 unchecked 异常可以避免在代码中大量使用 try-catch 块或 throws 关键字，使代码更加简洁。开发者可以将更多的精力放在业务逻辑上，而不是异常处理上。
灵活性：Spring 框架中的异常处理机制更加灵活，它提供了全局异常处理器和异常转换器等功能，可以统一处理异常。使用 unchecked 异常可以更好地与这些机制结合，实现统一的异常处理。
与业务逻辑分离：将异常处理与业务逻辑分离，使代码的结构更加清晰。业务逻辑只需要关注业务本身，异常处理由 Spring 框架统一负责。

以下是一个简单的 Spring 数据访问示例：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public List<String> getUsernames() {
        return jdbcTemplate.queryForList("SELECT username FROM users", String.class);
    }
}

在这个示例中，JdbcTemplate 的方法可能会抛出 DataAccessException 及其子类的异常，这些异常是 unchecked 异常，不需要在方法签名中声明抛出，也不需要在方法内部进行捕获处理。Spring 框架会在全局异常处理器中统一处理这些异常。

四、异常丢失的经典案例

4.1 异常丢失的概念

异常丢失是指在异常处理过程中，一个异常被另一个异常所覆盖，导致原始异常信息丢失的现象。这种情况通常会使调试和排查问题变得困难。

4.2 经典案例分析

4.2.1 在 `finally` 块中抛出异常

public class ExceptionLossInFinally {
    public static void main(String[] args) {
        try {
            // 模拟抛出异常
            throw new RuntimeException("原始异常");
        } finally {
            // 在 finally 块中抛出另一个异常
            throw new RuntimeException("finally 块中的异常");
        }
    }
}

在这个示例中，try 块中抛出了一个 RuntimeException，但在 finally 块中又抛出了另一个 RuntimeException。由于 finally 块中的代码无论如何都会执行，并且 finally 块中的异常会覆盖 try 块中的异常，导致原始异常信息丢失。

4.2.2 在 `catch` 块中抛出异常

public class ExceptionLossInCatch {
    public static void main(String[] args) {
        try {
            // 模拟抛出异常
            throw new RuntimeException("原始异常");
        } catch (RuntimeException e) {
            // 在 catch 块中抛出另一个异常
            throw new RuntimeException("catch 块中的异常", e);
        }
    }
}

在这个示例中，try 块中抛出了一个 RuntimeException，在 catch 块中捕获到该异常后，又抛出了另一个 RuntimeException，并将原始异常作为参数传递。虽然这里保留了原始异常的引用，但如果没有正确处理，仍然可能导致异常信息的丢失。

4.3 避免异常丢失的方法

记录异常信息：在捕获异常时，使用日志记录工具（如 Log4j、SLF4J 等）记录异常信息，包括异常的堆栈跟踪信息。这样即使异常被覆盖，也可以从日志中查看原始异常信息。
正确处理异常：在 finally 块中尽量避免抛出异常，如果必须抛出异常，要确保原始异常信息不会丢失。可以将原始异常封装到新的异常中，或者使用日志记录原始异常信息。
使用异常链：在抛出新的异常时，将原始异常作为参数传递给新的异常，形成异常链。这样可以保留原始异常的信息，方便调试和排查问题。

以下是一个使用异常链避免异常丢失的示例：

import java.io.IOException;

public class AvoidExceptionLoss {
    public static void main(String[] args) {
        try {
            methodThatThrowsException();
        } catch (CustomException e) {
            // 打印异常链信息
            Throwable cause = e.getCause();
            while (cause != null) {
                System.out.println("Cause: " + cause.getMessage());
                cause = cause.getCause();
            }
        }
    }

    public static void methodThatThrowsException() throws CustomException {
        try {
            // 模拟抛出异常
            throw new IOException("原始异常");
        } catch (IOException e) {
            // 抛出新的异常，并将原始异常作为参数传递
            throw new CustomException("新的异常", e);
        }
    }
}

class CustomException extends Exception {
    public CustomException(String message, Throwable cause) {
        super(message, cause);
    }
}

在这个示例中，methodThatThrowsException 方法中捕获到 IOException 后，抛出了一个 CustomException，并将 IOException 作为参数传递给 CustomException。在 main 方法中捕获到 CustomException 后，可以通过 getCause() 方法获取原始异常信息。

五、finally 块中 return 覆盖 try 块返回值（字节码层面解析）

5.1 现象描述

在 Java 中，如果 try 块和 finally 块中都有 return 语句，finally 块中的 return 语句会覆盖 try 块中的 return 语句。

以下是一个示例：

public class FinallyReturnOverride {
    public static int test() {
        int result = 0;
        try {
            result = 1;
            return result;
        } finally {
            result = 2;
            return result;
        }
    }

    public static void main(String[] args) {
        int value = test();
        System.out.println("返回值: " + value);
    }
}

在这个示例中，try 块中 result 的值为 1，并执行了 return 语句。但由于 finally 块中也有 return 语句，最终返回的值是 finally 块中 result 的值 2。

5.2 字节码层面解析

为了深入理解这个现象，我们可以查看上述代码的字节码。使用 javap -c FinallyReturnOverride 命令可以查看字节码信息。

Compiled from "FinallyReturnOverride.java"
public class FinallyReturnOverride {
  public FinallyReturnOverride();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static int test();
    Code:
       0: iconst_0
       1: istore_0
       2: iconst_1
       3: istore_0
       4: iload_0
       5: istore_1
       6: iconst_2
       7: istore_0
       8: iload_0
       9: ireturn
      10: astore_2
      11: iconst_2
      12: istore_0
      13: iload_0
      14: ireturn

  public static void main(java.lang.String[]);
    Code:
       0: invokestatic  #2                  // Method test:()I
       3: istore_1
       4: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
       7: new           #4                  // class java/lang/StringBuilder
      10: dup
      11: invokespecial #5                  // Method java/lang/StringBuilder."<init>":()V
      14: ldc           #6                  // String 返回值: 
      16: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      19: iload_1
      20: invokevirtual #8                  // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
      23: invokevirtual #9                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      26: invokevirtual #10                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      29: return
}

从字节码中可以看出，在 try 块中，result 的值 1 被存储在局部变量表的索引 1 位置（istore_1），但在执行 finally 块时，result 的值被更新为 2，并最终返回。这是因为在 Java 中，finally 块中的代码无论如何都会执行，并且 finally 块中的 return 语句会覆盖 try 块中的 return 语句。

5.3 避免 `finally` 块中 `return` 覆盖 `try` 块返回值的方法

避免在 finally 块中使用 return 语句：尽量将 return 语句放在 try 块或 catch 块中，避免在 finally 块中使用 return 语句，以免覆盖 try 块中的返回值。
使用异常处理：如果需要在 finally 块中执行一些清理操作，可以使用异常处理机制，确保 finally 块中的代码不会影响 try 块中的返回值。

以下是一个避免 finally 块中 return 覆盖 try 块返回值的示例：

public class AvoidFinallyReturnOverride {
    public static int test() {
        int result = 0;
        try {
            result = 1;
            return result;
        } finally {
            result = 2;
            // 不使用 return 语句
        }
    }

    public static void main(String[] args) {
        int value = test();
        System.out.println("返回值: " + value);
    }
}

在这个示例中，finally 块中没有使用 return 语句，因此 try 块中的返回值不会被覆盖，最终返回的值是 1。

六、全局异常处理器设计

6.1 全局异常处理器的概念

全局异常处理器是指在应用程序中统一处理异常的机制。它可以捕获应用程序中抛出的所有异常，并进行统一的处理，如记录日志、返回统一的错误信息等。使用全局异常处理器可以提高代码的可维护性和可扩展性，避免在每个方法中都编写重复的异常处理代码。

6.2 设计思路

设计全局异常处理器的基本思路是：定义一个全局异常处理类，使用注解或配置的方式将该类标记为全局异常处理器。在该类中定义不同类型异常的处理方法，当应用程序中抛出异常时，全局异常处理器会根据异常的类型调用相应的处理方法。

6.3 实操流程

6.3.1 创建自定义异常类

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

6.3.2 创建全局异常处理类

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(CustomException.class)
    public ResponseEntity<String> handleCustomException(CustomException e) {
        return new ResponseEntity<>("自定义异常: " + e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
    }

    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity<String> handleRuntimeException(RuntimeException e) {
        return new ResponseEntity<>("运行时异常: " + e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

在这个示例中，使用 @ControllerAdvice 注解将 GlobalExceptionHandler 类标记为全局异常处理器。使用 @ExceptionHandler 注解定义不同类型异常的处理方法，当应用程序中抛出 CustomException 或 RuntimeException 时，会调用相应的处理方法。

6.3.3 创建控制器类

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {
    @GetMapping("/test")
    public String test() {
        throw new CustomException("这是一个自定义异常");
    }
}

在这个示例中，TestController 类中的 test 方法抛出了一个 CustomException，该异常会被全局异常处理器捕获并处理。

6.3.4 启动 Spring Boot 应用

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

启动该 Spring Boot 应用后，访问 /test 接口，会看到全局异常处理器返回的错误信息。

6.4 代码解释

@ControllerAdvice 注解：用于标记一个类为全局异常处理器，该类中的异常处理方法会应用到所有的控制器类中。
@ExceptionHandler 注解：用于定义异常处理方法，指定要处理的异常类型。当应用程序中抛出指定类型的异常时，会调用该方法进行处理。
ResponseEntity：用于封装响应信息，包括响应状态码和响应体。

七、Spring 的 @ControllerAdvice 实现原理

7.1 @ControllerAdvice 注解的作用

@ControllerAdvice 是 Spring 框架提供的一个注解，用于定义全局异常处理器、全局数据绑定和全局数据预处理等功能。它可以将多个控制器中共同的异常处理逻辑、数据绑定逻辑等抽取到一个类中，提高代码的可维护性和可复用性。

7.2 实现原理

@ControllerAdvice 的实现原理主要涉及 Spring 的 AOP（面向切面编程）和 Bean 后置处理器。具体步骤如下：

7.2.1 扫描 `@ControllerAdvice` 注解的类

在 Spring 应用启动时，会扫描所有带有 @ControllerAdvice 注解的类，并将这些类注册为 Bean。

7.2.2 解析 `@ExceptionHandler` 注解

Spring 会解析 @ControllerAdvice 注解类中的 @ExceptionHandler 注解，将异常处理方法与对应的异常类型进行关联。

7.2.3 异常处理

当控制器方法抛出异常时，Spring 会根据异常的类型查找对应的 @ExceptionHandler 注解的方法，并调用该方法进行异常处理。

7.3 源码分析

以下是 Spring 框架中与 @ControllerAdvice 相关的部分源码分析：

7.3.1 `ControllerAdviceBean` 类

public class ControllerAdviceBean implements Ordered {
    private final Object bean;
    private final String beanName;
    private final int order;
    private final Class<?> beanType;

    // 构造函数和其他方法...

    public static ControllerAdviceBean create(ApplicationContext context, Object beanOrBeanName) {
        if (beanOrBeanName instanceof String) {
            String beanName = (String) beanOrBeanName;
            return new ControllerAdviceBean(beanName, context);
        } else {
            Object bean = beanOrBeanName;
            return new ControllerAdviceBean(bean);
        }
    }

    // 其他方法...
}

ControllerAdviceBean 类用于封装 @ControllerAdvice 注解的 Bean，包含 Bean 的名称、类型、顺序等信息。

7.3.2 `ExceptionHandlerExceptionResolver` 类

public class ExceptionHandlerExceptionResolver extends AbstractHandlerMethodExceptionResolver
        implements InitializingBean {
    private final Map<Class<? extends Throwable>, ExceptionHandlerMethodResolver> exceptionHandlerCache =
            new ConcurrentHashMap<>(64);

    // 其他方法...

    @Override
    protected ModelAndView doResolveHandlerMethodException(HttpServletRequest request,
            HttpServletResponse response, HandlerMethod handlerMethod, Exception exception) {
        ServletInvocableHandlerMethod exceptionHandlerMethod = getExceptionHandlerMethod(handlerMethod, exception);
        if (exceptionHandlerMethod == null) {
            return null;
        }

        try {
            if (logger.isDebugEnabled()) {
                logger.debug("Using @ExceptionHandler " + exceptionHandlerMethod);
            }
            ServletWebRequest webRequest = new ServletWebRequest(request, response);
            ModelAndViewContainer mavContainer = new ModelAndViewContainer();
            exceptionHandlerMethod.invokeAndHandle(webRequest, mavContainer, exception);
            if (mavContainer.isRequestHandled()) {
                return new ModelAndView();
            } else {
                return getModelAndView(mavContainer, modelFactory, webRequest);
            }
        } catch (Exception invocationEx) {
            // 处理异常处理方法调用过程中抛出的异常
            if (logger.isErrorEnabled()) {
                logger.error("Failed to invoke @ExceptionHandler method: " + exceptionHandlerMethod, invocationEx);
            }
            return null;
        }
    }

    // 其他方法...
}

ExceptionHandlerExceptionResolver 类是 Spring 框架中用于处理 @ExceptionHandler 注解的异常解析器。当控制器方法抛出异常时，doResolveHandlerMethodException 方法会查找对应的 @ExceptionHandler 注解的方法，并调用该方法进行异常处理。

7.4 总结

@ControllerAdvice 注解通过 Spring 的 AOP 和 Bean 后置处理器机制，实现了全局异常处理、全局数据绑定和全局数据预处理等功能。它将多个控制器中共同的逻辑抽取到一个类中，提高了代码的可维护性和可复用性。

八、综合实操：异常处理在实际项目中的应用

8.1 需求分析

假设我们要开发一个简单的 Web 应用，实现用户注册和登录功能。在用户注册和登录过程中，可能会出现各种异常，如用户名已存在、密码错误等。我们需要设计一个全局异常处理器，统一处理这些异常，并返回统一的错误信息给客户端。

8.2 实操步骤

8.2.1 创建自定义异常类

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

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

8.2.2 创建用户服务类

import java.util.HashMap;
import java.util.Map;

public class UserService {
    private static final Map<String, String> users = new HashMap<>();

    public void register(String username, String password) {
        if (users.containsKey(username)) {
            throw new UsernameExistsException("用户名已存在");
        }
        users.put(username, password);
    }

    public void login(String username, String password) {
        if (!users.containsKey(username)) {
            throw new RuntimeException("用户不存在");
        }
        String storedPassword = users.get(username);
        if (!storedPassword.equals(password)) {
            throw new PasswordErrorException("密码错误");
        }
    }
}

8.2.3 创建全局异常处理类

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(UsernameExistsException.class)
    public ResponseEntity<String> handleUsernameExistsException(UsernameExistsException e) {
        return new ResponseEntity<>("注册失败: " + e.getMessage(), HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(PasswordErrorException.class)
    public ResponseEntity<String> handlePasswordErrorException(PasswordErrorException e) {
        return new ResponseEntity<>("登录失败: " + e.getMessage(), HttpStatus.UNAUTHORIZED);
    }

    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity<String> handleRuntimeException(RuntimeException e) {
        return new ResponseEntity<>("系统错误: " + e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

8.2.4 创建控制器类

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    private final UserService userService = new UserService();

    @GetMapping("/register")
    public String register(@RequestParam String username, @RequestParam String password) {
        userService.register(username, password);
        return "注册成功";
    }

    @GetMapping("/login")
    public String login(@RequestParam String username, @RequestParam String password) {
        userService.login(username, password);
        return "登录成功";
    }
}

8.2.5 启动 Spring Boot 应用

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

8.3 代码解释

自定义异常类：定义了 UsernameExistsException 和 PasswordErrorException 两个自定义异常类，用于表示用户名已存在和密码错误的异常情况。
用户服务类：UserService 类实现了用户注册和登录的业务逻辑，在注册和登录过程中，如果出现异常，会抛出相应的自定义异常。
全局异常处理类：GlobalExceptionHandler 类使用 @ControllerAdvice 注解标记为全局异常处理器，使用 @ExceptionHandler 注解定义了不同类型异常的处理方法，当应用程序中抛出相应的异常时，会调用对应的处理方法。
控制器类：UserController 类提供了用户注册和登录的接口，调用 UserService 类的方法进行业务处理。
Spring Boot 应用：Application 类是 Spring Boot 应用的入口类，启动该应用后，可以通过访问 /register 和 /login 接口进行用户注册和登录操作。

九、常见问题与解决方案

9.1 异常处理过于复杂导致代码可读性差

9.1.1 问题描述

在一些复杂的业务逻辑中，异常处理代码可能会变得非常复杂，导致代码的可读性和可维护性下降。

9.1.2 解决方案

分层处理：将异常处理逻辑分层，不同层次处理不同类型的异常。例如，在 DAO 层处理数据库操作异常，在 Service 层处理业务逻辑异常，在 Controller 层处理全局异常。
使用全局异常处理器：使用全局异常处理器统一处理异常，避免在每个方法中都编写重复的异常处理代码。
记录日志：使用日志记录工具记录异常信息，方便调试和排查问题。

9.2 异常处理不当导致资源泄漏

9.2.1 问题描述

在异常处理过程中，如果没有正确关闭资源，可能会导致资源泄漏，如数据库连接未关闭、文件流未关闭等。

9.2.2 解决方案

使用 try-with-resources 语句：对于实现了 AutoCloseable 接口的资源，使用 try-with-resources 语句可以自动关闭资源，避免资源泄漏。

import java.io.FileInputStream;
import java.io.IOException;

public class TryWithResourcesExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("test.txt")) {
            int data;
            while ((data = fis.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            System.out.println("读取文件时出现异常: " + e.getMessage());
        }
    }
}

在 finally 块中关闭资源：对于没有实现 AutoCloseable 接口的资源，在 finally 块中手动关闭资源。

9.3 全局异常处理器无法捕获某些异常

9.3.1 问题描述

在某些情况下，全局异常处理器可能无法捕获某些异常，导致异常信息无法统一处理。

9.3.2 解决方案

检查异常类型：确保全局异常处理器中定义的异常处理方法覆盖了所有可能抛出的异常类型。
检查异常抛出位置：有些异常可能在过滤器、拦截器等组件中抛出，需要在这些组件中进行异常处理，或者将异常抛出到控制器层，由全局异常处理器处理。

十、总结与展望

10.1 总结

本文围绕 Java 异常处理展开，从基础的 checked 与 unchecked 异常的区别入手，深入剖析了 JDBC 和 Spring 选择不同异常类型的原因，通过具体案例探讨了异常丢失的问题，从字节码层面解析了 finally 块中 return 覆盖 try 块返回值的现象，最后详细介绍了全局异常处理器的设计以及 Spring 的 @ControllerAdvice 实现原理。通过综合实操案例，展示了异常处理在实际项目中的应用。

10.2 展望

随着 Java 技术的不断发展，异常处理机制也会不断完善和优化。未来，可能会出现更加智能和灵活的异常处理方式，如基于人工智能的异常诊断和处理。同时，开发者也需要不断学习和掌握新的异常处理技术，以提高代码的健壮性和稳定性。

十一、参考文献

[1] 《Effective Java》
[2] 《Java核心技术》
[3] 《Spring实战》
[4] Oracle Java 官方文档

十二、附录：常见问题解答

12.1 checked 异常和 unchecked 异常应该如何选择使用？

如果异常是由程序外部的问题引起的，如文件操作、网络连接等，通常使用 checked 异常，强制开发者处理这些异常。
如果异常是由程序的逻辑错误引起的，如空指针异常、数组越界异常等，通常使用 unchecked 异常，让开发者在调试和测试过程中及时发现问题。

12.2 如何在全局异常处理器中记录异常信息？

可以在全局异常处理器的异常处理方法中使用日志记录工具（如 Log4j、SLF4J 等）记录异常信息，包括异常的堆栈跟踪信息。例如：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class GlobalExceptionHandler {
    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity<String> handleRuntimeException(RuntimeException e) {
        logger.error("发生运行时异常", e);
        return new ResponseEntity<>("系统错误: " + e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

12.3 `finally` 块中的代码一定会执行吗？

在大多数情况下，finally 块中的代码一定会执行。但有以下几种情况除外：

程序在 try 块或 catch 块中调用了 System.exit() 方法，终止了 JVM 的运行。
程序在 try 块或 catch 块中发生了死循环或无限递归。
程序在 try 块或 catch 块中发生了硬件故障或操作系统崩溃。

12.4 如何在 Spring 中自定义异常响应格式

在 Spring 项目里，通常期望返回统一且规范的异常响应格式，这样便于前端开发人员处理错误信息。下面详细介绍如何自定义异常响应格式。

定义异常响应类

首先，要定义一个类来表示异常响应的结构，其中包含错误码、错误信息等内容。

public class ErrorResponse {
    private int status;
    private String message;
    private String errorCode;

    public ErrorResponse(int status, String message, String errorCode) {
        this.status = status;
        this.message = message;
        this.errorCode = errorCode;
    }

    // Getters 和 Setters 方法
    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public String getErrorCode() {
        return errorCode;
    }

    public void setErrorCode(String errorCode) {
        this.errorCode = errorCode;
    }
}

自定义全局异常处理器

接着，在全局异常处理器中使用这个异常响应类。

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class CustomGlobalExceptionHandler {

    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity<ErrorResponse> handleRuntimeException(RuntimeException e) {
        ErrorResponse errorResponse = new ErrorResponse(HttpStatus.INTERNAL_SERVER_ERROR.value(), e.getMessage(), "RUNTIME_ERROR");
        return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);
    }

    @ExceptionHandler(IllegalArgumentException.class)
    public ResponseEntity<ErrorResponse> handleIllegalArgumentException(IllegalArgumentException e) {
        ErrorResponse errorResponse = new ErrorResponse(HttpStatus.BAD_REQUEST.value(), e.getMessage(), "INVALID_ARGUMENT");
        return new ResponseEntity<>(errorResponse, HttpStatus.BAD_REQUEST);
    }
}

在上述代码中，针对不同类型的异常，创建了对应的 ErrorResponse 对象，并将其封装在 ResponseEntity 中返回。

12.5 如何在异常处理中使用日志进行调试

在异常处理过程中，日志是非常重要的调试工具。通过日志可以记录异常发生的详细信息，便于后续排查问题。

引入日志框架

通常使用 SLF4J 作为日志门面，Logback 作为日志实现。在 pom.xml 中添加以下依赖：

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.36</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.11</version>
</dependency>

在异常处理中记录日志

在全局异常处理器中添加日志记录功能。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class LoggingGlobalExceptionHandler {
    private static final Logger logger = LoggerFactory.getLogger(LoggingGlobalExceptionHandler.class);

    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleException(Exception e) {
        logger.error("发生异常", e);
        return new ResponseEntity<>("系统出现异常，请稍后重试", HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

在上述代码中，使用 logger.error 方法记录异常信息，同时将异常对象作为参数传递，这样可以记录异常的堆栈跟踪信息。

12.6 如何处理异步方法中的异常

在 Spring 中，异步方法的异常处理与同步方法有所不同。通常使用 @Async 注解来标记异步方法。

定义异步方法

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import java.util.concurrent.CompletableFuture;

@Service
public class AsyncService {

    @Async
    public CompletableFuture<String> asyncMethod() {
        try {
            // 模拟耗时操作
            Thread.sleep(2000);
            if (Math.random() > 0.5) {
                throw new RuntimeException("异步方法抛出异常");
            }
            return CompletableFuture.completedFuture("异步方法执行成功");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return CompletableFuture.failedFuture(e);
        } catch (RuntimeException e) {
            return CompletableFuture.failedFuture(e);
        }
    }
}

处理异步方法的异常

在调用异步方法时，需要处理可能出现的异常。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import java.util.concurrent.CompletableFuture;

@Component
public class AsyncExceptionHandler implements CommandLineRunner {

    @Autowired
    private AsyncService asyncService;

    @Override
    public void run(String... args) throws Exception {
        CompletableFuture<String> future = asyncService.asyncMethod();
        future.exceptionally(ex -> {
            System.out.println("异步方法出现异常: " + ex.getMessage());
            return null;
        }).thenAccept(result -> {
            if (result != null) {
                System.out.println("异步方法结果: " + result);
            }
        });
    }
}

在上述代码中，使用 exceptionally 方法处理异步方法抛出的异常，使用 thenAccept 方法处理正常结果。

体需求进行调整和优化。同时，代码的版权归原作者所有，如有侵权，请联系作者进行删除。

开源鸿蒙跨平台开发者社区

开源鸿蒙跨平台开发社区汇聚开发者与厂商，共建“一次开发，多端部署”的开源生态，致力于降低跨端开发门槛，推动万物智联创新。

更多推荐

## Flutter 三方库 dio 的鸿蒙化适配与网络请求实战指南

开源鸿蒙跨平台开发者社区

c/c++移植适配指导

开源鸿蒙跨平台开发者社区

Flutter 三方库 dio 的鸿蒙化适配指南：实战文章列表功能

开源鸿蒙跨平台开发者社区

所有评论(0)

查看更多评论

AI_DL_CODE

@weixin_39815573

已为社区贡献1条内容

【Java基础：系统性学习指南】异常处理：从语法到架构思维

AI_DL_CODE

文章目录

【Java基础：系统性学习】异常处理：从语法到架构思维

关键词

一、引言

二、checked vs unchecked 异常

2.1 异常的基本概念

2.2 checked 异常

2.3 unchecked 异常

2.4 checked 异常和 unchecked 异常的区别

三、为什么 JDBC 用 checked 异常而 Spring 用 unchecked

3.1 JDBC 使用 checked 异常的原因

3.2 Spring 使用 unchecked 异常的原因

四、异常丢失的经典案例

4.1 异常丢失的概念

4.2 经典案例分析

4.2.1 在 finally 块中抛出异常

4.2.2 在 catch 块中抛出异常

4.3 避免异常丢失的方法

五、finally 块中 return 覆盖 try 块返回值（字节码层面解析）

5.1 现象描述

5.2 字节码层面解析

5.3 避免 finally 块中 return 覆盖 try 块返回值的方法

六、全局异常处理器设计

6.1 全局异常处理器的概念

6.2 设计思路

6.3 实操流程

6.3.1 创建自定义异常类

6.3.2 创建全局异常处理类

6.3.3 创建控制器类

6.3.4 启动 Spring Boot 应用

6.4 代码解释

七、Spring 的 @ControllerAdvice 实现原理

7.1 @ControllerAdvice 注解的作用

7.2 实现原理

7.2.1 扫描 @ControllerAdvice 注解的类

7.2.2 解析 @ExceptionHandler 注解

7.2.3 异常处理

7.3 源码分析

7.3.1 ControllerAdviceBean 类

7.3.2 ExceptionHandlerExceptionResolver 类

7.4 总结

八、综合实操：异常处理在实际项目中的应用

8.1 需求分析

8.2 实操步骤

8.2.1 创建自定义异常类

8.2.2 创建用户服务类

8.2.3 创建全局异常处理类

8.2.4 创建控制器类

8.2.5 启动 Spring Boot 应用

8.3 代码解释

九、常见问题与解决方案

9.1 异常处理过于复杂导致代码可读性差

9.1.1 问题描述

9.1.2 解决方案

9.2 异常处理不当导致资源泄漏

9.2.1 问题描述

9.2.2 解决方案

9.3 全局异常处理器无法捕获某些异常

9.3.1 问题描述

9.3.2 解决方案

十、总结与展望

10.1 总结

10.2 展望

十一、参考文献

十二、附录：常见问题解答

12.1 checked 异常和 unchecked 异常应该如何选择使用？

12.2 如何在全局异常处理器中记录异常信息？

12.3 finally 块中的代码一定会执行吗？

12.4 如何在 Spring 中自定义异常响应格式

定义异常响应类

自定义全局异常处理器

12.5 如何在异常处理中使用日志进行调试

引入日志框架

在异常处理中记录日志

12.6 如何处理异步方法中的异常

定义异步方法

处理异步方法的异常

所有评论(0)

4.2.1 在 `finally` 块中抛出异常

4.2.2 在 `catch` 块中抛出异常

5.3 避免 `finally` 块中 `return` 覆盖 `try` 块返回值的方法

7.2.1 扫描 `@ControllerAdvice` 注解的类

7.2.2 解析 `@ExceptionHandler` 注解

7.3.1 `ControllerAdviceBean` 类

7.3.2 `ExceptionHandlerExceptionResolver` 类

12.3 `finally` 块中的代码一定会执行吗？