<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-loadbalancer</artifactId>
</dependency>
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-dependencies</artifactId>
      <version>${spring-cloud.version}</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

@SpringBootApplication
// 開(kāi)啟Feign功能，在該注解中你還可以配置，如下3個(gè)重要的信息：
// 1. 為所有的FeignClient提供統(tǒng)一默認(rèn)的配置
// 2. 指定掃描那些包寫(xiě)的類(lèi)
// 3. 指定有哪些@FeignClient類(lèi)
@EnableFeignClients
public class AppApplication {


  public static void main(String[] args) {
    SpringApplication.run(AppApplication.class, args);
  }


}

public class FeignClientFactoryBean implements FactoryBean {
  public Object getObject() {
    return getTarget();
  }
  <T> T getTarget() {
    FeignContext context = beanFactory != null ? beanFactory.getBean(FeignContext.class) : 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();
      // 負(fù)載均衡處理
      return (T) loadBalance(builder, context, new HardCodedTarget<>(type, name, url));
    }
    // ...
  }
  protected <T> T loadBalance(Feign.Builder builder, FeignContext context, HardCodedTarget<T> target) {
    // 在OpenFeign中核心實(shí)現(xiàn)負(fù)載均衡的類(lèi)就是具體的Client類(lèi)
    // Feign負(fù)載均衡能力實(shí)現(xiàn)通過(guò)具體Client實(shí)現(xiàn)，每一個(gè)FeignClient客戶(hù)端都會(huì)對(duì)應(yīng)一個(gè)子容器AnnotationConfigApplicationContext
    // 根據(jù)@FeignClient配置的服務(wù)名name或value為key，從一個(gè)LoadBalancerClientFactory（父類(lèi)）中的Map中查找該name對(duì)應(yīng)的容器
    // 如果不存在則創(chuàng)建一個(gè)AnnotationConfigApplicationContext。每個(gè)子容器都設(shè)置了父容器，如果通過(guò)子容器查找不到Client的實(shí)現(xiàn)，那么會(huì)從父容器中查找
    Client client = getOptional(context, Client.class);
  }
}

<!-- httpclient -->
<dependency>
  <groupId>io.github.openfeign</groupId>
  <artifactId>feign-httpclient</artifactId>
  <version>${version}</version>
</dependency>
<!-- okhttp -->
<dependency>
  <groupId>io.github.openfeign</groupId>
  <artifactId>feign-okhttp</artifactId>
  <version>${version}</version>
</dependency>

@Import({ 
  HttpClientFeignLoadBalancerConfiguration.class, 
  OkHttpFeignLoadBalancerConfiguration.class, 
  HttpClient5FeignLoadBalancerConfiguration.class, 
  DefaultFeignLoadBalancerConfiguration.class })
public class FeignLoadBalancerAutoConfiguration {
}

class DefaultFeignLoadBalancerConfiguration {


  @Bean
  @ConditionalOnMissingBean
  // 沒(méi)有啟用spring-retry重試功能
  @Conditional(OnRetryNotEnabledCondition.class)
  public Client feignClient(LoadBalancerClient loadBalancerClient, LoadBalancerClientFactory loadBalancerClientFactory) {
    // 這里構(gòu)造函數(shù)第一個(gè)參數(shù)將會(huì)成為最終執(zhí)行遠(yuǎn)程接口調(diào)用的實(shí)現(xiàn)
    return new FeignBlockingLoadBalancerClient(new Client.Default(null, null), loadBalancerClient, loadBalancerClientFactory);
  }
}

public class FeignBlockingLoadBalancerClient implements Client {
  // 此Client代理對(duì)象是上面的new Client.Default(null, null)
  private final Client delegate;
  private final LoadBalancerClient loadBalancerClient;
  private final LoadBalancerClientFactory loadBalancerClientFactory;
  public FeignBlockingLoadBalancerClient(Client delegate, LoadBalancerClient loadBalancerClient, LoadBalancerClientFactory loadBalancerClientFactory) {
    this.delegate = delegate;
    this.loadBalancerClient = loadBalancerClient;
    this.loadBalancerClientFactory = loadBalancerClientFactory;
  }
  @Override
  public Response execute(Request request, Request.Options options) throws IOException {
    final URI originalUri = URI.create(request.url());
    // 獲取服務(wù)名serviceId
    String serviceId = originalUri.getHost();
    String hint = getHint(serviceId);
    DefaultRequest<RequestDataContext> lbRequest = new DefaultRequest<>(new RequestDataContext(buildRequestData(request), hint));
    // ...
    // 通過(guò)負(fù)載均衡客戶(hù)端獲取指定serviceId的服務(wù)實(shí)例
    ServiceInstance instance = loadBalancerClient.choose(serviceId, lbRequest);
    // ...
    // 通過(guò)獲取到的ServiceInstance實(shí)例，重新構(gòu)造請(qǐng)求地址
    String reconstructedUrl = loadBalancerClient.reconstructURI(instance, originalUri).toString();
    // 重新構(gòu)建一個(gè)新的請(qǐng)求
    Request newRequest = buildRequest(request, reconstructedUrl);
    LoadBalancerProperties loadBalancerProperties = loadBalancerClientFactory.getProperties(serviceId);
    return executeWithLoadBalancerLifecycleProcessing(delegate, options, newRequest, lbRequest, lbResponse, supportedLifecycleProcessors, loadBalancerProperties.isUseRawStatusCodeInResponseData());
  }


  protected Request buildRequest(Request request, String reconstructedUrl) {
    return Request.create(request.httpMethod(), reconstructedUrl, request.headers(), request.body(),
      request.charset(), request.requestTemplate());
  }
}

public class BlockingLoadBalancerClientAutoConfiguration {


  @Bean
  @ConditionalOnBean(LoadBalancerClientFactory.class)
  @ConditionalOnMissingBean
  public LoadBalancerClient blockingLoadBalancerClient(LoadBalancerClientFactory loadBalancerClientFactory) {
    return new BlockingLoadBalancerClient(loadBalancerClientFactory);
  }
}

public class BlockingLoadBalancerClient implements LoadBalancerClient {


  private final ReactiveLoadBalancer.Factory<ServiceInstance> loadBalancerClientFactory;


  public BlockingLoadBalancerClient(ReactiveLoadBalancer.Factory<ServiceInstance> loadBalancerClientFactory) {
    this.loadBalancerClientFactory = loadBalancerClientFactory;
  }


  public <T> ServiceInstance choose(String serviceId, Request<T> request) {
    // 獲取一個(gè)負(fù)載均衡器，默認(rèn)是輪詢(xún)策略
    ReactiveLoadBalancer<ServiceInstance> loadBalancer = loadBalancerClientFactory.getInstance(serviceId);
    if (loadBalancer == null) {
      return null;
    }
    Response<ServiceInstance> loadBalancerResponse = Mono.from(loadBalancer.choose(request)).block();
    if (loadBalancerResponse == null) {
      return null;
    }
    return loadBalancerResponse.getServer();
  }
  // 重新構(gòu)造請(qǐng)求的uri
  public URI reconstructURI(ServiceInstance serviceInstance, URI original) {
    return LoadBalancerUriTools.reconstructURI(serviceInstance, original);
  }
}
public final class LoadBalancerUriTools {
  public static URI reconstructURI(ServiceInstance serviceInstance, URI original) {
    // ...
    return doReconstructURI(serviceInstance, original);
  }
  private static URI doReconstructURI(ServiceInstance serviceInstance, URI original) {
    String host = serviceInstance.getHost();
    String scheme = Optional.ofNullable(serviceInstance.getScheme()).orElse(computeScheme(original, serviceInstance));
    int port = computePort(serviceInstance.getPort(), scheme);


    if (Objects.equals(host, original.getHost()) && port == original.getPort() && Objects.equals(scheme, original.getScheme())) {
      return original;
    }
    boolean encoded = containsEncodedParts(original);
    return UriComponentsBuilder.fromUri(original).scheme(scheme).host(host).port(port).build(encoded).toUri();
  }
}

public class RoundRobinLoadBalancer implements ReactorServiceInstanceLoadBalancer {
  public Mono<Response<ServiceInstance>> choose(Request request) {
    ServiceInstanceListSupplier supplier = serviceInstanceListSupplierProvider
      .getIfAvailable(NoopServiceInstanceListSupplier::new);
    return supplier.get(request).next()
      .map(serviceInstances -> processInstanceResponse(supplier, serviceInstances));
  }


  private Response<ServiceInstance> processInstanceResponse(ServiceInstanceListSupplier supplier, List<ServiceInstance> serviceInstances) {
    Response<ServiceInstance> serviceInstanceResponse = getInstanceResponse(serviceInstances);
    if (supplier instanceof SelectedInstanceCallback && serviceInstanceResponse.hasServer()) {
      ((SelectedInstanceCallback) supplier).selectedServiceInstance(serviceInstanceResponse.getServer());
    }
    return serviceInstanceResponse;
  }


  private Response<ServiceInstance> getInstanceResponse(List<ServiceInstance> instances) {
    // ...
    // 如果只有一個(gè)實(shí)例
    if (instances.size() == 1) {
      return new DefaultResponse(instances.get(0));
    }


    // Ignore the sign bit, this allows pos to loop sequentially from 0 to
    // Integer.MAX_VALUE
    int pos = this.position.incrementAndGet() & Integer.MAX_VALUE;


    ServiceInstance instance = instances.get(pos % instances.size());


    return new DefaultResponse(instance);
  }
}

final class LoadBalancerUtils {
  static Response executeWithLoadBalancerLifecycleProcessing(Client feignClient, Request.Options options,
    Request feignRequest, org.springframework.cloud.client.loadbalancer.Request lbRequest,
    org.springframework.cloud.client.loadbalancer.Response<ServiceInstance> lbResponse,
    Set<LoadBalancerLifecycle> supportedLifecycleProcessors, boolean useRawStatusCodes) throws IOException {
    return executeWithLoadBalancerLifecycleProcessing(feignClient, options, feignRequest, lbRequest, lbResponse, supportedLifecycleProcessors, true, useRawStatusCodes);
  }
  static Response executeWithLoadBalancerLifecycleProcessing(Client feignClient, Request.Options options,
    Request feignRequest, org.springframework.cloud.client.loadbalancer.Request lbRequest,
    org.springframework.cloud.client.loadbalancer.Response<ServiceInstance> lbResponse,
    Set<LoadBalancerLifecycle> supportedLifecycleProcessors, boolean loadBalanced, boolean useRawStatusCodes) throws IOException {
    // 這里執(zhí)行生命周期實(shí)際調(diào)用前動(dòng)作
    try {
      // 執(zhí)行時(shí)間的調(diào)用，而這里的feignClient就是在FeignBlockingLoadBalancerClient傳遞過(guò)來(lái)的，new Client.Default(null, null)
      Response response = feignClient.execute(feignRequest, options);
      // 這里執(zhí)行生命周期回調(diào)，省略
      return response;
    }
    // ...
  }
}

public interface Client {
  public Response execute(Request request, Options options) throws IOException {
    // 通過(guò)JDK自帶的網(wǎng)絡(luò)連接進(jìn)行處理
    HttpURLConnection connection = convertAndSend(request, options);
    return convertResponse(connection, request);
  }
}