1 概述

在Spring Cloud微服務(wù)體系中，服務(wù)于服務(wù)之間的調(diào)用，是避免不了的，
我們可以通過Http請求的方式進(jìn)行調(diào)用，當(dāng)然這樣并不是一個(gè)很好的選擇，
OpenFeign是一個(gè)http請求調(diào)用的輕量級框架，可以以Java接口注解的方式調(diào)用Http請求，
而不用像Java中通過封裝HTTP請求報(bào)文的方式直接調(diào)用。
    
同時(shí)OpenFeign的使用也比較簡單，一般我們通過兩個(gè)注解進(jìn)行配置即可，
`@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的名稱，如果項(xiàng)目使用了Ribbon，name屬性會(huì)作為微服務(wù)的名稱，用于服務(wù)發(fā)現(xiàn)
	@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的名稱，如果項(xiàng)目使用了Ribbon，name屬性會(huì)作為微服務(wù)的名稱，用于服務(wù)發(fā)現(xiàn)
	@AliasFor("value")
	String name() default "";

	/**
	 * @return the @Qualifier value for the feign client.
	 */
	String qualifier() default "";

	//url一般用于調(diào)試，可以手動(dòng)指定@FeignClient調(diào)用的地址
	String url() default "";

	//當(dāng)發(fā)生http 404錯(cuò)誤時(shí)，如果該字段位true，會(huì)調(diào)用decoder進(jìn)行解碼，否則拋出FeignException
	boolean decode404() default false;

	//Feign配置類，可以自定義Feign的Encoder、Decoder、LogLevel、Contract
	Class<?>[] configuration() default {};

	//定義容錯(cuò)的處理類，當(dāng)調(diào)用遠(yuǎn)程接口失敗或超時(shí)時(shí)，會(huì)調(diào)用對應(yīng)接口的容錯(cuò)邏輯，fallback指定的類必須實(shí)現(xiàn)@FeignClient標(biāo)記的接口
	Class<?> fallback() default void.class;

	//工廠類，用于生成fallback類示例，通過這個(gè)屬性我們可以實(shí)現(xiàn)每個(gè)接口通用的容錯(cuò)邏輯，減少重復(fù)的代碼
	Class<?> fallbackFactory() default void.class;

	//定義當(dāng)前FeignClient的統(tǒng)一前綴，當(dāng)我們項(xiàng)目中配置了server.context-path,server.servlet-path時(shí)使用
	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 學(xué)習(xí)思路

接下來我們通過思考下面的問題，進(jìn)行源碼的學(xué)習(xí):

1. @FeignClient被注入的接口，如何被解析和注入的呢
2. @Autowired可以針對@FeignClient注入實(shí)例對象，是如何注入的，注入的又是什么對象呢
3. FeingClient聲明的接口被解析后，以什么方式存儲(chǔ)和調(diào)用的呢
4. OpenFeign如何集成Ribbon實(shí)現(xiàn)負(fù)載均衡的呢

• 問題剖析

@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容器的方法呢？

1. ImportSelector (批量注入bean，例如spring boot自動(dòng)裝配原理)
2. ImportBeanDefinitionRegister (動(dòng)態(tài)構(gòu)建bean)
3. BeanFactoryPostProcessor (spring提供的擴(kuò)展，首先他必須是一個(gè)Bean)
4. SpringFactoryLoad (spi的機(jī)制)

ImportBeanDefinitionRegister可以實(shí)現(xiàn)動(dòng)態(tài)bean的構(gòu)建，也就是我們可以把自己需要的bean注入到ioc容器中
下面通過一個(gè)案例進(jìn)行演示：

5 案例演示

下面我們先通過一個(gè)案例去通過spring提供的擴(kuò)展類ImportBeanDefinitionRegister演示如何讓一個(gè)Bean注入到Ioc容器中，因?yàn)镺penFeign中也是用的這種方式，這用有助于我們對于源碼的理解。

6 源碼分析

我們首先分析@EnableFeignClients注解

• @EnableFeignClients

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {
...
}

我們可以看到@EnableFeignClients內(nèi)部有一個(gè)@Import注解，@Import注解,功能就是和Spring XML 里面 的 一樣. @Import注解是用來導(dǎo)入配置類或者一些需要前置加載的類.
@Import支持 三種方式
1.帶有@Configuration的配置類(4.2 版本之前只可以導(dǎo)入配置類，4.2版本之后 也可以導(dǎo)入 普通類)
2.ImportSelector 的實(shí)現(xiàn)
3.ImportBeanDefinitionRegistrar 的實(shí)現(xiàn)

這里FeignClientsRegistrar類就是通過第三種方式導(dǎo)入到ioc容器中的

class FeignClientsRegistrar
		implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
	@Override
	public void registerBeanDefinitions(AnnotationMetadata metadata,
			BeanDefinitionRegistry registry) {
	    //注冊@EnableFeignClients中定義defaultConfiguration屬性下的類，包裝成FeignClientSpecification，注冊到Spring容器。
　　    //在@FeignClient中有一個(gè)屬性：configuration，這個(gè)屬性是表示各個(gè)FeignClient自定義的配置類，
       //后面也會(huì)通過調(diào)用registerClientConfiguration方法來注冊成FeignClientSpecification到容器。
　　    //所以，這里可以完全理解在@EnableFeignClients中配置的是做為兜底的配置，在各個(gè)@FeignClient配置的就是自定義的情況。   
		registerDefaultConfiguration(metadata, registry);
		//重點(diǎn)分析該方法 *****
		//收集所有標(biāo)記了@FeignClient的接口,并把接口對應(yīng)的代理類的實(shí)現(xiàn)注入到ioc容器中
		registerFeignClients(metadata, registry);
	}		
}

FeignClientsRegistrar我們可以看到確實(shí)實(shí)現(xiàn)了ImportBeanDefinitionRegistrar接口，并實(shí)現(xiàn)了registerBeanDefinitions方法。

• registerFeignClients(metadata, registry);
  該方法的主要步驟如下：
  1.查找FeignClient
  2.得到一個(gè)@FeignClient的接口的集合
  3.解析@FeignClient注解中的元數(shù)據(jù)信息
  4.遍歷這些FeignClient接口，注入一個(gè)動(dòng)態(tài)Bean實(shí)例（通過動(dòng)態(tài)代理的方式實(shí)現(xiàn)）

public void registerFeignClients(AnnotationMetadata metadata,
			BeanDefinitionRegistry registry) {
		ClassPathScanningCandidateComponentProvider scanner = getScanner();
		scanner.setResourceLoader(this.resourceLoader);

		Set<String> basePackages;
		//收集該注解的元數(shù)據(jù)信息：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相關(guān)屬性會(huì)進(jìn)入到這里
		if (clients == null || clients.length == 0) {
			//添加需要掃描的注解@FeignClient
			scanner.addIncludeFilter(annotationTypeFilter);
			//該方法就是根據(jù)@EnableFeignClients注解的屬性信息去獲取需要掃描的路徑
			basePackages = getBasePackages(metadata);
		}
		//基于client屬性配置的類以及類所在的包進(jìn)行掃描
		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)));
		}
		//遍歷所有的路徑獲取標(biāo)有@FeignClient注解的接口
		for (String basePackage : basePackages) {
			//找到候選的對象（標(biāo)有@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");
					//獲取每個(gè)接口中定義的元數(shù)據(jù)信息，即@FeignClient注解中配置的屬性值例如，value,name,path,url等
					Map<String, Object> attributes = annotationMetadata
							.getAnnotationAttributes(
									FeignClient.class.getCanonicalName());
					//獲取name的屬性值
					String name = getClientName(attributes);
					//注冊被調(diào)用客戶端配置
                    //注冊(微服務(wù)名).FeignClientSpecification類型的bean
                    //對beanname的名稱進(jìn)行拼接: name.FeignClientSpecification ，例如我們上面獲取的naem值等于：${feign.baseInfoManagement.name:baseInfoManagement/baseInfoManagement}
                    //拼接后：${feign.baseInfoManagement.name:baseInfoManagement/baseInfoManagement}.FeignClientSpecification               
					registerClientConfiguration(registry, name,
							attributes.get("configuration"));
                    注冊 FeignClient 重點(diǎn)分析*****
					registerFeignClient(registry, annotationMetadata, attributes);
				}
			}
		}
	}

	protected Set<String> getBasePackages(AnnotationMetadata importingClassMetadata) {
		//@EnableFeignClients 元數(shù)據(jù)信息就是我們在該注解中配置的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
  把接口對應(yīng)的代理類注入到ioc容器中：注冊 FeignClient，組裝BeanDefinition，實(shí)質(zhì)是一個(gè)FeignClientFactoryBean，然后注冊到Spring IOC容器。

private void registerFeignClient(BeanDefinitionRegistry registry,
			AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
			//獲取到標(biāo)注了@FeignClient注解的接口全路徑：com.train.service.feign.BaseInfoManagementFeign
		String className = annotationMetadata.getClassName();
		//構(gòu)建FeignClientFactoryBean類型的BeanDefinitionBuilder
		BeanDefinitionBuilder definition = BeanDefinitionBuilder
				.genericBeanDefinition(FeignClientFactoryBean.class);
	    //屬性值校驗(yàn)
		validate(attributes);
		//將屬性設(shè)置到 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"));
		//設(shè)置 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);
	}

分析到這里其實(shí)只是把我們的代理類封裝成BeanDefinition對象，但是并沒有實(shí)例化，在spring中我們知道，加載到IOC容器中的類都要先封裝成BeanDefinition對象，因?yàn)槲覀儾粌H需要類的類的信息，還可能配置了一些其他屬性，例如@Lazy，@DependsOn等。那這里后續(xù)肯定是通過sring進(jìn)行實(shí)例化的，這里就不做過多分析，主要流程如下：

1. Spring容器啟動(dòng)，調(diào)用AbstractApplicationContext#refresh方法，
2. 在refresh方法內(nèi)部調(diào)用finishBeanFactoryInitialization方法對單例bean進(jìn)行初始化，
   finishBeanFactoryInitialization方法調(diào)用getBean獲取name對應(yīng)的bean實(shí)例，如果不存在，則創(chuàng)建一個(gè)，即調(diào)用doGetBean方法。
3. doGetBean調(diào)用createBean方法，createBean方法調(diào)用doCreateBean方法。
4. doCreateBean()方法主要是根據(jù) beanName、mbd、args，使用對應(yīng)的策略創(chuàng)建 bean 實(shí)例，并返回包裝類 BeanWrapper。
5. doCreateBean方法中調(diào)用populateBean對 bean 進(jìn)行屬性填充；其中，可能存在依賴于其他 bean 的屬性，則會(huì)遞歸初始化依賴的 bean 實(shí)例，初始化階段又涉及到三級緩存以及AOP的實(shí)現(xiàn)。

• FeignClientFactoryBean
  上面我們分析會(huì)構(gòu)建FeignClientFactoryBean類型的BeanDefinitionBuilder，那么這個(gè)對象是什么呢，我們接下來進(jìn)行分析：

class FeignClientFactoryBean
		implements FactoryBean<Object>, InitializingBean, ApplicationContextAware {
}

首先我們可以看到它實(shí)現(xiàn)了Spring中給我們提供擴(kuò)展使用的三個(gè)類分別是FactoryBean,InitializingBean,ApplicationContextAware 。

1. InitializingBean的作用
   1：spring為bean提供了兩種初始化bean的方式，實(shí)現(xiàn)InitializingBean接口，實(shí)現(xiàn)afterPropertiesSet方法，或者在配置文件中同過init-method指定，兩種方式可以同時(shí)使用
   2：實(shí)現(xiàn)InitializingBean接口是直接調(diào)用afterPropertiesSet方法，比通過反射調(diào)用init-method指定的方法效率相對來說要高點(diǎn)。但是init-method方式消除了對spring的依賴
   3：如果調(diào)用afterPropertiesSet方法時(shí)出錯(cuò)，則不調(diào)用init-method指定的方法。

2. ApplicationContextAware
   通過它Spring容器會(huì)自動(dòng)把上下文環(huán)境對象調(diào)用ApplicationContextAware接口中的setApplicationContext方法,可以通過這個(gè)上下文環(huán)境對象得到Spring容器中的Bean

3. FactoryBean的作用（此處重點(diǎn)分析）
FactoryBean我們應(yīng)該都很熟悉，一種Bean創(chuàng)建的一種方式，對Bean的一種擴(kuò)展。對于復(fù)雜的Bean對象初始化創(chuàng)建使用其可封裝對象的創(chuàng)建細(xì)節(jié)。那我我們肯定要看到getObject()方法了呀：
注意：這里涉及到一個(gè)面試題 BeanFactory vs FactoryBean。

	@Override
	public Object getObject() throws Exception {
		return getTarget();
	}
	<T> T getTarget() {
	//從applicationContext取出FeignContext，F(xiàn)eignContext繼承了NamedContextFactory，
	//它是用來統(tǒng)一維護(hù)feign中各個(gè)feign客戶端相互隔離的上下文。
	//FeignContext注冊到容器是在FeignAutoConfiguration上完成的。
		FeignContext context = this.applicationContext.getBean(FeignContext.class);
		
		//構(gòu)建feign.builder，在構(gòu)建時(shí)會(huì)向FeignContext獲取配置的Encoder，Decoder等各種信息。
		//FeignContext在上文中已經(jīng)提到會(huì)為每個(gè)Feign客戶端分配了一個(gè)容器，它們的父容器就是spring容器。
		Feign.Builder builder = feign(context);
        //如果url為空，則走負(fù)載均衡，生成有負(fù)載均衡功能的代理類 (重點(diǎn)分析*****)
		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屬性，返回有負(fù)載均衡功能的代理對象
			return (T) loadBalance(builder, context,
					new HardCodedTarget<>(this.type, this.name, this.url));
		}
		//如果指定了url，則生成默認(rèn)的代理類
		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) {
		// 從上下文中獲取一個(gè) Client，默認(rèn)是LoadBalancerFeignClient。
		//它是在FeignRibbonClientAutoConfiguration這個(gè)自動(dòng)裝配類中，通過Import實(shí)現(xiàn)的
		Client client = getOptional(context, Client.class);
		if (client != null) {
			builder.client(client);
			Targeter targeter = get(context, Targeter.class);
			//這里就是為每個(gè)接口創(chuàng)建代理類這里有兩個(gè)實(shí)現(xiàn) HystrixTargeter 、DefaultTargeter 
			//很顯然，如果沒有配置 Hystrix ，這里會(huì)走 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) {
	//創(chuàng)建一個(gè)動(dòng)態(tài)代理類,最終會(huì)調(diào)用 ReflectiveFeign.newInstance
      return build().newInstance(target);
    }

public Feign build() {
//這個(gè)方法是用來創(chuàng)建一個(gè)動(dòng)態(tài)代理的方法，在生成動(dòng)態(tài)代理之前，會(huì)根據(jù)Contract協(xié)議（協(xié)議解析規(guī)則，解析接口類的注解信息，解析成內(nèi)部的MethodHandler的處理方式。會(huì)解析我們在每個(gè)接口中定義的參數(shù)，方法類型等。
      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創(chuàng)建一個(gè)動(dòng)態(tài)代理類
      return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);
    }

//target就是我們的原始接口
public <T> T newInstance(Target<T> target) {
//根據(jù)接口類和Contract協(xié)議解析方式，解析接口類上的方法和注解，轉(zhuǎn)換成內(nèi)部的MethodHandler處理方式
//nameToHandle集合包含的屬性可以看下面的圖進(jìn)行理解
    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;
        //判斷是不是接口中的默認(rèn)方法
      } 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 為接口類創(chuàng)建動(dòng)態(tài)實(shí)現(xiàn)，將所有的請求轉(zhuǎn)換給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;
  }

1. nameToHandler
   

• targetToHandlersByName.apply(target);
  targetToHandlersByName.apply(target) :根據(jù)Contract協(xié)議規(guī)則，解析接口類的注解信息，解析成內(nèi)部表現(xiàn)：targetToHandlersByName.apply(target);會(huì)解析接口方法上的注解，從而解析出方法粒度的特定的配置信息，然后生產(chǎn)一個(gè)SynchronousMethodHandler 然后需要維護(hù)一個(gè)的map，放入InvocationHandler的實(shí)現(xiàn)FeignInvocationHandler中。

• FeignInvocationHandler.invoke

OpenFeign調(diào)用過程 :
在前面的分析中，我們知道OpenFeign最終返回的是一個(gè) ReflectiveFeign.FeignInvocationHandler 的對象。那么當(dāng)客戶端發(fā)起請求時(shí)，會(huì)進(jìn)入到 FeignInvocationHandler.invoke 方法中，這個(gè)大家都知道，它是一個(gè)動(dòng)態(tài)代理的實(shí)現(xiàn)。

    @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();
      }
// 利用分發(fā)器篩選方法，找到對應(yīng)的handler 進(jìn)行處理,也就是根據(jù)請求目標(biāo)對應(yīng)的url找到需要執(zhí)行的方法進(jìn)行調(diào)用
      return dispatch.get(method).invoke(args);
    }

• SynchronousMethodHandler.invoke
  而接著，在invoke方法中，會(huì)調(diào)用 this.dispatch.get(method)).invoke(args) 。this.dispatch.get(method) 會(huì)返回一個(gè)SynchronousMethodHandler，進(jìn)行攔截處理。這個(gè)方法會(huì)根據(jù)參數(shù)生成完成的RequestTemplate對象，這個(gè)對象是Http請求的模版，代碼如下。

  @Override
  public Object invoke(Object[] argv) throws Throwable {
  	//得到RequestTemplate 對象
    RequestTemplate template = buildTemplateFromArgs.create(argv);
    Options options = findOptions(argv);
    //重試機(jī)制的實(shí)現(xiàn)
    Retryer retryer = this.retryer.clone();
    while (true) {
      try {
      	//請求的調(diào)用 
        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;
          }
        }
        //如果實(shí)現(xiàn)了日志類的打印，會(huì)打印日志信息
        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 {
    //發(fā)起遠(yuǎn)程通信
    //這里的 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);
	獲取返回結(jié)果，并解析
    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());
      }
    }
  }

上面主要進(jìn)行的步驟就是，我們根據(jù)@FeignClient注解定義的接口，會(huì)通過動(dòng)態(tài)代理給每個(gè)接口生成一個(gè)代理類，每個(gè)代理類中保存了URL和目標(biāo)方法的對應(yīng)管理，來調(diào)用對應(yīng)的方法。

• 總體過程：

1. 主程序入口添加了@EnableFeignClients注解開啟對FeignClient掃描加載處理。根據(jù)Feign Client的開發(fā)規(guī)范，定義接口并加@FeignClient注解。

2. 當(dāng)程序啟動(dòng)時(shí)，會(huì)進(jìn)行包掃描，掃描所有@FeignClients的注解的類，并且將這些信息注入Spring IOC容器中，當(dāng)定義的的Feign接口中的方法被調(diào)用時(shí)，通過JDK動(dòng)態(tài)代理方式，來生成具體的RequestTemplate。當(dāng)生成代理時(shí)，F(xiàn)eign會(huì)為每個(gè)接口方法創(chuàng)建一個(gè)RequestTemplate對象，該對象封裝可HTTP請求需要的全部信息，如請求參數(shù)名，請求方法等信息都是在這個(gè)過程中確定的。

3. 然后RequestTemplate生成Request，然后把Request交給Client去處理，這里指的Client可以是JDK原生的URLConnection、Apache的HttpClient、也可以是OKhttp，最后Client被封裝到LoadBalanceClient類，這個(gè)類結(jié)合Ribbon負(fù)載均衡發(fā)起服務(wù)之間的調(diào)用。