#负载均衡模式

@Configuration
public class RibbonConfiguration {
    
    @Bean
    public IRule ribbonRule() {
        // 使用区域亲和策略：优先选择同区域实例，避免跨机房调用
        ZoneAvoidanceRule rule = new ZoneAvoidanceRule();
        rule.setAvailabilityPredicate(
            new AvailabilityPredicate() {
                @Override
                public boolean apply(com.netflix.loadbalancer.Server s) {
                    // 过滤掉断路器打开的服务实例
                    DiscoveryEnabledServer server = (DiscoveryEnabledServer) s;
                    return server.isReadyToServe();
                }
            }
        );
        return rule;
    }
}

// 指定服务使用自定义 Ribbon 配置
@RibbonClient(name = "user-service", configuration = RibbonConfiguration.class)
public class UserServiceRibbonClient {
    // ...
}

@Configuration
public class RetryConfiguration {
    
    @Bean
    public RetryHandler retryHandler() {
        return new DefaultLoadBalancerRetryHandler(
            3,  // 最大重试次数
            1,  // 同一实例最大重试次数
            true  // 是否对所有操作重试
        );
    }
}

@Configuration
@LoadBalancerClient(name = "user-service", configuration = LoadBalancerConfig.class)
public class LoadBalancerConfig {
    
    @Bean
    public ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(
            ServiceInstanceListSupplier supplier) {
        return new RandomLoadBalancer(supplier);
    }
    
    @Bean
    public ServiceInstanceListSupplier serviceInstanceListSupplier(
            ConfigurableApplicationContext context) {
        return ServiceInstanceListSupplier.builder()
            .withDiscoveryClient()
            .withSameInstancePreference()
            .build(context);
    }
}

public class WeightedLoadBalancer implements ReactorServiceInstanceLoadBalancer {
    
    private final ObjectProvider<ServiceInstanceListSupplier> supplierProvider;
    private final String serviceId;
    private final AtomicLong sequence = new AtomicLong(0);
    
    public WeightedLoadBalancer(
            ObjectProvider<ServiceInstanceListSupplier> supplierProvider,
            String serviceId) {
        this.supplierProvider = supplierProvider;
        this.serviceId = serviceId;
    }
    
    @Override
    public Mono<Response<ServiceInstance>> choose(Request<?> request) {
        ServiceInstanceListSupplier supplier = supplierProvider.getIfAvailable();
        return supplier.get(request)
            .next()
            .map(instances -> getInstanceResponse(instances, request));
    }
    
    private Response<ServiceInstance> getInstanceResponse(
            List<ServiceInstance> instances, Request<?> request) {
        
        if (instances.isEmpty()) {
            return new EmptyResponse();
        }
        
        // 根据响应时间权重选择实例
        Map<ServiceInstance, Integer> weights = calculateWeights(instances);
        int totalWeight = weights.values().stream().mapToInt(Integer::intValue).sum();
        int randomValue = ThreadLocalRandom.current().nextInt(totalWeight);
        
        int cumulative = 0;
        for (Map.Entry<ServiceInstance, Integer> entry : weights.entrySet()) {
            cumulative += entry.getValue();
            if (randomValue < cumulative) {
                return new Response<>(entry.getKey());
            }
        }
        
        // 兜底：返回随机实例
        return new Response<>(instances.get(
            ThreadLocalRandom.current().nextInt(instances.size())));
    }
    
    private Map<ServiceInstance, Integer> calculateWeights(
            List<ServiceInstance> instances) {
        Map<ServiceInstance, Integer> weights = new HashMap<>();
        
        for (ServiceInstance instance : instances) {
            // 从实例元数据获取权重，默认 100
            Integer weight = instance.getMetadata()
                .getOrDefault("weight", 100);
            weights.put(instance, weight);
        }
        
        return weights;
    }
}

@FeignClient(name = "user-service")
public interface UserFeignClient {
    
    @GetMapping("/users/{id}")
    User getUser(@PathVariable Long id);
    
    @GetMapping("/users")
    List<User> getUsers(@RequestParam List<Long> ids);
}