springboot集成spring loadbalancer实现客户端负载均衡

在 Spring Boot 中实现负载均衡，通常需要结合 Spring Cloud 组件，比如 Spring Cloud LoadBalancer。Spring Cloud LoadBalancer 是一个客户端负载均衡器，可以与 Spring Boot 集成，实现微服务之间的负载均衡。

以下是一个简单的示例，展示如何在 Spring Boot 中集成 Spring Cloud LoadBalancer 来实现负载均衡。

前提条件
确保你已经设置好 Spring Boot 项目。
添加 Spring Cloud 相关依赖。

1. 添加依赖
   在你的 pom.xml 文件中添加以下依赖：

<dependencies>
    <!-- Spring Boot Starter Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Spring Cloud Starter LoadBalancer -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-loadbalancer</artifactId>
    </dependency>
    
    <!-- Spring Cloud OpenFeign (如果需要使用 Feign 客户端) -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
</dependencies>
 
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>2021.0.5</version> <!-- 确保使用与项目兼容的版本 -->
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

2. 配置服务注册与发现（可选）
   通常，负载均衡与服务注册与发现结合使用，比如使用 Eureka。这里简单展示配置，假设使用 Eureka：

添加 Eureka 客户端依赖。
配置 application.yml 或 application.properties。
示例配置 (application.yml)

spring:
  application:
    name: my-service
  cloud:
    loadbalancer:
      ribbon:
        enabled: false # 确保不使用 Ribbon，因为我们使用 Spring Cloud LoadBalancer
    discovery:
      locator:
        enabled: true
 
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

3. 使用 RestTemplate 或 OpenFeign 进行负载均衡
   使用 RestTemplate
   创建一个配置类，将 RestTemplate 配置为负载均衡的。

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
 
@Configuration
public class AppConfig {
 
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

使用 RestTemplate 调用其他服务。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
 
@Service
public class MyService {
 
    @Autowired
    private RestTemplate restTemplate;
 
    public String callOtherService() {
        // 假设有一个服务名为 "other-service"
        return restTemplate.getForObject("http://other-service/some-endpoint", String.class);
    }
}

使用 OpenFeign
启用 Feign 客户端。

import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.Configuration;
 
@Configuration
@EnableFeignClients
public class FeignConfig {
}

创建一个 Feign 客户端接口。

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
 
@FeignClient(name = "other-service")
public interface OtherServiceClient {
 
    @GetMapping("/some-endpoint")
    String getSomeData();
}

使用 Feign 客户端。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service
public class MyService {
 
    @Autowired
    private OtherServiceClient otherServiceClient;
 
    public String callOtherService() {
        return otherServiceClient.getSomeData();
    }
}

总结
通过以上步骤，你可以在 Spring Boot 中使用 Spring Cloud LoadBalancer 实现负载均衡。根据需要选择使用 RestTemplate 或 OpenFeign，两者都支持负载均衡。通常，OpenFeign 提供了更简洁的代码和更好的可读性。

在 Spring Boot 中，通过 Spring Cloud LoadBalancer 可以实现客户端负载均衡，而不需要依赖像 Eureka 这样的服务注册与发现中心（尽管在实际生产环境中，结合服务注册与发现是更常见的做法）。为了简单演示，我们可以直接在代码中定义多个服务实例的地址，并使用 Spring Cloud LoadBalancer 来实现负载均衡。

以下是一个简单的示例，展示如何在 Spring Boot 中通过 Spring Cloud LoadBalancer 对两个服务实例进行负载均衡。

示例说明
假设我们有两个服务实例，它们的 URL 分别是 http://localhost:8081/service 和 http://localhost:8082/service。我们将使用 RestTemplate 并通过 @LoadBalanced 的方式来实现对这些实例的负载均衡。

步骤
添加依赖
确保在 pom.xml 中添加了 Spring Cloud LoadBalancer 和 Spring Web 的依赖。

<dependencies>
    <!-- Spring Boot Starter Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Spring Cloud Starter LoadBalancer -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-loadbalancer</artifactId>
    </dependency>
</dependencies>
 
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>2021.0.5</version> <!-- 确保使用与项目兼容的版本 -->
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

配置自定义的 LoadBalancerClientFactory（模拟服务实例）
由于没有使用服务注册中心，我们需要手动配置服务实例。我们可以通过自定义 LoadBalancerClientFactory 或使用 NamedContextFactory 来模拟这一点。不过，更简单的方法是直接使用 @LoadBalanced 和一个自定义的 ServiceInstanceListSupplier（Spring Cloud 2020.0.3+ 引入的功能）。

由于直接配置 ServiceInstanceListSupplier 相对复杂，这里我们通过一个简单的 RestTemplate 结合自定义逻辑来模拟负载均衡。

使用 RestTemplate 和自定义逻辑
由于 Spring Cloud LoadBalancer 通常与服务注册中心一起使用，这里我们手动实现一个简单的负载均衡逻辑。

java
import org.springframework.boot.CommandLineRunner;
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.stereotype.Service;
import org.springframework.web.client.RestTemplate;
 
import java.util.Arrays;
import java.util.List;
import java.util.Random;
 
@SpringBootApplication
public class LoadBalancerExampleApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(LoadBalancerExampleApplication.class, args);
    }
 
    @Bean
    @LoadBalanced // 虽然在这里没有直接使用服务注册，但可以保留以备将来使用
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
 
    @Bean
    public CommandLineRunner run(MyService myService) {
        return args -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(myService.callService());
            }
        };
    }
}

@Service
class MyService {
 
    private final RestTemplate restTemplate;
    private final List<String> serviceUrls = Arrays.asList(
            "http://localhost:8081/service",
            "http://localhost:8082/service"
    );
    private final Random random = new Random();
 
    public MyService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }
 
    public String callService() {
        String url = serviceUrls.get(random.nextInt(serviceUrls.size()));
        return restTemplate.getForObject(url, String.class);
    }
}

说明
自定义负载均衡逻辑：在这个示例中，我们没有使用 Spring Cloud LoadBalancer 的内置功能来自动发现服务实例，而是通过一个简单的随机选择逻辑来模拟负载均衡。
服务实例：我们手动定义了两个服务实例的 URL。
RestTemplate：使用 RestTemplate 来调用服务。
实际生产环境
在实际生产环境中，建议使用服务注册与发现中心（如 Eureka、Consul 等），并利用 Spring Cloud LoadBalancer 的自动发现功能来管理服务实例。这样可以更方便地扩展和管理服务实例。