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

luffylv

已于 2022-05-09 10:14:17 修改

阅读量5.8k

点赞数 4

分类专栏： SpringCloud 文章标签： java spring cloud

于 2021-12-22 18:15:23 首次发布

本文链接：https://blog.csdn.net/m0_47503416/article/details/122089913

版权

SpringCloud 专栏收录该内容

5 篇文章 1 订阅

订阅专栏

一、场景

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

二、模拟服务端异常

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

客户端代码

TestErrorController

@Slf4j
@RestController
@RequestMapping("/test")
public class TestErrorController {

    @Autowired
    private TestErrorFeignService testErrorFeignService;

    /**
     * 测试异常
     */
    @RequestMapping("/testError")
    public ResultBody testError() {
        String result;
        try {
            result = testErrorFeignService.testError();
        } catch (Exception e) {
            log.error("TestService testError e :{}.", e);
            return ResultBody.fail500(e.getMessage());
        }
        return ResultBody.success(result);
    }
}

TestErrorFeignService

@FeignClient(name = "service-provider",path = "/test")
public interface TestErrorFeignService {

    /**
     * 测试异常
     */
    @RequestMapping(value = "/testError")
    public String testError();
}

服务端代码

TestErrorController

@Slf4j
@RestController
@RequestMapping("/test")
public class TestErrorController {

    /**
     * 测试异常
     */
    @RequestMapping("/testError")
    public String testError() {
        int i;
        try {
            i = 16 / 0;
        } catch (Exception e) {
            log.error("TestErrorService testError 异常，异常信息为:{}.", e);
            throw e;
        }
        return "provider" + i;
    }
}

运行后查看日志

服务端日志

客户端日志

通过上面日志可以看出，服务端日志显示是算数异常并且告诉我们是因为 / 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）

import com.example.rtbootconsumer.common.constants.ErrorCode;
import com.example.rtbootconsumer.common.constants.ErrorMessage;
import com.example.rtbootconsumer.common.exception.BusinessException;
import com.example.rtbootconsumer.common.exception.ServerException;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.support.DefaultMessageSourceResolvable;
import org.springframework.util.CollectionUtils;
import org.springframework.validation.ObjectError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import javax.servlet.http.HttpServletResponse;
import java.io.Serializable;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Description 全局异常捕获
 **/
@Slf4j
@RestControllerAdvice
public class GlobalExceptionAdvice {

    /**
     *  捕获业务异常
     */
    @ExceptionHandler(value = {BusinessException.class})
    public ErrorResponse processBusinessException(HttpServletResponse response, BusinessException exception) {
        log.error(exception.getMessage(), exception);
        // 设置HTTP状态码
        response.setStatus(ErrorCode.BUSINESS_EXCEPTION);
        response.setContentType("application/json;charset=UTF-8");
        return new ErrorResponse(exception.getCode(), exception.getMessage());
    }

    /**
     * 捕获系统异常
     */
    @ExceptionHandler(value = {Exception.class, ServerException.class})
    public ErrorResponse processServerException(HttpServletResponse response, Exception exception) {
        log.error(exception.getMessage(), exception);
        // 设置HTTP状态码
        response.setStatus(ErrorCode.INTERNAL_SERVER_ERROR);
        response.setContentType("application/json;charset=UTF-8");
        return new ErrorResponse(ErrorCode.INTERNAL_SERVER_ERROR, exception.getMessage());
    }

    /**
     * 捕获参数校验异常
     */
    @ExceptionHandler(value = {MethodArgumentNotValidException.class})
    public ErrorResponse handleException(HttpServletResponse response, MethodArgumentNotValidException exception) {
        log.error(exception.getMessage(), exception);
        // 设置HTTP状态码
        response.setStatus(ErrorCode.PARAMETER_VALIDATION_ERROR);
        List<ObjectError> errorList = exception.getBindingResult().getAllErrors();
        ErrorResponse errorResponse;
        if (CollectionUtils.isEmpty(errorList)) {
            errorResponse = new ErrorResponse(ErrorCode.PARAMETER_VALIDATION_ERROR, ErrorMessage.INTERNAL_SERVER_ERROR);
        } else {
            List<String> errorMessageList = errorList.stream().map(DefaultMessageSourceResolvable::getDefaultMessage).collect(Collectors.toList());
            String errorMessage = String.join(",", errorMessageList);
            errorResponse = new ErrorResponse(ErrorCode.PARAMETER_VALIDATION_ERROR, errorMessage);
        }
        return errorResponse;
    }

    @Data
    @AllArgsConstructor
    private class ErrorResponse implements Serializable {

        private static final long serialVersionUID = -4306504824565204107L;

        private int code;

        private String message;
    }
}

错误码常量类（ErrorCode）

public class ErrorCode {

    /**
     *  系统内部异常
     */
    public static final int INTERNAL_SERVER_ERROR = 500;

    /**
     *  业务异常
     */
    public static final int BUSINESS_EXCEPTION = 550;

    /**
     *  参数不合法
     */
    public static final int PARAMETER_VALIDATION_ERROR = 450;

}

自定义业务异常（BusinessException）

import lombok.Data;

/**
 * @Description 业务异常
 **/
@Data
public class BusinessException extends RuntimeException {

    private static final long serialVersionUID = 843904622605906038L;

    private int code;

    private String message;

    public BusinessException(int code, String message) {
        super(message);
        this.code = code;
        this.message = message;
    }

    public BusinessException(int code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
        this.message = message;
    }

}

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

import lombok.Data;

/**
 * @Description 参数校验异常
 **/
@Data
public class ParamValidateException extends RuntimeException {

    private static final long serialVersionUID = 806485898682779782L;

    private int code;

    private String message;

    public ParamValidateException(int code, String message) {
        super(message);
        this.code = code;
        this.message = message;
    }

    public ParamValidateException(int code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
        this.message = message;
    }
}

自定义系统异常（ServerException ）

import lombok.Data;

/**
 * @Description 系统异常
 **/
@Data
public class ServerException extends RuntimeException {

    private static final long serialVersionUID = 761184035642900420L;

    private int code;

    private String message;

    public ServerException(int code, String message) {
        super(message);
        this.code = code;
        this.message = message;
    }

    public ServerException(int code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
        this.message = message;
    }
}

客户端

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

自定义错误解码器（FeignClientErrorDecoder）

import com.example.rtbootprovider.common.constants.ErrorCode;
import com.example.rtbootprovider.common.exception.BusinessException;
import com.example.rtbootprovider.common.exception.ParamValidateException;
import com.example.rtbootprovider.common.exception.ServerException;
import com.google.gson.Gson;
import feign.Response;
import feign.Util;
import feign.codec.ErrorDecoder;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpStatus;

import java.io.IOException;

/**
 * @Description 自定义错误解码器
 **/
@Slf4j
@Configuration
public class FeignClientErrorDecoder implements ErrorDecoder {

    @Override
    public Exception decode(String methodKey, Response response) {
        try {
            if (response.body() != null) {
                String errorContent = Util.toString(response.body().asReader());
                Gson gson = new Gson();
                if (response.status() == ErrorCode.INTERNAL_SERVER_ERROR) {
                    return gson.fromJson(errorContent, ServerException.class);
                } else if (response.status() == ErrorCode.PARAMETER_VALIDATION_ERROR) {
                    return gson.fromJson(errorContent, ParamValidateException.class);
                } else if (response.status() == ErrorCode.BUSINESS_EXCEPTION) {
                    return gson.fromJson(errorContent, BusinessException.class);
                }
            }
        } catch (IOException e) {
            log.error("FeignClientErrorDecoder decode exception:{}.", e);
            return e;
        }
        return new Exception("服务端未知异常！");
    }
}

效果展示

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

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

注意：

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的字符串内容。

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

luffylv

关注

4
点赞
踩
25

收藏

觉得还不错? 一键收藏
打赏
6
评论
SpringCloud组件OpenFeign——将服务端详细异常信息返回给客户端

一、场景最近使用单位封装的微服务架构搭建微服务项目，封装的不太多，大部分可以按原生的SpringCloud组件的使用方式使用。涉及到的组件有Nacos、Ribbon、OpenFeign、Hystrix、Sentinel。领导让搭建微服务项目，并且不使用Hystrix和Sentinel做服务熔断和降级，即客户端通过OpenFeign调用服务端服务，如果服务端异常直接返回给客户端，客户端能够捕获并打印出异常信息。二、模拟服务端异常先让服务端产生一个算数异常并抛出，看一下正常情况下客户端会怎么样。.
复制链接

扫一扫