@SpringBootApplication
@EnableDiscoveryClient
@RestController
public class DiscoverClient {
  public static void main(String[] args) {
    SpringApplication.run(DiscoverClient.class, args);
  }
​
  @RequestMapping("/ribbonService")
  public String ribbonService(){
    return "hello too ribbon";
  }
}

@Configuration
public class RibbonConfig {
​
  /**
   * 實(shí)例化ribbon使用的RestTemplate
   * @return
   */
  @Bean
  @LoadBalanced
  public RestTemplate rebbionRestTemplate(){
    return new RestTemplate();
  }
  
  /**
  * 配置隨機(jī)負(fù)載策略，需要配置屬性service-B.ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RandomRule
  */
  @Bean
  public IRule ribbonRule() {
    return new RandomRule();
  }
}
​

@SpringBootApplication(scanBasePackages = "garine.learn.ribbon.loadblance")
@EnableDiscoveryClient
@RestController
public class TestRibbonApplocation {
  public static void main(String[] args) {
    SpringApplication.run(TestRibbonApplocation.class, args);
  }
​
  @Autowired
  @LoadBalanced
  RestTemplate restTemplate;
​
  @GetMapping("/{applicationName}/ribbonService")
  public String ribbonService(@PathVariable("applicationName") String applicationName){
    return restTemplate.getForObject("http://" + applicationName+"/ribbonService", String.class);
  }
}

ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution)
throws IOException;

@Configuration
@ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
static class LoadBalancerInterceptorConfig {
  @Bean
  //定義ribbon的攔截器
  public LoadBalancerInterceptor ribbonInterceptor(
     LoadBalancerClient loadBalancerClient,
     LoadBalancerRequestFactory requestFactory) {
   return new LoadBalancerInterceptor(loadBalancerClient, requestFactory);
  }
​
  @Bean
  @ConditionalOnMissingBean
  //定義注入器，用來(lái)將攔截器注入到RestTemplate中，跟上面配套使用
  public RestTemplateCustomizer restTemplateCustomizer(
     final LoadBalancerInterceptor loadBalancerInterceptor) {
   return restTemplate -> {
        List<ClientHttpRequestInterceptor> list = new ArrayList<>(
            restTemplate.getInterceptors());
        list.add(loadBalancerInterceptor);
        restTemplate.setInterceptors(list);
      };
  }
}

@Configuration
@ConditionalOnClass(RestTemplate.class)
@ConditionalOnBean(LoadBalancerClient.class)
@EnableConfigurationProperties(LoadBalancerRetryProperties.class)
public class LoadBalancerAutoConfiguration {
​
  @LoadBalanced
  @Autowired(required = false)
  private List<RestTemplate> restTemplates = Collections.emptyList();
​
  @Bean
  public SmartInitializingSingleton loadBalancedRestTemplateInitializerDeprecated(
     final ObjectProvider<List<RestTemplateCustomizer>> restTemplateCustomizers) {
    //遍歷context中的注入器，調(diào)用注入方法。
   return () -> restTemplateCustomizers.ifAvailable(customizers -> {
      for (RestTemplate restTemplate : LoadBalancerAutoConfiguration.this.restTemplates) {
        for (RestTemplateCustomizer customizer : customizers) {
          customizer.customize(restTemplate);
        }
      }
    });
  }
  //......
  }

@Bean
  @LoadBalanced
  public RestTemplate rebbionRestTemplate(){
    return new RestTemplate();
  }

/**
 * Annotation to mark a RestTemplate bean to be configured to use a LoadBalancerClient
 * @author Spencer Gibb
 */
@Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Qualifier
public @interface LoadBalanced {
}

public class LoadBalancerInterceptor implements ClientHttpRequestInterceptor {
​
  private LoadBalancerClient loadBalancer;
  private LoadBalancerRequestFactory requestFactory;
​
  public LoadBalancerInterceptor(LoadBalancerClient loadBalancer, LoadBalancerRequestFactory requestFactory) {
    this.loadBalancer = loadBalancer;
    this.requestFactory = requestFactory;
  }
​
  public LoadBalancerInterceptor(LoadBalancerClient loadBalancer) {
    // for backwards compatibility
    this(loadBalancer, new LoadBalancerRequestFactory(loadBalancer));
  }
​
  @Override
  public ClientHttpResponse intercept(final HttpRequest request, final byte[] body,
      final ClientHttpRequestExecution execution) throws IOException {
    final URI originalUri = request.getURI();
    String serviceName = originalUri.getHost();
    Assert.state(serviceName != null, "Request URI does not contain a valid hostname: " + originalUri);
    return this.loadBalancer.execute(serviceName, requestFactory.createRequest(request, body, execution));
  }
}

@Override
public <T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException {
  ILoadBalancer loadBalancer = getLoadBalancer(serviceId);
  //在這里負(fù)載均衡選擇服務(wù)
  Server server = getServer(loadBalancer);
  if (server == null) {
   throw new IllegalStateException("No instances available for " + serviceId);
  }
  RibbonServer ribbonServer = new RibbonServer(serviceId, server, isSecure(server,
     serviceId), serverIntrospector(serviceId).getMetadata(server));
//執(zhí)行請(qǐng)求邏輯
  return execute(serviceId, ribbonServer, request);
}

protected Server getServer(ILoadBalancer loadBalancer) {
  if (loadBalancer == null) {
   return null;
  }
  //
  return loadBalancer.chooseServer("default"); // TODO: better handling of key
}

public Server chooseServer(Object key) {
  if (counter == null) {
    counter = createCounter();
  }
  counter.increment();
  if (rule == null) {
    return null;
  } else {
    try {
      //使用配置對(duì)應(yīng)負(fù)載規(guī)則選擇服務(wù)
      return rule.choose(key);
    } catch (Exception e) {
      logger.warn("LoadBalancer [{}]: Error choosing server for key {}", name, key, e);
      return null;
    }
  }
}

public Server choose(ILoadBalancer lb, Object key) {
  if (lb == null) {
    return null;
  }
  Server server = null;
​
  while (server == null) {
    if (Thread.interrupted()) {
      return null;
    }
    //獲取可用服務(wù)列表
    List<Server> upList = lb.getReachableServers();
    List<Server> allList = lb.getAllServers();
​
    //隨機(jī)一個(gè)數(shù)
    int serverCount = allList.size();
    if (serverCount == 0) {
      /*
       * No servers. End regardless of pass, because subsequent passes
       * only get more restrictive.
       */
      return null;
    }
​
    int index = rand.nextInt(serverCount);
    server = upList.get(index);
​
    if (server == null) {
      /*
       * The only time this should happen is if the server list were
       * somehow trimmed. This is a transient condition. Retry after
       * yielding.
       */
      Thread.yield();
      continue;
    }
​
    if (server.isAlive()) {
      return (server);
    }
​
    // Shouldn't actually happen.. but must be transient or a bug.
    server = null;
    Thread.yield();
  }
  return server;
}