SpringCloud OpenFeign源码详细解析

简介

OpenFeign 是Spring Cloud中的一个组件，经常用来在项目中进行Http调用其他服务的接口，在于对服务端接口的绑定。
使用方式是比较简单的，让我们来探究一下使用原理吧！
阅读条件：

• 要有Spring源码的基础
• 使用过原生的Feign
• SpringBoot源码基础

源码解析入口：@EnableFeignClients

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

	String[] basePackages() default {};

	Class<?>[] basePackageClasses() default {};

	Class<?>[] defaultConfiguration() default {};

	Class<?>[] clients() default {};
}

注解里面的参数配置，都可以在官网找到说明，这里就不介绍了。
点进去我们可以在注解上看到这样 一段代码：
@Import(FeignClientsRegistrar.class)
这个是往Spring容器里面注入一个类。
核心在于 FeignClientsRegistrar 实现了 ImportBeanDefinitionRegistrar。
ImportBeanDefinitionRegistrar是Spring中的一个扩展点，实现该接口的方法，我们可以动态的往容器里面注入其他类的信息，然后走Spring的生命周期，创建出Bean。
要说明的一点实现了ImportBeanDefinitionRegistrar的类，该实现类的执行时机在于Spring对配置类的解析阶段执行的，熟悉Spring源码的同学都知道，Spring是先扫描合格的配置类，从配置类中获取要创建Bean的类信息，注册成BeanDefinition简称bd，最后在统一进行实例化。
Spring在解析配置类的时候，会判断该类是否实现了ImportBeanDefinitionRegistrar，是的话就创建对象，执行接口方法，这样也就会执行我们写的自定义逻辑，往容器里面注入bd。
我们直接找到 FeignClientsRegistrar 实现的注入bd方法:

	@Override
	public void registerBeanDefinitions(AnnotationMetadata metadata,
			BeanDefinitionRegistry registry) {
		// 对 @EnableFeignClients 解析
		registerDefaultConfiguration(metadata, registry);
		// 对 @FeignClient 解析
		registerFeignClients(metadata, registry);
	}

我们直接看对 @FeignClient 的解析。

1.@FeignClient

只看核心部分：

	public void registerFeignClients(AnnotationMetadata metadata,
			BeanDefinitionRegistry registry) {
			// 创建一个扫描器
		ClassPathScanningCandidateComponentProvider scanner = getScanner();
		scanner.setResourceLoader(this.resourceLoader);
		basePackages = getBasePackages(metadata);
		for (String basePackage : basePackages) {
		  // 扫描指定的包下面的 @FeignClient
			Set<BeanDefinition> candidateComponents = scanner
					.findCandidateComponents(basePackage);
			for (BeanDefinition candidateComponent : candidateComponents) {
			     // 核心方法：向容器中注入 FeignClientSpecification
			     registerClientConfiguration(registry, name,
							attributes.get("configuration"));
			     // 核心方法：注册接口，注册到容器
					registerFeignClient(registry, annotationMetadata, attributes);
			}
		}
	}
	
	/**
	* 这个地方每一个 @FeignClient 都会向容器中注入一个 FeignClientSpecification 的用意是什么呢？
	* 在 FeignAutoConfiguration 自动配置里面我们会进行分析，就是为了实现 容器配置隔离。
	* 每一个 @FeignClient 如果指定了 configuration 属性的值，都会对应一个Spring容器，达到隔离的效果。
	* 官网中为啥会说 如果@FeignClient中 指定了 configuration 对应的Class不需要加@Configuration注解呢？在下面我们会进行分析的
	**/
	private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name,
			Object configuration) {
		// configuration 是 @FeignClient 中的 class<?>[] configuration() default {} 值;
		// 向容器中注入 FeignClientSpecification	
		BeanDefinitionBuilder builder = BeanDefinitionBuilder
				.genericBeanDefinition(FeignClientSpecification.class);
		builder.addConstructorArgValue(name);
		builder.addConstructorArgValue(configuration);
		registry.registerBeanDefinition(
				name + "." + FeignClientSpecification.class.getSimpleName(),
				builder.getBeanDefinition());
	}

private void registerFeignClient(BeanDefinitionRegistry registry,
			AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
		String className = annotationMetadata.getClassName();
		// 注入接口的实际bd类型是 FeignClientFactoryBean
		BeanDefinitionBuilder definition = BeanDefinitionBuilder
				.genericBeanDefinition(FeignClientFactoryBean.class);
		definition.addPropertyValue("url", getUrl(attributes));
		definition.addPropertyValue("path", getPath(attributes));
		String name = getName(attributes);
		definition.addPropertyValue("name", name);
		String contextId = getContextId(attributes);
		definition.addPropertyValue("contextId", contextId);
		definition.addPropertyValue("type", className);
		definition.addPropertyValue("decode404", attributes.get("decode404"));
		definition.addPropertyValue("fallback", attributes.get("fallback"));
		definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
		// AUTOWIRE_BY_TYPE，方法注入
		definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);

		String alias = contextId + "FeignClient";
		AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
		// 构造了bd
		BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
				new String[] { alias });
		BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
	}

上面就是扫描包，得到加了注解的类接口信息，然后根据每一个FeignClient，修改bd后向容器注入。
这一步比较重要的就是，统一修改了bd的类信息为FeignClientFactoryBean，并设置了各种参数。

2.FeignClientFactoryBean

重要的就是这个类的实例化，继承体系上我们可以看到FeignClientFactoryBean是一个FactoryBean，也就是说Spring在创建该类实例的时候，会去调FactoryBean的getObject()方法，下面只要重点分析getObject()方法即可。

	@Override
	public Object getObject() throws Exception {
		return getTarget();
	}
	
  <T> T getTarget() {
    // FeignContext 是从 FeignAutoConfiguration 注入进来的(重要)
		FeignContext context = this.applicationContext.getBean(FeignContext.class);
		// feign(context);原生api构建Feign Client
		Feign.Builder builder = feign(context);
		if (!StringUtils.hasText(this.url)) {
			if (!this.name.startsWith("http")) {
				this.url = "http://" + this.name;
			}
			this.url += cleanPath();
			// 服务名的调用方式,,负载均衡调用
			return (T) loadBalance(builder, context,
					new HardCodedTarget<>(this.type, this.name, this.url));
		}
		// 指定了 url 方式
		String url = this.url + cleanPath();
		Client client = getOptional(context, Client.class);
		Targeter targeter = get(context, Targeter.class);
		// 在往下面就是生成动态代理对象等
		return (T) targeter.target(this, builder, context,
				new HardCodedTarget<>(this.type, this.name, url));
	}

	/**
	*get(context, xxx.class) 是从容器中获取的对应的实现类，但并不是直接从当前容器中获取，
	*前面说过 配置隔离，每一个@FeignClient 如果指定了 configuration 属性的值 都会生成
	*一个Spring容器，会根据指定的名称，获取指定的Spring容器，然后从Spring容器里面获取这个xxx.class的实现
	**/
	protected Feign.Builder feign(FeignContext context) {
			// get(context, FeignLoggerFactory.class); 是从Spring容器中获取的
			FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
			Logger logger = loggerFactory.create(this.type);
			// 原生Feign的构建
			Feign.Builder builder = get(context, Feign.Builder.class)
					.logger(logger)
					.encoder(get(context, Encoder.class))
					.decoder(get(context, Decoder.class))
					.contract(get(context, Contract.class));
			// @formatter:on
			configureFeign(context, builder);
			return builder;
		}

	protected <T> T loadBalance(Feign.Builder builder, FeignContext context,
			HardCodedTarget<T> target) {
		// 从容器中获取 Client.class,真正发起http请求的实现，这个地方可以进行负载均衡请求
		// FeignRibbonClientAutoConfiguration: feign调用ribbon 负载均衡的自动配置
		Client client = getOptional(context, Client.class);
		if (client != null) {
			builder.client(client);
			Targeter targeter = get(context, Targeter.class);
			return targeter.target(this, builder, context, target);
		}
	}

Client的实现：
FeignBlockingLoadBalancerClient
LoadBalancerFeignClient

3.FeignAutoConfiguration

public class FeignAutoConfiguration {

	/**
	* 这个地方注入进来了前面扫描到的每一个@FeignClient 修改bd过后的 FeignClientSpecification
	**/
	@Autowired(required = false)
	private List<FeignClientSpecification> configurations = new ArrayList<>();

	@Bean
	public FeignContext feignContext() {
	  // 比较重要的一个类
		FeignContext context = new FeignContext();
		context.setConfigurations(this.configurations);
		return context;
	}
}	

FeignContext 继承 NamedContextFactory

public class FeignContext extends NamedContextFactory<FeignClientSpecification> {
	public FeignContext() {
	  // 这个 FeignClientsConfiguration 是Spring默认为Feign提供的上下文信息
	  // 上下文信息里面有 feign.Decoder，feign.Encoder，feign.Contract 等等
	  // 我们没有指定的话，就会用这个类提供的
		super(FeignClientsConfiguration.class, "feign", "feign.client.name");
	}
}

NamedContextFactory：命名空间类

public abstract class NamedContextFactory<C extends NamedContextFactory.Specification>
		implements DisposableBean, ApplicationContextAware {
	private final String propertySourceName;
	private final String propertyName;
	// 拼接的名字，Spring上下文
	private Map<String, AnnotationConfigApplicationContext> contexts = new ConcurrentHashMap<>();
	// 拼接的名字，FeignClientSpecification
	private Map<String, C> configurations = new ConcurrentHashMap<>();
	// 父Spring上下文
	private ApplicationContext parent;
	// FeignClientsConfiguration
	private Class<?> defaultConfigType;

	public NamedContextFactory(Class<?> defaultConfigType, String propertySourceName,
			String propertyName) {
		this.defaultConfigType = defaultConfigType;
		this.propertySourceName = propertySourceName;
  }
  // 上面的get(context, FeignLoggerFactory.class); 最终会掉这个方法先获取容器
	protected AnnotationConfigApplicationContext getContext(String name) {
		if (!this.contexts.containsKey(name)) {
			synchronized (this.contexts) {
				if (!this.contexts.containsKey(name)) {
				  // map 中不存在，就会重新创建
					this.contexts.put(name, createContext(name));
				}
			}
		}
		return this.contexts.get(name);
	}
	protected AnnotationConfigApplicationContext createContext(String name) {
	  // 手动创建 AnnotationConfigApplicationContext 
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
		if (this.configurations.containsKey(name)) {
			for (Class<?> configuration : this.configurations.get(name)
					.getConfiguration()) {
				// 注入configuration也就是@FeignClient指定的configuration属性的值
				context.register(configuration);
			}
		}
		// 默认的 FeignClientsConfiguration，也注入到容器
		context.register(PropertyPlaceholderAutoConfiguration.class,
				this.defaultConfigType);
		if (this.parent != null) {
		  // 设置父上下文，也就是当前项目启动的Spring容器
			context.setParent(this.parent);
			context.setClassLoader(this.parent.getClassLoader());
		}
		// 刷新容器
		context.refresh();
		return context;
	}
}  		

createContext(String name)里解释了官网的这一段说明：

4. FeignRibbonClientAutoConfiguration

前面说了，真正发起 http 请求的类是 Client client = getOptional(context, Client.class);

public interface Client {
  /**
   * Executes a request against its {@link Request#url() url} and returns a response.
   */
  Response execute(Request request, Options options) throws IOException;
}  

我们来看一下FeignRibbonClientAutoConfiguration：

@Import({ HttpClientFeignLoadBalancedConfiguration.class,
		OkHttpFeignLoadBalancedConfiguration.class,
		DefaultFeignLoadBalancedConfiguration.class })
public class FeignRibbonClientAutoConfiguration {
	@Bean
	@Primary
	@ConditionalOnMissingBean
	@ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
	public CachingSpringLoadBalancerFactory cachingLBClientFactory(
			SpringClientFactory factory) {
		return new CachingSpringLoadBalancerFactory(factory);
	}

	@Bean
	@Primary
	@ConditionalOnMissingBean
	@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
	public CachingSpringLoadBalancerFactory retryabeCachingLBClientFactory(
			SpringClientFactory factory, LoadBalancedRetryFactory retryFactory) {
		return new CachingSpringLoadBalancerFactory(factory, retryFactory);
	}
}

导入了一个 DefaultFeignLoadBalancedConfiguration：

@Configuration(proxyBeanMethods = false)
class DefaultFeignLoadBalancedConfiguration {
	
	/**
	* 注入了一个具备负载均衡的Client：LoadBalancerFeignClient
	**/
	@Bean
	@ConditionalOnMissingBean
	public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
			SpringClientFactory clientFactory) {
		return new LoadBalancerFeignClient(new Client.Default(null, null), cachingFactory,
				clientFactory);
	}

}

FeignRibbonClientAutoConfiguration，FeignAutoConfiguration的加载时机：
基于SpringBoot的自动装配原理。

总结图

自此源码分析结束！