feign client feignClient 熔断

向右看齐 2023-07-10 11:30 9阅读 0赞

feignclient 有着很多的优势，代码简洁、可以均衡调用（内置ribbon）nclient 有着很多的优势，代码简洁、可以均衡调用（内置ribbon），等等。。。。

但是用feignclient 去调用外部接口时，绝大数小伙伴都会遇到熔断这个问题，而且没有任何报错信息，结果让人无从查起，无迹可寻！！！！这是最让人困扰的，也是很多老程序员不愿意使用的原因之一（本来一个httpclient解决绝的事情，用了feignclient可能会因为排除问题浪费大量的时间）

我最近也遇到了，因为需要再请求头内做认证，调用外部服务，代码写完（我现在很少出bug），测试的时候总是熔断，这就很讨厌了，几经周折，差点打算换httpclient了，但是我下定决心我要把这个问题找到，不然以后万一在遇到熔断，不好处理还是需要绕过去。

话不多说，直接翻源码，看看这个请求是为啥熔断，经过一系列的找。。。。

终于，（各位小伙伴重点来了！！！）找到了熔断的原因

**openfeign/feign-core/9.3.1/feign-core-9.3.1-sources.jar!/feign/SynchronousMethodHandler.java**

大家记住这个类，以后有熔断直接打断点调试就可以拿到请求信息和返回信息！！！

插入源码信息：

/**
     * Copyright 2012-2018 The Feign Authors
     *
     * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
     * in compliance with the License. You may obtain a copy of the License at
     *
     * http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing, software distributed under the License
     * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
     * or implied. See the License for the specific language governing permissions and limitations under
     * the License.
     */
    package feign;
    
    import java.io.IOException;
    import java.util.List;
    import java.util.concurrent.TimeUnit;
    import feign.InvocationHandlerFactory.MethodHandler;
    import feign.Request.Options;
    import feign.codec.DecodeException;
    import feign.codec.Decoder;
    import feign.codec.ErrorDecoder;
    import static feign.ExceptionPropagationPolicy.UNWRAP;
    import static feign.FeignException.errorExecuting;
    import static feign.FeignException.errorReading;
    import static feign.Util.checkNotNull;
    import static feign.Util.ensureClosed;
    
    final class SynchronousMethodHandler implements MethodHandler {
    
      private static final long MAX_RESPONSE_BUFFER_SIZE = 8192L;
    
      private final MethodMetadata metadata;
      private final Target<?> target;
      private final Client client;
      private final Retryer retryer;
      private final List<RequestInterceptor> requestInterceptors;
      private final Logger logger;
      private final Logger.Level logLevel;
      private final RequestTemplate.Factory buildTemplateFromArgs;
      private final Options options;
      private final Decoder decoder;
      private final ErrorDecoder errorDecoder;
      private final boolean decode404;
      private final boolean closeAfterDecode;
      private final ExceptionPropagationPolicy propagationPolicy;
    
      private SynchronousMethodHandler(Target<?> target, Client client, Retryer retryer,
          List<RequestInterceptor> requestInterceptors, Logger logger,
          Logger.Level logLevel, MethodMetadata metadata,
          RequestTemplate.Factory buildTemplateFromArgs, Options options,
          Decoder decoder, ErrorDecoder errorDecoder, boolean decode404,
          boolean closeAfterDecode, ExceptionPropagationPolicy propagationPolicy) {
        this.target = checkNotNull(target, "target");
        this.client = checkNotNull(client, "client for %s", target);
        this.retryer = checkNotNull(retryer, "retryer for %s", target);
        this.requestInterceptors =
            checkNotNull(requestInterceptors, "requestInterceptors for %s", target);
        this.logger = checkNotNull(logger, "logger for %s", target);
        this.logLevel = checkNotNull(logLevel, "logLevel for %s", target);
        this.metadata = checkNotNull(metadata, "metadata for %s", target);
        this.buildTemplateFromArgs = checkNotNull(buildTemplateFromArgs, "metadata for %s", target);
        this.options = checkNotNull(options, "options for %s", target);
        this.errorDecoder = checkNotNull(errorDecoder, "errorDecoder for %s", target);
        this.decoder = checkNotNull(decoder, "decoder for %s", target);
        this.decode404 = decode404;
        this.closeAfterDecode = closeAfterDecode;
        this.propagationPolicy = propagationPolicy;
      }
    
      @Override
      public Object invoke(Object[] argv) throws Throwable {
        RequestTemplate template = buildTemplateFromArgs.create(argv);
        Retryer retryer = this.retryer.clone();
        while (true) {
          try {
            return executeAndDecode(template);
          } catch (RetryableException e) {
            try {
              retryer.continueOrPropagate(e);
            } catch (RetryableException th) {
              Throwable cause = th.getCause();
              if (propagationPolicy == UNWRAP && cause != null) {
                throw cause;
              } else {
                throw th;
              }
            }
            if (logLevel != Logger.Level.NONE) {
              logger.logRetry(metadata.configKey(), logLevel);
            }
            continue;
          }
        }
      }
    
      Object executeAndDecode(RequestTemplate template) throws Throwable {
        Request request = targetRequest(template);
    
        if (logLevel != Logger.Level.NONE) {
          logger.logRequest(metadata.configKey(), logLevel, request);
        }
    
        Response response;
        long start = System.nanoTime();
        try {
          response = client.execute(request, options);
        } catch (IOException e) {
          if (logLevel != Logger.Level.NONE) {
            logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime(start));
          }
          throw errorExecuting(request, e);
        }
        long elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
    
        boolean shouldClose = true;
        try {
          if (logLevel != Logger.Level.NONE) {
            response =
                logger.logAndRebufferResponse(metadata.configKey(), logLevel, response, elapsedTime);
          }
          if (Response.class == metadata.returnType()) {
            if (response.body() == null) {
              return response;
            }
            if (response.body().length() == null ||
                response.body().length() > MAX_RESPONSE_BUFFER_SIZE) {
              shouldClose = false;
              return response;
            }
            // Ensure the response body is disconnected
            byte[] bodyData = Util.toByteArray(response.body().asInputStream());
            return response.toBuilder().body(bodyData).build();
          }
          if (response.status() >= 200 && response.status() < 300) {
            if (void.class == metadata.returnType()) {
              return null;
            } else {
              Object result = decode(response);
              shouldClose = closeAfterDecode;
              return result;
            }
          } else if (decode404 && response.status() == 404 && void.class != metadata.returnType()) {
            Object result = decode(response);
            shouldClose = closeAfterDecode;
            return result;
          } else {
            throw errorDecoder.decode(metadata.configKey(), response);
          }
        } catch (IOException e) {
          if (logLevel != Logger.Level.NONE) {
            logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime);
          }
          throw errorReading(request, response, e);
        } finally {
          if (shouldClose) {
            ensureClosed(response.body());
          }
        }
      }
    
      long elapsedTime(long start) {
        return TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
      }
    
      Request targetRequest(RequestTemplate template) {
        for (RequestInterceptor interceptor : requestInterceptors) {
          interceptor.apply(template);
        }
        return target.apply(template);
      }
    
      Object decode(Response response) throws Throwable {
        try {
          return decoder.decode(response, metadata.returnType());
        } catch (FeignException e) {
          throw e;
        } catch (RuntimeException e) {
          throw new DecodeException(e.getMessage(), e);
        }
      }
    
      static class Factory {
    
        private final Client client;
        private final Retryer retryer;
        private final List<RequestInterceptor> requestInterceptors;
        private final Logger logger;
        private final Logger.Level logLevel;
        private final boolean decode404;
        private final boolean closeAfterDecode;
        private final ExceptionPropagationPolicy propagationPolicy;
    
        Factory(Client client, Retryer retryer, List<RequestInterceptor> requestInterceptors,
            Logger logger, Logger.Level logLevel, boolean decode404, boolean closeAfterDecode,
            ExceptionPropagationPolicy propagationPolicy) {
          this.client = checkNotNull(client, "client");
          this.retryer = checkNotNull(retryer, "retryer");
          this.requestInterceptors = checkNotNull(requestInterceptors, "requestInterceptors");
          this.logger = checkNotNull(logger, "logger");
          this.logLevel = checkNotNull(logLevel, "logLevel");
          this.decode404 = decode404;
          this.closeAfterDecode = closeAfterDecode;
          this.propagationPolicy = propagationPolicy;
        }
    
        public MethodHandler create(Target<?> target,
                                    MethodMetadata md,
                                    RequestTemplate.Factory buildTemplateFromArgs,
                                    Options options,
                                    Decoder decoder,
                                    ErrorDecoder errorDecoder) {
          return new SynchronousMethodHandler(target, client, retryer, requestInterceptors, logger,
              logLevel, md, buildTemplateFromArgs, options, decoder,
              errorDecoder, decode404, closeAfterDecode, propagationPolicy);
        }
      }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTEwNjA5MDY_size_16_color_FFFFFF_t_70][]

feign client把非200的以及404(`可以配置是否纳入异常`)都算成error，都转给errorDecoder去处理了

所以这就是熔断的原因!!!大家记住这个类就在也不用怕熔断了！！！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTEwNjA5MDY_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200302141719387.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTEwNjA5MDY=,size_16,color_FFFFFF,t_70