1 概述
在Spring Cloud微服务体系中，服务于服务之间的调用，是避免不了的，
我们可以通过Http请求的方式进行调用，当然这样并不是一个很好的选择，
OpenFeign是一个http请求调用的轻量级框架，可以以Java接口注解的方式调用Http请求，
而不用像Java中通过封装HTTP请求报文的方式直接调用。
同时OpenFeign的使用也比较简单，一般我们通过两个注解进行配置即可，
`@FeignClient`和`@EnableFeignClients`.
2 注解的属性含义
- @EnableFeignClients
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {
//属性的别名，可类比：@ComponentScan注解
String[] value() default {};
//扫描包下带注释的组件
String[] basePackages() default {};
//basePackages() 的类型安全的替代方法，用于指定要扫描带注释的组件的软件包，指定类别的包装将被扫描。
Class<?>[] basePackageClasses() default {};
//适用于所有自定义@Configuration,可以包含组成客户端的部分的@Bean
Class<?>[] defaultConfiguration() default {};
//用@FeignClient注释的类的列表，如果不为空，则禁用类路径*扫描。
Class<?>[] clients() default {};
}
- @FeignClient
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface FeignClient {
//指定FeignClient的名称，如果项目使用了Ribbon，name属性会作为微服务的名称，用于服务发现
@AliasFor("name")
String value() default "";
/**
* The service id with optional protocol prefix. Synonym for {@link #value() value}.
* @deprecated use {@link #name() name} instead
* @return the service id with optional protocol prefix
*/
@Deprecated
String serviceId() default "";
/**
* This will be used as the bean name instead of name if present, but will not be used
* as a service id.
* @return bean name instead of name if present
*/
String contextId() default "";
//指定FeignClient的名称，如果项目使用了Ribbon，name属性会作为微服务的名称，用于服务发现
@AliasFor("value")
String name() default "";
/**
* @return the <code>@Qualifier</code> value for the feign client.
*/
String qualifier() default "";
//url一般用于调试，可以手动指定@FeignClient调用的地址
String url() default "";
//当发生http 404错误时，如果该字段位true，会调用decoder进行解码，否则抛出FeignException
boolean decode404() default false;
//Feign配置类，可以自定义Feign的Encoder、Decoder、LogLevel、Contract
Class<?>[] configuration() default {};
//定义容错的处理类，当调用远程接口失败或超时时，会调用对应接口的容错逻辑，fallback指定的类必须实现@FeignClient标记的接口
Class<?> fallback() default void.class;
//工厂类，用于生成fallback类示例，通过这个属性我们可以实现每个接口通用的容错逻辑，减少重复的代码
Class<?> fallbackFactory() default void.class;
//定义当前FeignClient的统一前缀，当我们项目中配置了server.context-path,server.servlet-path时使用
String path() default "";
/**
* @return whether to mark the feign proxy as a primary bean. Defaults to true.
*/
boolean primary() default true;
}
3 版本信息
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
<version>2.1.4.RELEASE</version>
</dependency>
4 学习思路
接下来我们通过思考下面的问题，进行源码的学习:
- @FeignClient被注入的接口，如何被解析和注入的呢
- @Autowired可以针对@FeignClient注入实例对象，是如何注入的，注入的又是什么对象呢
- FeingClient声明的接口被解析后，以什么方式存储和调用的呢
- OpenFeign如何集成Ribbon实现负载均衡的呢
- 问题剖析
@FeignClient(value = "${feign.baseInfoManagement.name:baseInfoManagement/baseInfoManagement}")
public interface BaseInfoManagementFeign {
}
@SpringBootApplication(exclude = {FlywayAutoConfiguration.class})
@ComponentScan(basePackages = {"com.hikvision.idatafusion.**"})
@MapperScan(basePackages = {"com.hikvision.**.dao.**", "com.hikvision.**.mapper.**"})
@EnableFeignClients(basePackages = {"com.hikvision.idatafusion.**"})
@EnableDiscoveryClient
@EnableScheduling
public class ResourceControlApplication {
public static void main(String[] args) {
SpringApplication.run(ResourceControlApplication.class, args);
}
}
OpenFeign注解扫描的解析
那么我们知道哪些可以把外部bean注入到ioc容器的方法呢？
- ImportSelector (批量注入bean，例如spring boot自动装配原理)
- ImportBeanDefinitionRegister (动态构建bean)
- BeanFactoryPostProcessor (spring提供的扩展，首先他必须是一个Bean)
- SpringFactoryLoad (spi的机制)
ImportBeanDefinitionRegister可以实现动态bean的构建，也就是我们可以把自己需要的bean注入到ioc容器中
下面通过一个案例进行演示：
5 案例演示
下面我们先通过一个案例去通过spring提供的扩展类ImportBeanDefinitionRegister演示如何让一个Bean注入到Ioc容器中，因为OpenFeign中也是用的这种方式，这用有助于我们对于源码的理解。
6 源码分析
我们首先分析@EnableFeignClients注解
- @EnableFeignClients
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {
...
}
我们可以看到@EnableFeignClients内部有一个@Import注解，@Import注解,功能就是和Spring XML 里面 的 一样. @Import注解是用来导入配置类或者一些需要前置加载的类.
@Import支持 三种方式
1.带有@Configuration的配置类(4.2 版本之前只可以导入配置类，4.2版本之后 也可以导入 普通类)
2.ImportSelector 的实现
3.ImportBeanDefinitionRegistrar 的实现
这里FeignClientsRegistrar类就是通过第三种方式导入到ioc容器中的
class FeignClientsRegistrar
implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata,
BeanDefinitionRegistry registry) {
//注册@EnableFeignClients中定义defaultConfiguration属性下的类，包装成FeignClientSpecification，注册到Spring容器。
//在@FeignClient中有一个属性：configuration，这个属性是表示各个FeignClient自定义的配置类，
//后面也会通过调用registerClientConfiguration方法来注册成FeignClientSpecification到容器。
//所以，这里可以完全理解在@EnableFeignClients中配置的是做为兜底的配置，在各个@FeignClient配置的就是自定义的情况。
registerDefaultConfiguration(metadata, registry);
//重点分析该方法 *****
//收集所有标记了@FeignClient的接口,并把接口对应的代理类的实现注入到ioc容器中
registerFeignClients(metadata, registry);
}
}
FeignClientsRegistrar我们可以看到确实实现了ImportBeanDefinitionRegistrar接口，并实现了registerBeanDefinitions方法。
- registerFeignClients(metadata, registry);
该方法的主要步骤如下：
1.查找FeignClient
2.得到一个@FeignClient的接口的集合
3.解析@FeignClient注解中的元数据信息
4.遍历这些FeignClient接口，注入一个动态Bean实例（通过动态代理的方式实现）
public void registerFeignClients(AnnotationMetadata metadata,
BeanDefinitionRegistry registry) {
ClassPathScanningCandidateComponentProvider scanner = getScanner();
scanner.setResourceLoader(this.resourceLoader);
Set<String> basePackages;
//收集该注解的元数据信息：value ，basePackages ，basePackageClasses 等
Map<String, Object> attrs = metadata
.getAnnotationAttributes(EnableFeignClients.class.getName());
AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
FeignClient.class);
//获取@EnableFeignClients注解中的client属性
final Class<?>[] clients = attrs == null ? null
: (Class<?>[]) attrs.get("clients");
//如果没有配置client相关属性会进入到这里
if (clients == null || clients.length == 0) {
//添加需要扫描的注解@FeignClient
scanner.addIncludeFilter(annotationTypeFilter);
//该方法就是根据@EnableFeignClients注解的属性信息去获取需要扫描的路径
basePackages = getBasePackages(metadata);
}
//基于client属性配置的类以及类所在的包进行扫描
else {
final Set<String> 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)));
}
//遍历所有的路径获取标有@FeignClient注解的接口
for (String basePackage : basePackages) {
//找到候选的对象（标有@FeignClient注解的接口）封装成BeanDefinition对象
Set<BeanDefinition> 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");
//获取每个接口中定义的元数据信息，即@FeignClient注解中配置的属性值例如，value,name,path,url等
Map<String, Object> attributes = annotationMetadata
.getAnnotationAttributes(
FeignClient.class.getCanonicalName());
//获取name的属性值
String name = getClientName(attributes);
//注册被调用客户端配置
//注册(微服务名).FeignClientSpecification类型的bean
//对beanname的名称进行拼接: name.FeignClientSpecification ，例如我们上面获取的naem值等于：${feign.baseInfoManagement.name:baseInfoManagement/baseInfoManagement}
//拼接后：${feign.baseInfoManagement.name:baseInfoManagement/baseInfoManagement}.FeignClientSpecification
registerClientConfiguration(registry, name,
attributes.get("configuration"));
注册 FeignClient 重点分析*****
registerFeignClient(registry, annotationMetadata, attributes);
}
}
}
}
protected Set<String> getBasePackages(AnnotationMetadata importingClassMetadata) {
//@EnableFeignClients 元数据信息就是我们在该注解中配置的key:value值
Map<String, Object> attributes = importingClassMetadata
.getAnnotationAttributes(EnableFeignClients.class.getCanonicalName());
//遍历属性信息，拿到需要扫描的路径
Set<String> basePackages = new HashSet<>();
for (String pkg : (String[]) attributes.get("value")) {
if (StringUtils.hasText(pkg)) {
basePackages.add(pkg);
}
}
for (String pkg : (String[]) attributes.get("basePackages")) {
if (StringUtils.hasText(pkg)) {
basePackages.add(pkg);
}
}
for (Class<?> clazz : (Class[]) attributes.get("basePackageClasses")) {
basePackages.add(ClassUtils.getPackageName(clazz));
}
if (basePackages.isEmpty()) {
basePackages.add(
ClassUtils.getPackageName(importingClassMetadata.getClassName()));
}
return basePackages;
}
- registerFeignClient
把接口对应的代理类注入到ioc容器中：注册 FeignClient，组装BeanDefinition，实质是一个FeignClientFactoryBean，然后注册到Spring IOC容器。
private void registerFeignClient(BeanDefinitionRegistry registry,
AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
//获取到标注了@FeignClient注解的接口全路径：com.train.service.feign.BaseInfoManagementFeign
String className = annotationMetadata.getClassName();
//构建FeignClientFactoryBean类型的BeanDefinitionBuilder
BeanDefinitionBuilder definition = BeanDefinitionBuilder
.genericBeanDefinition(FeignClientFactoryBean.class);
//属性值校验
validate(attributes);
//将属性设置到 FeignClientFactoryBean 中，也就是我们在@FeignClient中配置的属性值
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注入的类型，按类型注入
definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
String alias = contextId + "FeignClient";
AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
boolean primary = (Boolean) attributes.get("primary"); // has a default, won't be
// null
beanDefinition.setPrimary(primary);
String qualifier = getQualifier(attributes);
if (StringUtils.hasText(qualifier)) {
alias = qualifier;
}
//将BeanDefinition包装成BeanDefinitionHolder，用于注册
BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
new String[] { alias });
//注册 BeanDefinition
BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
}
分析到这里其实只是把我们的代理类封装成BeanDefinition对象，但是并没有实例化，在spring中我们知道，加载到IOC容器中的类都要先封装成BeanDefinition对象，因为我们不仅需要类的类的信息，还可能配置了一些其他属性，例如@Lazy，@DependsOn等。那这里后续肯定是通过sring进行实例化的，这里就不做过多分析，主要流程如下：
- Spring容器启动，调用AbstractApplicationContext#refresh方法，
- 在refresh方法内部调用finishBeanFactoryInitialization方法对单例bean进行初始化，
finishBeanFactoryInitialization方法调用getBean获取name对应的bean实例，如果不存在，则创建一个，即调用doGetBean方法。 - doGetBean调用createBean方法，createBean方法调用doCreateBean方法。
- doCreateBean()方法主要是根据 beanName、mbd、args，使用对应的策略创建 bean 实例，并返回包装类 BeanWrapper。
- doCreateBean方法中调用populateBean对 bean 进行属性填充；其中，可能存在依赖于其他 bean 的属性，则会递归初始化依赖的 bean 实例，初始化阶段又涉及到三级缓存以及AOP的实现。
- FeignClientFactoryBean
上面我们分析会构建FeignClientFactoryBean类型的BeanDefinitionBuilder，那么这个对象是什么呢，我们接下来进行分析：
class FeignClientFactoryBean
implements FactoryBean<Object>, InitializingBean, ApplicationContextAware {
}
首先我们可以看到它实现了Spring中给我们提供扩展使用的三个类分别是FactoryBean,InitializingBean,ApplicationContextAware 。
-
InitializingBean的作用
1：spring为bean提供了两种初始化bean的方式，实现InitializingBean接口，实现afterPropertiesSet方法，或者在配置文件中同过init-method指定，两种方式可以同时使用
2：实现InitializingBean接口是直接调用afterPropertiesSet方法，比通过反射调用init-method指定的方法效率相对来说要高点。但是init-method方式消除了对spring的依赖
3：如果调用afterPropertiesSet方法时出错，则不调用init-method指定的方法。 -
ApplicationContextAware
通过它Spring容器会自动把上下文环境对象调用ApplicationContextAware接口中的setApplicationContext方法,可以通过这个上下文环境对象得到Spring容器中的Bean
3. FactoryBean的作用（此处重点分析）
FactoryBean我们应该都很熟悉，一种Bean创建的一种方式，对Bean的一种扩展。对于复杂的Bean对象初始化创建使用其可封装对象的创建细节。那我我们肯定要看到getObject()方法了呀：
注意：这里涉及到一个面试题 BeanFactory vs FactoryBean。
@Override
public Object getObject() throws Exception {
return getTarget();
}
<T> T getTarget() {
//从applicationContext取出FeignContext，FeignContext继承了NamedContextFactory，
//它是用来统一维护feign中各个feign客户端相互隔离的上下文。
//FeignContext注册到容器是在FeignAutoConfiguration上完成的。
FeignContext context = this.applicationContext.getBean(FeignContext.class);
//构建feign.builder，在构建时会向FeignContext获取配置的Encoder，Decoder等各种信息。
//FeignContext在上文中已经提到会为每个Feign客户端分配了一个容器，它们的父容器就是spring容器。
Feign.Builder builder = feign(context);
//如果url为空，则走负载均衡，生成有负载均衡功能的代理类 (重点分析*****)
if (!StringUtils.hasText(this.url)) {
if (!this.name.startsWith("http")) {
this.url = "http://" + this.name;
}
else {
this.url = this.name;
}
this.url += cleanPath();
//@FeignClient没有配置url属性，返回有负载均衡功能的代理对象
return (T) loadBalance(builder, context,
new HardCodedTarget<>(this.type, this.name, this.url));
}
//如果指定了url，则生成默认的代理类
if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
this.url = "http://" + this.url;
}
String url = this.url + cleanPath();
Client client = getOptional(context, Client.class);
if (client != null) {
if (client instanceof LoadBalancerFeignClient) {
// not load balancing because we have a url,
// but ribbon is on the classpath, so unwrap
client = ((LoadBalancerFeignClient) client).getDelegate();
}
builder.client(client);
}
Targeter targeter = get(context, Targeter.class);
return (T) targeter.target(this, builder, context,
new HardCodedTarget<>(this.type, this.name, url));
}
protected <T> T loadBalance(Feign.Builder builder, FeignContext context,
HardCodedTarget<T> target) {
// 从上下文中获取一个 Client，默认是LoadBalancerFeignClient。
//它是在FeignRibbonClientAutoConfiguration这个自动装配类中，通过Import实现的
Client client = getOptional(context, Client.class);
if (client != null) {
builder.client(client);
Targeter targeter = get(context, Targeter.class);
//这里就是为每个接口创建代理类这里有两个实现 HystrixTargeter 、DefaultTargeter
//很显然，如果没有配置 Hystrix ，这里会走 DefaultTargeter
return targeter.target(this, builder, context, target);
}
throw new IllegalStateException(
"No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-netflix-ribbon?");
}
- DefaultTargeter
class DefaultTargeter implements Targeter {
@Override
public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign,
FeignContext context, Target.HardCodedTarget<T> target) {
return feign.target(target);
}
}
- Feign
public <T> T target(Target<T> target) {
//创建一个动态代理类,最终会调用 ReflectiveFeign.newInstance
return build().newInstance(target);
}
public Feign build() {
//这个方法是用来创建一个动态代理的方法，在生成动态代理之前，会根据Contract协议（协议解析规则，解析接口类的注解信息，解析成内部的MethodHandler的处理方式。会解析我们在每个接口中定义的参数，方法类型等。
SynchronousMethodHandler.Factory synchronousMethodHandlerFactory =
new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors, logger,
logLevel, decode404, closeAfterDecode, propagationPolicy);
ParseHandlersByName handlersByName =
new ParseHandlersByName(contract, options, encoder, decoder, queryMapEncoder,
errorDecoder, synchronousMethodHandlerFactory);
//ReflectiveFeign创建一个动态代理类
return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);
}
//target就是我们的原始接口
public <T> T newInstance(Target<T> target) {
//根据接口类和Contract协议解析方式，解析接口类上的方法和注解，转换成内部的MethodHandler处理方式
//nameToHandle集合包含的属性可以看下面的图进行理解
Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);
Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();
List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>();
//遍历接口中的所有方法
for (Method method : target.type().getMethods()) {
//如果是Object中提供的方法，跳过
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)));
}
}
// 基于Proxy.newProxyInstance 为接口类创建动态实现，将所有的请求转换给InvocationHandler 处理。
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;
}
- nameToHandler
-
targetToHandlersByName.apply(target);
targetToHandlersByName.apply(target) :根据Contract协议规则，解析接口类的注解信息，解析成内部表现：targetToHandlersByName.apply(target);会解析接口方法上的注解，从而解析出方法粒度的特定的配置信息，然后生产一个SynchronousMethodHandler 然后需要维护一个<method，MethodHandler>的map，放入InvocationHandler的实现FeignInvocationHandler中。 -
FeignInvocationHandler.invoke
OpenFeign调用过程 :
在前面的分析中，我们知道OpenFeign最终返回的是一个 ReflectiveFeign.FeignInvocationHandler 的对象。那么当客户端发起请求时，会进入到 FeignInvocationHandler.invoke 方法中，这个大家都知道，它是一个动态代理的实现。
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if ("equals".equals(method.getName())) {
try {
Object otherHandler =
args.length > 0 && args[0] != null ? Proxy.getInvocationHandler(args[0]) : null;
return equals(otherHandler);
} catch (IllegalArgumentException e) {
return false;
}
} else if ("hashCode".equals(method.getName())) {
return hashCode();
} else if ("toString".equals(method.getName())) {
return toString();
}
// 利用分发器筛选方法，找到对应的handler 进行处理,也就是根据请求目标对应的url找到需要执行的方法进行调用
return dispatch.get(method).invoke(args);
}
- SynchronousMethodHandler.invoke
而接着，在invoke方法中，会调用 this.dispatch.get(method)).invoke(args) 。this.dispatch.get(method) 会返回一个SynchronousMethodHandler，进行拦截处理。这个方法会根据参数生成完成的RequestTemplate对象，这个对象是Http请求的模版，代码如下。
@Override
public Object invoke(Object[] argv) throws Throwable {
//得到RequestTemplate 对象
RequestTemplate template = buildTemplateFromArgs.create(argv);
Options options = findOptions(argv);
//重试机制的实现
Retryer retryer = this.retryer.clone();
while (true) {
try {
//请求的调用
return executeAndDecode(template, options);
} catch (RetryableException e) {
try {
retryer.continueOrPropagate(e);
} catch (RetryableException th) {
Throwable cause = th.getCause();
if (propagationPolicy == UNWRAP && cause != null) {
throw cause;
} else {
throw th;
}
}
//如果实现了日志类的打印，会打印日志信息
if (logLevel != Logger.Level.NONE) {
logger.logRetry(metadata.configKey(), logLevel);
}
continue;
}
}
}
Object executeAndDecode(RequestTemplate template, Options options) throws Throwable {
Request request = targetRequest(template);
if (logLevel != Logger.Level.NONE) {
logger.logRequest(metadata.configKey(), logLevel, request);
}
Response response;
long start = System.nanoTime();
try {
//发起远程通信
//这里的 client.execute 的 client 的类型是LoadBalancerFeignClient
//走到这里就是我们前门分析的ribbon那一套了，这里不做说明
response = client.execute(request, options);
} catch (IOException e) {
if (logLevel != Logger.Level.NONE) {
logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime(start));
}
throw errorExecuting(request, e);
}
long elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
获取返回结果，并解析
boolean shouldClose = true;
try {
if (logLevel != Logger.Level.NONE) {
response =
logger.logAndRebufferResponse(metadata.configKey(), logLevel, response, elapsedTime);
}
if (Response.class == metadata.returnType()) {
if (response.body() == null) {
return response;
}
if (response.body().length() == null ||
response.body().length() > MAX_RESPONSE_BUFFER_SIZE) {
shouldClose = false;
return response;
}
// Ensure the response body is disconnected
byte[] bodyData = Util.toByteArray(response.body().asInputStream());
return response.toBuilder().body(bodyData).build();
}
if (response.status() >= 200 && response.status() < 300) {
if (void.class == metadata.returnType()) {
return null;
} else {
Object result = decode(response);
shouldClose = closeAfterDecode;
return result;
}
} else if (decode404 && response.status() == 404 && void.class != metadata.returnType()) {
Object result = decode(response);
shouldClose = closeAfterDecode;
return result;
} else {
throw errorDecoder.decode(metadata.configKey(), response);
}
} catch (IOException e) {
if (logLevel != Logger.Level.NONE) {
logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime);
}
throw errorReading(request, response, e);
} finally {
if (shouldClose) {
ensureClosed(response.body());
}
}
}
上面主要进行的步骤就是，我们根据@FeignClient注解定义的接口，会通过动态代理给每个接口生成一个代理类，每个代理类中保存了URL和目标方法的对应管理，来调用对应的方法。
- 总体过程：
-
主程序入口添加了@EnableFeignClients注解开启对FeignClient扫描加载处理。根据Feign Client的开发规范，定义接口并加@FeignClient注解。
-
当程序启动时，会进行包扫描，扫描所有@FeignClients的注解的类，并且将这些信息注入Spring IOC容器中，当定义的的Feign接口中的方法被调用时，通过JDK动态代理方式，来生成具体的RequestTemplate。当生成代理时，Feign会为每个接口方法创建一个RequestTemplate对象，该对象封装可HTTP请求需要的全部信息，如请求参数名，请求方法等信息都是在这个过程中确定的。
-
然后RequestTemplate生成Request，然后把Request交给Client去处理，这里指的Client可以是JDK原生的URLConnection、Apache的HttpClient、也可以是OKhttp，最后Client被封装到LoadBalanceClient类，这个类结合Ribbon负载均衡发起服务之间的调用。
