Spring Cloud Feign--全局异常处理--方法/实例

红太狼 2022-12-08 05:52 327阅读 0赞

原文网址：[Spring Cloud Feign--全局异常处理--方法/实例\_IT利刃出鞘的博客-CSDN博客][Spring Cloud Feign--_--_IT_-CSDN]

# 简介 #

**说明**

本文用实例介绍feign的全局异常处理。

之前介绍过feign的fallback，它可以出现异常时进行处理，使得代码出现问题能继续往下走，而不是直接报错。

但实际上，一般出现异常时是出错直接抛异常来处理的，很少去使用fallback进行降级。

本文介绍的全局异常处理，开发中更加常用。（与SpringMVC的全局异常用法基本相同，就多了个解码器（decoder）。SpringMVC的全局异常见：[SpringMVC/SpringBoot--全局异常处理/全局响应/全局请求--实例\_IT利刃出鞘的博客-CSDN博客][SpringMVC_SpringBoot--_--_IT_-CSDN]  
）

# 代码结构 #

**说明**

本文将以电商中常见的下单减库存为例进行说明。

一共两个微服务：订单微服务（order），库存微服务（storage）。用户访问order的controller，order通过feign调用storage来减库存。流程图如下图所示：

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_16_color_FFFFFF_t_70_g_se_x_16][]

1.  本文只展示如何处理feign的全局异常，所以，不创建数据库之类的，只展示全局异常处理这个核心逻辑。
2.  看本文（feign全局异常处理）的应该都是有一定工作经验的人，所以本文只展示核心代码。省略pom.xml、application.yml、项目搭建等。

**代码结构图**

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_12_color_FFFFFF_t_70_g_se_x_16][]

（被我涂掉的是与本文无关的项目（配置中心、网关等））

**框架的版本**

spring-boot-starter-parent:2.3.7.RELEASE  
spring-cloud-dependencies:Hoxton.SR9

# 公用项目（common） #

## Feign的decoder（本文核心） ##

**配置类**

package com.example.common.config.feign;
    
    import feign.Logger;
    import feign.codec.Decoder;
    import feign.codec.Encoder;
    import org.springframework.beans.factory.ObjectFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.autoconfigure.http.HttpMessageConverters;
    import org.springframework.cloud.openfeign.support.ResponseEntityDecoder;
    import org.springframework.cloud.openfeign.support.SpringEncoder;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
     
    @Configuration
    public class FeignConfig {
        @Autowired
        private ObjectFactory<HttpMessageConverters> messageConverters;
     
        @Bean
        public Encoder feignEncoder() {
            return new SpringEncoder(messageConverters);
        }
     
        @Bean
        public Decoder feignDecoder() {
            return new ResponseEntityDecoder(new FeignResultDecoder(messageConverters));
        }
     
        @Bean
        public Logger.Level feignLoggerLevel() {
            return Logger.Level.FULL;
        }
    }

**decoder（解码器）**

package com.example.common.config.feign;
    
    import com.example.common.common.entity.Result;
    import com.fasterxml.jackson.databind.JavaType;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import feign.FeignException;
    import feign.Response;
    import feign.codec.DecodeException;
    import feign.codec.Decoder;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.ObjectFactory;
    import org.springframework.boot.autoconfigure.http.HttpMessageConverters;
    import org.springframework.http.HttpHeaders;
    import org.springframework.http.HttpStatus;
    import org.springframework.http.client.ClientHttpResponse;
    import org.springframework.web.client.HttpMessageConverterExtractor;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
    import java.lang.reflect.WildcardType;
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Map;
     
    @Slf4j
    public class FeignResultDecoder implements Decoder {
     
        private ObjectFactory<HttpMessageConverters> messageConverters;
     
        public FeignResultDecoder(ObjectFactory<HttpMessageConverters> messageConverters) {
            this.messageConverters = messageConverters;
        }
     
        @SuppressWarnings({"unchecked", "rawtypes"})
        @Override
        public Object decode(Response response, Type type) throws IOException, FeignException {
            if (type instanceof Class
                    || type instanceof ParameterizedType
                    || type instanceof WildcardType) {
                if (type == Result.class) {
                    HttpMessageConverterExtractor<?> extractor = new HttpMessageConverterExtractor(
                            type, this.messageConverters.getObject().getConverters());
                    return extractor.extractData(new FeignResponseAdapter(response));
                } else {
                    Result result = (Result) decode(response, Result.class);
                    if (result.isSuccess()) {
                        if (type == Object.class) {
                            return result.getData();
                        } else {
                            ObjectMapper objectMapper = new ObjectMapper();
                            String json = objectMapper.writeValueAsString(result.getData());
                            JavaType javaType = objectMapper.getTypeFactory().constructType(type);
                            return objectMapper.readValue(json, javaType);
                        }
                    } else {
                        log.error("失败原因:" + result.getMessage());
                        throw new DecodeException(response.status(), result.getMessage(), response.request());
                    }
                }
            }
            throw new RuntimeException("type is not an instance of Class or ParameterizedType or WildcardType: " + type);
        }
     
        private final class FeignResponseAdapter implements ClientHttpResponse {
     
            private final Response response;
     
            private FeignResponseAdapter(Response response) {
                this.response = response;
            }
     
            @Override
            public HttpStatus getStatusCode() {
                return HttpStatus.valueOf(this.response.status());
            }
     
            @Override
            public int getRawStatusCode() {
                return this.response.status();
            }
     
            @Override
            public String getStatusText() {
                return this.response.reason();
            }
     
            @Override
            public void close() {
                try {
                    this.response.body().close();
                } catch (IOException ex) {
                    // Ignore exception on close...
                }
            }
     
            @Override
            public InputStream getBody() throws IOException {
                return this.response.body().asInputStream();
            }
     
            @Override
            public HttpHeaders getHeaders() {
                return getHttpHeaders(this.response.headers());
            }
        }
     
        private HttpHeaders getHttpHeaders(Map<String, Collection<String>> headers) {
            HttpHeaders httpHeaders = new HttpHeaders();
            for (Map.Entry<String, Collection<String>> entry : headers.entrySet()) {
                httpHeaders.put(entry.getKey(), new ArrayList<>(entry.getValue()));
            }
            return httpHeaders;
        }
    }

## MVC全局异常/全局响应 ##

**全局异常**

package com.example.common.common.advice;
    
    import com.example.common.common.entity.Result;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.core.Ordered;
    import org.springframework.core.annotation.AnnotationUtils;
    import org.springframework.core.annotation.Order;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.ResponseStatus;
    import org.springframework.web.bind.annotation.RestControllerAdvice;
    
    @Slf4j
    @Order(Ordered.LOWEST_PRECEDENCE - 1)
    @RestControllerAdvice
    public class GlobalExceptionAdvice {
        @ExceptionHandler(Exception.class)
        public Result<Object> handleException(Exception e) throws Exception {
            log.error(e.getMessage(), e);
    
            // 如果某个自定义异常有@ResponseStatus注解，就继续抛出
            if (AnnotationUtils.findAnnotation(e.getClass(), ResponseStatus.class) != null) {
                throw e;
            }
    
            // 实际项目中应该这样写，防止用户看到详细的异常信息
            // return new Result().failure().message.message("操作失败");
            return new Result<>().failure().message(e.getMessage());
        }
    }

**全局响应**

package com.example.common.common.advice;
    
    import com.example.common.common.entity.Result;
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.core.MethodParameter;
    import org.springframework.core.Ordered;
    import org.springframework.core.annotation.Order;
    import org.springframework.http.MediaType;
    import org.springframework.http.converter.HttpMessageConverter;
    import org.springframework.http.server.ServerHttpRequest;
    import org.springframework.http.server.ServerHttpResponse;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
    
    @Slf4j
    @Order(Ordered.LOWEST_PRECEDENCE)
    @ControllerAdvice
    public class GlobalResponseBodyAdvice implements ResponseBodyAdvice<Object> {
        @Override
        public boolean supports(MethodParameter returnType,
                                Class<? extends HttpMessageConverter<?>> converterType) {
            // 若接口返回的类型本身就是ResultWrapper，则无需操作，返回false
            // return !returnType.getParameterType().equals(ResultWrapper.class);
            return true;
        }
    
        @Override
        @ResponseBody
        public Object beforeBodyWrite(Object body, MethodParameter returnType,
                                      MediaType selectedContentType,
                                      Class<? extends HttpMessageConverter<?>> selectedConverterType,
                                      ServerHttpRequest request, ServerHttpResponse response) {
    
    
            if (body instanceof String) {
                // 若返回值为String类型，需要包装为String类型返回。否则会报错
                try {
                    ObjectMapper objectMapper = new ObjectMapper();
                    Result<Object> result = new Result<>().data(body);
                    return objectMapper.writeValueAsString(result);
                } catch (JsonProcessingException e) {
                    throw new RuntimeException("序列化String错误");
                }
            } else if (body instanceof Result) {
                return body;
            }
    
            return new Result<>().data(body);
        }
    }

## FeignClient ##

package com.example.common.feign;
    
    import org.springframework.cloud.openfeign.FeignClient;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    
    @FeignClient("storage")
    public interface StorageFeignClient {
        @PostMapping("/feign/storage/decreaseStorageFault")
        Boolean decreaseStorageFault(@RequestParam("productId") Long productId, @RequestParam("count") Integer count);
    }

注意：必须有返回值。如果返回值写为void，则无法执行到上边的“decoder”逻辑里边。

## **返回值包装类** ##

package com.example.common.common.entity;
    
    import lombok.Data;
     
    @Data
    public class Result<T> {
        private boolean success = true;
     
        private int code = 1000;
     
        private String message;
     
        private T data;
     
        public Result() {
        }
     
        public Result(boolean success) {
            this.success = success;
        }
     
        public Result<T> success(boolean success) {
            Result<T> result = new Result<>(success);
            if (success) {
                result.code = 1000;
            } else {
                result.code = 1001;
            }
            return result;
        }
     
        public Result<T> success() {
            return success(true);
        }
     
        public Result<T> failure() {
            return success(false);
        }
     
        /**
         * @param code {@link ResultCode#getCode()}
         */
        public Result<T> code(int code) {
            this.code = code;
            return this;
        }
     
        public Result<T> message(String message) {
            this.message = message;
            return this;
        }
     
        public Result<T> data(T data) {
            this.data = data;
            return this;
        }
    }

# 调用端（order） #

**OrderController**

package com.example.order.controller;
    
    import com.example.common.common.entity.Result;
    import com.example.common.feign.StorageFeignClient;
    import com.example.order.entity.Order;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * http://localhost:9011/order/createFault/?productId=1&count=10
     */
    
    @RestController
    @RequestMapping("/order")
    public class OrderController {
        @Autowired
        private StorageFeignClient storageFeignClient;
    
        // 在减库存时刻意抛出异常
        @PostMapping("createFault")
        public Result createFault(Order order) {
            storageFeignClient.decreaseStorageFault(order.getProductId(), order.getCount());
            return new Result().message("创建订单成功");
        }
    }

当然，实际项目里应该把feign调用写到service中，我为了展示核心逻辑，直接写到了controller。

# 被调用端（storage） #

package com.example.storage.feign;
    
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    public class FeignController {
        @PostMapping("/feign/storage/decreaseStorageFault")
        public Boolean decreaseStorageFault(@RequestParam("productId")Long productId, @RequestParam("count")Integer count) {
            int i = 1 / 0;
            return true;
        }
    }

# 测试 #

postman访问：[http://localhost:9011/order/createFault/?productId=1&count=10][http_localhost_9011_order_createFault_productId_1_count_10]

**postman结果**

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_20_color_FFFFFF_t_70_g_se_x_16][]

**调用方（order）后端结果**

2021-09-19 20:02:47.454 ERROR 26884 --- [strix-storage-1] c.e.c.config.feign.FeignResultDecoder    : 失败原因:/ by zero
    2021-09-19 20:02:47.473 ERROR 26884 --- [nio-9011-exec-1] c.e.c.c.advice.GlobalExceptionAdvice     : StorageFeignClient#decreaseStorageFault(Long,Integer) failed and no fallback available.
    
    com.netflix.hystrix.exception.HystrixRuntimeException: StorageFeignClient#decreaseStorageFault(Long,Integer) failed and no fallback available.
    	at com.netflix.hystrix.AbstractCommand$22.call(AbstractCommand.java:822) ~[hystrix-core-1.5.18.jar:1.5.18]
    	at com.netflix.hystrix.AbstractCommand$22.call(AbstractCommand.java:807) ~[hystrix-core-1.5.18.jar:1.5.18]
    	at rx.internal.operators.OperatorOnErrorResumeNextViaFunction$4.onError(OperatorOnErrorResumeNextViaFunction.java:140) ~[rxjava-1.3.8.jar:1.3.8]
    	at rx.internal.operators.OnSubscribeDoOnEach$DoOnEachSubscriber.onError(OnSubscribeDoOnEach.java:87) ~[rxjava-1.3.8.jar:1.3.8]
    	...
    	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) ~[na:1.8.0_201]
    	at java.lang.Thread.run(Thread.java:748) ~[na:1.8.0_201]
    Caused by: feign.codec.DecodeException: / by zero
    	at com.example.common.config.feign.FeignResultDecoder.decode(FeignResultDecoder.java:59) ~[classes/:na]
    	at org.springframework.cloud.openfeign.support.ResponseEntityDecoder.decode(ResponseEntityDecoder.java:62) ~[spring-cloud-openfeign-core-2.2.6.RELEASE.jar:2.2.6.RELEASE]
    	at feign.AsyncResponseHandler.decode(AsyncResponseHandler.java:115) ~[feign-core-10.10.1.jar:na]
    	at feign.AsyncResponseHandler.handleResponse(AsyncResponseHandler.java:87) ~[feign-core-10.10.1.jar:na]
    	at feign.SynchronousMethodHandler.executeAndDecode(SynchronousMethodHandler.java:138) ~[feign-core-10.10.1.jar:na]
    	at feign.SynchronousMethodHandler.invoke(SynchronousMethodHandler.java:89) ~[feign-core-10.10.1.jar:na]
    	at feign.hystrix.HystrixInvocationHandler$1.run(HystrixInvocationHandler.java:109) ~[feign-hystrix-10.10.1.jar:na]
    	at com.netflix.hystrix.HystrixCommand$2.call(HystrixCommand.java:302) ~[hystrix-core-1.5.18.jar:1.5.18]
    	at com.netflix.hystrix.HystrixCommand$2.call(HystrixCommand.java:298) ~[hystrix-core-1.5.18.jar:1.5.18]
    	at rx.internal.operators.OnSubscribeDefer.call(OnSubscribeDefer.java:46) ~[rxjava-1.3.8.jar:1.3.8]
    	... 27 common frames omitted

**被调用方（storage）后端结果**

2021-09-19 20:02:47.413 ERROR 28488 --- [nio-9021-exec-1] c.e.c.c.advice.GlobalExceptionAdvice     : / by zero
    
    java.lang.ArithmeticException: / by zero
    	at com.example.storage.feign.FeignController.decreaseStorageFault(FeignController.java:21) ~[classes/:na]
    	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.8.0_201]
    	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:1.8.0_201]
    	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_201]
    	at java.lang.reflect.Method.invoke(Method.java:498) ~[na:1.8.0_201]
    	at org.springframework.web.method.support.InvocableHandlerMethod.doInvoke(InvocableHandlerMethod.java:190) ~[spring-web-5.2.12.RELEASE.jar:5.2.12.RELEASE]
    	at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:138) ~[spring-web-5.2.12.RELEASE.jar:5.2.12.RELEASE]
    	at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:105) ~[spring-webmvc-5.2.12.RELEASE.jar:5.2.12.RELEASE]
    	at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:878) ~[spring-webmvc-5.2.12.RELEASE.jar:5.2.12.RELEASE]
    	at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:792) ~[spring-webmvc-5.2.12.RELEASE.jar:5.2.12.RELEASE]
    	at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:87) ~[spring-webmvc-5.2.12.RELEASE.jar:5.2.12.RELEASE]
    	at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:1040) ~[spring-webmvc-5.2.12.RELEASE.jar:5.2.12.RELEASE]
    	at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:943) ~[spring-webmvc-5.2.12.RELEASE.jar:5.2.12.RELEASE]
    	...
    	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) [na:1.8.0_201]
    	at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61) [tomcat-embed-core-9.0.41.jar:9.0.41]
    	at java.lang.Thread.run(Thread.java:748) [na:1.8.0_201]

# 其他网址 #

[Springboot2.x使用feign自定义Decoder，Advice\_qq\_33371766的博客-CSDN博客][Springboot2.x_feign_Decoder_Advice_qq_33371766_-CSDN]

[Spring Cloud Feign--_--_IT_-CSDN]: https://knife.blog.csdn.net/article/details/108672819
[SpringMVC_SpringBoot--_--_IT_-CSDN]: https://knife.blog.csdn.net/article/details/120314868
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_16_color_FFFFFF_t_70_g_se_x_16]: /images/20221123/e02e3be7078348a7aa9d5df9ffaa2523.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_12_color_FFFFFF_t_70_g_se_x_16]: /images/20221123/e3a88d5d9d5541fa816c5f4802110a38.png
[http_localhost_9011_order_createFault_productId_1_count_10]: http://localhost:9011/order/createFault/?productId=1&count=10
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20221123/0a00501d19394e409a4b039594adfe67.png
[Springboot2.x_feign_Decoder_Advice_qq_33371766_-CSDN]: https://blog.csdn.net/qq_33371766/article/details/106957687