SpringBoot全局异常处理知多少？详细介绍处理方法，附相关源代码-51CTO.COM

Spring Boot提供了一种简单且灵活的方式来处理应用程序中的异常，即全局异常处理。全局异常处理允许我们定义一个统一的异常处理器，以捕获应用程序中发生的所有异常，并提供自定义的错误响应。

在本文中，我将详细介绍Spring Boot全局异常处理的方法，并提供源代码和相关说明。

一、创建全局异常处理器

首先，我们需要创建一个全局异常处理器。我们可以通过实现ErrorController接口或使用@ControllerAdvice注解来创建全局异常处理器。

1、实现ErrorController接口

我们可以创建一个类，实现ErrorController接口，并重写getErrorPath()和errorHandle()方法来处理异常。

import org.springframework.boot.web.servlet.error.ErrorController;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GlobalErrorController implements ErrorController {

    private static final String PATH = "/error";

    @RequestMapping(value = PATH)
    public String errorHandle() {
        // 处理异常逻辑
        return "Error handling logic goes here";
    }

    @Override
    public String getErrorPath() {
        return PATH;
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

在上面的代码中，我们创建了一个名为GlobalErrorController的类，它实现了ErrorController接口。我们使用@RestController注解将该类标记为一个控制器，并使用@RequestMapping注解来映射处理异常的路径为/error。在errorHandle()方法中，我们可以编写自定义的异常处理逻辑。

2、使用@ControllerAdvice注解

另一种创建全局异常处理器的方法是使用@ControllerAdvice注解。我们可以创建一个带有@ControllerAdvice注解的类，并在其中定义一个或多个带有@ExceptionHandler注解的方法来处理异常。

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    @ResponseBody
    public String handleException(Exception e) {
        // 处理异常逻辑
        return "Error handling logic goes here";
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

在上面的代码中，我们创建了一个名为GlobalExceptionHandler的类，并使用@ControllerAdvice注解将其标记为全局异常处理器。我们使用@ExceptionHandler注解来指定要处理的异常类型，并在方法中编写自定义的异常处理逻辑。

二、配置全局异常处理器

接下来，我们需要将全局异常处理器配置到Spring Boot应用程序中。我们可以通过创建一个配置类，并使用@EnableWebMvc注解或实现WebMvcConfigurer接口来配置全局异常处理器。

1、使用@EnableWebMvc注解

我们可以创建一个配置类，并使用@EnableWebMvc注解来启用全局异常处理器。

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;

@Configuration
@EnableWebMvc
public class WebConfig {

}1.
2.
3.
4.
5.
6.
7.
8.

在上面的代码中，我们创建了一个名为WebConfig的配置类，并使用@EnableWebMvc注解来启用全局异常处理器。

2、实现WebMvcConfigurer接口

另一种配置全局异常处理器的方法是创建一个配置类，并实现WebMvcConfigurer接口。

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
        resolvers.add(new GlobalExceptionHandler());
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

在上面的代码中，我们创建了一个名为WebConfig的配置类，并实现了WebMvcConfigurer接口。我们重写了configureHandlerExceptionResolvers()方法，并将全局异常处理器添加到异常解析器列表中。

三、自定义异常处理逻辑

在全局异常处理器中，我们可以编写自定义的异常处理逻辑。以下是一些常见的处理逻辑示例：

1、返回自定义错误信息

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

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleException(Exception e) {
        String errorMessage = "An error occurred: " + e.getMessage();
        return new ResponseEntity<>(errorMessage, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

在上面的代码中，我们使用@RestControllerAdvice注解将GlobalExceptionHandler类标记为全局异常处理器。在handleException()方法中，我们可以捕获所有的Exception异常，并返回一个包含自定义错误信息的ResponseEntity对象。

2、返回自定义错误对象

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

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleException(Exception e) {
        ErrorResponse errorResponse = new ErrorResponse("An error occurred", e.getMessage());
        return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

在上面的代码中，我们创建了一个名为ErrorResponse的自定义错误对象，并在handleException()方法中返回该对象。该对象包含了自定义的错误信息和异常消息。

3、返回统一的错误格式

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

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleException(Exception e) {
        ErrorResponse errorResponse = new ErrorResponse("An error occurred", e.getMessage());
        return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);
    }

    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleUserNotFoundException(UserNotFoundException e) {
        ErrorResponse errorResponse = new ErrorResponse("User not found", e.getMessage());
        return new ResponseEntity<>(errorResponse, HttpStatus.NOT_FOUND);
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

在上面的代码中，我们创建了一个名为ErrorResponse的自定义错误对象，并在handleException()方法中返回该对象。在handleUserNotFoundException()方法中，我们捕获了UserNotFoundException异常，并返回一个包含自定义错误信息的ResponseEntity对象。

四、异常处理器的优先级

在Spring Boot应用程序中，可以存在多个全局异常处理器。当发生异常时，Spring Boot会根据异常处理器的优先级来选择合适的处理器。

默认情况下，Spring Boot使用@ControllerAdvice注解的处理器的优先级更高。如果多个处理器都能处理同一类型的异常，Spring Boot将选择具有最高优先级的处理器。

我们可以使用@Order注解来指定处理器的优先级。优先级值越小，优先级越高。

import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
@Order(1)
public class GlobalExceptionHandler1 {

    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleException(Exception e) {
        String errorMessage = "An error occurred: " + e.getMessage();
        return new ResponseEntity<>(errorMessage, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

@RestControllerAdvice
@Order(2)
public class GlobalExceptionHandler2 {

    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleException(Exception e) {
        String errorMessage = "An error occurred: " + e.getMessage();
        return new ResponseEntity<>(errorMessage, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.

在上面的代码中，GlobalExceptionHandler1的优先级为1，GlobalExceptionHandler2的优先级为2。当发生异常时，GlobalExceptionHandler1将被选择为处理器。

五、测试全局异常处理器

最后，我们可以编写一些测试用例来测试全局异常处理器。

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;

@SpringBootTest
@AutoConfigureMockMvc
public class GlobalExceptionHandlerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testHandleException() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.get("/error"))
                .andExpect(MockMvcResultMatchers.status().isInternalServerError())
                .andExpect(MockMvcResultMatchers.content().string("An error occurred: Internal Server Error"));
    }

    @Test
    public void testHandleUserNotFoundException() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.get("/user/123"))
                .andExpect(MockMvcResultMatchers.status().isNotFound())
                .andExpect(MockMvcResultMatchers.content().string("User not found: 123"));
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.

在上面的代码中，我们使用MockMvc来模拟HTTP请求，并使用MockMvcRequestBuilders构建请求。在testHandleException()方法中，我们发送一个GET请求到/error路径，并断言返回的状态码为500，内容为"An error occurred: Internal Server Error"。在testHandleUserNotFoundException()方法中，我们发送一个GET请求到/user/123路径，并断言返回的状态码为404，内容为"User not found: 123"。

这些测试用例可以确保全局异常处理器按预期工作，并返回正确的错误信息。