Feign Api返回值为void时获取 Response信息

@RequestMapping("/provider/product")
@CompileStatic
interface IProductService {

    /**
     * 新增产品
     * @param ageConfigDTOList
     * @return
     */
    @PostMapping('/add')
    void save(@Validated @RequestBody ProductAO productAO)
」

@ExceptionHandler(BizException.class)
ResponseEntity<ResponseBean> handleBizException(BizException bizException, HandlerMethod handlerMethod) {
    log.warn("BizException caught of method with name [${handlerMethod.method.name}]. Message: [${bizException.message}]")
    return ResponseEntity.ok(ResponseBean.fail(ResponseCodeEnum.ERROR, bizException.message))
}

@Override
protected ResponseEntity<ResponseBean> handleMethodArgumentNotValid(MethodArgumentNotValidException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
    log.warn("MethodArgumentNotValidException caught of request [${request.getDescription(false)}]. Message: [${ex.message}]")
    List<FieldError> errors = ex.bindingResult.fieldErrors
    List<String> messageList = errors.collect { it.defaultMessage }
    return ResponseEntity.ok(ResponseBean.fail(ResponseCodeEnum.INVALID_INPUT, messageList.join(",")))
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients    

class FeignClientsRegistrar
        implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
    // 处理默认配置类
        registerDefaultConfiguration(metadata, registry);
    // 注册被 @FeignClient 标记的接口
        registerFeignClients(metadata, registry);
    }
}

public void registerFeignClients(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {

        ...

        for (String basePackage : basePackages) {
            Set<BeanDefinition> candidateComponents = scanner
                    .findCandidateComponents(basePackage);
            for (BeanDefinition candidateComponent : candidateComponents) {
                if (candidateComponent instanceof AnnotatedBeanDefinition) {
                    ...
                    // 注册 FeignClient
                    registerFeignClient(registry, annotationMetadata, attributes);
                }
            }
        }
    }

private void registerFeignClient(BeanDefinitionRegistry registry,
            AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
        String className = annotationMetadata.getClassName();
    // 拿到FeignClientFactoryBean的BeanDefinitionBuilder
        BeanDefinitionBuilder definition = BeanDefinitionBuilder
                .genericBeanDefinition(FeignClientFactoryBean.class);
        ...

        BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
                new String[] { alias });
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }

@Override
public Object getObject() throws Exception {
    return getTarget();
}

<T> T getTarget() {
    FeignContext context = this.applicationContext.getBean(FeignContext.class);
    Feign.Builder builder = feign(context);

  // 如果FeignClient没有指定URL(配置的是service)
  if (!StringUtils.hasText(this.url)) {
        if (!this.name.startsWith("http")) {
            this.url = "http://" + this.name;
        }
        else {
            this.url = this.name;
        }
        this.url += cleanPath();
        return (T) loadBalance(builder, context,
                new HardCodedTarget<>(this.type, this.name, this.url));
    }
    if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
        this.url = "http://" + this.url;
    }
    String url = this.url + cleanPath();
    Client client = getOptional(context, Client.class);
    if (client != null) {
        if (client instanceof LoadBalancerFeignClient) {
            // not load balancing because we have a url,
            // but ribbon is on the classpath, so unwrap
            client = ((LoadBalancerFeignClient) client).getDelegate();
        }
        if (client instanceof FeignBlockingLoadBalancerClient) {
            // not load balancing because we have a url,
            // but Spring Cloud LoadBalancer is on the classpath, so unwrap
            client = ((FeignBlockingLoadBalancerClient) client).getDelegate();
        }
        builder.client(client);
    }
    Targeter targeter = get(context, Targeter.class);
    return (T) targeter.target(this, builder, context,
            new HardCodedTarget<>(this.type, this.name, url));
}

 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);
 }

  @Override
  public Object invoke(Object[] argv) throws Throwable {
    // 利用参数构建请求模板, argv 就是被MVC注解描述的各种参数
    RequestTemplate template = buildTemplateFromArgs.create(argv);
    Retryer retryer = this.retryer.clone();
    while (true) {
      try {
        // 执行请求  
        return executeAndDecode(template);
      } catch (RetryableException e) {
        retryer.continueOrPropagate(e);
        if (logLevel != Logger.Level.NONE) {
          logger.logRetry(metadata.configKey(), logLevel);
        }
        continue;
      }
    }
  }

  Object executeAndDecode(RequestTemplate template) throws Throwable {
      // 应用Feign 的拦截器
      Request request = targetRequest(template);
      Response response;
      long start = System.nanoTime();
      try {
        // 真正发起请求  
        response = client.execute(request, options);
        // ensure the request is set. TODO: remove in Feign 10
        response.toBuilder().request(request).build();
      } catch (IOException e) {
        ...
      }
      try {
        // response 处理机制，可以自定义Decoder来处理response
        if (response.status() >= 200 && response.status() < 300) {
          if (void.class == metadata.returnType()) {
            return null;
          } else {
            return decode(response);
          }
        } else if (decode404 && response.status() == 404 && void.class != metadata.returnType()) {
          return decode(response);
        } else {
          throw errorDecoder.decode(metadata.configKey(), response);
        }
      } ...
    }

if (void.class == metadata.returnType()) {
   return null;
}