一、 了解LoadBalancer

1.1 介绍

SpringCloud 提供了自己的客户端负载均衡器抽象和实现。对于负载平衡机制，增加了ReactiveLoadBalancer接口，并提供了Round-Robin-based的实现。为了从响应式服务中选择实例，使用InstanceListSupplier。目前，我们支持基于服务发现的ServiceInstanceListSupplier实现，该实现使用类路径中可用的发现客户端从服务发现中检索可用实例。

1.2 Load Balancer客户端

使用@LoadBalanced注解标识负载均衡客户端

  • 非阻塞式负载均衡客户端 WebClient
  • 阻塞是负载均衡客户端 RestTemplate

实际上都是通过ClientHttpRequestInterceptor请求拦截器实现的。 具体实现细节可以看LoadBalancerInterceptor

二、 案例实践

2.1 创建SpringBoot 项目 (ribbon-customer-service)

2.2 pom.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         <version>2.1.4.RELEASE</version>
  9.         <relativePath/> <!-- lookup parent from repository -->
  10.     </parent>
  11.     <groupId>cn.hdj</groupId>
  12.     <artifactId>ribbon-customer-service</artifactId>
  13.     <version>0.0.1-SNAPSHOT</version>
  14.     <name>RibbonCustomerService</name>
  15.     <description>Demo project for Spring Boot</description>
  17.     <properties>
  18.         <java.version>1.8</java.version>
  19.         <spring-cloud.version>Greenwich.SR1</spring-cloud.version>
  20.     </properties>
  22.     <dependencies>
  24.         <dependency>
  25.             <groupId>org.springframework.boot</groupId>
  26.             <artifactId>spring-boot-starter-web</artifactId>
  27.         </dependency>
  28.         <dependency>
  29.             <groupId>org.springframework.boot</groupId>
  30.             <artifactId>spring-boot-starter-actuator</artifactId>
  31.         </dependency>
  32.         <dependency>
  33.             <groupId>org.springframework.cloud</groupId>
  34.             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  35.         </dependency>
  36.         <dependency>
  37.             <groupId>org.projectlombok</groupId>
  38.             <artifactId>lombok</artifactId>
  39.             <optional>true</optional>
  40.         </dependency>
  41.         <dependency>
  42.             <groupId>org.springframework.boot</groupId>
  43.             <artifactId>spring-boot-starter-test</artifactId>
  44.             <scope>test</scope>
  45.         </dependency>
  46.         <dependency>
  47.             <groupId>org.apache.httpcomponents</groupId>
  48.             <artifactId>httpclient</artifactId>
  49.             <version>4.5.12</version>
  50.             <scope>compile</scope>
  51.         </dependency>
  52.     </dependencies>
  55.     <dependencyManagement>
  56.         <dependencies>
  57.             <dependency>
  58.                 <groupId>org.springframework.cloud</groupId>
  59.                 <artifactId>spring-cloud-dependencies</artifactId>
  60.                 <version>${spring-cloud.version}</version>
  61.                 <type>pom</type>
  62.                 <scope>import</scope>
  63.             </dependency>
  64.         </dependencies>
  65.     </dependencyManagement>
  68.     <build>
  69.         <plugins>
  70.             <plugin>
  71.                 <groupId>org.springframework.boot</groupId>
  72.                 <artifactId>spring-boot-maven-plugin</artifactId>
  73.             </plugin>
  74.         </plugins>
  75.     </build>
  77. </project>

2.3 配置文件

  • application.yml
  1. server:
  2.   port: 8004
  • bootstrap.yml
  1. spring:
  2.   application:
  3.     name: ribbon-customer-service #应用服务名称

2.4 配置RestTemplate 作为LoadBalancer客户端

  1. @EnableDiscoveryClient
  2. @SpringBootApplication
  3. public class RibbonCustomerServiceApplication {
  4.     public static void main(String[] args) {
  5.         SpringApplication.run(RibbonCustomerServiceApplication.class, args);
  6.     }
  8.     /**
  9.      * 配置请求线程池
  10.      *
  11.      * @return
  12.      */
  13.     @Bean
  14.     public HttpComponentsClientHttpRequestFactory requestFactory() {
  15.         PoolingHttpClientConnectionManager connectionManager =
  16.                 new PoolingHttpClientConnectionManager(30, TimeUnit.SECONDS);
  17.         connectionManager.setMaxTotal(200);
  18.         connectionManager.setDefaultMaxPerRoute(20);
  19.         CloseableHttpClient httpClient = HttpClients.custom()
  20.                 .setConnectionManager(connectionManager)
  21.                 .evictIdleConnections(30, TimeUnit.SECONDS)
  22.                 .disableAutomaticRetries()
  23.                 // 有 Keep-Alive 认里面的值，没有的话永久有效
  24.                 //.setKeepAliveStrategy(DefaultConnectionKeepAliveStrategy.INSTANCE)
  25.                 // 换成自定义的
  26.                 .setKeepAliveStrategy(new ConnectionKeepAliveStrategy() {
  27.                     private final long DEFAULT_SECONDS = 30;
  29.                     @Override
  30.                     public long getKeepAliveDuration(HttpResponse response, HttpContext httpContext) {
  31.                         return Arrays.asList(response.getHeaders(HTTP.CONN_KEEP_ALIVE))
  32.                                 .stream()
  33.                                 .filter(h -> StringUtils.equalsIgnoreCase(h.getName(), "timeout")
  34.                                         && StringUtils.isNumeric(h.getValue()))
  35.                                 .findFirst()
  36.                                 .map(h -> NumberUtils.toLong(h.getValue(), DEFAULT_SECONDS))
  37.                                 .orElse(DEFAULT_SECONDS) * 1000;
  38.                     }
  39.                 })
  40.                 .build();
  42.         HttpComponentsClientHttpRequestFactory requestFactory =
  43.                 new HttpComponentsClientHttpRequestFactory(httpClient);
  45.         return requestFactory;
  46.     }
  48.     /**
  49.      * RestTemplate 客户端
  50.      *
  51.      * @param builder
  52.      * @return
  53.      *
  54.      *  @LoadBalanced 标识使用RestTemplate 作为LoadBalancerClient
  55.      */
  56.     @LoadBalanced
  57.     @Bean
  58.     public RestTemplate restTemplate(RestTemplateBuilder builder) {
  59.         return builder
  60.                 .setConnectTimeout(Duration.ofMillis(100))
  61.                 .setReadTimeout(Duration.ofMillis(500))
  62.                 .requestFactory(this::requestFactory)
  63.                 .build();
  64.     }
  65. }

2.5 请求远程服务

  1. @Slf4j
  2. @RestController
  3. public class RibbonController {
  5.     @Autowired
  6.     private RestTemplate restTemplate;
  7.     @Autowired
  8.     private DiscoveryClient discoveryClient;
  11.     /**
  12.      * 使用RestTemplate 读取远程服务菜单信息
  13.      *
  14.      * @return
  15.      */
  16.     @GetMapping("/getMenu")
  17.     public Map<String, Object> readRemoteMenu() {
  19.         Map<String, Object> map = new HashMap<>(16);
  21.         //通过服务名称获取服务的请求地址
  22.         log.info("DiscoveryClient: {}", discoveryClient.getClass().getName());
  23.         //"waiter-service" 是 spring.application.name中定义的名称
  24.         List<String> list = discoveryClient.getInstances("waiter-service")
  25.                 .stream()
  26.                 .map(s -> {
  27.                     log.info("Host: {}, Port: {}", s.getHost(), s.getPort());
  28.                     return String.format("Host: %s, Port: %d", s.getHost(), s.getPort());
  29.                 })
  30.                 .collect(Collectors.toList());
  32.         map.put("remote address", list);
  34.         //请求远程服务
  35.         ParameterizedTypeReference<List<String>> ptr =
  36.                 new ParameterizedTypeReference<List<String>>() {
  37.                 };
  38.         ResponseEntity<List<String>> responseEntity = restTemplate
  39.                 .exchange("http://waiter-service/coffee/", HttpMethod.GET, HttpEntity.EMPTY, ptr);
  41.         responseEntity.getBody().forEach(c -> log.info("Coffee: {}", c));
  43.         map.put("response==>", responseEntity.getBody());
  44.         return map;
  45.     }
  46. }

注意：

  • 获取服务地址的方式

    1. EurekaClient#getNextServerFromEureka()
    2. DiscoveryClient#getInstances() （推荐，可用于不同的服务注册中心）

      2.6 启动euraka-waiter-service，eureka-server项目

      https://www.yuque.com/h_dj/lih6if/ar33ny

  • 修改euraka-waiter-service项目，添加web api 接口给ribbon-customer-service调用

    1. @RestController
    2. public class WaiterController {
    4.   @GetMapping(value = "/coffee",produces = "application/json")
    5.   public List<String> coffeeMenu() {
    6.       return Arrays.asList("instance3 ESPRESSO COFFEES $12", "HANDMADE COFFEES $15", "SOOTHING HOT ALTERNATIVES $20", "COLD ALTERNATIVES $8");
    7.   }
    8. }

  • 启动

eureka-server -> euraka-waiter-service -> ribbon-customer-service

  • 访问

http://localhost:8761/
image.png
http://localhost:8004/getMenu

  1. {"response==>":["ESPRESSO COFFEES $12","HANDMADE COFFEES $15","SOOTHING HOT ALTERNATIVES $20","COLD ALTERNATIVES $8"],"remote address":["Host: 192.168.43.122, Port: 33699"]}

LoadBalancer访问服务 完成

项目地址
https://github.com/h-dj/SpringCloud-Learning

参考