例子这次先不写了。。。间接源码走起。局部设计跟Ribbon一样，这边就不在累述，倡议先看Ribbon系列。
仍然从spring.factories说起。留神到这里有这几个类：FeignAutoConfiguration、FeignRibbonClientAutoConfiguration。
启动
FeignAutoConfiguration
加载FeignContext，这里会赋值FeignClientSpecification的汇合，
前面说FeignClientSpecification类怎么来的，其实跟Ribbon用的是同一个办法。
FeignContext的defaultConfigType是FeignClientsConfiguration.class，这个和Ribboon用法一样，前面会加载。
@Autowired(required = false)
private List<FeignClientSpecification> configurations = new ArrayList<>();
@Bean
public FeignContext feignContext() {
FeignContext context = new FeignContext();
context.setConfigurations(this.configurations);
return context;
}另一个加载的是HystrixTargeter，尽管是HystrixTargeter，如果Feign.Builder不是feign.hystrix.HystrixFeign.Builder，前面调用的还是Feign.Builder的target办法。
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(name = "feign.hystrix.HystrixFeign")
protected static class HystrixFeignTargeterConfiguration {
@Bean
@ConditionalOnMissingBean
public Targeter feignTargeter() {
return new HystrixTargeter();
}
}FeignRibbonClientAutoConfiguration
加载CachingSpringLoadBalancerFactory，这个类会注入SpringClientFactory，看过了Ribbon，是不是就晓得了他要做什么。没错，他会创立一个ILoadBalancer，用于负载平衡。
@Bean
@Primary
@ConditionalOnMissingBean
@ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
public CachingSpringLoadBalancerFactory cachingLBClientFactory(
SpringClientFactory factory) {
return new CachingSpringLoadBalancerFactory(factory);
}FeignRibbonClientAutoConfiguration还import了DefaultFeignLoadBalancedConfiguration类，在这个类，会创立一个LoadBalancerFeignClient，前面须要的Client就是他了。
@Bean
@ConditionalOnMissingBean
public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
SpringClientFactory clientFactory) {
return new LoadBalancerFeignClient(new Client.Default(null, null), cachingFactory,
clientFactory);
}
@EnableFeignClients
咱们应用feign的时候，都会应用这个注解，注解里Import了FeignClientsRegistrar这个类，FeignClientsRegistrar实现了ImportBeanDefinitionRegistrar接口，调用registerBeanDefinitions办法。这个办法做了两件事，一件事是注册FeignClientSpecification类，前面会注入到下面的FeignContext中，这个用法跟Ribbon – 几种自定义负载平衡策略提的一样。另外一件事就是创立FactoryBean。
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata,
BeanDefinitionRegistry registry) {
// 注册FeignClientSpecification类
registerDefaultConfiguration(metadata, registry);
// 通过注解的信息注册FeignClientFactoryBean类，
//这个是FactoryBean，所以容器fresh的时候会调用他的getObject办法
registerFeignClients(metadata, registry);
}这个办法就会扫描EnableFeignClients和FeignClient的注解，而后注册FeignClientFactoryBean类型的bean，这个是FactoryBean，所以容器fresh的时候会调用他的getObject办法。
public void registerFeignClients(AnnotationMetadata metadata,
BeanDefinitionRegistry registry) {
LinkedHashSet<BeanDefinition> candidateComponents = new LinkedHashSet<>();
// 扫描EnableFeignClients注解
Map<String, Object> attrs = metadata
.getAnnotationAttributes(EnableFeignClients.class.getName());
AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
FeignClient.class);
final Class<?>[] clients = attrs == null ? null
: (Class<?>[]) attrs.get("clients");
// 如果EnableFeignClients没有配置clients信息，扫描FeignClient注解
if (clients == null || clients.length == 0) {
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 {
// 如果配置clients信息，就疏忽FeignClient注解，间接读取clients信息
for (Class<?> clazz : clients) {
candidateComponents.add(new AnnotatedGenericBeanDefinition(clazz));
}
}
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<String, Object> attributes = annotationMetadata
.getAnnotationAttributes(FeignClient.class.getCanonicalName());
String name = getClientName(attributes);
registerClientConfiguration(registry, name,
attributes.get("configuration"));
// 注册FeignClientFactoryBean
registerFeignClient(registry, annotationMetadata, attributes);
}
}
}FeignClientFactoryBean#getObject
getObject会调用getTarget办法，他会创立一个Feign.Builder，创立的时候会传FeignContext，这个FeignContext的加载在下面曾经提过了。而后调用loadBalance办法返回代理对象，这个代理就是前面近程调用用的。
<T> T getTarget() {
FeignContext context = applicationContext.getBean(FeignContext.class);
Feign.Builder builder = feign(context);
if (!StringUtils.hasText(url)) {
if (!name.startsWith("http")) {
url = "http://" + name;
}
else {
url = name;
}
url += cleanPath();
return (T) loadBalance(builder, context,
new HardCodedTarget<>(type, name, url));
}
// 间接ip的模式，代码略
}FeignClientFactoryBean#feign
创立一个Feign.Builder，FeignContext#getInstance，这个类继承了NamedContextFactory，流程和ribbon的SpringClientFactory#getContext一样。下面提到FeignContext的defaultConfigType是FeignClientsConfiguration.class，所以还会加载OptionalDecoder解码、SpringEncoder编码、SpringMvcContract，解析MVC注解、NEVER_RETRY重试、DefaultFeignLoggerFactory日志、FeignClientConfigurer、Feign.builder()。
protected Feign.Builder feign(FeignContext context) {
FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
Logger logger = loggerFactory.create(type);
// @formatter:off
Feign.Builder builder = get(context, Feign.Builder.class)
// required values
.logger(logger)
.encoder(get(context, Encoder.class))
.decoder(get(context, Decoder.class))
.contract(get(context, Contract.class));
// @formatter:on
// 整合配置Feign.Builder
configureFeign(context, builder);
return builder;
}FeignClientFactoryBean#loadBalance
这里获取Client和Targeter类，Client就是下面的LoadBalancerFeignClient，他是所有共享的。Targeter是HystrixTargeter，他是serviceId公有的。下面曾经提了他最终是调用Feign.Builder#target。
protected <T> T loadBalance(Feign.Builder builder, FeignContext context,
HardCodedTarget<T> target) {
Client client = getOptional(context, Client.class);
if (client != null) {
builder.client(client);
Targeter targeter = get(context, Targeter.class);
return targeter.target(this, builder, context, target);
}
// 异样略
}Feign.Builder#target
build办法是构建一个ReflectiveFeign对象，newInstance是生成代理对象。
public <T> T target(Target<T> target) {
return build().newInstance(target);
}build办法中，ReflectiveFeign创立的时候传了ParseHandlersByName,InvocationHandlerFactory,SynchronousMethodHandler三个对象。
public Feign build() {
// 其余略
return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);
}代理对象生成，生成后，前面对代理对象的拜访，都会调用FeignInvocationHandler#invoke办法。
public <T> T newInstance(Target<T> target) {
// ParseHandlersByName是通过Contrac用来解析接口定义。
Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);
// 给每个办法创立一个SynchronousMethodHandler对象
Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();
List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>();
for (Method method : target.type().getMethods()) {
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)));
}
}
// 创立一个InvocationHandler对象，这里是FeignInvocationHandler
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;
}总结
启动的时候，为每个接口，生成代理对象。
办法调用
FeignInvocationHandler#invoke
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 其余略
//dispatch.get(method)获取的是SynchronousMethodHandler
return dispatch.get(method).invoke(args);
}SynchronousMethodHandler#invoke
调用LoadBalancerFeignClient#execute，LoadBalancerFeignClient加载下面曾经讲过了。
public Object invoke(Object[] argv) throws Throwable {
RequestTemplate template = buildTemplateFromArgs.create(argv);
// 其余略
return executeAndDecode(template, options);
// 其余略
}
Object executeAndDecode(RequestTemplate template, Options options) throws Throwable {
// 其余略
response = client.execute(request, options);
// 其余略
}LoadBalancerFeignClient#execute
@Override
public Response execute(Request request, Request.Options options) throws IOException {
try {
// 获取Uri
URI asUri = URI.create(request.url());
// 获取serviceId
String clientName = asUri.getHost();
URI uriWithoutHost = cleanUrl(request.url(), clientName);
FeignLoadBalancer.RibbonRequest ribbonRequest = new FeignLoadBalancer.RibbonRequest(
this.delegate, request, uriWithoutHost);
IClientConfig requestConfig = getClientConfig(options, clientName);
// 获取FeignLoadBalancer，通过FeignLoadBalancer调用申请
return lbClient(clientName)
.executeWithLoadBalancer(ribbonRequest, requestConfig).toResponse();
}
catch (ClientException e) {
IOException io = findIOException(e);
if (io != null) {
throw io;
}
throw new RuntimeException(e);
}
}lbClientFactory是CachingSpringLoadBalancerFactory，所以调用CachingSpringLoadBalancerFactory#create的create办法。
CachingSpringLoadBalancerFactory有个相熟的SpringClientFactory对象，他负责获取ILoadBalancer、IClientConfig、ServerIntrospector，而后通过这三个构建一个FeignLoadBalancer对象。既然失去了ILoadBalancer，那后续负载平衡的局部就不再持续了，参考Ribbon – 负载平衡流程。
private FeignLoadBalancer lbClient(String clientName) {
return this.lbClientFactory.create(clientName);
}
public FeignLoadBalancer create(String clientName) {
FeignLoadBalancer client = this.cache.get(clientName);
if (client != null) {
return client;
}
IClientConfig config = this.factory.getClientConfig(clientName);
ILoadBalancer lb = this.factory.getLoadBalancer(clientName);
ServerIntrospector serverIntrospector = this.factory.getInstance(clientName,
ServerIntrospector.class);
client = this.loadBalancedRetryFactory != null
? new RetryableFeignLoadBalancer(lb, config, serverIntrospector,
this.loadBalancedRetryFactory)
: new FeignLoadBalancer(lb, config, serverIntrospector);
this.cache.put(clientName, client);
return client;
}总结
次要是通过代理对象，而后调用Ribbon进行负载平衡。咱们这边只讲述了主流程，怎么构建HTTP申请，怎么解决返回后果，都略过了。。。。。
发表回复