Feign 解析

Fegin 的底层实现机制，是基于动态代理，Fegin 要实现接口调用，要把我们写的接口首先进行动态代理加上发送Http 请求的逻辑，然后把生成后的代理类注入到 Spring 容器当中
通过 @EnableFeignClients 注解上的 @Import 注解， FeignClientsRegistrar 类在这个类里面，实现了 Spring 的支持手动注册 Bean 到容器中的逻辑，通过扫描项目（如果手动配置了 clients 参数的话，就不会扫描项目）把所有的 FeignClient 扫描到，并遍历每个 FeignClient，构建成一个 FeignClientFactoryBean 类，FeignClientFactoryBean 的 getObject 里面会返回当前这个 Bean 的实例，Feign 就是在 getObject 里面添加了动态代理的逻辑

  1. @Retention(RetentionPolicy.RUNTIME)
  2. @Target(ElementType.TYPE)
  3. @Documented
  4. @Import(FeignClientsRegistrar.class)
  5. public @interface EnableFeignClients {
  8. }

注册 Feign Client 对象

@EnableFeignClients 导入了一个 FeignClientsRegistrar.class 接口，并实现了 ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware 三个接口

  • ImportBeanDefinitionRegistrar：可以手动注册一个 Bean 到 Spring 容器中
  • ResourceLoaderAware：可以读取 classpath 路径下的文件

  • EnvironmentAware：可以读取 Spring 全局配置信息 ```java class FeignClientsRegistrar

    1.   implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {

    @Override public void registerBeanDefinitions(AnnotationMetadata metadata,

    1.       BeanDefinitionRegistry registry) {
    2.   // 注册默认配置文件
    3.   registerDefaultConfiguration(metadata, registry);
    4.   // 注册 Fegin Client
    5.   registerFeignClients(metadata, registry);

    }

    // 注册默认配置文件 private void registerDefaultConfiguration(AnnotationMetadata metadata,

    1.       BeanDefinitionRegistry registry) {
    2.   Map<String, Object> defaultAttrs = metadata
    3.           .getAnnotationAttributes(EnableFeignClients.class.getName(), true);
    5.   if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) {
    6.       String name;
    7.       if (metadata.hasEnclosingClass()) {
    8.           name = "default." + metadata.getEnclosingClassName();
    9.       }
    10.       else {
    11.           name = "default." + metadata.getClassName();
    12.       }
    13.       registerClientConfiguration(registry, name,
    14.               defaultAttrs.get("defaultConfiguration"));
    15.   }

    }

    // 注册 Fegin Client public void registerFeignClients(AnnotationMetadata metadata,

    1.       BeanDefinitionRegistry registry) {
    2.   // 扫描器
    3.   ClassPathScanningCandidateComponentProvider scanner = getScanner();
    4.   scanner.setResourceLoader(this.resourceLoader);
    6.   Set<String> basePackages;
    8.   Map<String, Object> attrs = metadata
    9.           .getAnnotationAttributes(EnableFeignClients.class.getName());
    10.   // 过滤器
    11.   AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
    12.           FeignClient.class);
    13.   // 判断 @EnableFeignClients 是否定义了 clients
    14.   final Class<?>[] clients = attrs == null ? null
    15.           : (Class<?>[]) attrs.get("clients");
    16.   if (clients == null || clients.length == 0) {
    17.       scanner.addIncludeFilter(annotationTypeFilter);
    18.       // 扫描包
    19.       basePackages = getBasePackages(metadata);
    20.   }
    21.   else {
    22.       final Set<String> clientClasses = new HashSet<>();
    23.       basePackages = new HashSet<>();
    24.       for (Class<?> clazz : clients) {
    25.           basePackages.add(ClassUtils.getPackageName(clazz));
    26.           clientClasses.add(clazz.getCanonicalName());
    27.       }
    28.       AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() {
    29.           @Override
    30.           protected boolean match(ClassMetadata metadata) {
    31.               String cleaned = metadata.getClassName().replaceAll("\\$", ".");
    32.               return clientClasses.contains(cleaned);
    33.           }
    34.       };
    35.       scanner.addIncludeFilter(
    36.               new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
    37.   }
    39.   for (String basePackage : basePackages) {
    40.       Set<BeanDefinition> candidateComponents = scanner
    41.               .findCandidateComponents(basePackage);
    42.       for (BeanDefinition candidateComponent : candidateComponents) {
    43.           if (candidateComponent instanceof AnnotatedBeanDefinition) {
    44.               // verify annotated class is an interface
    45.               AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
    46.               AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
    47.               Assert.isTrue(annotationMetadata.isInterface(),
    48.                       "@FeignClient can only be specified on an interface");
    50.               Map<String, Object> attributes = annotationMetadata
    51.                       .getAnnotationAttributes(
    52.                               FeignClient.class.getCanonicalName());
    53.               // 通过注解属性获取微服务名称
    54.               String name = getClientName(attributes);
    55.               registerClientConfiguration(registry, name,
    56.                       attributes.get("configuration"));
    58.               // 注册 FeignClient 对象
    59.               registerFeignClient(registry, annotationMetadata, attributes);
    60.           }
    61.       }
    62.   }

    }

    private void registerFeignClient(BeanDefinitionRegistry registry,

    1.       AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
    2.   String className = annotationMetadata.getClassName();
    4.   //核心代码
    5.   BeanDefinitionBuilder definition = BeanDefinitionBuilder
    6.           .genericBeanDefinition(FeignClientFactoryBean.class);
  1.     validate(attributes);
  2.     //赋值操作
  3.     definition.addPropertyValue("url", getUrl(attributes));
  4.     definition.addPropertyValue("path", getPath(attributes));
  5.     String name = getName(attributes);
  6.     definition.addPropertyValue("name", name);
  7.     String contextId = getContextId(attributes);
  8.     definition.addPropertyValue("contextId", contextId);
  9.     definition.addPropertyValue("type", className);
  10.     definition.addPropertyValue("decode404", attributes.get("decode404"));
  11.     definition.addPropertyValue("fallback", attributes.get("fallback"));
  12.     definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
  13.     definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
  15.     String alias = contextId + "FeignClient";
  16.     AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
  18.     boolean primary = (Boolean) attributes.get("primary"); // has a default, won't be
  19.                                                             // null
  21.     beanDefinition.setPrimary(primary);
  23.     String qualifier = getQualifier(attributes);
  24.     if (StringUtils.hasText(qualifier)) {
  25.         alias = qualifier;
  26.     }
  28.     BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
  29.             new String[] { alias });
  30.     BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
  31. }

}

  3. <a name="vAi09"></a>
  4. #### FeignClientFactoryBean
  5. ```java
  6. class FeignClientFactoryBean
  7.         implements FactoryBean<Object>, InitializingBean, ApplicationContextAware {
  9.     @Override
  10.     public Object getObject() throws Exception {
  11.         return getTarget();
  12.     }
  14.     <T> T getTarget() {
  15.         FeignContext context = this.applicationContext.getBean(FeignContext.class);
  16.         Feign.Builder builder = feign(context);
  18.         if (!StringUtils.hasText(this.url)) {
  19.             if (!this.name.startsWith("http")) {
  20.                 this.url = "http://" + this.name;
  21.             }
  22.             else {
  23.                 this.url = this.name;
  24.             }
  25.             this.url += cleanPath();
  26.             // 获取负载均衡器
  27.             return (T) loadBalance(builder, context,
  28.                     new HardCodedTarget<>(this.type, this.name, this.url));
  29.         }
  30.         if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
  31.             this.url = "http://" + this.url;
  32.         }
  33.         String url = this.url + cleanPath();
  34.         Client client = getOptional(context, Client.class);
  35.         if (client != null) {
  36.             if (client instanceof LoadBalancerFeignClient) {
  37.                 // not load balancing because we have a url,
  38.                 // but ribbon is on the classpath, so unwrap
  39.                 client = ((LoadBalancerFeignClient) client).getDelegate();
  40.             }
  41.             builder.client(client);
  42.         }
  43.         Targeter targeter = get(context, Targeter.class);
  44.         return (T) targeter.target(this, builder, context,
  45.                 new HardCodedTarget<>(this.type, this.name, url));
  46.     }
  48.     protected <T> T loadBalance(Feign.Builder builder, FeignContext context,
  49.             HardCodedTarget<T> target) {
  50.         Client client = getOptional(context, Client.class);
  51.         if (client != null) {
  52.             builder.client(client);
  53.             Targeter targeter = get(context, Targeter.class);
  54.             // 执行代理逻辑
  55.             return targeter.target(this, builder, context, target);
  56.         }
  58.         throw new IllegalStateException(
  59.             "No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-netflix-ribbon?");
  60.     }
  62. }

返回动态代理类

代理逻辑是由 HystrixTargeter 来实现的

  1. class HystrixTargeter implements Targeter {
  3.     @Override
  4.     public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign,
  5.             FeignContext context, Target.HardCodedTarget<T> target) {
  6.         if (!(feign instanceof feign.hystrix.HystrixFeign.Builder)) {
  7.             return feign.target(target);
  8.         }
  9.         feign.hystrix.HystrixFeign.Builder builder = (feign.hystrix.HystrixFeign.Builder) feign;
  10.         String name = StringUtils.isEmpty(factory.getContextId()) ? factory.getName()
  11.                 : factory.getContextId();
  12.         SetterFactory setterFactory = getOptional(name, context, SetterFactory.class);
  13.         if (setterFactory != null) {
  14.             builder.setterFactory(setterFactory);
  15.         }
  16.         Class<?> fallback = factory.getFallback();
  17.         if (fallback != void.class) {
  18.             return targetWithFallback(name, context, target, builder, fallback);
  19.         }
  20.         Class<?> fallbackFactory = factory.getFallbackFactory();
  21.         if (fallbackFactory != void.class) {
  22.             return targetWithFallbackFactory(name, context, target, builder,
  23.                     fallbackFactory);
  24.         }
  26.         return feign.target(target);
  27.     }
  29. }
  32. public abstract class Feign {
  34.     public <T> T target(Target<T> target) {
  35.         return this.build().newInstance(target);
  36.     }
  38.     public <T> T newInstance(Target<T> target) {
  39.         Map<String, MethodHandler> nameToHandler = this.targetToHandlersByName.apply(target);
  40.         Map<Method, MethodHandler> methodToHandler = new LinkedHashMap();
  41.         List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList();
  42.         Method[] var5 = target.type().getMethods();
  43.         int var6 = var5.length;
  45.         for(int var7 = 0; var7 < var6; ++var7) {
  46.             Method method = var5[var7];
  47.             if (method.getDeclaringClass() != Object.class) {
  48.                 if (Util.isDefault(method)) {
  49.                     DefaultMethodHandler handler = new DefaultMethodHandler(method);
  50.                     defaultMethodHandlers.add(handler);
  51.                     methodToHandler.put(method, handler);
  52.                 } else {
  53.                     methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));
  54.                 }
  55.             }
  56.         }
  58.         InvocationHandler handler = this.factory.create(target, methodToHandler);
  59.         T proxy = Proxy.newProxyInstance(target.type().getClassLoader(), new Class[]{target.type()}, handler);
  60.         Iterator var12 = defaultMethodHandlers.iterator();
  62.         while(var12.hasNext()) {
  63.             DefaultMethodHandler defaultMethodHandler = (DefaultMethodHandler)var12.next();
  64.             defaultMethodHandler.bindTo(proxy);
  65.         }
  67.         return proxy;
  68.     }
  70. }

Feign 调用逻辑

Feign 会创建一个 InvocationHandler handler = this.factory.create(target, methodToHandler); 这里的实现类是 FeignInvocationHandler 里面由他的 invoke 方法

  1. static class FeignInvocationHandler implements InvocationHandler {
  3.     @Override
  4.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  5.       if ("equals".equals(method.getName())) {
  6.         try {
  7.           Object otherHandler =
  8.               args.length > 0 && args[0] != null ? Proxy.getInvocationHandler(args[0]) : null;
  9.           return equals(otherHandler);
  10.         } catch (IllegalArgumentException e) {
  11.           return false;
  12.         }
  13.       } else if ("hashCode".equals(method.getName())) {
  14.         return hashCode();
  15.       } else if ("toString".equals(method.getName())) {
  16.         return toString();
  17.       }
  19.       return dispatch.get(method).invoke(args);
  20.     }
  22. }
  1. final class SynchronousMethodHandler implements MethodHandler {
  3.     @Override
  4.      public Object invoke(Object[] argv) throws Throwable {
  5.         RequestTemplate template = buildTemplateFromArgs.create(argv);
  6.         Options options = findOptions(argv);
  7.         Retryer retryer = this.retryer.clone();
  8.         while (true) {
  9.             try {
  10.                 return executeAndDecode(template, options);
  11.             } catch (RetryableException e) {
  12.                 try {
  13.                     retryer.continueOrPropagate(e);
  14.                 } catch (RetryableException th) {
  15.                     Throwable cause = th.getCause();
  16.                     if (propagationPolicy == UNWRAP && cause != null) {
  17.                         throw cause;
  18.                     } else {
  19.                         throw th;
  20.                     }
  21.                 }
  22.                 if (logLevel != Logger.Level.NONE) {
  23.                     logger.logRetry(metadata.configKey(), logLevel);
  24.                 }
  25.                 continue;
  26.             }
  27.           }
  28.     }
  30.     Object executeAndDecode(RequestTemplate template, Options options) throws Throwable {
  31.         Request request = targetRequest(template);
  33.         if (logLevel != Logger.Level.NONE) {
  34.           logger.logRequest(metadata.configKey(), logLevel, request);
  35.         }
  37.         Response response;
  38.         long start = System.nanoTime();
  39.         try {
  40.           response = client.execute(request, options);
  41.         } catch (IOException e) {
  42.           if (logLevel != Logger.Level.NONE) {
  43.             logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime(start));
  44.           }
  45.           throw errorExecuting(request, e);
  46.         }
  47.         long elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
  49.         boolean shouldClose = true;
  50.         try {
  51.           if (logLevel != Logger.Level.NONE) {
  52.             response =
  53.                 logger.logAndRebufferResponse(metadata.configKey(), logLevel, response, elapsedTime);
  54.           }
  55.           if (Response.class == metadata.returnType()) {
  56.             if (response.body() == null) {
  57.               return response;
  58.             }
  59.             if (response.body().length() == null ||
  60.                 response.body().length() > MAX_RESPONSE_BUFFER_SIZE) {
  61.               shouldClose = false;
  62.               return response;
  63.             }
  64.             // Ensure the response body is disconnected
  65.             byte[] bodyData = Util.toByteArray(response.body().asInputStream());
  66.             return response.toBuilder().body(bodyData).build();
  67.           }
  68.           if (response.status() >= 200 && response.status() < 300) {
  69.             if (void.class == metadata.returnType()) {
  70.               return null;
  71.             } else {
  72.               Object result = decode(response);
  73.               shouldClose = closeAfterDecode;
  74.               return result;
  75.             }
  76.           } else if (decode404 && response.status() == 404 && void.class != metadata.returnType()) {
  77.             Object result = decode(response);
  78.             shouldClose = closeAfterDecode;
  79.             return result;
  80.           } else {
  81.             throw errorDecoder.decode(metadata.configKey(), response);
  82.           }
  83.         } catch (IOException e) {
  84.           if (logLevel != Logger.Level.NONE) {
  85.             logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime);
  86.           }
  87.           throw errorReading(request, response, e);
  88.         } finally {
  89.           if (shouldClose) {
  90.             ensureClosed(response.body());
  91.           }
  92.         }
  93.     }
  95. }

执行动态代理

  1. public class LoadBalancerFeignClient implements Client {
  3.     @Override
  4.     public Response execute(Request request, Request.Options options) throws IOException {
  5.         try {
  6.             URI asUri = URI.create(request.url());
  7.             String clientName = asUri.getHost();
  8.             URI uriWithoutHost = cleanUrl(request.url(), clientName);
  9.             FeignLoadBalancer.RibbonRequest ribbonRequest = new FeignLoadBalancer.RibbonRequest(
  10.                     this.delegate, request, uriWithoutHost);
  12.             IClientConfig requestConfig = getClientConfig(options, clientName);
  13.             return lbClient(clientName)
  14.                     .executeWithLoadBalancer(ribbonRequest, requestConfig).toResponse();
  15.         }
  16.         catch (ClientException e) {
  17.             IOException io = findIOException(e);
  18.             if (io != null) {
  19.                 throw io;
  20.             }
  21.             throw new RuntimeException(e);
  22.         }
  23.     }
  24. }
  1. public class FeignLoadBalancer extends
  2.         AbstractLoadBalancerAwareClient<FeignLoadBalancer.RibbonRequest, FeignLoadBalancer.RibbonResponse> {
  4.     @Override
  5.     public RibbonResponse execute(RibbonRequest request, IClientConfig configOverride)
  6.             throws IOException {
  7.         Request.Options options;
  8.         if (configOverride != null) {
  9.             RibbonProperties override = RibbonProperties.from(configOverride);
  10.             options = new Request.Options(override.connectTimeout(this.connectTimeout),
  11.                     override.readTimeout(this.readTimeout));
  12.         }
  13.         else {
  14.             options = new Request.Options(this.connectTimeout, this.readTimeout);
  15.         }
  16.         // 完成方法调用
  17.         Response response = request.client().execute(request.toRequest(), options);
  18.         return new RibbonResponse(request.getUri(), response);
  19.     }
  21. }