SpringBoot 2 使用 SpringCloud LoadBalancer 实现客户端负载均衡
开篇词
该指南将引导你创建负载均衡的微服务。
你将创建的应用
我们将构建一个使用 Spring Cloud LoadBalancer 的微服务应用，以在对另一个微服务的调用中提供客户端负载均衡。
你将需要的工具
- 大概 15 分钟左右；
- 你最喜欢的文本编辑器或集成开发环境（IDE）
- JDK 1.8 或更高版本；
- Gradle 4+ 或 Maven 3.2+
- 你还可以将代码直接导入到 IDE 中：
- Spring Too Suite (STS)
- IntelliJ IDEA
如何完成这个指南
像大多数的 Spring 入门指南一样，你可以从头开始并完成每个步骤，也可以绕过你已经熟悉的基本设置步骤。如论哪种方式，你最终都有可以工作的代码。
- 要从头开始，移步至用 Gradle 来构建；
- 要跳过基础，执行以下操作：
- 下载并解压缩该指南将用到的源代码，或借助 Git 来对其进行克隆操作：
git clone https://github.com/spring-guides/gs-spring-cloud-loadbalancer.git - 切换至
gs-spring-cloud-loadbalancer/initial目录； - 跳转至该指南的实现 “问好” 服务。
- 下载并解压缩该指南将用到的源代码，或借助 Git 来对其进行克隆操作：
待一切就绪后，可以检查一下 gs-spring-cloud-loadbalancer/complete 目录中的代码。
用 Gradle 来构建
首先，我们设置一个基本的构建脚本。在使用 Spring 构建应用时可以使用任何喜欢的构建系统，但此处包含使用 Gradle 和 Maven 所需的代码。如果你都不熟悉，请参阅使用 Gradle 构建 Java 项目或使用 Maven 构建 Java 项目。
创建目录结构
在我们选择的项目目录中，创建以下自目录结构；例如，在 *nix 系统上使用 mkdir -p src/main/java/hello：
└── src
└── main
└── java
└── hello
创建 Gradle 构建文件
以下是初始 Gradle 构建文件。
build.gradle
Spring Boot gradle 插件提供了许多方便的功能：
- 它收集类路径上的所有 jar，并构建一个可运行的单个超级 jar，这使执行和传输服务更加方便；
- 它搜索
public static void main()方法并将其标记为可运行类； - 它提供了一个内置的依赖解析器，用于设置版本号以及匹配 Spring Boot 依赖。我们可以覆盖所需的任何版本，但默认为 Boot 选择的一组版本。
用 Maven 来构建
首先，我们搭建一个基本的构建脚本。使用 Spring 构建应用时，可以使用任何喜欢的构建系统，但是此处包含了使用 Maven 所需的代码。如果你不熟悉 Maven，请参阅使用 Maven 构建 Java 项目。
创建目录结构
在我们选择的项目目录中，创建以下自目录结构；例如，在 *nix 系统上使用 mkdir -p src/main/java/hello：
└── src
└── main
└── java
└── hello
创建 Maven 构建文件
以下是初始 Maven 构建文件。
pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0modelVersion>
<groupId>org.springframeworkgroupId>
<artifactId>gs-spring-cloud-loadbalancerartifactId>
<version>0.1.0version>
<packaging>pompackaging>
<modules>
<module>say-hellomodule>
<module>usermodule>
modules>
project>
Spring Boot Maven 插件提供了许多方便的功能：
- 它收集类路径上的所有 jar，并构建一个可运行的单个超级 jar，这使执行和传输服务更加方便；
- 它搜索
public static void main()方法并将其标记为可运行类； - 它提供了一个内置的依赖解析器，用于设置版本号以及匹配 Spring Boot 依赖。我们可以覆盖所需的任何版本，但默认为 Boot 选择的一组版本。
用 IDE 来构建
- 阅读如何将该指南直接导入 Spring Tool Suite；
- 阅读如何在 IntelliJ IDEA 中使用该指南。
实现 “问好” 服务
我们的 “服务器” 服务称为 “问好”。它将从可通过 /greeting 访问的端点返回随机问候（从三个静态列表中挑选）。
在 src/main/java/hello 中，创建文件 SayHelloApplication.java。它看起来应该像这样：
say-hello/src/main/java/hello/SayHelloApplication.java
package hello;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@SpringBootApplication
public class SayHelloApplication {
private static Logger log = LoggerFactory.getLogger(SayHelloApplication.class);
public static void main(String[] args) {
SpringApplication.run(SayHelloApplication.class, args);
}
@GetMapping("/greeting")
public String greet() {
log.info("Access /greeting");
List<String> greetings = Arrays.asList("Hi there", "Greetings", "Salutations");
Random rand = new Random();
int randomNum = rand.nextInt(greetings.size());
return greetings.get(randomNum);
}
@GetMapping("/")
public String home() {
log.info("Access /");
return "Hi!";
}
}
这是一个简单的 @RestController，其中一个 @RequestMapping 方法用于 /greeting，然后另一个用于根路径 /。
我们将在本地与客户端服务应用一起运行该应用的多个实例，因此创建目录 src/main/resources，在其中创建文件 application.yml，然后在该文件中为 server.port 设置默认值。（我们还将指示该应用的其他示例也可以在其他端口上运行，这样，当我们使该 Say Hello 实例运行时，不会与客户端发生冲突）。在该文件中时，我们还将为我们的服务设置 spring.application.name。
say-hello/src/main/resources/application.yml
spring:
application:
name: say-hello
server:
port: 8090
从客户端服务访问
用户将看到 “用户” 应用。它将调用 Say Hello 应用获取问候语，然后在用户访问 /hi 和 /hello 的端点时将其发送给我们的用户。
在用户应用目录的 src/main/java/hello 下，添加文件 UserApplication.java：
user/src/main/java/hello/UserApplication.java
package hello;
import reactor.core.publisher.Mono;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.reactive.ReactorLoadBalancerExchangeFilterFunction;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.reactive.function.client.WebClient;
/**
* @author Olga Maciaszek-Sharma
*/
@SpringBootApplication
@RestController
public class UserApplication {
private final WebClient.Builder loadBalancedWebClientBuilder;
private final ReactorLoadBalancerExchangeFilterFunction lbFunction;
public UserApplication(WebClient.Builder webClientBuilder,
ReactorLoadBalancerExchangeFilterFunction lbFunction) {
this.loadBalancedWebClientBuilder = webClientBuilder;
this.lbFunction = lbFunction;
}
public static void main(String[] args) {
SpringApplication.run(UserApplication.class, args);
}
@RequestMapping("/hi")
public Mono<String> hi(@RequestParam(value = "name", defaultValue = "Mary") String name) {
return loadBalancedWebClientBuilder.build().get().uri("http://say-hello/greeting")
.retrieve().bodyToMono(String.class)
.map(greeting -> String.format("%s, %s!", greeting, name));
}
@RequestMapping("/hello")
public Mono<String> hello(@RequestParam(value = "name", defaultValue = "John") String name) {
return WebClient.builder()
.filter(lbFunction)
.build().get().uri("http://say-hello/greeting")
.retrieve().bodyToMono(String.class)
.map(greeting -> String.format("%s, %s!", greeting, name));
}
}
我们还添加一个 @Configuration 类，在其中将设置负载均衡的 WebClient.Builder 实例：
user/src/main/java/hello/WebClientConfig.java
package hello;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.loadbalancer.annotation.LoadBalancerClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.client.WebClient;
@Configuration
@LoadBalancerClient(name = "say-hello", configuration = SayHelloConfiguration.class)
public class WebClientConfig {
@LoadBalanced
@Bean
WebClient.Builder webClientBuilder() {
return WebClient.builder();
}
}
该配置提供了 @LoadBalanced WebClient.Builder 实例，当有人点击 UserApplication.java 的 hi 端点时使用该实例。命中 hi 端点后，我们将使用该构建器创建一个 WebClient 实例，该实例将用于向 Say Hello 服务的 URL 发出 HTTP GET 请求，并将结果作为 String 提供给我们。
在 UserApplication.java 中，我们还添加了一个 /hello 端点，该端点在下面执行相同的操作，但是，我们没有使用 @Loadbalanced 注解，而是使用了 @Autowired 负载均很器交换过滤函数的 lbFunction，该函数通过 filter() 方法以编程方式构建一个 WebClient 实例。
即使我们为两个端点设置的负载均衡
WebClient实例略有不同，但两个端点的最终行为是完全相同的。在下面使用 Spring Cloud LoadBalancer 来选择 “Say Hello” 服务的适当实例。
将 spring.application.name 和 server.port 属性添加到 src/main/resources/application.properties 或 src/main/resources/application.yml：
user/src/main/resources/application.yml
spring:
application:
name: user
server:
port: 8888
跨服务器实例负载均衡
如我们所见，在 WebClientConfig.java 中，我们使用 @LoadBalancerClient 注解传递了 LoadBalancer 的自定义配置：
@LoadBalancerClient(name = "say-hello", configuration = SayHelloConfiguration.class)。这意味着每当与名为 say-hello 的服务联系时，Spring Cloud LoadBalancer 都将使用 SayHelloConfiguration.java 中提供的配置，而不是使用默认配置运行：
user/src/main/java/hello/SayHelloConfiguration.java
package hello;
import java.util.Arrays;
import java.util.List;
import reactor.core.publisher.Flux;
import org.springframework.cloud.client.DefaultServiceInstance;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
/**
* @author Olga Maciaszek-Sharma
*/
@Configuration
public class SayHelloConfiguration {
@Bean
@Primary
ServiceInstanceListSupplier serviceInstanceListSupplier() {
return new DemoServiceInstanceListSuppler("say-hello");
}
}
class DemoServiceInstanceListSuppler implements ServiceInstanceListSupplier {
private final String serviceId;
DemoServiceInstanceListSuppler(String serviceId) {
this.serviceId = serviceId;
}
@Override
public String getServiceId() {
return serviceId;
}
@Override
public Flux<List<ServiceInstance>> get() {
return Flux.just(Arrays
.asList(new DefaultServiceInstance(serviceId + "1", serviceId, "localhost", 8090, false),
new DefaultServiceInstance(serviceId + "2", serviceId, "localhost", 9092, false),
new DefaultServiceInstance(serviceId + "3", serviceId, "localhost", 9999, false)));
}
}
这里，我们提供了一个自定义 ServiceInstancedListSupplier，其中包含三个硬编码实例，Spring Cloud LoadBalancer 将在调用 “Say Hello” 服务时从中选择这些实例。
添加了该步骤以说明如何将自己的自定义配置传递给 Spring Cloud LoadBalancer。但是，我们不需要使用
@LoadBalancerClient注解并为 LoadBalancer 创建自己的配置。最典型的方法是将 Spring Cloud LoadBalancer 与服务发现一起使用。如果我们的类路径上有任何DiscoveryClient，默认的 Spring Cloud LoadBalancer 配置将在后台使用它来检查服务实例。这样，我们还将仅从已启动并正在运行的实例中进行选择。我们可以通过该指南学习如何使用ServiceDiscovery。
我们还添加了一个具有默认 server.port 和 spring.application.name 的 application.yml 文件：
user/src/main/resources/application.yml
spring:
application:
name: user
server:
port: 8888
尝试一下
可以使用 Gradle 运行 Say Hello 服务：
./gradlew :say-hello:bootRun
SERVER_PORT=9092 ./gradlew :say-hello:bootRun
SERVER_PORT=9999 ./gradlew :say-hello:bootRun
./gradlew :user:bootRun
或 Maven：
./mvnw spring-boot:run -pl say-hello
SERVER_PORT=9092 ./mvnw spring-boot:run -pl say-hello
SERVER_PORT=9999 ./mvnw spring-boot:run -pl say-hello
./mvnw spring-boot:run -pl user
然后启动用户服务。访问 http://localhost:8888/hi，然后查看 Say Hello 服务实例。
而且我们对用户服务的请求应导致对 “问好” 的调用以循环形式分布在正在运行的实例中：
2016-03-09 21:15:28.915 INFO 90046 --- [nio-8090-exec-7] hello.SayHelloApplication : Access /greeting
测试应用
现在该应用正在运行，我们可以对其进行测试。
现在，我们可以在用户服务上访问 /hi 或 /hello 并看到有好的问候：
$ curl http://localhost:8888/hi
Greetings, Mary!
$ curl http://localhost:8888/hi?name=Orontes
Salutations, Orontes!
概述
恭喜你！我们刚刚开发了一个 Spring 应用！
想看指南的其他内容？请访问该指南的所属专栏：《Spring 官方指南》