1 概述

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

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

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

	//當發生http 404錯誤時，如果該字段位true，會調用decoder進行解碼，否則拋出FeignException
	boolean decode404() default false;

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

	//定義容錯的處理類，當調用遠程接口失敗或超時時，會調用對應接口的容錯邏輯，fallback指定的類必須實現@FeignClient標記的接口
	Class<?> fallback() default void.class;

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

	//定義當前FeignClient的統一前綴，當我們項目中配置了server.context-path,server.servlet-path時使用
	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 學習思路

接下來我們通過思考下面的問題，進行源碼的學習:

1. @FeignClient被注入的接口，如何被解析和注入的呢
2. @Autowired可以針對@FeignClient注入實例對象，是如何注入的，注入的又是什么對象呢
3. FeingClient聲明的接口被解析后，以什么方式存儲和調用的呢
4. OpenFeign如何集成Ribbon實現負載均衡的呢

• 問題剖析

@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自動裝配原理)
2. ImportBeanDefinitionRegister (動態構建bean)
3. BeanFactoryPostProcessor (spring提供的擴展，首先他必須是一個Bean)
4. SpringFactoryLoad (spi的機制)

ImportBeanDefinitionRegister可以實現動態bean的構建，也就是我們可以把自己需要的bean注入到ioc容器中
下面通過一個案例進行演示：

5 案例演示

下面我們先通過一個案例去通過spring提供的擴展類ImportBeanDefinitionRegister演示如何讓一個Bean注入到Ioc容器中，因為OpenFeign中也是用的這種方式，這用有助于我們對于源碼的理解。

6 源碼分析

我們首先分析@EnableFeignClients注解

• @EnableFeignClients

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

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

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

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

FeignClientsRegistrar我們可以看到確實實現了ImportBeanDefinitionRegistrar接口，并實現了registerBeanDefinitions方法。

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

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;
	}

• 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進行實例化的，這里就不做過多分析，主要流程如下：

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

• FeignClientFactoryBean
  上面我們分析會構建FeignClientFactoryBean類型的BeanDefinitionBuilder，那么這個對象是什么呢，我們接下來進行分析：

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

首先我們可以看到它實現了Spring中給我們提供擴展使用的三個類分別是FactoryBean,InitializingBean,ApplicationContextAware 。

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

2. ApplicationContextAware
   通過它Spring容器會自動把上下文環境對象調用ApplicationContextAware接口中的setApplicationContext方法,可以通過這個上下文環境對象得到Spring容器中的Bean

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

	@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;
  }

1. nameToHandler
   

• targetToHandlersByName.apply(target);
  targetToHandlersByName.apply(target) :根據Contract協議規則，解析接口類的注解信息，解析成內部表現：targetToHandlersByName.apply(target);會解析接口方法上的注解，從而解析出方法粒度的特定的配置信息，然后生產一個SynchronousMethodHandler 然后需要維護一個的map，放入InvocationHandler的實現FeignInvocationHandler中。

• FeignInvocationHandler.invoke

OpenFeign調用過程 :
在前面的分析中，我們知道OpenFeign最終返回的是一個 ReflectiveFeign.FeignInvocationHandler 的對象。那么當客戶端發起請求時，會進入到 FeignInvocationHandler.invoke 方法中，這個大家都知道，它是一個動態代理的實現。

    @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 = 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和目標方法的對應管理，來調用對應的方法。

• 總體過程：

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

2. 當程序啟動時，會進行包掃描，掃描所有@FeignClients的注解的類，并且將這些信息注入Spring IOC容器中，當定義的的Feign接口中的方法被調用時，通過JDK動態代理方式，來生成具體的RequestTemplate。當生成代理時，Feign會為每個接口方法創建一個RequestTemplate對象，該對象封裝可HTTP請求需要的全部信息，如請求參數名，請求方法等信息都是在這個過程中確定的。

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