Spring Boot 4 Microservices & REST APIs · 课时

使用 Ribbon 实现客户端负载均衡

集成 Ribbon，在多个服务实例之间实现客户端负载均衡。

第 2 / 3 课11 个步骤

使用 Ribbon 实现客户端负载均衡 是 CoddyKit 上的免费 Spring Boot 4 Microservices & REST APIs 课时。这是第 2 节课，共 3 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Spring Boot 4 Microservices & REST APIs 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Spring Boot 4 Microservices & REST APIs 课程共包含 3 节课。

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

What is Load Balancing?

In a microservices world, applications often have multiple copies (instances) of the same service running. This is for scalability and high availability.

Load balancing is the process of distributing incoming network traffic across these multiple instances. It ensures no single service instance gets overwhelmed.

Scalability: Handle more users by adding more instances.
High Availability: If one instance fails, others can take over.
Performance: Distribute work evenly to reduce response times.

Client-Side vs. Server-Side LB

There are two main types of load balancing:

Server-Side Load Balancing: A dedicated component (like Nginx or a hardware load balancer) sits in front of your services. Clients send requests to this component, and it forwards them to an appropriate service instance.
Client-Side Load Balancing: The client application itself is responsible for knowing about all available service instances and choosing one for each request. This is where tools like Ribbon come in!

Ribbon: Your Client-Side Helper

Ribbon is a client-side load balancer that integrates seamlessly with Spring Cloud applications. It helps your client service pick the right instance of a target service.

How does Ribbon know about service instances? It works hand-in-hand with a service discovery mechanism, like Eureka. Eureka tells Ribbon where services are, and Ribbon decides which one to call.

Adding Load Balancing Dependency

To enable client-side load balancing in your Spring Boot application, you typically include the Spring Cloud LoadBalancer dependency. While 'Ribbon' is in the lesson title, Spring Cloud LoadBalancer is its modern successor and works similarly.

Add this to your pom.xml:

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

Load Balanced RestTemplate

The easiest way to use client-side load balancing is with Spring's RestTemplate. By simply adding the @LoadBalanced annotation to your RestTemplate bean, Spring configures it to use a load balancer.

When you make an HTTP call, you'll use the logical service name (e.g., my-service) instead of a specific IP address and port. The load balancer (Ribbon/Spring Cloud LoadBalancer) resolves this name to a real instance.

Client Calling a Service (Code)

Here's a simple Spring Boot client application that uses a load-balanced RestTemplate to call another service named my-service. For this to work, my-service must be registered with a service discovery server (like Eureka).

package com.coddykit;

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.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@RestController
public class MyClientApplication {

    private final RestTemplate restTemplate;

    // Inject the load-balanced RestTemplate
    public MyClientApplication(@LoadBalanced RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

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

    // Define the load-balanced RestTemplate bean
    @Bean
    @LoadBalanced 
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    // Endpoint to call 'my-service'
    @GetMapping("/call-my-service")
    public String callMyService() {
        // Use the logical service ID 'my-service'
        return restTemplate.getForObject("http://my-service/hello", String.class);
    }
}

Load Balancing Algorithms

Ribbon (and Spring Cloud LoadBalancer) can use different algorithms to decide which service instance to call. Some common ones include:

Round Robin: Distributes requests sequentially to each instance (e.g., instance 1, then 2, then 3, then 1 again).
Random: Picks a random instance for each request.
Availability Filtering: Ignores instances that are marked as down or unresponsive.
Weighted Response Time: Favors instances that have historically responded faster.

Configuring Load Balancing Rules

You can configure the load balancing rule for a specific service in your application.yml or application.properties. For example, to use a Round Robin rule for my-service (using older Ribbon config style):

my-service.ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RoundRobinRule

While this specific syntax is for older Ribbon, the concept of configuring rules per service is similar in Spring Cloud LoadBalancer, often done via custom configurations or properties.

Benefits of Client-Side LB

Client-side load balancing offers several advantages in a microservices architecture:

Simpler Infrastructure: No need for a separate hardware or software load balancer component.
Direct Communication: Clients communicate directly with service instances, potentially reducing latency.
Dynamic Scaling: Easily adapts to new service instances registering or deregistering with service discovery.
Granular Control: The client can implement custom load balancing logic or apply different rules per service.

Quick Check on Load Balancing

You've learned about client-side load balancing. Let's test your understanding.

在交互式课程中回答

Recap: Client-Side Load Balancing

Great job! You've explored client-side load balancing with Ribbon (and its successor, Spring Cloud LoadBalancer).

We learned that load balancing distributes traffic across service instances for scalability and availability.
Client-side load balancing means the client itself chooses which instance to call, often using a logical service name.
The @LoadBalanced annotation on a RestTemplate bean is key for enabling this feature in Spring Boot.
Various algorithms like Round Robin can be used to distribute requests.

This approach makes your microservices more robust and efficient!

免费开始

用 AI 导师学习 Java — 免费

在浏览器中编写并运行真实代码，获得全天候 AI 导师的即时帮助，并在网页或应用中继续学习。

课程: 24
课程: 93

免费开始学习查看完整课程

常见问题解答

「使用 Ribbon 实现客户端负载均衡」课时是免费的吗？

是的 — 「使用 Ribbon 实现客户端负载均衡」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Spring Boot 4 Microservices & REST APIs 课程的其余内容，请升级到 CoddyKit PRO。 Spring Boot 4 Microservices & REST APIs 课程共包含 3 节课。

「使用 Ribbon 实现客户端负载均衡」这节课中我会学到什么？

集成 Ribbon，在多个服务实例之间实现客户端负载均衡。你通过在浏览器中直接运行的动手代码来练习 Spring Boot 4 Microservices & REST APIs，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Spring Boot 4 Microservices & REST APIs 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Spring Boot 4 Microservices & REST APIs 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 2 节课，共 3 节。

「使用 Ribbon 实现客户端负载均衡」课时需要多长时间？

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

我能在这节 Spring Boot 4 Microservices & REST APIs 课中编写并运行代码吗？

能。每节 Spring Boot 4 Microservices & REST APIs 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Spring Boot 4 Microservices & REST APIs