Feign源码解析

文章目录

• • 代码示例
  • 源码解析
  • • 自动装配
    • 初始化
    • 生成动态代理类
    • 调用接口方法
  • 参考资料

代码示例

启动类上添加@EnableFeignClients注解，表示开启feign功能

@SpringBootApplication
@EnableFeignClients
public class ServiceFeignApplication { 
    public static void main(String[] args) { 
        SpringApplication.run( ServiceFeignApplication.class, args );
    }
}
@FeignClient(value = "eureka-client") //指定调用哪个服务
public interface FeignService { 
    @RequestMapping("/hello")
    String helloFromClientOne(@RequestParam("name") String name);
}

源码解析

自动装配

先看feign的自动装配，即看下spring.factories中有哪些自动装配类

其中主要的就是FeignRibbonClientAutoConfiguration和FeignAutoConfiguration
先看下FeignRibbonClientAutoConfiguration，看类名应该是跟ribbon的负载均衡有关，feign默认使用ribbon作为负载均衡器

@ConditionalOnClass({  ILoadBalancer.class, Feign.class })
@Configuration
@AutoConfigureBefore(FeignAutoConfiguration.class)
@EnableConfigurationProperties({  FeignHttpClientProperties.class })
//Order is important here, last should be the default, first should be optional
// see https://github.com/spring-cloud/spring-cloud-netflix/issues/2086#issuecomment-316281653
@Import({  HttpClientFeignLoadBalancedConfiguration.class,
        OkHttpFeignLoadBalancedConfiguration.class,
        DefaultFeignLoadBalancedConfiguration.class })
public class FeignRibbonClientAutoConfiguration { 
    // 用于创建并缓存负载均衡器
    @Bean
    @Primary
    @ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
    public CachingSpringLoadBalancerFactory cachingLBClientFactory(
            SpringClientFactory factory) { 
        return new CachingSpringLoadBalancerFactory(factory);
    }
    @Bean
    @Primary
    @ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
    public CachingSpringLoadBalancerFactory retryabeCachingLBClientFactory(
        SpringClientFactory factory,
        LoadBalancedRetryFactory retryFactory) { 
        return new CachingSpringLoadBalancerFactory(factory, retryFactory);
    }
    @Bean
    @ConditionalOnMissingBean
    public Request.Options feignRequestOptions() { 
        return LoadBalancerFeignClient.DEFAULT_OPTIONS;
    }
}

@AutoConfigureBefore(FeignAutoConfiguration.class)说明FeignRibbonClientAutoConfiguration先于FeignAutoConfiguration加载
看注解CachingSpringLoadBalancerFactory应该是跟重试相关的
Request.Options是超时的设置
该配置类最重要的就是import了另外3个配置类

HttpClientFeignLoadBalancedConfiguration

@Configuration
@ConditionalOnClass(ApacheHttpClient.class)
@ConditionalOnProperty(value = "feign.httpclient.enabled", matchIfMissing = true)
class HttpClientFeignLoadBalancedConfiguration { 
    @Configuration
    @ConditionalOnMissingBean(CloseableHttpClient.class)
    protected static class HttpClientFeignConfiguration { 
    // 创建httpclient以及一些相关配置
    }
        @Bean
        @ConditionalOnMissingBean(Client.class)
        public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
                                  SpringClientFactory clientFactory, HttpClient httpClient) { 
            ApacheHttpClient delegate = new ApacheHttpClient(httpClient);
            return new LoadBalancerFeignClient(delegate, cachingFactory, clientFactory);
        }
}

OkHttpFeignLoadBalancedConfiguration

@Configuration
@ConditionalOnClass(OkHttpClient.class)
@ConditionalOnProperty(value = "feign.okhttp.enabled")
class OkHttpFeignLoadBalancedConfiguration { 
    @Configuration
    @ConditionalOnMissingBean(okhttp3.OkHttpClient.class)
    protected static class OkHttpFeignConfiguration { 
    // 创建OkHttpClient以及一些相关配置
    }
    @Bean
    @ConditionalOnMissingBean(Client.class)
    public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
                              SpringClientFactory clientFactory, okhttp3.OkHttpClient okHttpClient) { 
        OkHttpClient delegate = new OkHttpClient(okHttpClient);
        return new LoadBalancerFeignClient(delegate, cachingFactory, clientFactory);
    }
}

DefaultFeignLoadBalancedConfiguration

@Configuration
class DefaultFeignLoadBalancedConfiguration { 
    @Bean
    @ConditionalOnMissingBean
    public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
                              SpringClientFactory clientFactory) { 
        return new LoadBalancerFeignClient(new Client.Default(null, null),
                cachingFactory, clientFactory);
    }
}

这3个配置类均是用来创建执行request的client的，默认是Client.Default，而ApacheHttpClient和OkHttpClient均需要导入相应的依赖以及开启配置，这说明可以使用HttpClient和OKHttp来替代默认的HttpUrlConnection。该3个配置创建client均使用LoadBalancerFeignClient来包装一层，说明都是带负载均衡功能的client。
FeignAutoConfiguration

@Configuration
@ConditionalOnClass(Feign.class)
@EnableConfigurationProperties({ FeignClientProperties.class, FeignHttpClientProperties.class})
public class FeignAutoConfiguration { 
    @Autowired(required = false)
    private List<FeignClientSpecification> configurations = new ArrayList<>();
    @Bean
    public HasFeatures feignFeature() { 
        return HasFeatures.namedFeature("Feign", Feign.class);
    }
    @Bean
    public FeignContext feignContext() { 
        FeignContext context = new FeignContext();
        context.setConfigurations(this.configurations);
        return context;
    }
    @Configuration
    @ConditionalOnClass(name = "feign.hystrix.HystrixFeign")
    protected static class HystrixFeignTargeterConfiguration { 
        @Bean
        @ConditionalOnMissingBean
        public Targeter feignTargeter() { 
            return new HystrixTargeter();
        }
    }
    @Configuration
    @ConditionalOnMissingClass("feign.hystrix.HystrixFeign")
    protected static class DefaultFeignTargeterConfiguration { 
        @Bean
        @ConditionalOnMissingBean
        public Targeter feignTargeter() { 
            return new DefaultTargeter();
        }
    }
    // the following configuration is for alternate feign clients if
    // ribbon is not on the class path.
    // see corresponding configurations in FeignRibbonClientAutoConfiguration
    // for load balanced ribbon clients.
    @Configuration
    @ConditionalOnClass(ApacheHttpClient.class)
    @ConditionalOnMissingClass("com.netflix.loadbalancer.ILoadBalancer")
    @ConditionalOnMissingBean(CloseableHttpClient.class)
    @ConditionalOnProperty(value = "feign.httpclient.enabled", matchIfMissing = true)
    protected static class HttpClientFeignConfiguration { 
        private final Timer connectionManagerTimer = new Timer(
                "FeignApacheHttpClientConfiguration.connectionManagerTimer", true);
        @Autowired(required = false)
        private RegistryBuilder registryBuilder;
        private CloseableHttpClient httpClient;
        @Bean
        @ConditionalOnMissingBean(HttpClientConnectionManager.class)
        public HttpClientConnectionManager connectionManager(
                ApacheHttpClientConnectionManagerFactory connectionManagerFactory,
                FeignHttpClientProperties httpClientProperties) { 
            final HttpClientConnectionManager connectionManager = connectionManagerFactory
                    .newConnectionManager(httpClientProperties.isDisableSslValidation(), httpClientProperties.getMaxConnections(),
                            httpClientProperties.getMaxConnectionsPerRoute(),
                            httpClientProperties.getTimeToLive(),
                            httpClientProperties.getTimeToLiveUnit(), registryBuilder);
            this.connectionManagerTimer.schedule(new TimerTask() { 
                @Override
                public void run() { 
                    connectionManager.closeExpiredConnections();
                }
            }, 30000, httpClientProperties.getConnectionTimerRepeat());
            return connectionManager;
        }
        @Bean
        public CloseableHttpClient httpClient(ApacheHttpClientFactory httpClientFactory,
                HttpClientConnectionManager httpClientConnectionManager,
                FeignHttpClientProperties httpClientProperties) { 
            RequestConfig defaultRequestConfig = RequestConfig.custom()
                    .setConnectTimeout(httpClientProperties.getConnectionTimeout())
                    .setRedirectsEnabled(httpClientProperties.isFollowRedirects())
                    .build();
            this.httpClient = httpClientFactory.createBuilder().
                    setConnectionManager(httpClientConnectionManager).
                    setDefaultRequestConfig(defaultRequestConfig).build();
            return this.httpClient;
        }
        @Bean
        @ConditionalOnMissingBean(Client.class)
        public Client feignClient(HttpClient httpClient) { 
            return new ApacheHttpClient(httpClient);
        }
        @PreDestroy
        public void destroy() throws Exception { 
            connectionManagerTimer.cancel();
            if(httpClient != null) { 
                httpClient.close();
            }
        }
    }
    @Configuration
    @ConditionalOnClass(OkHttpClient.class)
    @ConditionalOnMissingClass("com.netflix.loadbalancer.ILoadBalancer")
    @ConditionalOnMissingBean(okhttp3.OkHttpClient.class)
    @ConditionalOnProperty(value = "feign.okhttp.enabled")
    protected static class OkHttpFeignConfiguration { 
        private okhttp3.OkHttpClient okHttpClient;
        @Bean
        @ConditionalOnMissingBean(ConnectionPool.class)
        public ConnectionPool httpClientConnectionPool(FeignHttpClientProperties httpClientProperties,
                                                       OkHttpClientConnectionPoolFactory connectionPoolFactory) { 
            Integer maxTotalConnections = httpClientProperties.getMaxConnections();
            Long timeToLive = httpClientProperties.getTimeToLive();
            TimeUnit ttlUnit = httpClientProperties.getTimeToLiveUnit();
            return connectionPoolFactory.create(maxTotalConnections, timeToLive, ttlUnit);
        }
        @Bean
        public okhttp3.OkHttpClient client(OkHttpClientFactory httpClientFactory,
                                           ConnectionPool connectionPool, FeignHttpClientProperties httpClientProperties) { 
            Boolean followRedirects = httpClientProperties.isFollowRedirects();
            Integer connectTimeout = httpClientProperties.getConnectionTimeout();
            Boolean disableSslValidation = httpClientProperties.isDisableSslValidation();
            this.okHttpClient = httpClientFactory.createBuilder(disableSslValidation).
                    connectTimeout(connectTimeout, TimeUnit.MILLISECONDS).
                    followRedirects(followRedirects).
                    connectionPool(connectionPool).build();
            return this.okHttpClient;
        }
        @PreDestroy
        public void destroy() { 
            if(okHttpClient != null) { 
                okHttpClient.dispatcher().executorService().shutdown();
                okHttpClient.connectionPool().evictAll();
            }
        }
        @Bean
        @ConditionalOnMissingBean(Client.class)
        public Client feignClient() { 
            return new OkHttpClient(this.okHttpClient);
        }
    }
}

FeignAutoConfiguration则就是单单feign的自动装配类。可以看到，这个配置类也创建了几个bean，包括FeignContext，Targeter等，Targeter还分为HystrixTargeter和DefaultTargeter，由于feign集成了hystrix，所以这里会创建HystrixTargeter。该配置类也有创建Client的代码，不带负载均衡功能，但是由于FeignRibbonClientAutoConfiguration先生效，已经有Client的bean了，所以这里不会重复创建bean。

自动装配类也就是创建一些相关的bean，具体的入口还得看开启feign的注解。

初始化

先看@EnableFeignClients注解

/** * 扫描被@FeignClient 注解标注的类作为feign客户端 * */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients { 
    String[] value() default { };
    String[] basePackages() default { };
    Class<?>[] basePackageClasses() default { };
    /** * feign全局配置类 */
    Class<?>[] defaultConfiguration() default { };
    /** * 用@FeignClient注释的类列表。如果不为空，则禁用类路径扫描，否则扫描类路径 */
    Class<?>[] clients() default { };
}

看到了@Import(FeignClientsRegistrar.class)
FeignClientsRegistrar实现了ImportBeanDefinitionRegistrar接口，在Spring容器初始化过程中会调用registerBeanDefinitions方法动态注册BeanDefinition，这是第三方框架与Spring集成的常用方式。

@Override
public void registerBeanDefinitions(AnnotationMetadata metadata,
                                    BeanDefinitionRegistry registry) { 
    registerDefaultConfiguration(metadata, registry);
    registerFeignClients(metadata, registry);
}

这里包括两个步骤
1、注册@EnableFeignClients中定义defaultConfiguration属性下的类，包装成FeignClientSpecification，注册到Spring容器

private void registerDefaultConfiguration(AnnotationMetadata metadata,
                                          BeanDefinitionRegistry registry) { 
    Map<String, Object> defaultAttrs = metadata
        .getAnnotationAttributes(EnableFeignClients.class.getName(), true);
    if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) { 
        String name;
        if (metadata.hasEnclosingClass()) { 
            name = "default." + metadata.getEnclosingClassName();
        }
        else { 
            name = "default." + metadata.getClassName();
        }
        // 注册feign的全局配置类
        registerClientConfiguration(registry, name,
                                    defaultAttrs.get("defaultConfiguration"));
    }
}
private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name,
                                         Object configuration) { 
    // 使用BeanDefinitionBuilder构建BeanDefinition，bean类型是FeignClientSpecification
    BeanDefinitionBuilder builder = BeanDefinitionBuilder
        .genericBeanDefinition(FeignClientSpecification.class);
    // 添加FeignClientSpecification构造方法的两个参数
    builder.addConstructorArgValue(name);
    builder.addConstructorArgValue(configuration);
    registry.registerBeanDefinition(
        name + "." + FeignClientSpecification.class.getSimpleName(),
        builder.getBeanDefinition());
}

将所有的全局配置配包装成一个FeignClientSpecification，里面包括name和配置类数组，后面每个feign客户端自定义配置也会分别包装为FeignClientSpecification。
2、对于每个@FeignClient进行解析，并将他们注册到spring容器

public void registerFeignClients(AnnotationMetadata metadata,
        BeanDefinitionRegistry registry) { 
    ClassPathScanningCandidateComponentProvider scanner = getScanner();
    scanner.setResourceLoader(this.resourceLoader);
    Set<String> basePackages;
    Map<String, Object> attrs = metadata
            .getAnnotationAttributes(EnableFeignClients.class.getName());
    // 只过滤出带@FeignClient注解的类 
    AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
            FeignClient.class);
    final Class<?>[] clients = attrs == null ? null
            : (Class<?>[]) attrs.get("clients");
    // 如果@EnableFeignClients注解中的clients属性没有设置，则扫描类路径下的包
    if (clients == null || clients.length == 0) { 
        scanner.addIncludeFilter(annotationTypeFilter);
        basePackages = getBasePackages(metadata);
    }
    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)));
    }
    // 扫描包
    for (String basePackage : basePackages) { 
        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");
                Map<String, Object> attributes = annotationMetadata
                        .getAnnotationAttributes(
                                FeignClient.class.getCanonicalName());
                String name = getClientName(attributes);
                // 把@FeignClient上配置的configuration包装成FeignClientSpecification到容器中
                registerClientConfiguration(registry, name,
                        attributes.get("configuration"));
                // 注册feign客户端
                registerFeignClient(registry, annotationMetadata, attributes);
            }
        }
    }
}

registerFeignClient方法把FeignClientFactoryBean注入到容器，FeignClientFactoryBean用于生产FeignClient

private void registerFeignClient(BeanDefinitionRegistry registry,
        AnnotationMetadata annotationMetadata, Map<String, Object> attributes) { 
    String className = annotationMetadata.getClassName();
    // bean类型是FeignClientFactoryBean
    BeanDefinitionBuilder definition = BeanDefinitionBuilder
            .genericBeanDefinition(FeignClientFactoryBean.class);
    validate(attributes);
    // 设置bean的属性
    definition.addPropertyValue("url", getUrl(attributes));
    definition.addPropertyValue("path", getPath(attributes));
    String name = getName(attributes);
    definition.addPropertyValue("name", name);
    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 = name + "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);
}

FeignClientFactoryBean实现了FactoryBean接口，所以当获取FeignClientFactoryBean实例时是调用FeignClientFactoryBean的getObject方法。

FeignClientSpecification继承了NamedContextFactory.Specification，而NamedContextFactory用于创建子上下文将NamedContextFactory.Specification放入其中。NamedContextFactory中维护一个context的map，name是各个feignClient，value是AnnotationConfigApplicationContext即子上下文，即每个feign客户端都有一个自己的上下文，互不影响，这点跟Ribbon一样。在feign中定义了一个FeignContext继承NamedContextFactory，来统一维护feign中各个feign客户端相互隔离的上下文。

/** * 创建 feign 类实例的工厂。 它为每个客户端名称创建一个 Spring ApplicationContext， * 并从那里提取它需要的 bean */
public class FeignContext extends NamedContextFactory<FeignClientSpecification> { 
    public FeignContext() { 
        super(FeignClientsConfiguration.class, "feign", "feign.client.name");
    }
}
public abstract class NamedContextFactory<C extends NamedContextFactory.Specification>
        implements DisposableBean, ApplicationContextAware { 
    public interface Specification { 
        String getName();
        Class<?>[] getConfiguration();
    }
    /** * 维护每个feign的上下文 */
    private Map<String, AnnotationConfigApplicationContext> contexts = new ConcurrentHashMap<>();
    /** * 维护每个feign的配置类 */
    private Map<String, C> configurations = new ConcurrentHashMap<>();
    private ApplicationContext parent;
    /** * feign默认配置类，FeignClientsConfiguration */
    private Class<?> defaultConfigType;
    private final String propertySourceName;
    private final String propertyName;
    public NamedContextFactory(Class<?> defaultConfigType, String propertySourceName,
            String propertyName) { 
        this.defaultConfigType = defaultConfigType;
        this.propertySourceName = propertySourceName;
        this.propertyName = propertyName;
    }
}

可以看到Feign默认的配置类是FeignClientsConfiguration，这个在后面创建feign的各自容器时都会加载一次。
FeignContext是在上文提到的feign自动装配类中创建的

configurations就是前面注册的每个FeignClientSpecification bean实例。

生成动态代理类

上面说到registerFeignClient方法把FeignClientFactoryBean注入到容器，而FeignClientFactoryBean又实现了FactoryBean接口，所以在创建单例bean时是调用FeignClientFactoryBean的getObject方法来生成feignClient的代理对象（每个feign接口都有一个FeignClientFactoryBean的bean定义，存放了注解信息）

public Object getObject() throws Exception { 
    // 从spring容器获取上文提到的FeignContext对象
    FeignContext context = applicationContext.getBean(FeignContext.class);
    // 从spring容器获取Feign.Builder对象
    Feign.Builder builder = feign(context);
    // 如果@FeignClient的url属性没有配置，则走这里面的逻辑
    // 该例子中url = "", name = "eureka-client"
    // url为空说明走负载均衡
    if (!StringUtils.hasText(this.url)) { 
        String url;
        if (!this.name.startsWith("http")) { 
            url = "http://" + this.name;
        }
        else { 
            url = this.name;
        }
        // url = "http://eureka-client"
        url += cleanPath();
        // 去负载均衡
        return loadBalance(builder, context, new HardCodedTarget<>(this.type,
                                                                   this.name, 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 lod 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 targeter.target(this, builder, context, new HardCodedTarget<>(
        this.type, this.name, url));
}

得到Feign.Builder对象，用来构建Feign对象

protected Feign.Builder feign(FeignContext context) { 
    FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
    Logger logger = loggerFactory.create(this.type);
    // 从各自的容器中获取相关组件来组建Feign
    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
    // 根据优先级从各自的配置文件和.properties文件中加载配置
    // 把application.yml的属性配置进builder中
    configureFeign(context, builder);
    return builder;
}
protected <T> T get(FeignContext context, Class<T> type) { 
    // 从各自的容器中获取相关组件
    T instance = context.getInstance(this.name, type);
    if (instance == null) { 
        throw new IllegalStateException("No bean found of type " + type + " for "
                                        + this.name);
    }
    return instance;
}
public <T> T getInstance(String name, Class<T> type) { 
    // 从map中获取feignClient所属的容器，name就是@FeignClient注解的名称
    AnnotationConfigApplicationContext context = getContext(name);
    if (BeanFactoryUtils.beanNamesForTypeIncludingAncestors(context,
                                                            type).length > 0) { 
        return context.getBean(type);
    }
    return null;
}
protected AnnotationConfigApplicationContext getContext(String name) { 
    // 获取feignClient所属的容器，若没有则创建一个
    if (!this.contexts.containsKey(name)) { 
        synchronized (this.contexts) { 
            if (!this.contexts.containsKey(name)) { 
                // 创建自己的容器，其中会加载自己的配置类和默认配置类
                // 所以默认配置类每个容器中都会加载，如果没有自定义配置，则使用默认的配置组件
                this.contexts.put(name, createContext(name));
            }
        }
    }
    return this.contexts.get(name);
}

这个Feign.Builder也是从spring容器拿的，FeignClientsConfiguration中有两个，一个hystrix的，一个retryer(默认)的

虽说feign集成了hystrix，但看生效条件只有在配置文件中启用hystrix，才会创建第一个。
然后创建HardCodedTarget对象，调用loadBalance方法

protected <T> T loadBalance(Feign.Builder builder, FeignContext context,
                            HardCodedTarget<T> target) { 
    Client client = getOptional(context, Client.class);
    if (client != null) { 
        // 给builder设置client
        builder.client(client);
        Targeter targeter = get(context, Targeter.class);
        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?");
}

通过容器拿到一个Client，自动装配中提到Client注入的是LoadBalancerFeignClient，里面包装了Client.Default，用来执行request请求的

在getObject方法的最后会调用Targeter.target方法来组装对象。通过容器拿到一个Targeter，targeter定义在FeignAutoConfiguration自动装配类中

因为该demo中feign本身集成了hystrix，有HystrixFeign类，所以默认是使用HystrixTargeter

@Override
public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign, FeignContext context,
                    Target.HardCodedTarget<T> target) { 
    // 这个例子中没有启用hystrix，所以Builder不是用hystrix相关的，所以这里直接调用feign.target(target)
    if (!(feign instanceof feign.hystrix.HystrixFeign.Builder)) { 
        return feign.target(target);
    }
    feign.hystrix.HystrixFeign.Builder builder = (feign.hystrix.HystrixFeign.Builder) feign;
    SetterFactory setterFactory = getOptional(factory.getName(), context,
                                              SetterFactory.class);
    if (setterFactory != null) { 
        builder.setterFactory(setterFactory);
    }
    Class<?> fallback = factory.getFallback();
    if (fallback != void.class) { 
        return targetWithFallback(factory.getName(), context, target, builder, fallback);
    }
    Class<?> fallbackFactory = factory.getFallbackFactory();
    if (fallbackFactory != void.class) { 
        return targetWithFallbackFactory(factory.getName(), context, target, builder, fallbackFactory);
    }
    return feign.target(target);
}
public <T> T target(Target<T> target) { 
    return build().newInstance(target);
}
public Feign build() { 
    SynchronousMethodHandler.Factory synchronousMethodHandlerFactory =
        new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors, logger,
                                             logLevel, decode404);
    ParseHandlersByName handlersByName =
        new ParseHandlersByName(contract, options, encoder, decoder,
                                errorDecoder, synchronousMethodHandlerFactory);
    return new ReflectiveFeign(handlersByName, invocationHandlerFactory);
}

这里才看到使用builder创建Feign实例，再利用Feign实例去创建代理对象
ReflectiveFeign

public <T> T newInstance(Target<T> target) { 
    // 根据contract，解析target里面所有方法，包含属性和各种springmvc注解解析，
    // 形成SynchronousMethodHandler
    Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);
    // method与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
    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;
}

使用默认的InvocationHandler工厂类创建InvocationHandler实例，其中维护了Target和Map

public interface InvocationHandlerFactory { 
  InvocationHandler create(Target target, Map<Method, MethodHandler> dispatch);
  /** * Like {@link InvocationHandler#invoke(Object, java.lang.reflect.Method, Object[])}, except for a * single method. */
  interface MethodHandler { 
    Object invoke(Object[] argv) throws Throwable;
  }
  static final class Default implements InvocationHandlerFactory { 
    @Override
    public InvocationHandler create(Target target, Map<Method, MethodHandler> dispatch) { 
      return new ReflectiveFeign.FeignInvocationHandler(target, dispatch);
    }
  }
}

最后使用Proxy.newProxyInstance创建代理对象，后面调用feign接口的方法就会调用到ReflectiveFeign.FeignInvocationHandler类的invoke方法。这里需要对每个定义的接口方法进行特定的处理实现，所以这里会出现一个MethodHandler的概念，就是对应方法级别的InvocationHandler。

调用接口方法

调用接口方法最终调用到FeignInvocationHandler类的invoke方法

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();
    }
    // 交给对应方法的处理器处理
    return dispatch.get(method).invoke(args);
}

当代理类接到执行请求时， 通过一个map分发给对应的MethodHandler执行，如此就实现了针对每个方法的个性化代理实现
SynchronousMethodHandler

public Object invoke(Object[] argv) throws Throwable { 
    // 构建一个RequestTemplate请求模板
    RequestTemplate template = buildTemplateFromArgs.create(argv);
    Retryer retryer = this.retryer.clone();
    while (true) { 
        try { 
            return executeAndDecode(template);
        } catch (RetryableException e) { 
            // 重试
            retryer.continueOrPropagate(e);
            if (logLevel != Logger.Level.NONE) { 
                logger.logRetry(metadata.configKey(), logLevel);
            }
            continue;
        }
    }
}
Object executeAndDecode(RequestTemplate template) throws Throwable { 
    // 根据请求模板生成request请求对象，目前的请求url是http://eureka-client/hello?name=huang
    Request request = targetRequest(template);
    if (logLevel != Logger.Level.NONE) { 
        logger.logRequest(metadata.configKey(), logLevel, request);
    }
    Response response;
    long start = System.nanoTime();
    try { 
        // 执行请求并返回响应
        response = client.execute(request, options);
        // ensure the request is set. TODO: remove in Feign 10
        response.toBuilder().request(request).build();
    } 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);
            // ensure the request is set. TODO: remove in Feign 10
            response.toBuilder().request(request).build();
        }
        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 { 
                return decode(response);
            }
        } else if (decode404 && response.status() == 404 && void.class != metadata.returnType()) { 
            return decode(response);
        } 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());
        }
    }
}

Client底层可以是HttpUrlConnection、HttpClient也可以是Okhttp
LoadBalancerFeignClient

public Response execute(Request request, Request.Options options) throws IOException { 
    try { 
        URI asUri = URI.create(request.url());
        String clientName = asUri.getHost();
        URI uriWithoutHost = cleanUrl(request.url(), clientName);
        // 创建RibbonRequest
        FeignLoadBalancer.RibbonRequest ribbonRequest = new FeignLoadBalancer.RibbonRequest(
            this.delegate, request, uriWithoutHost);
        IClientConfig requestConfig = getClientConfig(options, clientName);
        // 负载均衡器是使用ribbon的ZoneAwareLoadBalancer
        // 用FeignLoadBalancer包装了一层
        return lbClient(clientName).executeWithLoadBalancer(ribbonRequest,
                                                            requestConfig).toResponse();
    }
    catch (ClientException e) { 
        IOException io = findIOException(e);
        if (io != null) { 
            throw io;
        }
        throw new RuntimeException(e);
    }
}

看下如何选择负载均衡器

private FeignLoadBalancer lbClient(String clientName) { 
    return this.lbClientFactory.create(clientName);
}

CachingSpringLoadBalancerFactory

public class CachingSpringLoadBalancerFactory { 
    private final SpringClientFactory factory;
    private LoadBalancedRetryFactory loadBalancedRetryFactory = null;
    private volatile Map<String, FeignLoadBalancer> cache = new ConcurrentReferenceHashMap<>();
    public CachingSpringLoadBalancerFactory(SpringClientFactory factory) { 
        this.factory = factory;
    }
    public CachingSpringLoadBalancerFactory(SpringClientFactory factory, LoadBalancedRetryFactory loadBalancedRetryPolicyFactory) { 
        this.factory = factory;
        this.loadBalancedRetryFactory = loadBalancedRetryPolicyFactory;
    }
    public FeignLoadBalancer create(String clientName) { 
        // 根据clientName从缓存中获取相对应的负载均衡器
        FeignLoadBalancer client = this.cache.get(clientName);
        if(client != null) { 
            return client;
        }
        IClientConfig config = this.factory.getClientConfig(clientName);
        // 从SpringClientFactory中获取负载均衡器，该SpringClientFactory是ribbon的，
        // 根据feign的FeignContext类似，都继承了NamedContextFactory，
        // 缓存了每个客户端的spring容器，所以也就相当于从各自的spring容器中获取ILoadBalancer实例
        ILoadBalancer lb = this.factory.getLoadBalancer(clientName);
        ServerIntrospector serverIntrospector = this.factory.getInstance(clientName, ServerIntrospector.class);
        // 使用FeignLoadBalancer包装后放到缓存中。如果启用了重试，则用RetryableFeignLoadBalancer
        client = loadBalancedRetryFactory != null ? new RetryableFeignLoadBalancer(lb, config, serverIntrospector,
            loadBalancedRetryFactory) : new FeignLoadBalancer(lb, config, serverIntrospector);
        this.cache.put(clientName, client);
        return client;
    }
}

可以看到也是通过ILoadBalancer来作为负载均衡器，而ILoadBalancer是Ribbon非常核心的一个组件，在初始化的时候会从EurekaClient获取服务列表，EurekaClient中获取服务实例，然后通过IL oadBalancer中的IRule组件的负载均衡算法，在同一个服务的多个服务实例中choose挑选一个 服务出来，作为本次请求的服务实例目标。看下如何通过负载均衡器选择一个服务后执行请求

public T executeWithLoadBalancer(final S request, final IClientConfig requestConfig) throws ClientException { 
    LoadBalancerCommand<T> command = buildLoadBalancerCommand(request, requestConfig);
    try { 
        // 在submit中会选择一个具体的服务
        return command.submit(
            new ServerOperation<T>() { 
                // 选择到一个服务后会回调该方法
                @Override
                public Observable<T> call(Server server) { 
                    // 替换URI
                    URI finalUri = reconstructURIWithServer(server, request.getUri());
                    S requestForServer = (S) request.replaceUri(finalUri);
                    try { 
                        // 执行请求
                        return Observable.just(AbstractLoadBalancerAwareClient.this.execute(requestForServer, requestConfig));
                    } 
                    catch (Exception e) { 
                        return Observable.error(e);
                    }
                }
            })
            .toBlocking()
            .single();
    } catch (Exception e) { 
        Throwable t = e.getCause();
        if (t instanceof ClientException) { 
            throw (ClientException) t;
        } else { 
            throw new ClientException(e);
        }
    }
}

进入到submit看看

public Observable<T> submit(final ServerOperation<T> operation) { 
        final ExecutionInfoContext context = new ExecutionInfoContext();
        // .........
        Observable<T> o = 
                (server == null ? selectServer() : Observable.just(server))
                .concatMap(new Func1<Server, Observable<T>>() { 
                    //........
                });
       // .......
}

其它代码也看不懂，咱就看selectServer方法，看名称应该是选择服务

private Observable<Server> selectServer() { 
    return Observable.create(new OnSubscribe<Server>() { 
        @Override
        public void call(Subscriber<? super Server> next) { 
            try { 
                Server server = loadBalancerContext.getServerFromLoadBalancer(loadBalancerURI, loadBalancerKey);   
                next.onNext(server);
                next.onCompleted();
            } catch (Exception e) { 
                next.onError(e);
            }
        }
    });
}

再跟进getServerFromLoadBalancer

public Server getServerFromLoadBalancer(@Nullable URI original, @Nullable Object loadBalancerKey) throws ClientException { 
    String host = null;
    int port = -1;
    if (original != null) { 
        host = original.getHost();
    }
    if (original != null) { 
        Pair<String, Integer> schemeAndPort = deriveSchemeAndPortFromPartialUri(original);        
        port = schemeAndPort.second();
    }
    // Various Supported Cases
    // The loadbalancer to use and the instances it has is based on how it was registered
    // In each of these cases, the client might come in using Full Url or Partial URL
    // 获取负载均衡器
    ILoadBalancer lb = getLoadBalancer();
    if (host == null) { 
        // Partial URI or no URI Case
        // well we have to just get the right instances from lb - or we fall back
        if (lb != null){ 
            // 负载均衡选择一个服务
            Server svc = lb.chooseServer(loadBalancerKey);
            if (svc == null){ 
                throw new ClientException(ClientException.ErrorType.GENERAL,
                                          "Load balancer does not have available server for client: "
                                          + clientName);
            }
            host = svc.getHost();
            if (host == null){ 
                throw new ClientException(ClientException.ErrorType.GENERAL,
                                          "Invalid Server for :" + svc);
            }
            logger.debug("{} using LB returned Server: {} for request {}", new Object[]{ clientName, svc, original});
            return svc;
        } else { 
            // No Full URL - and we dont have a LoadBalancer registered to
            // obtain a server
            // if we have a vipAddress that came with the registration, we
            // can use that else we
            // bail out
            if (vipAddresses != null && vipAddresses.contains(",")) { 
                throw new ClientException(
                    ClientException.ErrorType.GENERAL,
                    "Method is invoked for client " + clientName + " with partial URI of ("
                    + original
                    + ") with no load balancer configured."
                    + " Also, there are multiple vipAddresses and hence no vip address can be chosen"
                    + " to complete this partial uri");
            } else if (vipAddresses != null) { 
                try { 
                    Pair<String,Integer> hostAndPort = deriveHostAndPortFromVipAddress(vipAddresses);
                    host = hostAndPort.first();
                    port = hostAndPort.second();
                } catch (URISyntaxException e) { 
                    throw new ClientException(
                        ClientException.ErrorType.GENERAL,
                        "Method is invoked for client " + clientName + " with partial URI of ("
                        + original
                        + ") with no load balancer configured. "
                        + " Also, the configured/registered vipAddress is unparseable (to determine host and port)");
                }
            } else { 
                throw new ClientException(
                    ClientException.ErrorType.GENERAL,
                    this.clientName
                    + " has no LoadBalancer registered and passed in a partial URL request (with no host:port)."
                    + " Also has no vipAddress registered");
            }
        }
    } else { 
        // Full URL Case
        // This could either be a vipAddress or a hostAndPort or a real DNS
        // if vipAddress or hostAndPort, we just have to consult the loadbalancer
        // but if it does not return a server, we should just proceed anyways
        // and assume its a DNS
        // For restClients registered using a vipAddress AND executing a request
        // by passing in the full URL (including host and port), we should only
        // consult lb IFF the URL passed is registered as vipAddress in Discovery
        boolean shouldInterpretAsVip = false;
        if (lb != null) { 
            shouldInterpretAsVip = isVipRecognized(original.getAuthority());
        }
        if (shouldInterpretAsVip) { 
            Server svc = lb.chooseServer(loadBalancerKey);
            if (svc != null){ 
                host = svc.getHost();
                if (host == null){ 
                    throw new ClientException(ClientException.ErrorType.GENERAL,
                                              "Invalid Server for :" + svc);
                }
                logger.debug("using LB returned Server: {} for request: {}", svc, original);
                return svc;
            } else { 
                // just fall back as real DNS
                logger.debug("{}:{} assumed to be a valid VIP address or exists in the DNS", host, port);
            }
        } else { 
            // consult LB to obtain vipAddress backed instance given full URL
            //Full URL execute request - where url!=vipAddress
            logger.debug("Using full URL passed in by caller (not using load balancer): {}", original);
        }
    }
    // end of creating final URL
    if (host == null){ 
        throw new ClientException(ClientException.ErrorType.GENERAL,"Request contains no HOST to talk to");
    }
    // just verify that at this point we have a full URL
    return new Server(host, port);
}