Fegin的学习笔记

feign调用ribbon的关键类就是该类。该类通过继承AbstractLoadBalancerAwareClient并实现IClient接口完成了对ribbon负载均衡的封装。

public class FeignLoadBalancer extends
		AbstractLoadBalancerAwareClient {
		//完成最终的请求
		public RibbonResponse execute(RibbonRequest request, IClientConfig configOverride)
			throws IOException {
		Request.Options options;
		if (configOverride != null) {
			RibbonProperties override = RibbonProperties.from(configOverride);
			options = new Request.Options(override.connectTimeout(this.connectTimeout),
					override.readTimeout(this.readTimeout));
		}
		else {
			options = new Request.Options(this.connectTimeout, this.readTimeout);
		}
		//跟到execute里可以看到底层就是jdk的http请求
		Response response = request.client().execute(request.toRequest(), options);
		return new RibbonResponse(request.getUri(), response);
	}
	//对IClient中ClientRequest的实现
	protected static class RibbonRequest extends ClientRequest implements Cloneable        {
	      ...省略代码
    }
    
   //对IClient中IResponse的实现
   protected static class RibbonResponse implements IResponse {
		 ...省略代码
  }
}

至此feign和ribbon的调用关系已经梳理清楚了。总结如下
1 ribbon提供一套负载均衡api类LoadBalancerContext
2 ribbon定义了一套请求标准IClient接口
3 ribbon提供了一个抽象类AbstractLoadBalancerAwareClient，通过一个模板方法将上边两点完美的封装到一起。
4 feign的FeignLoadBalancer类继承了AbstractLoadBalancerAwareClient并实现了IClient标准，最终拥有的负载均衡的能力

通过对第一个问题的探索，可以了解到feign的核心类就是FeignLoadBalancer。所以这次探索的目的有两个
1 找到feign的入口类
2 从入口类入手找到FeignLoadBalancer类

这个注解就是feign的入口。其源头来至springboot自动装配，这里不展开了。把这里当作起点

@import(FeignClientsRegistrar.class)//跟这个注册器
public @interface EnableFeignClients {
    ...省略代码
}

该类主要有如下几个功能
1 确认是否开启了feign的自动装配
2 找到系统中所有被@FeignClient修饰的接口 [这个注解中封装了BeanDefinition所需要的数据]
3 通过FeignClientFactoryBean类为每一个@FeignClient修饰的接口 创建代理类，并将代理类交由spring容器管理

class FeignClientsRegistrar
		implements importBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
	//入口方法	
    @Override
	public void registerBeanDefinitions(Annotationmetadata metadata,
			BeanDefinitionRegistry registry) {
		registerDefaultConfiguration(metadata, registry);
		//跟这个方法
		registerFeignClients(metadata, registry);
	}
	//注册客户端
    public void registerFeignClients(Annotationmetadata metadata,
			BeanDefinitionRegistry registry) {
		ClassPathScanningCandidateComponentProvider scanner = getScanner();
		scanner.setResourceLoader(this.resourceLoader);

		Set basePackages;
		//看项目中有么有EnableFeignClients注解，是否开启了自动装配feign
		Map attrs = metadata
				.getAnnotationAttributes(EnableFeignClients.class.getName());
		AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
				FeignClient.class);
		final Class[] clients = attrs == null ? null
				: (Class[]) attrs.get("clients");
		if (clients == null || clients.length == 0) {
			scanner.addIncludeFilter(annotationTypeFilter);
			basePackages = getbasePackages(metadata);
		}
		else {
			final Set 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) {
			Set 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");
					//拿到注解中的元数据
					Map attributes = annotationmetadata
							.getAnnotationAttributes(
									FeignClient.class.getCanonicalName());

					String name = getClientName(attributes);
					registerClientConfiguration(registry, name,
							attributes.get("configuration"));
                    //重点在这里 继续跟这里
					registerFeignClient(registry, annotationmetadata, attributes);
				}
			}
		}
	}
    //真正的注册客户端
    private void registerFeignClient(BeanDefinitionRegistry registry,
			Annotationmetadata annotationmetadata, Map attributes) {
		String className = annotationmetadata.getClassName();
		BeanDefinitionBuilder definition = BeanDefinitionBuilder
		         //重点在这里
		         //FeignClientFactoryBean本质是一个FactoryBean
		         //需要了解spring的一些知识，这里不展开了直接说结论
		         //所有被@FeignClient修饰的接口对应的代理类其实就来自于FeignClientFactoryBean的getObject方法
		         //后面继续跟FeignClientFactoryBean的getObject方法
				.genericBeanDefinition(FeignClientFactoryBean.class);
		validate(attributes);
		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"));
		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;
		}

		BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
				new String[] { alias });
		BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
	}

}

该类的作用就是为所有被@FeignClient修饰的接口生成代理对象

class FeignClientFactoryBean
		implements FactoryBean