概括
Feign是Netflix开发的声明式、模板化的HTTP客户端，其灵感来自Retrofit、JAXRS-2.0以及WebSocket。 Feign可帮助我们更加便捷、优雅地调用HTTP API。 Feign支持多种注解，例如Feign自带的注解或者JAX-RS注解等。Spring Cloud openfeign对Feign进行了 增强，使其支持Spring MVC注解，另外还整合了Ribbon和Eureka，从而使得Feign的使用更加方便
OpenFeign源码解析
我们先看下添加的依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
可以看到starter？看到这个第一反应就是和springboot的自动装配联系在一起，我们去看下fascories文件
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.cloud.openfeign.ribbon.FeignRibbonClientAutoConfiguration,\
org.springframework.cloud.openfeign.FeignAutoConfiguration,\
org.springframework.cloud.openfeign.encoding.FeignAcceptGzipEncodingAutoConfiguration,\
org.springframework.cloud.openfeign.encoding.FeignContentGzipEncodingAutoConfiguration
FeignAutoConfiguration 自动装配 FeignContext 和 Targeter，以及 Client 配置。
FeignContext 是每个 FeignClient 的装配上下文，默认的配置是 FeignClientsConfiguration
Targeter 有两种实现：一是 DefaultTargeter，直接调用 Feign.Builder； 二是 HystrixTargeter，调用 HystrixFeign.Builder，开启熔断。
Client ：自动装配 ApacheHttpClient，OkHttpClient，装配条件不满足时，默认就是 Client.Default。但这些 Client 都没有实现负载均衡。
FeignRibbonClientAutoConfiguration 实现负载均衡，负载均衡是在 Client 这一层实现的。
HttpClientFeignLoadBalancedConfiguration ApacheHttpClient 实现负载均衡
OkHttpFeignLoadBalancedConfiguration OkHttpClient实现负载均衡
DefaultFeignLoadBalancedConfiguration Client.Default实现负载均衡
org.springframework.cloud.openfeign.encoding.FeignAcceptGzipEncodingAutoConfiguration,org.springframework.cloud.openfeign.encoding.FeignContentGzipEncodingAutoConfiguration： 这两个自动化装配类是关于 请求和响应的压缩配置的.
接下来我们通过思考下面的问题，进行源码的学习:
@FeignClient被注入的接口，如何被解析和注入的呢
@Autowired可以针对@FeignClient注入实例对象，是如何注入的，注入的又是什么对象呢
FeingClient声明的接口被解析后，以什么方式存储和调用的呢
OpenFeign如何集成Ribbon实现负载均衡的呢
openfeign和springboot继承需要要用@EnableFeignClients注解：
@SpringBootApplication
@EnableEurekaClient
@EnableHystrix
@EnableFeignClients
public class XXXApiApplication {
public static void main(String[] args) {
SpringApplication.run(XXXApiApplication.class, args);
}
}
那么我们知道哪些可以把外部bean注入到ioc容器的方法呢？
1、importSelector (批量注入bean，例如spring boot自动装配原理)
2、ImportBeanDefinitionRegister (动态构建bean)
3、BeanFactoryPostProcessor (spring提供的扩展，首先他必须是一个Bean)
4、SpringFactoryLoad (spi的机制)
ImportBeanDefinitionRegister可以实现动态bean的构建，也就是我们可以把自己需要的bean注入到ioc容器中
我们点进去看下@EnableFeignClients注解：
@Import支持 三种方式
1.带有@Configuration的配置类(4.2 版本之前只可以导入配置类，4.2版本之后 也可以导入 普通类)
2.ImportSelector 的实现
3.ImportBeanDefinitionRegistrar 的实现
这里FeignClientsRegistrar类就是通过第三种方式导入到ioc容器中的
通过@Impor为我们注入FeignClientsRegistrar.class
FeignClientsRegistrar
实现了ImportBeanDefinitionRegistrar接口并重写了registerBeanDefinitions方法
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata,
BeanDefinitionRegistry registry) {
registerDefaultConfiguration(metadata, registry);
registerFeignClients(metadata, registry);
}
其中registerDefaultConfiguration(metadata, registry);方法主要是获取@EnableFeignClients注解参数defaultConfiguration
重点来了registerFeignClients(metadata, registry)
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;
}
egisterFeignClients(metadata, registry)该方法的主要步骤如下：
1.查找FeignClient
2.得到一个@FeignClient的接口的集合
3.解析@FeignClient注解中的元数据信息
4.遍历这些FeignClient接口，注入一个动态Bean实例（通过动态代理的方式实现）
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，那么这个对象是什么呢，我们接下来进行分析：
首先我们可以看到它实现了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
FactoryBean的作用
实现了factoryBean的接口会调用getObject方法创建bean
@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;
}
在前面的分析中，我们知道OpenFeign最终返回的是一个 ReflectiveFeign.FeignInvocationHandler 的对象。那么当客户端发起请求时，会进入到 FeignInvocationHandler.invoke 方法中，这个大家都知道，它是一个动态代理的实现。
OpenFeign调用过程 :
@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 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负载均衡发起服务之间的调用。
最后附上原理图
下一篇：OpenFeign的使用
