Spring Cloud Feign源码分析

如何使用Spring Cloud Feign进行声明式调用

前面文章写过Spring Cloud Feign的介绍，对如何使用Spring Cloud Feign进行了说明，现在再简单回顾一下：
1.在启动类上添加@EnableFeignClients注解，开启FeignClient
2.创建一个FeignClient接口，接口上添加@FeignClient注解，并指明远程调用其他服务的服务名，接口中可以声明方法。
3.在controller通过这个FeignClient进行调用。

下面是介绍的文章。
Spring Cloud Feign介绍

Spring Cloud Feign源码分析：

下面就分析下源码，看看这个调用到底经历了什么。

既然在启动类上添加了@EnableFeignClients注解，那就看看这个注解的源码：

/**
 * Scans for interfaces that declare they are feign clients (via {@link FeignClient
 * @FeignClient}). Configures component scanning directives for use with
 * {@link org.springframework.context.annotation.Configuration
 * @Configuration} classes.
 *
 * @author Spencer Gibb
 * @author Dave Syer
 * @since 1.0
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {

    String[] value() default {};

    String[] basePackages() default {};

    Class[] basePackageClasses() default {};

    Class[] defaultConfiguration() default {};

    Class[] clients() default {};
}

从这个注解上面的注释可以知道，这个注解会扫描所有的Feign Client，也就是带有@FeignClient的接口。EnableFeignClients注解上还有个@Import(FeignClientsRegistrar.class)，引入了FeignClientsRegistrar这个类，从这个类的名字上看，这是Feign Client注册的一个类，那就再进去这个类看一下代码。
这个类实现了ImportBeanDefinitionRegistrar,ResourceLoaderAware, BeanClassLoaderAware 这三个接口，实现了接口里的方法。
ImportBeanDefinitionRegistrar接口中有个registerBeanDefinitions方法，在FeignClientsRegistrar中进行了实现，下面看下代码：

@Override
public void registerBeanDefinitions(AnnotationMetadata metadata,
        BeanDefinitionRegistry registry) {
    registerDefaultConfiguration(metadata, registry);
    registerFeignClients(metadata, registry);
}

可以看到，在这个方法中，先后调用了两个方法，registerDefaultConfiguration和registerFeignClients。

private void registerDefaultConfiguration(AnnotationMetadata metadata,
        BeanDefinitionRegistry registry) {
    Map defaultAttrs = metadata
            .getAnnotationAttributes(EnableFeignClients.class.getName(), true);

    if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) {
        String name;
        if (metadata.hasEnclosingClass()) {
            name = "default." + metadata.getEnclosingClassName();
        }
        else {
            name = "default." + metadata.getClassName();
        }
        registerClientConfiguration(registry, name,
                defaultAttrs.get("defaultConfiguration"));
    }
}

这个方法主要就是扫描EnableFeignClients标签里配置的信息并注册。

public void registerFeignClients(AnnotationMetadata metadata,
        BeanDefinitionRegistry registry) {
    ClassPathScanningCandidateComponentProvider scanner = getScanner();
    scanner.setResourceLoader(this.resourceLoader);

    Set basePackages;

    Map attrs = metadata
            .getAnnotationAttributes(EnableFeignClients.class.getName());
    AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
            FeignClient.class);
    final Class[] clients = attrs == null ? null
            : (Class[]) attrs.get("clients");
    if (clients == null || clients.length == 0) {
        scanner.addIncludeFilter(annotationTypeFilter);
        basePackages = getBasePackages(metadata);
    }
    else {
        final Set clientClasses = new HashSet<>();
        basePackages = new HashSet<>();
        for (Class clazz : clients) {
            basePackages.add(ClassUtils.getPackageName(clazz));
            clientClasses.add(clazz.getCanonicalName());
        }
        AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() {
            @Override
            protected boolean match(ClassMetadata metadata) {
                String cleaned = metadata.getClassName().replaceAll("\\$", ".");
                return clientClasses.contains(cleaned);
            }
        };
        scanner.addIncludeFilter(
                new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
    }

    for (String basePackage : basePackages) {
        Set candidateComponents = scanner
                .findCandidateComponents(basePackage);
        for (BeanDefinition candidateComponent : candidateComponents) {
            if (candidateComponent instanceof AnnotatedBeanDefinition) {
                // verify annotated class is an interface
                AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
                AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
                Assert.isTrue(annotationMetadata.isInterface(),
                        "@FeignClient can only be specified on an interface");

                Map attributes = annotationMetadata
                        .getAnnotationAttributes(
                                FeignClient.class.getCanonicalName());

                String name = getClientName(attributes);
                registerClientConfiguration(registry, name,
                        attributes.get("configuration"));

                registerFeignClient(registry, annotationMetadata, attributes);
            }
        }
    }
}

在registerFeignClients方法中，也是扫描@FeignClient注解修饰的接口，把接口信息和注解上的信息都赋值到BeanDefinitionBuilder中，然后再注入到IOC容器中。

在相同的路径下，还会看到两个配置类：FeignAutoConfiguration和FeignClientsConfiguration。这是自动加载配置类，在FeignClientsConfiguration还可以看到对Hystrix的配置。

在这个路径下还有个FeignClientFactoryBean类，这个类实现了FactoryBean接口。当调用到FeignClient的时候，就会从IOC中读取这个FeignClientFactoryBean并且调用getObject方法。下面就是getObject方法：

@Override
public Object getObject() throws Exception {
    FeignContext context = applicationContext.getBean(FeignContext.class);
    Feign.Builder builder = feign(context);

    if (!StringUtils.hasText(this.url)) {
        String url;
        if (!this.name.startsWith("http")) {
            url = "http://" + this.name;
        }
        else {
            url = this.name;
        }
        url += cleanPath();
        return loadBalance(builder, context, new HardCodedTarget<>(this.type,
                this.name, url));
    }
    if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
        this.url = "http://" + this.url;
    }
    String url = this.url + cleanPath();
    return targeter.target(this, builder, context, new HardCodedTarget<>(
            this.type, this.name, url));
}

这个方法先从上下文中获取FeignContext对象，然后通过FeignContext对象构建Feign.Builder。接下来会分两种情况进行处理，一种是@FeignClient没有配置url的时候，会对负载均衡进行集成，一种是@FeignClient配置url的时候，进入最后的target方法看下，方法会调用Feign.Builder的target方法：

public  T target(Target target) {
  return build().newInstance(target);
}

public Feign build() {
  SynchronousMethodHandler.Factory synchronousMethodHandlerFactory =
      new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors, logger,
                                           logLevel, decode404);
  ParseHandlersByName handlersByName =
      new ParseHandlersByName(contract, options, encoder, decoder,
                              errorDecoder, synchronousMethodHandlerFactory);
  return new ReflectiveFeign(handlersByName, invocationHandlerFactory);
}

在target方法中，会调用ReflectiveFeign的newInstance方法。下面再去这个方法里面看下。

/**
 * creates an api binding to the {@code target}. As this invokes reflection, care should be taken
 * to cache the result.
 */
@SuppressWarnings("unchecked")
@Override
public  T newInstance(Target target) {
  Map nameToHandler = targetToHandlersByName.apply(target);
  Map methodToHandler = new LinkedHashMap();
  List defaultMethodHandlers = new LinkedList();

  for (Method method : target.type().getMethods()) {
    if (method.getDeclaringClass() == Object.class) {
      continue;
    } else if(Util.isDefault(method)) {
      DefaultMethodHandler handler = new DefaultMethodHandler(method);
      defaultMethodHandlers.add(handler);
      methodToHandler.put(method, handler);
    } else {
      methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));
    }
  }
  InvocationHandler handler = factory.create(target, methodToHandler);
  T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(), new Class[]{target.type()}, handler);

  for(DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) {
    defaultMethodHandler.bindTo(proxy);
  }
  return proxy;
}

在newInstance方法中，一开始就调用targetToHandlersByName.apply(target);方法，返回了一个Map格式的对象，进去这个方法看一下：

  public Map<String, MethodHandler> apply(Target key) {
    List<MethodMetadata> metadata = contract.parseAndValidatateMetadata(key.type());
    Map<String, MethodHandler> result = new LinkedHashMap<String, MethodHandler>();
    for (MethodMetadata md : metadata) {
      BuildTemplateByResolvingArgs buildTemplate;
      if (!md.formParams().isEmpty() && md.template().bodyTemplate() == null) {
        buildTemplate = new BuildFormEncodedTemplateFromArgs(md, encoder);
      } else if (md.bodyIndex() != null) {
        buildTemplate = new BuildEncodedTemplateFromArgs(md, encoder);
      } else {
        buildTemplate = new BuildTemplateByResolvingArgs(md);
      }
      result.put(md.configKey(),
                 factory.create(key, md, buildTemplate, options, decoder, errorDecoder));
    }
    return result;
  }
}

这个方法返回的result，key是MethodMetadata的configKey，value是调用factory.create(key, md, buildTemplate, options, decoder, errorDecoder)返回的对象，那就再进去方法看下：

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

这个方法直接就是新建了一个SynchronousMethodHandler对象，SynchronousMethodHandler对象中，有个invoke方法。

@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) {
      retryer.continueOrPropagate(e);
      if (logLevel != Logger.Level.NONE) {
        logger.logRetry(metadata.configKey(), logLevel);
      }
      continue;
    }
  }
}

SynchronousMethodHandler类就行进行拦截处理的，实际执行这个invoke方法，通过参数生成RequestTemplate对象，然后调用executeAndDecode方法，通过RequestTemplate构建request，通过http client调用，获取Response。