logo
DEEPLEARN
banner
NEWS LETTER

Java后端开发你应该知道的全局异常处理

Scroll down

​ 在开发Web应用程序时，异常处理是一项非常重要的任务。异常处理可以提高程序的健壮性和稳定性。Java后端开发人员可以设计一个统一的全局异常处理方案来解决异常处理的问题，避免代码冗余，提高开发效率。在本文中，我们将介绍如何设计Java后端的全局异常处理方案。

什么是全局异常处理？

​ 全局异常处理是一种将异常处理代码从业务逻辑中分离出来的技术。在Java中，全局异常处理使用@ControllerAdvice注解定义一个全局的异常处理类。在该类中，使用@ExceptionHandler注解捕获异常并进行处理。使用全局异常处理技术，可以统一处理异常，提高代码的复用性，降低代码的冗余度。

如何设计Java后端的全局异常处理方案？

设计Java后端的全局异常处理方案包括以下几个步骤：

1. 定义自定义异常类

定义自定义异常类可以使异常信息更加明确，方便后续的处理。自定义异常类需要继承Exception类或其子类。在自定义异常类中，可以定义异常编码和异常消息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class MyException extends Exception {
    private String code;
    private String message;

    public MyException(String code, String message) {
        this.code = code;
        this.message = message;
    }

    public String getCode() {
        return code;
    }

    public String getMessage() {
        return message;
    }
}

2. 定义全局异常处理类

定义全局异常处理类需要使用@ControllerAdvice注解。在该类中，使用@ExceptionHandler注解捕获异常并进行处理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(MyException.class)
    @ResponseBody
    public ResponseEntity<ErrorResponse> handleMyException(MyException e) {
        ErrorResponse errorResponse = new ErrorResponse(e.getCode(), e.getMessage());
        return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);
    }

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

@ControllerAdvice注解可以让我们定义一个全局的异常处理类。@ExceptionHandler注解用于捕获异常，并将异常信息封装到ErrorResponse类中。@ResponseBody注解用于返回自定义的异常信息，HttpStatus.INTERNAL_SERVER_ERROR表示返回500错误。

3. 定义异常编码和异常消息

在自定义异常类中，我们需要定义异常编码和异常消息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class ErrorResponse {
    private String code;
    private String message;

    public ErrorResponse(String code, String message) {
        this.code = code;
        this.message = message;
    }

    public String getCode() {
        return code;
    }

    public String getMessage() {
        return message;
    }
}

4. 前端处理异常信息

​ 前端可以根据返回的异常编码和异常消息，对异常进行相应的处理。在使用Axios进行数据请求时，可以通过拦截器拦截返回的异常信息。

1
2
3
4
5
6
7
8
9
10
11
12
import axios from 'axios'

axios.interceptors.response.use(
    response => response,
    error => {
        const response = error.response;
        if (response.status === 500) {
            console.log(response.data.code, response.data.message);
        }
        return Promise.reject(error);
    }
);

​ 在拦截器中，使用if语句判断是否返回500错误。如果是，就将异常编码和异常消息输出到控制台上。这样，在前端出现异常时，我们可以通过控制台输出的信息快速定位异常，进行相应的处理。

利用面向切面AOP对全局异常进行处理

​ 利用面向切面编程（AOP）可以更方便地实现Java后端的全局统一异常处理。我们可以通过AOP将异常处理代码从业务逻辑代码中分离出来，降低代码耦合度，提高代码的可维护性和可扩展性。

下面是利用AOP实现Java后端全局统一异常处理的步骤：

  1. 定义一个异常处理类，用于处理全局异常。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@ControllerAdvice
public class GlobalExceptionHandler {

    /**
     * 处理全局异常
     */
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleException(Exception e) {
        log.error("全局异常信息：{}", e.getMessage());
        ErrorResponse errorResponse = new ErrorResponse();
        errorResponse.setCode(500);
        errorResponse.setMessage("服务器出错啦！");
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse);
    }
}

​ 在上面的代码中，我们使用@ControllerAdvice注解定义了一个全局异常处理类，用于处理所有的异常。在该类中，我们定义了一个handleException方法，该方法用于处理所有的异常，将异常信息封装到一个ErrorResponse对象中，并将该对象返回给前端。

  1. 定义一个切面类，用于捕获所有的异常。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Aspect
@Component
public class ExceptionAspect {

    @Around("execution(* com.example.demo.controller.*.*(..))")
    public Object handleException(ProceedingJoinPoint pjp) throws Throwable {
        Object result;
        try {
            result = pjp.proceed();
        } catch (Exception e) {
            log.error("异常信息：{}", e.getMessage());
            ErrorResponse errorResponse = new ErrorResponse();
            errorResponse.setCode(500);
            errorResponse.setMessage("服务器出错啦！");
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse);
        }
        return result;
    }
}

在上面的代码中，我们使用@Aspect注解定义了一个切面类，用于捕获所有的异常。在该类中，我们定义了一个handleException方法，该方法用于处理所有的异常。如果有异常发生，该方法会将异常信息封装到一个ErrorResponse对象中，并将该对象返回给前端。

  1. 配置AOP。

在Spring Boot中，我们可以通过@Configuration注解定义一个配置类，并使用@EnableAspectJAutoProxy注解开启AOP功能。

1
2
3
4
5
@Configuration
@EnableAspectJAutoProxy
public class AopConfig {

}

在上面的代码中，我们定义了一个AopConfig类，并使用@EnableAspectJAutoProxy注解开启AOP功能。

  1. 测试。

​ 现在，我们已经完成了全局统一异常处理的配置，可以进行测试了。在测试过程中，如果出现异常，会自动被切面类捕获并处理，返回给前端一个ErrorResponse对象。

1
2
3
4
5
6
7
8
9
@RestController
public class TestController {

    @GetMapping("/test")
    public String test() {
        int i = 1 / 0;
        return "test";
    }
}

​ 在上面的代码中，我们定义了一个TestController类，并在其中的test方法中故意抛出一个异常。当我们访问该接口时，会自动被切面类捕获并进行统一异常处理。

​ 在这个例子中，我们使用了切面技术实现了全局统一异常处理，这种方式相比于try-catch代码块的方式更加简洁和优雅，也更易于维护。同时，AOP还可以用于处理其他方面的逻辑，比如日志、缓存、权限控制等。

​ 当然，这种方式也存在一些限制和注意事项。比如，如果应用中存在多个切面，可能会出现切面的执行顺序问题，需要手动配置切面执行的顺序。另外，在使用AOP时，也需要注意对性能的影响，如果切面代码逻辑过于复杂或者切入的方法过多，可能会对应用的性能产生一定的影响。

​ 全局统一异常处理是Java后端开发中不可或缺的一部分，通过切面技术实现全局异常处理可以有效地提高代码的可维护性和可读性，也可以更加方便地对异常信息进行管理和处理。

总结

​ 在Java后端开发中，异常处理是一项非常重要的任务。通过设计一个统一的全局异常处理方案，我们可以将异常处理代码从业务逻辑中分离出来，避免代码冗余，提高开发效率。在本文中，我们介绍了Java后端的全局异常处理方案，包括定义自定义异常类、定义全局异常处理类、定义异常编码和异常消息以及前端处理异常信息。希望本文能够对Java后端开发人员设计统一全局异常处理方案有所帮助。定性。

如果这篇文章对你有帮助，你可以请作者喝一杯蜜雪冰城。

其他文章
cover
后端
计算机导论
  • 23/05/05
  • 09:03
  • 6.5k
  • 22
cover
code
Java并发编程
  • 23/04/23
  • 09:32
  • 0
  • 1
© 2023- 2023 一个很闲的vegetable
由 Hexo 驱动 v6.3.0 主题 - Async v2.0.4
我们永远不会止步不前！！！