API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) · 课时

使用 Spring Cloud LoadBalancer 进行负载均衡

使用 Spring Cloud LoadBalancer 在客户端执行负载均衡，将请求路由到某个服务的多个实例。

使用 Spring Cloud LoadBalancer 进行负载均衡 是 CoddyKit 上的免费 API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) 课时。这是第 3 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

What is Client-Side Load Balancing?

In a microservices architecture, you often have multiple instances of the same service running. Client-side load balancing means the client (the service consumer) is responsible for choosing which instance to send a request to.

Unlike server-side load balancing (like Nginx), where a central proxy distributes requests, here the client actively participates in the decision. This can reduce network hops and improve responsiveness.

Introducing Spring Cloud LoadBalancer

Spring Cloud LoadBalancer is a client-side load balancer that works seamlessly with Spring Cloud applications. It's the modern successor to Netflix Ribbon in the Spring ecosystem.

It integrates with service discovery mechanisms (like Eureka or Consul) to get a list of available service instances and then applies a load balancing algorithm to select one for each request.

Adding LoadBalancer to Your Project

To use Spring Cloud LoadBalancer, you typically add the spring-cloud-starter-loadbalancer dependency to your Spring Boot project. This starter brings in all necessary components.

It's often used alongside a service discovery client (e.g., Eureka Client) so LoadBalancer knows which service instances are available.

Load Balancing with RestTemplate

You can easily enable client-side load balancing for RestTemplate by adding the @LoadBalanced annotation to its bean definition. This tells Spring Cloud to intercept calls and use LoadBalancer.

Notice how we call the service using its logical name (MY-SERVICE) instead of a specific IP:port.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class RestTemplateClient {

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

  public static void main(String[] args) {
    SpringApplication.run(RestTemplateClient.class, args);
    
    // Example usage (in a real app, this would be in a service)
    // RestTemplate restTemplate = applicationContext.getBean(RestTemplate.class);
    // String response = restTemplate.getForObject("http://MY-SERVICE/hello", String.class);
    // System.out.println("Response from MY-SERVICE: " + response);
  }
}

Load Balancing with WebClient

For reactive applications, WebClient is the preferred choice. You can enable load balancing for it by applying @LoadBalanced to a WebClient.Builder bean.

Similar to RestTemplate, you use the service's logical name in the URL, and LoadBalancer handles the instance resolution.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.reactive.function.client.WebClient;

@SpringBootApplication
public class WebClientClient {

  @LoadBalanced
  @Bean
  public WebClient.Builder webClientBuilder() {
    return WebClient.builder();
  }

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

    // Example usage (in a real app, this would be in a service)
    // WebClient webClient = applicationContext.getBean(WebClient.Builder.class).build();
    // webClient.get().uri("http://MY-SERVICE/greet")
    //     .retrieve().bodyToMono(String.class)
    //     .subscribe(response -> System.out.println("Response: " + response));
  }
}

How Service Discovery Powers It

Spring Cloud LoadBalancer doesn't magically know about service instances. It relies on service discovery, like Eureka or Consul, to provide a list of healthy, available instances for a given service ID.

When a client makes a request using a logical service name (e.g., MY-SERVICE), LoadBalancer queries the service registry, gets the list of instances, and then picks one.

Default Strategy: Round Robin

By default, Spring Cloud LoadBalancer uses the Round Robin algorithm. This means it cycles through the available service instances in order, distributing requests evenly.

For example, if you have three instances (A, B, C), the first request goes to A, the second to B, the third to C, the fourth back to A, and so on.

Gateway Routing with LoadBalancer

Spring Cloud Gateway automatically integrates with Spring Cloud LoadBalancer. When you define a route using a service ID (e.g., lb://MY-SERVICE), the Gateway uses LoadBalancer to resolve the actual instance address.

This means your gateway can route requests to multiple instances of a backend service without you needing to manually manage their IPs and ports.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
@EnableDiscoveryClient // Enables service discovery client (e.g., Eureka)
public class GatewayApplication {

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

  @Bean
  public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
    return builder.routes()
      .route("my_service_route", r -> r.path("/api/**")
        .uri("lb://MY-SERVICE")) // 'lb://' indicates load-balanced service
      .build();
  }
}

Customizing Load Balancing Strategies

While Round Robin is the default, Spring Cloud LoadBalancer is extensible. You can configure custom load balancing algorithms if your needs are more complex.

For example, you might want a 'Least Connections' strategy, which sends requests to the instance with the fewest active connections, or a 'Sticky Session' approach to route a user's requests consistently to the same server.

Quick Check: LoadBalancer Purpose

Which of the following are primary benefits or characteristics of using Spring Cloud LoadBalancer?

Recap: Client-Side Load Balancing

We've explored Spring Cloud LoadBalancer, a key component for building resilient microservices. It enables clients to intelligently distribute requests across multiple instances of a service.

It's a client-side solution, distinct from server-side proxies.
It works with service discovery (e.g., Eureka) to find service instances.
You can use it with @LoadBalanced RestTemplate or WebClient.Builder.
It's automatically integrated into Spring Cloud Gateway for routing.
The default load balancing strategy is Round Robin.

This ensures your applications can scale horizontally and remain available even if some service instances fail.

常见问题解答

「使用 Spring Cloud LoadBalancer 进行负载均衡」课时是免费的吗？

是的 — 「使用 Spring Cloud LoadBalancer 进行负载均衡」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) 课程的其余内容，请升级到 CoddyKit PRO。 API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) 课程共包含 4 节课。

「使用 Spring Cloud LoadBalancer 进行负载均衡」这节课中我会学到什么？

使用 Spring Cloud LoadBalancer 在客户端执行负载均衡，将请求路由到某个服务的多个实例。你通过在浏览器中直接运行的动手代码来练习 API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway)，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) 需要有经验吗？

无需任何先前经验。CoddyKit 上的 API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 3 节课，共 4 节。

「使用 Spring Cloud LoadBalancer 进行负载均衡」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) 课中编写并运行代码吗？

能。每节 API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway)