devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringCloud组件OpenFeign——将服务端详细异常信息返回给客户端_java open fein获取异常信息

作者：我家小花儿 | 2024-02-15 12:46:43

赞

踩

java open fein获取异常信息

 一、场景

最近使用单位封装的微服务架构搭建微服务项目，封装的不太多，大部分可以按原生的SpringCloud组件的使用方式使用。涉及到的组件有Nacos、Ribbon、OpenFeign、Hystrix、Sentinel。领导让搭建微服务项目，但是不使用Hystrix和Sentinel做服务熔断和降级，即只需要客户端通过OpenFeign调用服务端服务。如果服务端方法异常，则直接将详细的异常信息返回给客户端，客户端能够捕获并打印出异常信息。在调用处便可知道报错原因，而无需再查看服务端日志。

二、模拟服务端异常

先让服务端产生一个算数异常并抛出，看一下正常情况下客户端会怎么样。

客户端代码

TestErrorController

  1. @Slf4j
  2. @RestController
  3. @RequestMapping("/test")
  4. public class TestErrorController {
  5.  
  6.     @Autowired
  7.     private TestErrorFeignService testErrorFeignService;
  8.  
  9.     /**
  10.      * 测试异常
  11.      */
  12.     @RequestMapping("/testError")
  13.     public ResultBody testError() {
  14.         String result;
  15.         try {
  16.             result = testErrorFeignService.testError();
  17.         } catch (Exception e) {
  18.             log.error("TestService testError e :{}.", e);
  19.             return ResultBody.fail500(e.getMessage());
  20.         }
  21.         return ResultBody.success(result);
  22.     }
  23. }

TestErrorFeignService

  1. @FeignClient(name = "service-provider",path = "/test")
  2. public interface TestErrorFeignService {
  3.  
  4.     /**
  5.      * 测试异常
  6.      */
  7.     @RequestMapping(value = "/testError")
  8.     public String testError();
  9. }

服务端代码

TestErrorController

  1. @Slf4j
  2. @RestController
  3. @RequestMapping("/test")
  4. public class TestErrorController {
  5.  
  6.     /**
  7.      * 测试异常
  8.      */
  9.     @RequestMapping("/testError")
  10.     public String testError() {
  11.         int i;
  12.         try {
  13.             i = 16 / 0;
  14.         } catch (Exception e) {
  15.             log.error("TestErrorService testError 异常，异常信息为:{}.", e);
  16.             throw e;
  17.         }
  18.         return "provider" + i;
  19.     }
  20. }

运行后查看日志

服务端日志

 客户端日志

 

 通过上面日志可以看出，服务端日志显示是算数异常并且告诉我们是因为 / by zero。但是查看客户端打印的日志发现，捕获并打印的异常信息是feign.FeignException$InternalServerError: status 500 reading TestErrorFeignService#testError()。通过客户端的异常信息我们只知道客户端通过OpenFeign调用服务端的testError()方法异常，客户端产生的是状态码为500的FeignException。至于为什么会异常我们通过上述客户端日志无从得知，需要查看服务端日志。很明显这并不能满足我的需求。

三、OpenFeign如何处理调用异常

在解决该问题之前，我们首先要知道通过OpenFeign调用服务端接口异常的话是如何处理的。SynchronousMethodHandler->executeAndDecode这个方法第110行是真正调用服务端方法并返回一个feign.Response。如下图

 同样是该方法，从第138行到152行是对返回结果feign.Response的一个处理。可以看到，如果该结果不满足(response.status() >= 200 && response.status() < 300)且(decode404 && response.status() == 404 && void.class != metadata.returnType())时，会通过错误解码器进行解码，该方法会返回一个异常，然后抛出。如下图。

 OpenFeign提供了一个接口ErrorDecoder，该接口只有一个抽象方法decode，默认情况下是使用其静态内部类Default的decode方法对于Response的status不在2xx范围的HTTP进行解码的。如下图

四、解决方式

通过上面分析，给我们提供了一种思路，如果服务端异常后，我们返回一个状态码非200之类的，并且带有异常信息的响应。客户端实现这个接口并重写decode方法，实现我们自定义的错误解码器，就可以实现我们想要的效果，并且可以转换成我们想要的异常。具体方式如下。

服务端

首先服务端需要全局异常捕获，在服务端添加如下类。该类中主要捕获三种异常，服务端异常细分为系统异常、业务异常、参数校验异常。在捕获到异常后，将异常信息（e.getMessage()）添加到响应中。当然，捕获的异常可以再细分。

全局异常捕获类（GlobalExceptionHandler）

  1. import com.example.rtbootconsumer.common.constants.ErrorCode;
  2. import com.example.rtbootconsumer.common.constants.ErrorMessage;
  3. import com.example.rtbootconsumer.common.exception.BusinessException;
  4. import com.example.rtbootconsumer.common.exception.ServerException;
  5. import lombok.AllArgsConstructor;
  6. import lombok.Data;
  7. import lombok.extern.slf4j.Slf4j;
  8. import org.springframework.context.support.DefaultMessageSourceResolvable;
  9. import org.springframework.util.CollectionUtils;
  10. import org.springframework.validation.ObjectError;
  11. import org.springframework.web.bind.MethodArgumentNotValidException;
  12. import org.springframework.web.bind.annotation.ExceptionHandler;
  13. import org.springframework.web.bind.annotation.RestControllerAdvice;
  14.  
  15. import javax.servlet.http.HttpServletResponse;
  16. import java.io.Serializable;
  17. import java.util.List;
  18. import java.util.stream.Collectors;
  19.  
  20. /**
  21.  * @Description 全局异常捕获
  22.  **/
  23. @Slf4j
  24. @RestControllerAdvice
  25. public class GlobalExceptionAdvice {
  26.  
  27.     /**
  28.      *  捕获业务异常
  29.      */
  30.     @ExceptionHandler(value = {BusinessException.class})
  31.     public ErrorResponse processBusinessException(HttpServletResponse response, BusinessException exception) {
  32.         log.error(exception.getMessage(), exception);
  33.         // 设置HTTP状态码
  34.         response.setStatus(ErrorCode.BUSINESS_EXCEPTION);
  35.         response.setContentType("application/json;charset=UTF-8");
  36.         return new ErrorResponse(exception.getCode(), exception.getMessage());
  37.     }
  38.  
  39.     /**
  40.      * 捕获系统异常
  41.      */
  42.     @ExceptionHandler(value = {Exception.class, ServerException.class})
  43.     public ErrorResponse processServerException(HttpServletResponse response, Exception exception) {
  44.         log.error(exception.getMessage(), exception);
  45.         // 设置HTTP状态码
  46.         response.setStatus(ErrorCode.INTERNAL_SERVER_ERROR);
  47.         response.setContentType("application/json;charset=UTF-8");
  48.         return new ErrorResponse(ErrorCode.INTERNAL_SERVER_ERROR, exception.getMessage());
  49.     }
  50.  
  51.     /**
  52.      * 捕获参数校验异常
  53.      */
  54.     @ExceptionHandler(value = {MethodArgumentNotValidException.class})
  55.     public ErrorResponse handleException(HttpServletResponse response, MethodArgumentNotValidException exception) {
  56.         log.error(exception.getMessage(), exception);
  57.         // 设置HTTP状态码
  58.         response.setStatus(ErrorCode.PARAMETER_VALIDATION_ERROR);
  59.         List<ObjectError> errorList = exception.getBindingResult().getAllErrors();
  60.         ErrorResponse errorResponse;
  61.         if (CollectionUtils.isEmpty(errorList)) {
  62.             errorResponse = new ErrorResponse(ErrorCode.PARAMETER_VALIDATION_ERROR, ErrorMessage.INTERNAL_SERVER_ERROR);
  63.         } else {
  64.             List<String> errorMessageList = errorList.stream().map(DefaultMessageSourceResolvable::getDefaultMessage).collect(Collectors.toList());
  65.             String errorMessage = String.join(",", errorMessageList);
  66.             errorResponse = new ErrorResponse(ErrorCode.PARAMETER_VALIDATION_ERROR, errorMessage);
  67.         }
  68.         return errorResponse;
  69.     }
  70.  
  71.     @Data
  72.     @AllArgsConstructor
  73.     private class ErrorResponse implements Serializable {
  74.  
  75.         private static final long serialVersionUID = -4306504824565204107L;
  76.  
  77.         private int code;
  78.  
  79.         private String message;
  80.     }
  81. }

错误码常量类（ErrorCode）

  1. public class ErrorCode {
  2.  
  3.     /**
  4.      *  系统内部异常
  5.      */
  6.     public static final int INTERNAL_SERVER_ERROR = 500;
  7.  
  8.     /**
  9.      *  业务异常
  10.      */
  11.     public static final int BUSINESS_EXCEPTION = 550;
  12.  
  13.     /**
  14.      *  参数不合法
  15.      */
  16.     public static final int PARAMETER_VALIDATION_ERROR = 450;
  17.  
  18. }

自定义业务异常（BusinessException）

  1. import lombok.Data;
  2.  
  3. /**
  4.  * @Description 业务异常
  5.  **/
  6. @Data
  7. public class BusinessException extends RuntimeException {
  8.  
  9.     private static final long serialVersionUID = 843904622605906038L;
  10.  
  11.     private int code;
  12.  
  13.     private String message;
  14.  
  15.     public BusinessException(int code, String message) {
  16.         super(message);
  17.         this.code = code;
  18.         this.message = message;
  19.     }
  20.  
  21.     public BusinessException(int code, String message, Throwable cause) {
  22.         super(message, cause);
  23.         this.code = code;
  24.         this.message = message;
  25.     }
  26.  
  27. }

自定义参数校验异常（ParamValidateException）

  1. import lombok.Data;
  2.  
  3. /**
  4.  * @Description 参数校验异常
  5.  **/
  6. @Data
  7. public class ParamValidateException extends RuntimeException {
  8.  
  9.     private static final long serialVersionUID = 806485898682779782L;
  10.  
  11.     private int code;
  12.  
  13.     private String message;
  14.  
  15.     public ParamValidateException(int code, String message) {
  16.         super(message);
  17.         this.code = code;
  18.         this.message = message;
  19.     }
  20.  
  21.     public ParamValidateException(int code, String message, Throwable cause) {
  22.         super(message, cause);
  23.         this.code = code;
  24.         this.message = message;
  25.     }
  26. }

自定义系统异常（ServerException ）

  1. import lombok.Data;
  2.  
  3. /**
  4.  * @Description 系统异常
  5.  **/
  6. @Data
  7. public class ServerException extends RuntimeException {
  8.  
  9.     private static final long serialVersionUID = 761184035642900420L;
  10.  
  11.     private int code;
  12.  
  13.     private String message;
  14.  
  15.     public ServerException(int code, String message) {
  16.         super(message);
  17.         this.code = code;
  18.         this.message = message;
  19.     }
  20.  
  21.     public ServerException(int code, String message, Throwable cause) {
  22.         super(message, cause);
  23.         this.code = code;
  24.         this.message = message;
  25.     }
  26. }

客户端

客户端新增自定义错误解码器

自定义错误解码器（FeignClientErrorDecoder）

  1. import com.example.rtbootprovider.common.constants.ErrorCode;
  2. import com.example.rtbootprovider.common.exception.BusinessException;
  3. import com.example.rtbootprovider.common.exception.ParamValidateException;
  4. import com.example.rtbootprovider.common.exception.ServerException;
  5. import com.google.gson.Gson;
  6. import feign.Response;
  7. import feign.Util;
  8. import feign.codec.ErrorDecoder;
  9. import lombok.extern.slf4j.Slf4j;
  10. import org.springframework.context.annotation.Configuration;
  11. import org.springframework.http.HttpStatus;
  12.  
  13. import java.io.IOException;
  14.  
  15. /**
  16.  * @Description 自定义错误解码器
  17.  **/
  18. @Slf4j
  19. @Configuration
  20. public class FeignClientErrorDecoder implements ErrorDecoder {
  21.  
  22.     @Override
  23.     public Exception decode(String methodKey, Response response) {
  24.         try {
  25.             if (response.body() != null) {
  26.                 String errorContent = Util.toString(response.body().asReader());
  27.                 Gson gson = new Gson();
  28.                 if (response.status() == ErrorCode.INTERNAL_SERVER_ERROR) {
  29.                     return gson.fromJson(errorContent, ServerException.class);
  30.                 } else if (response.status() == ErrorCode.PARAMETER_VALIDATION_ERROR) {
  31.                     return gson.fromJson(errorContent, ParamValidateException.class);
  32.                 } else if (response.status() == ErrorCode.BUSINESS_EXCEPTION) {
  33.                     return gson.fromJson(errorContent, BusinessException.class);
  34.                 }
  35.             }
  36.         } catch (IOException e) {
  37.             log.error("FeignClientErrorDecoder decode exception:{}.", e);
  38.             return e;
  39.         }
  40.         return new Exception("服务端未知异常！");
  41.     }
  42. }

效果展示 

添加完上面两个类就可以实现我们期望的效果，重新启动客户端和服务端项目并查看效果，客户端日志如下。

可以看出，客户端 打印出了服务端详细的异常信息了。

注意：

1、如果将异常信息String转换为IOException类，gson.fromJson(errorContent,IOException.class);捕获到的是FeignException。

 因为如果通过错误解码器生成的是IOException，会被catch到并通过errorReading(request, response, e);方法转换为FeignException。

2、错误解码器中response的status即为我们在全局异常捕获中设置的HttpServletResponse的status，即response.setStatus();我们在全局异常捕获中返回的自定义响应ResultBody中的内容就是错误解码器中入参Response的body的字符串内容。

如有错误，烦请指正，谢谢！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/84605
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号