负载均衡：解密 Spring Cloud LoadBalancer 动态权重与自定义算法

在微服务架构的高并发通信体系中，客户端负载均衡是保证后端实例流量均匀分布、避免单点过载的关键组件。随着 Netflix Ribbon 停止维护，Spring Cloud 推出了其官方替代者——**Spring Cloud LoadBalancer**。

Spring Cloud LoadBalancer 内置了简易的**轮询（RoundRobin）**与**随机（Random）**负载算法。然而，在真实的生产环境中，各个服务器的硬件配置（CPU、内存）往往是不对等的。例如：高性能机器 A 应该承担 80% 的流量，而低配机器 B 只能承载 20%。

为了支持硬件异构场景，我们需要将内置流控升级为**基于动态权重的负载均衡算法（Weighted Load Balancing）**。

本文将系统拆解 Spring Cloud LoadBalancer 的工作原理、主流算法对比、以及基于 Nacos 权重的自定义负载算法开发实战。

一、 核心对比：三大客户端负载均衡算法

不同负载均衡算法在流量均衡度、动态调优支持及业务场景适用性上表现各异：

二、 Spring Cloud LoadBalancer 自定义权重负载流转拓扑

当网关或 Feign 发起一次远程调用，且我们接入了自定义权重负载均衡器时，其挑选实例的拓扑如下：

      [ 客户端 RPC 调用 (如 GET /api/v1/orders) ]
                           │
                           ▼ 1. 拦截请求，调度负载均衡器
          [ ReactorServiceInstanceLoadBalancer ]
                           │
                           ▼ 2. 从注册中心（Nacos）拉取存活实例列表
              [ 实例列表 (ServiceInstances) ]
              - Instance A (权重: 8.0) ──> 占区间 [0, 8.0)
              - Instance B (权重: 2.0) ──> 占区间 [8.0, 10.0]
                           │
                           ▼ 3. 统计总权重: 8.0 + 2.0 = 10.0
             【 4. 产生区间内的随机双精度数 】
                           │  (例如随机产生: randomValue = 5.6)
                           │
                           ▼ 5. 命中区间判定: 5.6 处于 [0, 8.0)
              【 选定 Instance A 】
                           │
                           ▼ 6. 返回结果，发起网络转发
             [ 重定向至 Instance A (端口: 8081) ]

三、 代码实战：编写基于 Nacos 动态权重的自定义负载均衡器

以下代码展示了如何通过实现 ReactorServiceInstanceLoadBalancer 接口，编写一个自定义的动态权重负载均衡器，并在微服务中进行全局装配：

1. 自定义负载均衡器类（Java Layer）

package com.company.infra.loadbalancer;

import org.springframework.beans.factory.ObjectProvider;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.DefaultResponse;
import org.springframework.cloud.client.loadbalancer.EmptyResponse;
import org.springframework.cloud.client.loadbalancer.Response;
import org.springframework.cloud.loadbalancer.core.*;
import reactor.core.publisher.Mono;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

/**
 * 自定义动态权重负载均衡器
 */
public class NacosWeightLoadBalancer implements ReactorServiceInstanceLoadBalancer {

    private final ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;
    private final String serviceId;

    public NacosWeightLoadBalancer(ObjectProvider<ServiceInstanceListSupplier> supplierProvider, String serviceId) {
        this.serviceInstanceListSupplierProvider = supplierProvider;
        this.serviceId = serviceId;
    }

    @Override
    public Mono<Response<ServiceInstance>> choose(Request request) {
        ServiceInstanceListSupplier supplier = serviceInstanceListSupplierProvider.getIfAvailable();
        if (supplier == null) {
            return Mono.just(new EmptyResponse());
        }
        return supplier.get(request).next().map(this::getInstanceResponse);
    }

    private Response<ServiceInstance> getInstanceResponse(List<ServiceInstance> instances) {
        if (instances.isEmpty()) {
            return new EmptyResponse();
        }

        // 1. 统计存活实例的总权重
        double totalWeight = 0.0;
        for (ServiceInstance instance : instances) {
            // 从 Nacos 元数据中提取配置的权重参数，默认值为 1.0
            double weight = Double.parseDouble(instance.getMetadata().getOrDefault("nacos.weight", "1.0"));
            totalWeight += weight;
        }

        // 2. 在总权重区间内产生一个随机浮点数
        double randomValue = ThreadLocalRandom.current().nextDouble(totalWeight);

        // 3. 轮盘赌匹配：判定随机值落入哪个实例的权重区间内
        double currentSum = 0.0;
        for (ServiceInstance instance : instances) {
            double weight = Double.parseDouble(instance.getMetadata().getOrDefault("nacos.weight", "1.0"));
            currentSum += weight;
            if (randomValue <= currentSum) {
                System.out.println("[LoadBalancer] 选中实例: " + instance.getHost() + ":" + instance.getPort() + ", 权重: " + weight);
                return new DefaultResponse(instance);
            }
        }

        return new DefaultResponse(instances.get(0));
    }
}

2. 全局配置装配层

package com.company.infra.loadbalancer.config;

import com.company.infra.loadbalancer.NacosWeightLoadBalancer;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.loadbalancer.core.ReactorLoadBalancer;
import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.core.env.Environment;

public class CustomLoadBalancerConfiguration {

    @Bean
    public ReactorLoadBalancer<ServiceInstance> reactorServiceInstanceLoadBalancer(
            Environment environment, LoadBalancerClientFactory loadBalancerClientFactory) {
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        return new NacosWeightLoadBalancer(
                loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name
        );
    }
}

四、 总结

Spring Cloud LoadBalancer 的自定义动态权重负载算法，是云原生环境下应对异构服务器混部与灰度流控的“流量天平”。

It 通过**基于轮盘赌算法的随机区间概率映射，完美消除了默认均分算法导致低配机器过载崩溃的痛点，确保了集群整体的负载最优化；并与 Nacos 元数据机制解耦对齐，支持在运行期在线调整权重，达成了弹性自调优**。掌握这套 ReactorServiceInstanceLoadBalancer 接口定制流程与区间匹配算法，是进行高性能微服务调用链路调优、实现平滑灰度发布 of 核心看家本领！