#负载均衡策略深度解析

// ❌ 硬编码服务地址
@Service
public class UserService {
    private final String USER_SERVICE_URL = "http://192.168.1.101:8080";

    public User getUser(Long id) {
        return restTemplate.getForObject(
            USER_SERVICE_URL + "/user/" + id,
            User.class
        );
    }
}

// RoundRobinRule.java - 最简单的负载均衡策略
public class RoundRobinRule extends AbstractLoadBalancerRule {
    private AtomicInteger nextServerCyclicCounter;

    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        }

        List<Server> servers = lb.getReachableServers();  // 获取可用实例

        int serverCount = servers.size();
        if (serverCount == 0) {
            return null;
        }

        // 原子递增，取模得到下一个实例索引
        int next = nextServerCyclicCounter.incrementAndGet() % serverCount;

        return servers.get(next);
    }
}

/*
 * 轮询示例：
 * 假设有 3 个实例：实例0, 实例1, 实例2
 *
 * 请求1: next=1%3=0 -> 实例0
 * 请求2: next=2%3=1 -> 实例1
 * 请求3: next=3%3=2 -> 实例2
 * 请求4: next=4%3=0 -> 实例0
 * 请求5: next=5%3=1 -> 实例1
 * ...
 */

// WeightedResponseTimeRule.java - 根据响应时间加权
public class WeightedResponseTimeRule extends AbstractLoadBalancerRule {
    // 权重数组：每个实例的权重
    // 权重 = 权重区间上限 - 权重区间下限
    // 响应时间越短，权重越大
    private volatile List<Double> accumulatedWeights = new ArrayList<>();

    // 定时更新权重（默认 30 秒）
    @edu.umd.cs.findbugs.annotations.SuppressWarnings(value = "RC")
    public Server choose(ILoadBalancer lb, Object key) {
        List<Double> currentWeights = accumulatedWeights;

        if (currentWeights == null || currentWeights.isEmpty()) {
            // 没有权重数据时，退化为轮询
            return new RoundRobinRule().choose(lb, key);
        }

        // 随机一个 [0, 总权重) 的数字
        double random = ThreadLocalRandom.current().nextDouble(
            currentWeights.get(currentWeights.size() - 1)
        );

        // 二分查找：找到权重区间对应的实例
        int index = binarySearch(currentWeights, random);
        return servers.get(index);
    }

    // 权重计算逻辑
    // 假设有 3 个实例，响应时间分别为：
    // 实例0: 100ms
    // 实例1: 50ms
    // 实例2: 150ms
    //
    // 总权重 = 100 + 50 + 150 = 300
    // 归一化权重区间：
    // 实例0: [0, 100/300] = [0, 0.33)
    // 实例1: [100/300, 150/300] = [0.33, 0.5)
    // 实例2: [150/300, 300/300] = [0.5, 1.0)
    //
    // 随机值落在哪个区间，就选择哪个实例
    // 响应时间短的实例，区间越大，被选中的概率越高
}

// BestAvailableRule.java - 选择并发数最低的实例
public class BestAvailableRule extends ClientConfigEnabledRoundRobinRule {
    @Override
    public Server choose(Object key) {
        if (loadBalancerStats == null) {
            return super.choose(key);
        }

        List<Server> servers = loadBalancerStats.getFilteredServers(
            upServers,
            predicate  // AvailabilityPredicate：过滤不可用实例
        );

        // 找到并发数最低的实例
        int minimalConcurrentConnections = Integer.MAX_VALUE;
        Server chosen = null;

        for (Server server : servers) {
            int currentConnections = loadBalancerStats
                .getSingleServerStat(server)
                .getActiveRequestsCount();

            if (currentConnections < minimalConcurrentConnections) {
                minimalConcurrentConnections = currentConnections;
                chosen = server;
            }
        }

        return chosen;
    }
}

// RetryRule.java - 轮询 + 重试
public class RetryRule extends AbstractLoadBalancerRule {
    private IRule subRule = new RoundRobinRule();  // 底层使用轮询

    @Override
    public Server choose(Object key) {
        long deadline = System.currentTimeMillis() + maxRetryMillis;

        Server server = null;
        int retries = 0;

        while (System.currentTimeMillis() <= deadline) {
            try {
                server = subRule.choose(key);  // 调用底层策略
                return server;
            } catch (UnavailableServerException e) {
                // 实例不可用，重试
                retries++;
                if (retries >= maxRetries) {
                    throw e;
                }
            }
        }

        return server;
    }
}

// ZoneAvoidanceRule.java - 优先选择同 zone，避免不健康 zone
public class ZoneAvoidanceRule extends PredicateBasedRule {
    private CompositePredicate zonePredicate;

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
        // 构建复合断言
        // 1. ZoneAffinityPredicate：优先选择同 zone
        // 2. AvailibilityPredicate：过滤不健康 zone
        this.zonePredicate = CompositePredicate.create(
            new ZoneAffinityPredicate(this.zoneAffinityPredicate),
            new AvailibilityPredicate(this.zoneAffinityPredicate, stats),
            COMPOSITE_PREDICATE_VALUE
        );
    }

    @Override
    public Server choose(Object key) {
        List<Server> servers = lb.getAllServers();

        // 1. 计算每个 zone 的平均活跃请求数
        Map<String, ZoneStats> zoneStats = calculateZoneStats(servers);

        // 2. 淘汰不健康的 zone
        // 条件：zone 的平均活跃请求数 > 阈值（默认 0.9999）
        for (String zone : zoneStats.keySet()) {
            double loadPerServer = zoneStats.get(zone).getLoad();
            if (loadPerServer > Threshold > 0.999999) {
                zoneStats.remove(zone);  // 淘汰该 zone
            }
        }

        // 3. 在剩余 zone 中使用轮询
        List<Server> availableServers = filterByZone(servers, zoneStats);
        return new RoundRobinRule().chooseFrom(availableServers);
    }
}

// ReactorLoadBalancer<T> - 响应式负载均衡接口
public interface ReactorServiceInstanceLoadBalancer extends ReactorLoadBalancer<ServiceInstance> {
    Mono<Response<ServiceInstance>> choose(Request request);
}

// 核心实现
// 1. RoundRobinLoadBalancer - 轮询
// 2. RandomLoadBalancer - 随机
// 3. WeightedServiceInstanceLoadBalancer - 加权
// 4. ZonePreferenceServiceInstanceLoadBalancer - 区域感知

// ZonePreferenceServiceInstanceLoadBalancer.java
public class ZonePreferenceServiceInstanceLoadBalancer
    implements ReactorServiceInstanceLoadBalancer {

    @Override
    public Mono<Response<ServiceInstance>> choose(Request request) {
        ServiceInstance original = getPreviousServiceInstance(request);

        // 获取请求的 zone（通过 header 或其他方式）
        String zone = getZoneFromRequest(request);

        // 过滤出同 zone 的实例
        List<ServiceInstance> zoneInstances = instances.stream()
            .filter(instance -> Objects.equals(zone, instance.getZone()))
            .collect(Collectors.toList());

        // 同 zone 有可用实例，优先使用
        if (!zoneInstances.isEmpty()) {
            return chooseFrom(zoneInstances);
        }

        // 没有同 zone 实例，使用全量实例
        return chooseFrom(instances);
    }
}

// 使用场景：多机房部署时，优先调用同机房的实例
// 减少跨机房网络延迟
spring:
  cloud:
    loadbalancer:
      configurations: zone-preference
    discovery:
      zone: us-east-1a  # 当前实例所在的 zone

// 自定义基于权重的负载均衡器
public class CustomLoadBalancer
    implements ReactorServiceInstanceLoadBalancer {

    private final ObjectProvider<ServiceInstanceListSupplier> supplierProvider;

    @Override
    public Mono<Response<ServiceInstance>> choose(Request request) {
        return supplierProvider.getIfAvailable().flatMap(supplier -> {
            return supplier.get(request).next()
                .map(instances -> {
                    // 1. 获取实例权重
                    Map<String, Double> weights = getInstanceWeights(instances);

                    // 2. 过滤不可用实例
                    instances = filterAvailable(instances);

                    // 3. 加权随机选择
                    return doWeightedSelect(instances, weights);
                });
        });
    }

    private Response<ServiceInstance> doWeightedSelect(
        List<ServiceInstance> instances,
        Map<String, Double> weights) {

        double totalWeight = weights.values().stream()
            .mapToDouble(Double::doubleValue).sum();

        double random = ThreadLocalRandom.current().nextDouble() * totalWeight;

        double cumulative = 0;
        for (ServiceInstance instance : instances) {
            cumulative += weights.getOrDefault(instance.getInstanceId(), 0.0);
            if (random <= cumulative) {
                return new Response<>(instance);
            }
        }

        return new Response<>(instances.get(0));
    }
}

// 注册为 Spring Bean
@Configuration
public class LoadBalancerConfig {
    @Bean
    public ReactorServiceInstanceLoadBalancer customLoadBalancer(
        ObjectProvider<ServiceInstanceListSupplier> supplierProvider) {
        return new CustomLoadBalancer(supplierProvider);
    }
}

// 在 @FeignClient 中使用
@FeignClient(
    name = "user-service",
    configuration = LoadBalancerConfig.class
)
public interface UserClient {}

// 动态更新权重
@Configuration
public class DynamicWeightConfig {
    @Autowired
    private DynamicProperty dynamicProperty;

    @PostConstruct
    public void init() {
        dynamicProperty.addCallback("user-service.weight", (name, oldValue, newValue) -> {
            // 解析权重配置
            Map<String, Double> weights = parseWeights(newValue);
            // 更新 LoadBalancer 的权重
            updateWeights(weights);
        });
    }
}