Feign

public void registerFeignClients(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
	LinkedHashSet<BeanDefinition> candidateComponents = new LinkedHashSet<>();
	ClassPathScanningCandidateComponentProvider scanner = getScanner();
	scanner.setResourceLoader(this.resourceLoader);
	scanner.addIncludeFilter(new AnnotationTypeFilter(FeignClient.class));
	// 扫描包路径，将使用@FeignClient的类，封装为BeanDefinition
	Set<String> basePackages = getBasePackages(metadata);
	for (String basePackage : basePackages) {
		candidateComponents.addAll(scanner.findCandidateComponents(basePackage));
	}
	for (BeanDefinition beanDefinition : candidateComponents) {
		// 注册feign配置。会被转换为FeignClientSpecification实例
		registerClientConfiguration(registry, name, attributes.get("configuration"));
		// 注册feign客户端，注册的类是FeignClientFactoryBean，他会帮我们创建代理类。
		registerFeignClient(registry, annotationMetadata, attributes);
	}
}

private void registerFeignClient(BeanDefinitionRegistry registry, AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
    String className = annotationMetadata.getClassName();
    // 生成FeignClientFactoryBean这个BeanDefinition构造器
    BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(FeignClientFactoryBean.class);

    // 将@FeignClient的注解属性添加到builder
    definition.addPropertyValue("url", getUrl(attributes));
    definition.addPropertyValue("path", getPath(attributes));
    definition.addPropertyValue("fallback", attributes.get("fallback"));
	
    AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();

    // 注册FeignClientFactoryBean
    BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
}

Object executeAndDecode(RequestTemplate template, Options options) throws Throwable {
	Request request = targetRequest(template);
	Response response;
	try {
		// 调用客户端。LoadBalancerFeignClient。
		response = client.execute(request, options);
	} catch (IOException e) {
		throw errorExecuting(request, e);
	}

	// 调用解码器【默认没有解码器，容易导致性能下降】
	if (decoder != null)
		return decoder.decode(response, metadata.returnType());

	// 异步处理响应结果
	CompletableFuture<Object> resultFuture = new CompletableFuture<>();
	asyncResponseHandler.handleResponse(resultFuture, metadata.configKey(), response);
	
	return resultFuture.join();
}

public Response execute(Request request, Request.Options options) throws IOException {
	return lbClient("服务提供方name").executeWithLoadBalancer(ribbonRequest, requestConfig).toResponse();
}

// 只有两种LB，如果spring引入了 retry 组件，就是RetryableFeignLoadBalancer，否则 FeignLoadBalancer
public FeignLoadBalancer lbClient(String clientName) {
	return this.loadBalancedRetryFactory != null ? new RetryableFeignLoadBalancer() : new FeignLoadBalancer();
}

// FeignLoadBalancer#executeWithLoadBalancer 使用LB执行请求【异步】
public T executeWithLoadBalancer(final S request, final IClientConfig requestConfig) throws ClientException {
	LoadBalancerCommand<T> command = buildLoadBalancerCommand(request, requestConfig);
	return command.submit(
		new ServerOperation<T>() {
			public Observable<T> call(Server server) {
				// server是已经负载均衡好，拿来修改请求中的URL
				URI finalUri = reconstructURIWithServer(server, request.getUri());
				S requestForServer = (S) request.replaceUri(finalUri);
				// 执行ribbon的request请求
				return AbstractLoadBalancerAwareClient.this.execute(requestForServer, requestConfig);
			}
		}).toBlocking().single();
}

// LoadBalancerCommand#submit 
 -> LoadBalancerCommand#selectServer()
 -> LoadBalancerContext#getServerFromLoadBalancer()
 -> LoadBalancerContext#getLoadBalancer() 拿到一个 ZoneAwareLoadBalancer 实例
 -> ZoneAwareLoadBalancer#chooseServer()
 -> BaseLoadBalancer#chooseServer()
 
// 默认采用的是ZoneAvoidanceRule   RandomRule
public Server chooseServer(Object key) {
	return rule.choose(key);
}

public abstract class NamedContextFactory<C extends NamedContextFactory.Specification> implements DisposableBean, ApplicationContextAware {
    // 每个客户端，都是一个AnnotationConfigApplicationContext
	private Map<String, AnnotationConfigApplicationContext> contexts = new ConcurrentHashMap<>();
	private Map<String, C> configurations = new ConcurrentHashMap<>();
	private Class<?> defaultConfigType;
	public NamedContextFactory(Class<?> defaultConfigType, String propertySourceName, String propertyName) {
		this.defaultConfigType = defaultConfigType;
		this.propertySourceName = propertySourceName;
		this.propertyName = propertyName;
	}
}

public class SpringClientFactory extends NamedContextFactory<RibbonClientSpecification> {
	public SpringClientFactory() {
		super(RibbonClientConfiguration.class, NAMESPACE, "ribbon.client.name");
	}
}

public class PropertiesFactory {

	@Autowired
	private Environment environment;
	private Map<Class, String> classToProperty = new HashMap<>();
	public PropertiesFactory() {
		classToProperty.put(ILoadBalancer.class, "NFLoadBalancerClassName");
		classToProperty.put(IPing.class, "NFLoadBalancerPingClassName");
		classToProperty.put(IRule.class, "NFLoadBalancerRuleClassName");
		classToProperty.put(ServerList.class, "NIWSServerListClassName");
		classToProperty.put(ServerListFilter.class, "NIWSServerListFilterClassName");
	}

	public boolean isSet(Class clazz, String name) {
		return StringUtils.hasText(getClassName(clazz, name));
	}

	public String getClassName(Class clazz, String name) {
		if (this.classToProperty.containsKey(clazz)) {
			String classNameProperty = this.classToProperty.get(clazz);
			String className = 
			//                      服务名称   + ribbon          + 关键字
			environment.getProperty(name + "." + NAMESPACE + "." + classNameProperty);
			return className;
		}
		return null;
	}

	public <C> C get(Class<C> clazz, IClientConfig config, String name) {
		String className = getClassName(clazz, name);
		if (StringUtils.hasText(className)) {
			try {
				Class<?> toInstantiate = Class.forName(className);
				return (C) SpringClientFactory.instantiateWithConfig(toInstantiate,
						config);
			}
			catch (ClassNotFoundException e) {
				throw new IllegalArgumentException("Unknown class to load " + className
						+ " for class " + clazz + " named " + name);
			}
		}
		return null;
	}
}

public class FeignContext extends NamedContextFactory<FeignClientSpecification> {
	public FeignContext() {
		super(FeignClientsConfiguration.class, "feign", "feign.client.name");
	}
}

@Bean
public IClientConfig ribbonClientConfig() {
	DefaultClientConfigImpl config = new DefaultClientConfigImpl();
	config.loadProperties(this.name);
	config.set(CommonClientConfigKey.ConnectTimeout, getProperty(CommonClientConfigKey.ConnectTimeout, DEFAULT_CONNECT_TIMEOUT));
	config.set(CommonClientConfigKey.ReadTimeout, getProperty(CommonClientConfigKey.ReadTimeout, DEFAULT_READ_TIMEOUT));
	config.set(CommonClientConfigKey.GZipPayload, DEFAULT_GZIP_PAYLOAD);
	return config;
}

@Bean
public IRule ribbonRule(IClientConfig config) {
	if (this.propertiesFactory.isSet(IRule.class, name)) {
		return this.propertiesFactory.get(IRule.class, config, name);
	}
	ZoneAvoidanceRule rule = new ZoneAvoidanceRule();
	rule.initWithNiwsConfig(config);
	return rule;
}

@Bean
public IPing ribbonPing(IClientConfig config) {
   if (this.propertiesFactory.isSet(IPing.class, name)) {
      return this.propertiesFactory.get(IPing.class, config, name);
   }
   return new DummyPing();
}

@Import({ HttpClientFeignLoadBalancedConfiguration.class, 
		OkHttpFeignLoadBalancedConfiguration.class,  // 推荐使用OkHttp
		HttpClient5FeignLoadBalancedConfiguration.class,
		DefaultFeignLoadBalancedConfiguration.class  // 默认客户端，使用jdk提供的api。性能较差。
})
public class FeignRibbonClientAutoConfiguration {}


@ConditionalOnProperty("feign.okhttp.enabled")
@Import(OkHttpFeignConfiguration.class)
class OkHttpFeignLoadBalancedConfiguration {
	@Bean
	public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
			SpringClientFactory clientFactory, okhttp3.OkHttpClient okHttpClient) {
		OkHttpClient delegate = new OkHttpClient(okHttpClient);
		return new LoadBalancerFeignClient(delegate, cachingFactory, clientFactory);
	}
}

public class OpenFeignConfig {

    /**
     * 设置日志输出的内容【debug级别生效】
     * NONE：        默认，不显示任何日志；【性能最佳，适合于生产】
     * BASIC:       仅记录请求方法、URL、响应状态码及执行时间；【适用于生产环境定位测试问题】
     * HEADERS：     除了BASIC中定义的信息之外，还有请求头和响应头信息；
     * FULL：        除了HEADERS中定义的信息之外，还有请求的正文和响应数据。【本地开发环境使用】
     * @return
     */
    @Bean
    Logger.Level feignLogLevel() {
        return Logger.Level.NONE;
    }

    /**
     * 设置各类超时时间
     * @return
     */
    @Bean
    public Request.Options options() {
        return new Request.Options(
                1L, TimeUnit.SECONDS,
                1L, TimeUnit.SECONDS,
                true);
    }

    /**
     * 重试机制，默认情况下，当请求的接口出现异常不会进行重试。
     * @return
     */
    @Bean
    public Retryer feignRetryer() {
        return new Retryer.Default(100,
                TimeUnit.SECONDS.toMillis(1),
                2); //重试次数，间隔时间，最大时间
    }

    /**
     * 自定义拦截器【可以多个】
     * @return
     */
    @Bean
    public RequestInterceptor headerRequestInterceptor() {
        return template -> {
            template.header("X-API-TOKEN", "666666");
        };
    }
}