【Spring Cloud】OpenFeign与全局异常处理

已于 2024-01-16 23:25:36 修改
阅读量1.3k 收藏 11
点赞数 9
分类专栏： 微服务架构 Spring 文章标签： 统一异常处理 feign openfeign spring cloud
于 2024-01-04 13:59:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kevin_King1992/article/details/135370839
版权

简易原理图

原理基于请求头传递错误消息，利用aop和全局异常拦截机制实现。

在这里插入图片描述

服务提供者

  1. 远程调用本地方法b，throw异常出来
  2. FeignExceptionAspect AOP拦截处理异常到请求头中，继续throw
  3. GlobalExceptionHandler处理，返回响应ResponseVo

服务消费者

  1. controller方法中的远程调用完毕（异常），被FeignExceptionClient（自定义feign调用处理器）检测到请求头中错误码和错误信息，转化为本地BusinessException throw出来
  2. FeignExceptionAspect AOP拦截处理异常到请求头中，继续throw
  3. GlobalExceptionHandler处理，返回响应ResponseVo

上述异常处理机制与使用Decoder处理的异同优劣

  1. 上述异常处理机制代码简洁程度无法跟解码器处理方式比较，但是处理的细致，可以处理更多自定义的异常，比如：UserLoseException
  2. 上述处理机制不受限于原生feign的机制，解码器在处理void的时候会出现无法生效情况，并且通过寻找其他博文在低版本中可以通过反射修改强制属性执行解码器的方式得到解决，3.0.5版本不支持这种操作。
    博文链接如下：https://blog.csdn.net/m0_37298252/article/details/133690069
  3. ErrorDecoder生效处理http status 非200的

总结

  • feign本身不提供异常处理的方案，但是提供入参返参的编解码机制，有上述的分析我们知道Decoder生效必须是有返回值的方法，而不是void，所以全局微服务接口规范为必须有返参或者统一返回值即可。
  • 基于AOP的处理方案，前提是方法必须真正执行到，比如说MVC处理直接抛错，还没进入controller方法，则无法正确抛出错误信息，比如：404或者missig body等错误。如果出现这种情况，需要在全局异常拦截时特殊处理下。

基于AOP和自定义feign执行器代码实现

/**
 * 全局异常处理器
 */
@RestControllerAdvice
@Configuration
@Slf4j
public class GlobalExceptionHandler {

    @ExceptionHandler(value = Exception.class)
    public Object defaultErrorHandler(Exception e) throws Exception {
        log.error("系统异常：{}", e);
        return ResultUtils.error("系统异常", String.valueOf(HttpStatus.INTERNAL_SERVER_ERROR.value()));
    }


    /**
     * 处理运行时异常
     *
     * @param ex
     * @return
     */
    @ExceptionHandler(value = RuntimeException.class)
    public Object runtimeException(RuntimeException ex) {
        log.error("系统异常：{}", ex);
        return ResultUtils.error("系统异常！", String.valueOf(HttpStatus.EXPECTATION_FAILED.value()));
    }

    @ExceptionHandler(value = DecodeException.class)
    public Object decodeException(DecodeException ex) {
        log.error("系统异常：{}", ex);
        return ResultUtils.error(ex.getMessage(), String.valueOf(ex.status()));
}

    /**
     * 处理自定义业务异常
     *
     * @param ex
     * @return
     */
    @ExceptionHandler(value = BusinessException.class)
    public Object exceptionHandler(BusinessException ex) {
        log.error("业务异常详情:{}", ex);
        return ResultUtils.error(ex.getMessage(), ex.getCode());
    }


    @ExceptionHandler(value = UserContextLoseException.class)
    public Object notLoginException(UserContextLoseException e) {
        log.error("当前用户信息不存在异常：{}", e);
        return ResultUtils.notLogin();
    }

    /**
     * 方法入参校验异常处理 content-type!=application/json
     *
     * @param ex 异常
     * @return Object
     */
    @ExceptionHandler({BindException.class})
    public Object bindExceptionException(BindException ex) {
        List<String> validResult = ex.getBindingResult().getAllErrors().stream().map(ObjectError::getDefaultMessage).collect(Collectors.toList());
        log.warn("参数非法：{}", ex);
        return ResultUtils.error(validResult.get(0));
    }

    /**
     * 方法入参校验异常处理 content-type=application/json
     *
     * @param ex 异常
     * @return Object
     */
    @ExceptionHandler(value = MethodArgumentNotValidException.class)
    public Object methodArgumentNotValidException(MethodArgumentNotValidException ex) {
        List<String> validResult = ex.getBindingResult().getAllErrors().stream().map(ObjectError::getDefaultMessage).collect(Collectors.toList());
        log.warn("参数非法：{}", ex);
        // TODO 需要特殊处理异常，否则微服务接口被@Validated校验未通过时无法抛出对应的异常信息
        return ResultUtils.error(validResult.get(0));
    }

    /**
     * 请求类型不支持
     *
     * @param httpRequestMethodNotSupportedException
     * @return
     */
    @ExceptionHandler(value = HttpRequestMethodNotSupportedException.class)
    @ResponseStatus(HttpStatus.METHOD_NOT_ALLOWED)
    public Object handleNotSupportedHttpMethodException(HttpRequestMethodNotSupportedException httpRequestMethodNotSupportedException) {
        log.error("HttpRequestMethodNotSupportedException：{}", httpRequestMethodNotSupportedException);
        return ResultUtils.error(httpRequestMethodNotSupportedException.getMessage(), String.valueOf(HttpStatus.EXPECTATION_FAILED.value()));
    }

    /**
     * media type not support
     *
     * @param httpMediaTypeNotSupportedException
     * @return
     */
    @ExceptionHandler(value = HttpMediaTypeNotSupportedException.class)
    @ResponseStatus(HttpStatus.METHOD_NOT_ALLOWED)
    public Object handleNotSupportedHttpMethodException(HttpMediaTypeNotSupportedException httpMediaTypeNotSupportedException) {
        log.error("HttpMediaTypeNotSupportedException：{}", httpMediaTypeNotSupportedException);
        return ResultUtils.error(httpMediaTypeNotSupportedException.getMessage(), String.valueOf(HttpStatus.EXPECTATION_FAILED.value()));
    }
}

@Slf4j
@Aspect
@Order(value = 100)
@Component
public class FeignExceptionAspect {

    @Pointcut("@annotation(org.springframework.web.bind.annotation.RequestMapping)" +
            " || @annotation(org.springframework.web.bind.annotation.GetMapping)" +
            " || @annotation(org.springframework.web.bind.annotation.PostMapping)" +
            " || @annotation(org.springframework.web.bind.annotation.PutMapping)" +
            " || @annotation(org.springframework.web.bind.annotation.DeleteMapping)")
    public void pointcut() {
    }

    @Around("pointcut()")
    public Object around(ProceedingJoinPoint joinPoint) {
        try {
            Object proceed = joinPoint.proceed();
            return proceed;
        } catch (BusinessException e) {
            log.error("feign调用异常：{}", e.getMessage());
            if (null != RequestContextHolder.getRequestAttributes() && null != ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse()) {
                HttpServletResponse response = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
                response.setHeader(FEIGN_RESPONSE_HEADER_ERROR_CODE_KEY, e.getCode());
                response.setHeader(FEIGN_RESPONSE_HEADER_ERROR_MESSAGE_KEY, Base64.encode(e.getMessage(), "UTF-8"));
            }
            throw e;
        } catch (UserContextLoseException e) {
            log.error("用户信息缺失：{}", e);
            if (null != RequestContextHolder.getRequestAttributes() && null != ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse()) {
                HttpServletResponse response = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
                response.setHeader(FEIGN_RESPONSE_HEADER_ERROR_CODE_KEY, e.getCode());
                response.setHeader(FEIGN_RESPONSE_HEADER_ERROR_MESSAGE_KEY, Base64.encode(e.getMessage(), "UTF-8"));
            }
            throw e;
        } catch (FeignException e) {
            // 存在未发起远程调用前抛出的FeignException异常
            if (e instanceof FeignException.ServiceUnavailable) {
                FeignException.ServiceUnavailable serviceUnavailable = (FeignException.ServiceUnavailable) e;
                log.error(serviceUnavailable.getMessage());
                throw BusinessException.createException("服务不可用");
            }

            throw e;
        } catch (Throwable throwable) {
            Throwable cause = throwable.getCause();
            while (null != cause && null != cause.getCause()) {
                cause = cause.getCause();
            }

            if (cause instanceof BusinessException) {
                if (null != RequestContextHolder.getRequestAttributes() && null != ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse()) {
                    HttpServletResponse response = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
                    response.setHeader(FEIGN_RESPONSE_HEADER_ERROR_CODE_KEY, ((BusinessException) cause).getCode());
                    response.setHeader(FEIGN_RESPONSE_HEADER_ERROR_MESSAGE_KEY, Base64.encode((cause).getMessage(), CommonConsts.UTF8));
                }
                throw (BusinessException) cause;
            } else if (cause instanceof UserContextLoseException) {
                if (null != RequestContextHolder.getRequestAttributes() && null != ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse()) {
                    HttpServletResponse response = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
                    response.setHeader(FEIGN_RESPONSE_HEADER_ERROR_CODE_KEY, ((UserContextLoseException) cause).getCode());
                    response.setHeader(FEIGN_RESPONSE_HEADER_ERROR_MESSAGE_KEY, Base64.encode((cause).getMessage(), CommonConsts.UTF8));
                }
                throw (UserContextLoseException) cause;
            }
            log.error("接口调用异常：{}", throwable);
            throw new RuntimeException("未知异常");
        }
    }

}

@Slf4j
public class FeignExceptionClient implements Client {

    @Override
    public Response execute(Request request, Request.Options options) throws IOException {
        Response response = new ApacheHttpClient().execute(request, options);

        RequestTemplate requestTemplate = response.request().requestTemplate();
        Target<?> target = requestTemplate.feignTarget();

        String serviceName = target.name();
        Class<?> type = target.type();
        String api = type.getName();
        String url = requestTemplate.url();

        Collection<String> errorCodes = response.headers().get(FEIGN_RESPONSE_HEADER_ERROR_CODE_KEY);
        Collection<String> errormessage = response.headers().get(FEIGN_RESPONSE_HEADER_ERROR_MESSAGE_KEY);
        String errorMessage = null;
        if (null != errormessage && !errormessage.isEmpty()) {
            errorMessage = (String) ((List) errormessage).get(0);
            errorMessage = Base64.decodeStr(errorMessage, CommonConsts.UTF8);
        }

        if (CollectionUtils.isNotEmpty(errorCodes)) {
            logInvokeError(serviceName, api, url);

            Object errorCode = ((List) errorCodes).get(0);
            if (ResultConsts.NOT_LOGIN.toString().equals(errorCode)) {
                throw UserContextLoseException.createException();
            }

            if (String.valueOf(HttpStatus.EXPECTATION_FAILED.value()).equals(errorCode)) {
                throw BusinessException.createException("系统异常");
            }

            if (String.valueOf(HttpStatus.INTERNAL_SERVER_ERROR.value()).equals(errorCode)) {
                throw BusinessException.createException("系统异常");
            }

            if (StringUtils.isNotEmpty(errorMessage)) {
                throw BusinessException.createException(errorMessage);
            }
            throw BusinessException.createException("系统异常");
        }

        if (StringUtils.isNotEmpty(errorMessage)) {
            logInvokeError(serviceName, api, url);
            throw BusinessException.createException(errorMessage);
        }

        return response;
    }

    private void logInvokeError(String serviceName, String api, String method) {
        log.error("调用微服务[{}]-Api[{}]-Uri[{}]异常", serviceName, api, method);
    }
}

基于Decoder处理

public class FeignDecoder implements Decoder {
    @Override
    public Object decode(Response response, Type type) throws IOException, DecodeException, FeignException {
        String typeName = type.getTypeName();//   class  void
        if (StringUtils.isNotEmpty(typeName)) {
            Response.Body body = response.body();
            String resultString = Util.toString(body.asReader(Util.UTF_8));

            ResponseVO responseVO = JSONObject.parseObject(resultString, ResponseVO.class);
            if (null != responseVO) {
                if (null != responseVO.getCode() && !responseVO.getCode().toString().endsWith(String.valueOf(ResultConsts.SUCCESS_STATUS))) {
                    // 2002000100   417 not-login  100  business
                    throw new DecodeException(responseVO.getCode(), responseVO.getMessage(), response.request());
                }
            }
            Class<?> responseCls;
            try {
                responseCls = Class.forName(typeName);
            } catch (ClassNotFoundException e) {
                throw new RuntimeException(e);
            }
            return JSONObject.parseObject(resultString, responseCls);
        }
        return Util.emptyValueOf(type);
    }
}

public class FeignErrorDecoder implements ErrorDecoder {
    @Override
    public Exception decode(String methodKey, Response response) {
        return new ErrorDecoder.Default().decode(methodKey, response);
    }
}

bean注入

   @Bean
    public Decoder decoder() {
        return new FeignDecoder()::decode;
    }

    @Bean
    public ErrorDecoder errorDecoder() {
        return new FeignErrorDecoder()::decode;
    }
吃饼青年
关注
  • 9
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
在SpringCloud 使用Security+Oauth2 时候再去使用fegin，发现出现401未授权
05-31
我们在使用spring cloud时如果设置了oauth2授权模式，那么应用服务A再调用服务B时使用Feign请求会出现401授权认证的问题，那么解决办法就是在feign调用请求时获取到assessToken并设置到请求header中就可以解决这个问题了，资源包中有2个文件：FeignRequestInterceptor.java（拦截器）、OAuth2RestTemplateConfiguration.java（设置header），2个JAVA类，在spring boot框架下，客户端只需要正常引入了授权的JAR包，并把这2两个类放到可以被加载到的目录就可以了，其他都不需要做，可以保证feign正常访问。
Spring Cloud OpenFeign - 日志配置
11-26
需要注意的是：OpenFeign 的日志配置分为 全局配置和局部配置。全局配置：加了@Configuration注解表示全局配置，对所有服务起作用。局部配置：不加@Configuration注解表示局部配置，只针对指定的一个服务起作用。...
SpringCloud组件OpenFeign——将服务端详细异常信息返回给客户端
Luffy的博客
12-22 6039
一、场景 最近使用单位封装的微服务架构搭建微服务项目，封装的不太多，大部分可以按原生的SpringCloud组件的使用方式使用。涉及到的组件有Nacos、Ribbon、OpenFeign、Hystrix、Sentinel。领导让搭建微服务项目，并且不使用Hystrix和Sentinel做服务熔断和降级，即客户端通过OpenFeign调用服务端服务，如果服务端异常直接返回给客户端，客户端能够捕获并打印出异常信息。 二、模拟服务端异常 先让服务端产生一个算数异常并抛出，看一下正常情况下客户端会怎么样。 .
通过全局异常处理返回openfeign接口调用结果
liaomingwu的专栏
12-30 2057
没有添加全局异常处理时，当Controller的方法直接抛出异常时，openfeign会收到500错误，导致无法进行正常的处理。通过定义全局异常处理，将异常情况，通过预定义的错误码进行返回，以便调用端能够正常处理。
【Java高级】异步进行服务间feign调用导致token失效问题及解决
最新发布
jayxiaoxionger的博客
04-20 471
异步进行服务间feign调用导致token失效问题及解决。
【feign】SpringCloud OpenFeign Hystrix 统一异常处理及熔断机制
hkk666123的博客
04-05 6187
文章目录问题`@FeignClient`加上`fallback`方法，并获取异常信息保留原始异常信息不进入熔断，直接抛出异常总结 问题 最近在项目开发中，使用 Feign 调用服务，当触发熔断机制时，遇到了以下问题： 异常信息形如：TestService#addRecord(ParamVO) failed and no fallback available.； 获取不到服务提供方抛出的原始异常信息； 实现某些业务方法不进入熔断，直接往外抛出异常； 接下来将一一解决上述问题。 对于failed and n
Feign实现全局自定义异常处理
TaylorSwiftRed的博客
10-26 1296
开发中，A服务使用Feign调用B服务时，B服务中参数校验未通过抛出了自定义异常，错误码是自定义错误码，错误消息是“XXXXX不能为空”，返回到A服务时，A服务的feign异常拦截无法获取到自定义错误码。OpenFeign的FeignException返回的异常信息默认status为500。导致自定义错误码丢失
【微服务】OpenFeign+Sentinel集中处理远程调用异常
Sun的个人博客
03-30 1533
目前的消费者是Ribbon+restTemplate形式进行远程调用的 2.消费者的application.yml（配置nacos服务注册） 3.消费者的启动类（开启nacos的服务发现，以及启动OpenFeign） 4.com/sun/springcloud/service/MemberOpenfeignService.java 编写与远程调用的方法匹配的接口 1.将要远程调用的方法整个复制到这个接口，然后去掉方法体 2.在接口上添加@FeignClient注解，指定远程调用的服务在nacos中的名
OpenFeign的问题和解决方案
qq_36977323的博客
06-26 2218
在单体业务越来越复杂的情况，在单体项目已经无法满足当前业务需求的需要 (一般多指单体架构无法抗住系统的并发，某处业务高并发会导致整个系统崩溃无法使用)， 我们将要考虑根据业务拆分服务。
OpenFeign配置（全局异常解析、请求超时）
李大能
08-27 1745
OpenFeign自定义异常
openfeign和全局异常
大白猫的博客
10-31 826
我们在使用openfeign的时候经常会出现一些问题。
Feign请求及响应拦截器
热门推荐
fivehundredyearsago的博客
06-11 1万+
feign请求响应拦截
在openfeign客户端如何获取到服务端抛出的准确异常信息？？ openfeign调用（请求/响应）的各个大致过程
老照片
02-02 1622
在openfeign客户端如何获取到服务端抛出的准确异常信息？？ openfeign调用（请求/响应）的各个大致过程
feign服务端发现异常客户端处理的方法介绍
08-25
主要给大家介绍了关于feign服务端发现异常客户端处理的方法，文中通过示例代码介绍的非常详细，对大家学习或者使用feign具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
Spring Cloud OpenFeign - - - ＞拦截器
11-29
初学者很容易将 Spring MVC 拦截器 和 Spring Cloud OpenFeign 拦截器搞混，误以为OpenFeign拦截器就是SpringMVC拦截器：Spring MVC拦截器发生在客户端 和 服务端之间，在客户端向服务端发送请求时进行拦截处理。...
springcloud源码
08-13
Spring Cloud 是一个基于 Spring Boot 实现的微服务框架，它为开发者提供了在分布式系统（如配置管理、服务发现、断路器、智能路由、微代理、控制总线、一次性令牌、全局锁、领导选举、分布式会话、集群状态）操作的...
SpringCloud H版+SpringCloud alibaba
03-16
重点讲解了SpringCloud各种组件停止更新进入维护阶段后，后续技术组件的升级和替换策略及方案选型，既有传统Eureka、Ribbon、OpenFeign、Hystrix、Config等技术的升级讲解,又有Consul、Gateway、Bus、Stream、Sleuth...
Springcloud案例
12-18
SpringCloud 是一个基于 Spring Boot 实现的云应用开发工具集，它为开发者提供了在分布式系统（如配置管理、服务发现、断路器、智能路由、微代理、控制总线、一次性令牌、全局锁、领导选举、分布式会话、集群状态）...
如何使得全局异常不会捕获到openfeign降级异常
大白猫的博客
09-27 585
正常情况下写了一个降级处理，就是返回所有属性为空，但是这个降级异常被全局异常捕获了，导致程序报错，这个怎么解决。最后，在全局异常处理类上处理特定的异常。接下来，创建一个降级处理类，该类实现要调用的OpenFeign接口，并提供降级处理的实现。// 在这里可以忽略特定的降级异常，使得降级逻辑生效。// 在这里实现降级逻辑，例如返回空字符串或其他默认值。我在做项目的时候发现远程调用了一个服务，但是服务的url是不可连接的。
spring cloud gateway 实现全局异常处理
04-25
Spring Cloud Gateway能够自定义Filter用于处理异常情况，可以通过实现ErrorWebExceptionHandler接口来自定义全局异常处理。在这个实现中，可以自定义错误响应的格式，并对错误进行日志记录等操作。同时还可以使用@ControllerAdvice注解来处理Controller层的异常。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值