小许的技术驿站——SpringCloud-OpenFeign源码解析笔记
小弟有一个开源项目，希望大家可以多多一键三连，谢谢大家
后续的源码解析也都会进行同步更新上去
1、什么是OpenFeign？
根据上篇博客能够看到在使用 Eureka，loadBalance来进行服务调用时，都需要创建 RestTemplate组件进行 Http请求访问，但是如果每次都是用组件进行请求的话，我们在代码上面会写的很麻烦，而且也会很繁琐，所以 SpringCloud整合了 Feign客户端。而 Feign是一个声明性web服务客户端。Spring Cloud集成了Eureka、Spring Cloud CircuitBreaker和Spring Cloud LoadBalancer，在使用Feign时提供一个负载均衡的http客户端。并且可以解析Spring MVC注解，意思就是说，我们使用 Feign那么我们就可以不需要在手动使用 RestTemplate组件进行请求 Http接口了。
2、怎么使用OpenFeign？
我们首先改造一下我们消费者的代码。
/**
* 开启Eureka-CLient客户端，OpenFeign客户端
*/
@EnableEurekaClient
@EnableFeignClients
@SpringBootApplication
public class EurekaServiceBApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaServiceBApplication.class, args);
}
@RestController
@Configuration
public class ServiceBController {
/**
* SayHello 请求OpenFeign组件
**/
@Autowired
SayHelloClient sayHelloClient;
@RequestMapping(value = "/greeting/{name}", method = RequestMethod.GET)
public String greeting(@PathVariable("name") String name) {
return sayHelloClient.test(name);
}
}
}
/**
* 声明一个SayHello OpenFeign请求客户端
*/
@FeignClient("ServiceA")
public interface SayHelloClient {
/**
* 基于Http请求 ServiceA 的 /test/sayHello/{test} 接口
**/
@GetMapping("/test/sayHello/{test}")
String test(@PathVariable("test") String test);
}
根据上面的代码我们在请求 ServiceA/test/sayHello/接口时就不需要使用 RestTemplate组件了，而且在我们开发的过程中，就可以直接把Controller层加上一个接口打包成一个Jar包进行调用即可，这样能够保证接口的请求地址与参数都不会出问题，也能够简化开发。
3、@EnableFeignClients 注解详解
小知识：在看Spring相关的代码时，应该多去关注一些注解中 @Import导入的类，在 SpringBoot中应该多多关注 xxxAutoConfiguration类。
我们在 @EnableFeignClients注解中能够看到导入了 FeignClientsRegistrar.class类，从Spring源码结构来看，一般这样的类都是该注解的关键处理类，所以我们应该仔细阅读一下。
class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
// 注册全局默认的FeignClient配置组件
registerDefaultConfiguration(metadata, registry);
// 注册 @FeignClient 标注的接口
registerFeignClients(metadata, registry);
}
}
在 registerDefaultConfiguration(metadata, registry)主要是根据 @EnableFeignClients注解中的 defaultConfiguration属性加载默认的全局配置类，如果没有配置就默认使用 FeignClientSpecification.class进行注册，而最主要的是如何去注册 被@FeignClient注解标注的接口。
3.1 registerFeignClients(metadata, registry);
public void registerFeignClients(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
//被@FeignClient标注可以注册为 SpringBean的集合
LinkedHashSet<BeanDefinition> candidateComponents = new LinkedHashSet<>();
// 获取@EnableFeignClients的全部属性值
Map<String, Object> attrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName());
// 获取@EnableFeignClients属性中的clients属性
final Class<?>[] clients = attrs == null ? null : (Class<?>[]) attrs.get("clients");
//如果没有手动配置clients属性那么就通过包路径扫描进行注册
if (clients == null || clients.length == 0) {
//获取根据 classpath路径进行扫描的Provider类
ClassPathScanningCandidateComponentProvider scanner = getScanner();
scanner.setResourceLoader(this.resourceLoader);
//扫描被@FeignClient注解标注的接口
scanner.addIncludeFilter(new AnnotationTypeFilter(FeignClient.class));
//获取扫描包集合
Set<String> basePackages = getBasePackages(metadata);
for (String basePackage : basePackages) {
candidateComponents.addAll(scanner.findCandidateComponents(basePackage));
}
}
else {
// 把@EnableFeignClients的clients属性class数组添加到candidateComponents集合中
for (Class<?> clazz : clients) {
candidateComponents.add(new AnnotatedGenericBeanDefinition(clazz));
}
}
// 循环注册FeignClient SpringBean
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");
// 获取接口上面 @FeignClient标注的注解熟悉
Map<String, Object> attributes = annotationMetadata
.getAnnotationAttributes(FeignClient.class.getCanonicalName());
//获取 @FeignClient 以contextId->value->name->serviceId 进行逐步获取feign名称
String name = getClientName(attributes);
//注册当前FeignClient的配置类
registerClientConfiguration(registry, name, attributes.get("configuration"));
//注册FeignClient到Spring容器中
registerFeignClient(registry, annotationMetadata, attributes);
}
}
}
从上面的源码能够看到，其实 Feign的模式是和 loadbalance源码的模式是差不多的，都是一个 Client或者一个 loadbalance都会去维护一个 Spring ApplicationContext ，需要什么组件直接通过 getBean()进行获取，其配置全部都是通过配置类进行注册到 Spring上下文进行初始化与配置。
private void registerFeignClient(BeanDefinitionRegistry registry, AnnotationMetadata annotationMetadata,
Map<String, Object> attributes) {
// FeignClient 接口类名称
String className = annotationMetadata.getClassName();
// 反射获取FeignClient 接口类
Class clazz = ClassUtils.resolveClassName(className, null);
// 获取SpringBean Factory
ConfigurableBeanFactory beanFactory = registry instanceof ConfigurableBeanFactory
? (ConfigurableBeanFactory) registry : null;
String contextId = getContextId(beanFactory, attributes);
String name = getName(attributes);
//创建 FeignClientBean并且设置一些Bean的一些属性
FeignClientFactoryBean factoryBean = new FeignClientFactoryBean();
factoryBean.setBeanFactory(beanFactory);//设置Bean工厂
factoryBean.setName(name);//设置Bean名称
factoryBean.setContextId(contextId);//设置 Feign的上下文Id
factoryBean.setType(clazz);//设置Bean class类型
factoryBean.setRefreshableClient(isClientRefreshEnabled());// 设置是否自动刷新Client客户端，默认False
// 通过Spring BeanDefinitionBuilder 创建Bean
BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(clazz, () -> {
// 设置当前Feign客户端的请求Url地址
factoryBean.setUrl(getUrl(beanFactory, attributes));
// 设置当前Feign客户端的请求地址前缀
factoryBean.setPath(getPath(beanFactory, attributes));
// 设置当前Feign客户端请求404时，是解析请求还是抛出异常，默认false
factoryBean.setDecode404(Boolean.parseBoolean(String.valueOf(attributes.get("decode404"))));
//判断当前Feign客户端是否有返回处理对象，如果有就设置，当时返回的处理对象必须是SpringBean
Object fallback = attributes.get("fallback");
if (fallback != null) {
factoryBean.setFallback(fallback instanceof Class ? (Class<?>) fallback
: ClassUtils.resolveClassName(fallback.toString(), null));
}
//判断当前Feign客户端是否有返回处理对象工厂，该工厂必须要生成返回处理对象，也必须是SpringBean，如果有就设置
Object fallbackFactory = attributes.get("fallbackFactory");
if (fallbackFactory != null) {
factoryBean.setFallbackFactory(fallbackFactory instanceof Class ? (Class<?>) fallbackFactory
: ClassUtils.resolveClassName(fallbackFactory.toString(), null));
}
// 这里是最关键的一步，获取到的对象被 FeignClientFactoryBean动态代理处理过，在调用时会自动去请求Eureka服务接口
return factoryBean.getObject();
});
// 自动注入方式，根据类型自动注入
definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
// 是否是懒加载
definition.setLazyInit(true);
validate(attributes);
//从BeanDefinitionBuilder中获取上面配置的 BeanDefinition
AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
// 设置当前的 BeanDefinition 注入类型是 接口类型
beanDefinition.setAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE, className);
// 设置 feignClientsRegistrarFactoryBean 其根本是 FeignClientFactoryBean 对象，
// 主要是 getObject()方法获取被动态代理过的 FeignClient接口
beanDefinition.setAttribute("feignClientsRegistrarFactoryBean", factoryBean);
// 当前的beanDefinition是首先的，首先注入的
boolean primary = (Boolean) attributes.get("primary");
beanDefinition.setPrimary(primary);
// 当前Feign是否有别名，默认为空
String[] qualifiers = getQualifiers(attributes);
if (ObjectUtils.isEmpty(qualifiers)) {
qualifiers = new String[] { contextId + "FeignClient" };
}
//创建一个带有名称与别名的 Holder，其本身还是beanDefinition
BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, qualifiers);
// 注册 beanDefinition
BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
// 注册一个 refreshScope 默认不创建
registerOptionsBeanDefinition(registry, contextId);
}
根据这段源码我们看到了，其实被 @FeignClient标注的接口，会被注册成 SpringBean而在通过 FeignClientFactoryBean进行获取 Bean的时候，获取到的 Bean对象其实是被 Feign动态代理生成过了，这时候在调用接口的时候，就会被 Feign通过动态代理的方式去请求。
3.2 FeignClientFactoryBean#getObject
@Override
public Object getObject() {
return getTarget();
}
<T> T getTarget() {
FeignContext context = beanFactory != null ? beanFactory.getBean(FeignContext.class)
: applicationContext.getBean(FeignContext.class);
//创建一个 Feign.Builder 并且加载对应的 Feign配置文件参数
Feign.Builder builder = feign(context);
//判断在 @FeignClient注解中是否配置了 url 如果没有配置那么就默认使用 @FeignClient name 名称作为请求地址
if (!StringUtils.hasText(url)) {
if (!name.startsWith("http")) {
url = "http://" + name;
}
else {
url = name;
}
url += cleanPath();
// 生成一个 loadbalance的请求动态代理对象
return (T) loadBalance(builder, context, new HardCodedTarget<>(type, name, url));
}
// 如果设置了 url属性，那么就根据 url设置请求地址
if (StringUtils.hasText(url) && !url.startsWith("http")) {
url = "http://" + url;
}
String url = this.url + cleanPath();
// 获取Eureka Client 客户端，并且判断Eureka Client是使用那种方式进行请求，默认是 FeignBlockingLoadBalancerClient.class
Client client = getOptional(context, Client.class);
if (client != null) {
if (client instanceof FeignBlockingLoadBalancerClient) {
client = ((FeignBlockingLoadBalancerClient) client).getDelegate();
}
if (client instanceof RetryableFeignBlockingLoadBalancerClient) {
client = ((RetryableFeignBlockingLoadBalancerClient) client).getDelegate();
}
builder.client(client);
}
// 获取动态代理增强对象，默认是 DefaultTargeter对象
Targeter targeter = get(context, Targeter.class);
// 使用 DefaultTargeter 生成一个动态代理对象
return (T) targeter.target(this, builder, context, new HardCodedTarget<>(type, name, url));
}
读取配置文件配置FeignClient客户端
protected Feign.Builder feign(FeignContext context) {
// 从 Spring 容器中获取 logger工厂，默认是 Slf4jLogger
FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
Logger logger = loggerFactory.create(type);
// 从 Spring 容器中获取 Feign.Builder ，并且配置参数初始值
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));//配置SpringMVC 注解解析器
// 根据配置文件配置FeignClient配置参数
configureFeign(context, builder);
// 执行用户自己定义的创建 Feign Client构建器
applyBuildCustomizers(context, builder);
return builder;
}
private void applyBuildCustomizers(FeignContext context, Feign.Builder builder) {
// 由此能够知道自己定义的Feign构建，必须也是SpringBean
Map<String, FeignBuilderCustomizer> customizerMap = context.getInstances(contextId,
FeignBuilderCustomizer.class);
if (customizerMap != null) {
customizerMap.values().stream().sorted(AnnotationAwareOrderComparator.INSTANCE)
.forEach(feignBuilderCustomizer -> feignBuilderCustomizer.customize(builder));
}
additionalCustomizers.forEach(customizer -> customizer.customize(builder));
}
protected void configureFeign(FeignContext context, Feign.Builder builder) {
//从Spring容器中获取到 Feign Client 配置文件，主要是在 application.properties文件中配置的参数
FeignClientProperties properties = beanFactory != null ? beanFactory.getBean(FeignClientProperties.class)
: applicationContext.getBean(FeignClientProperties.class);
//从Spring容器中获取到当前Feign Client的全局配置
FeignClientConfigurer feignClientConfigurer = getOptional(context, FeignClientConfigurer.class);
setInheritParentContext(feignClientConfigurer.inheritParentConfiguration());
// 配置文件的读取流程是 全局的配置->Default默认配置参数->clientProperties单个feign client配置参数
// 覆盖顺序是对底层的覆盖最上层的
if (properties != null && inheritParentContext) {
if (properties.isDefaultToProperties()) {
//配置FeignClient全局配置参数
configureUsingConfiguration(context, builder);
//配置FeignClient默认配置参数
configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder);
//针对FeignClient单个服务读取配置参数
configureUsingProperties(properties.getConfig().get(contextId), builder);
}
else {
configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder);
configureUsingProperties(properties.getConfig().get(contextId), builder);
configureUsingConfiguration(context, builder);
}
}
else {
configureUsingConfiguration(context, builder);
}
}
protected void configureUsingConfiguration(FeignContext context, Feign.Builder builder) {
// 整体配置全部都是从Spring容器中获取对应的Bean对象，然后放入 Feign.Builder 对象中
Logger.Level level = getInheritedAwareOptional(context, Logger.Level.class);
if (level != null) {
builder.logLevel(level);
}
Retryer retryer = getInheritedAwareOptional(context, Retryer.class);
if (retryer != null) {
builder.retryer(retryer);
}
。。。
}
protected void configureUsingProperties(FeignClientProperties.FeignClientConfiguration config,
Feign.Builder builder) {
// 通过用户在application.properties配置文件中的配置，进行逐步设置相关参数
if (config == null) {
return;
}
if (config.getLoggerLevel() != null) {
builder.logLevel(config.getLoggerLevel());
}
//是否自动刷新feign client
if (!refreshableClient) {
connectTimeoutMillis = config.getConnectTimeout() != null ? config.getConnectTimeout()
: connectTimeoutMillis;
readTimeoutMillis = config.getReadTimeout() != null ? config.getReadTimeout() : readTimeoutMillis;
followRedirects = config.isFollowRedirects() != null ? config.isFollowRedirects() : followRedirects;
builder.options(new Request.Options(connectTimeoutMillis, TimeUnit.MILLISECONDS, readTimeoutMillis,
TimeUnit.MILLISECONDS, followRedirects));
}
if (config.getRetryer() != null) {
Retryer retryer = getOrInstantiate(config.getRetryer());
builder.retryer(retryer);
}
。。。
}
获取EurekaClient，并且生成动态代理对象
protected <T> T loadBalance(Feign.Builder builder, FeignContext context, HardCodedTarget<T> target) {
// 从Spring容器中获取到EurekaClient，默认是 FeignBlockingLoadBalancerClient 对象
Client client = getOptional(context, Client.class);
if (client != null) {
builder.client(client);
// 从Spring容器中获取 Targeter 动态代理类，默认是 DefaultTargeter
Targeter targeter = get(context, Targeter.class);
return targeter.target(this, builder, context, target);
}
}
class DefaultTargeter implements Targeter {
// 通过该代码能够看到，动态代理生成的对象还是通过Feign.Builder进行生成的
@Override
public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign, FeignContext context,
Target.HardCodedTarget<T> target) {
return feign.target(target);
}
}
public Feign build() {
// 对当前配置的FeignClient的参数根据this.capabilities集合进行增强，默认 this.capabilities 为空
Client client = (Client)Capability.enrich(this.client, this.capabilities);
Retryer retryer = (Retryer)Capability.enrich(this.retryer, this.capabilities);
List<RequestInterceptor> requestInterceptors = (List)this.requestInterceptors.stream().map((ri) -> {
return (RequestInterceptor)Capability.enrich(ri, this.capabilities);
}).collect(Collectors.toList());
Logger logger = (Logger)Capability.enrich(this.logger, this.capabilities);
Contract contract = (Contract)Capability.enrich(this.contract, this.capabilities);
Options options = (Options)Capability.enrich(this.options, this.capabilities);
Encoder encoder = (Encoder)Capability.enrich(this.encoder, this.capabilities);
Decoder decoder = (Decoder)Capability.enrich(this.decoder, this.capabilities);
InvocationHandlerFactory invocationHandlerFactory = (InvocationHandlerFactory)Capability.enrich(this.invocationHandlerFactory, this.capabilities);
QueryMapEncoder queryMapEncoder = (QueryMapEncoder)Capability.enrich(this.queryMapEncoder, this.capabilities);
Factory synchronousMethodHandlerFactory = new Factory(client, retryer, requestInterceptors, logger, this.logLevel, this.decode404, this.closeAfterDecode, this.propagationPolicy, this.forceDecoding);
ParseHandlersByName handlersByName = new ParseHandlersByName(contract, options, encoder, decoder, queryMapEncoder, this.errorDecoder, synchronousMethodHandlerFactory);
// 返回一个可以生成FeignClient动态代理的对象
return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);
}
public <T> T newInstance(Target<T> target) {
//根据 target对象创建对应方法的SpringMVC注解的MethodHandler，创建的MethodHandler是SynchronousMethodHandler
//所以在方法动态代理调用是，主要还是调用SynchronousMethodHandler 的invoke方法
Map<String, MethodHandler> nameToHandler = this.targetToHandlersByName.apply(target);
// 用于存储方法与解析SpringMVC注解的MethodHandler
Map<Method, MethodHandler> methodToHandler = new LinkedHashMap();
// 当 target 是 Object对象是，则会用到该list
List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList();
// 获取当前接口所有方法集合
Method[] var5 = target.type().getMethods();
int var6 = var5.length;
// 循环所有方法集合
for(int var7 = 0; var7 < var6; ++var7) {
Method method = var5[var7];
// 判断当前的方法是存在于对象中还是接口中
if (method.getDeclaringClass() != Object.class) {
// 当前的方法在对象（Object）中
if (Util.isDefault(method)) {
DefaultMethodHandler handler = new DefaultMethodHandler(method);
defaultMethodHandlers.add(handler);
methodToHandler.put(method, handler);
} else {
// 当前方法在接口（interface）中
//并且对该方法解析SpringMVC注解的nameToHandler放一起
methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));
}
}
}
// 通过动态代理构造工厂 InvocationHandlerFactory 创建一个 FeignInvocationHandler动态代理 Handler
InvocationHandler handler = this.factory.create(target, methodToHandler);
// 生成一个动态代理对象
T proxy = Proxy.newProxyInstance(target.type().getClassLoader(), new Class[]{target.type()}, handler);
// 若是对象中的方法则通过默认的 DefaultMethodHandler 绑定到创建成功的proxy动态代理上面
Iterator var12 = defaultMethodHandlers.iterator();
while(var12.hasNext()) {
DefaultMethodHandler defaultMethodHandler = (DefaultMethodHandler)var12.next();
defaultMethodHandler.bindTo(proxy);
}
//返回一个该 类/接口 的动态代理
return proxy;
}
从上面的代码中可以看到，当 调用FeignClientFactoryBean#getObject方法时，其实获取到的是一个已经被 Feign使用 Java原生的动态代理进行代理过的对象即 FeignInvocationHandler对象，这时候就知道我们在Spring自动注入 Feign Client的时候其实注入的就是 FeignInvocationHandler对象，接下来，我们来看一下，当我们调用 Feign Client请求服务接口时的调用流程。
4、OpenFeign 动态代理调用Eureka服务接口
FeignInvocationHandler动态代理核心方法
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (!"equals".equals(method.getName())) {
if ("hashCode".equals(method.getName())) {
return this.hashCode();
} else {
// 主要是这里通过创建时放入的methodToHandler，根据动态代理传过 // 来的方法获取该方法的MethodHandler，进行调用Eureka服务
return "toString".equals(method.getName()) ? this.toString() : ((MethodHandler)this.dispatch.get(method)).invoke(args);
}
} else {
try {
Object otherHandler = args.length > 0 && args[0] != null ? Proxy.getInvocationHandler(args[0]) : null;
return this.equals(otherHandler);
} catch (IllegalArgumentException var5) {
return false;
}
}
}
SynchronousMethodHandler方法动态代理执行源码
public Object invoke(Object[] argv) throws Throwable {
// 根据方法的SpringMVC注解进行解析请求，创建RequestTemplate
RequestTemplate template = this.buildTemplateFromArgs.create(argv);
// 获取请求超时等参数
Options options = this.findOptions(argv);
// 获取重试机制
Retryer retryer = this.retryer.clone();
while(true) {
try {
// 执行http请求调用
return this.executeAndDecode(template, options);
} catch (RetryableException var9) {
// feign 重试机制
RetryableException e = var9;
try {
retryer.continueOrPropagate(e);
} catch (RetryableException var8) {
Throwable cause = var8.getCause();
if (this.propagationPolicy == ExceptionPropagationPolicy.UNWRAP && cause != null) {
throw cause;
}
throw var8;
}
if (this.logLevel != Level.NONE) {
this.logger.logRetry(this.metadata.configKey(), this.logLevel);
}
}
}
}
//请求数据与解码响应数据
Object executeAndDecode(RequestTemplate template, Options options) throws Throwable {
//执行请求的一些Interceptor拦截器
Request request = this.targetRequest(template);
//开始请求时间
long start = System.nanoTime();
Response response;
try {
//通过 FeignBlockingLoadBalancerClient进行执行eureka接口调用
response = this.client.execute(request, options);
//根据response响应数据builder一下整理返回数据
response = response.toBuilder().request(request).requestTemplate(template).build();
} catch (IOException var12) {
// 如果Http请求出现IOException就是通信异常，就会throw FeignException 异常
// 在调用前已经 try catch捕获到FeignException该，并且也有相关的重试机制
throw FeignException.errorExecuting(request, var12);
}
// 获取请求调用消耗时长
long elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
if (this.decoder != null) {
// 根据Feign的解码器将返回的数据处理成该方法的返回类型
return this.decoder.decode(response, this.metadata.returnType());
} else {
// 如果没有自定义的解码器，就直接调用当前异步返回方法类型其核心还是使用默认的Decoder
CompletableFuture<Object> resultFuture = new CompletableFuture();
this.asyncResponseHandler.handleResponse(resultFuture, this.metadata.configKey(), response, this.metadata.returnType(), elapsedTime);
try {
if (!resultFuture.isDone()) {
throw new IllegalStateException("Response handling not done");
} else {
return resultFuture.join();
}
} catch (CompletionException var13) {
Throwable cause = var13.getCause();
if (cause != null) {
throw cause;
} else {
throw var13;
}
}
}
}
根据上面的代码能够看到，其实调用的方式还是使用的 FeignBlockingLoadBalancerClient而 FeignBlockingLoadBalancerClient也属于 LoadBalancer组件的范畴，所以在进行Eureka服务地址选择时，还是走的 LoadBalancer的那一套东西，只不过在获取到相应的请求地址时，会生成一个 Request请求，最核心还是调用 feign.Client.Default#convertResponse方法进行http调用
5、总结
从上面的源码解析，我们能够看到，OpenFeign的整体流程是
1、先根据 @EnableFeignClients注解所在的包名进行扫描下面所有的 @FeignClient接口，并且配置相关配置信息参数
2、获取到所有标注 @FeignClient接口进行循环创建 BeanDefinitionBuilder Spring Bean
3、每个BeanDefinitionBuilder都是一个 FactoryBean所以就会有返回一个通过 JDK 动态代理生成的对象进行返回给 Spring容器，而在通过Spring注入时，就会将动态代理过后的对象注入进去。即、FeignInvocationHandler
4、在调用 Feign Client接口时通过 FeignInvocationHandler动态代理对象进行远程调用 Eureka远程服务，主要是根据 FeignBlockingLoadBalancerClient通过 LoadBalancer组件进行获取对应的服务请求地址并且组装成一个 Request，通过 feign.Client.Default#convertResponse方法进行Http调用
5、在调用结束后通过返回的数据进行 Decoder解码返回参数，返回给调用方法
自此以上 OpenFeign主要流程已全部解析完毕