代码质量标准¶

// 类名：PascalCase
public class LoadBalancerFactory { }

// 方法名：camelCase
public ServiceInstance selectInstance() { }

// 常量：UPPER_SNAKE_CASE
public static final int DEFAULT_TIMEOUT = 30;

// 包名：小写，点分隔
package org.unreal.modelrouter.adapter;

// 正确的导入顺序
import java.util.List;           // Java 标准库
import java.util.concurrent.*;   // Java 标准库

import org.springframework.*;    // 第三方库

import org.unreal.modelrouter.*; // 项目内部包

// 好的例子：职责单一
public class TokenBucketRateLimiter implements RateLimiter {
    // 只负责令牌桶限流逻辑
}

// 不好的例子：职责混乱
public class ServiceManager {
    // 既管理服务，又处理限流，还负责监控
}

// 好的例子：对扩展开放，对修改关闭
public abstract class BaseAdapter {
    public final Mono<String> processRequest(String serviceType, String requestBody, ServiceInstance instance) {
        // 模板方法，子类扩展具体实现
        return doProcessRequest(serviceType, requestBody, instance);
    }

    protected abstract Mono<String> doProcessRequest(String serviceType, String requestBody, ServiceInstance instance);
}

// 好的例子：方法简洁，职责明确
public ServiceInstance selectInstance(List<ServiceInstance> instances, String clientInfo) {
    validateInstances(instances);
    return doSelect(instances, clientInfo);
}

private void validateInstances(List<ServiceInstance> instances) {
    if (instances == null || instances.isEmpty()) {
        throw new IllegalArgumentException("Instances cannot be null or empty");
    }
}

private ServiceInstance doSelect(List<ServiceInstance> instances, String clientInfo) {
    // 具体选择逻辑
}

// 好的例子：使用配置对象
public LoadBalancer createLoadBalancer(LoadBalanceConfig config) {
    // 实现逻辑
}

// 不好的例子：参数过多
public LoadBalancer createLoadBalancer(String type, int weight, boolean enabled, 
                                     long timeout, String strategy, Map<String, Object> properties) {
    // 参数过多，难以维护
}

// 业务异常：可恢复的错误
public class ServiceUnavailableException extends RuntimeException {
    public ServiceUnavailableException(String message, Throwable cause) {
        super(message, cause);
    }
}

// 系统异常：不可恢复的错误
public class ConfigurationException extends RuntimeException {
    public ConfigurationException(String message) {
        super(message);
    }
}

// 好的例子：具体的异常处理
public Mono<String> processRequest(String requestBody, ServiceInstance instance) {
    return webClient.post()
        .uri(instance.getBaseUrl() + instance.getPath())
        .bodyValue(requestBody)
        .retrieve()
        .bodyToMono(String.class)
        .onErrorMap(WebClientResponseException.class, ex -> {
            if (ex.getStatusCode().is5xxServerError()) {
                return new ServiceUnavailableException("Service temporarily unavailable", ex);
            }
            return new InvalidRequestException("Invalid request: " + ex.getMessage(), ex);
        })
        .timeout(Duration.ofSeconds(30))
        .onErrorMap(TimeoutException.class, ex -> 
            new ServiceTimeoutException("Request timeout", ex));
}

// 好的例子：结构化日志
log.info("Load balancer selected instance: type={}, instance={}, clientInfo={}", 
         balancerType, instance.getName(), clientInfo);

log.error("Failed to process request: serviceType={}, error={}", 
          serviceType, ex.getMessage(), ex);

// 不好的例子：信息不足
log.info("Selected instance");
log.error("Error occurred", ex);

// 好的例子：脱敏处理
log.info("User request: userId={}, requestId={}", 
         maskUserId(userId), requestId);

private String maskUserId(String userId) {
    if (userId == null || userId.length() <= 4) {
        return "****";
    }
    return userId.substring(0, 2) + "****" + userId.substring(userId.length() - 2);
}

/**
 * 负载均衡器工厂类
 * 
 * <p>负责创建和管理不同类型的负载均衡器实例。支持以下负载均衡策略：
 * <ul>
 *   <li>随机选择 (random)</li>
 *   <li>轮询调度 (round-robin)</li>
 *   <li>最少连接 (least-connections)</li>
 *   <li>IP哈希 (ip-hash)</li>
 * </ul>
 * 
 * <p>该类是线程安全的，可以在多线程环境中使用。
 * 
 * @author 开发者姓名
 * @since 1.0.0
 * @see LoadBalancer
 * @see LoadBalanceConfig
 */
public class LoadBalancerFactory {
    // 实现代码
}

/**
 * 根据配置创建负载均衡器实例
 * 
 * <p>根据提供的配置信息创建对应类型的负载均衡器。如果配置中指定的类型
 * 不支持，将抛出 IllegalArgumentException 异常。
 * 
 * @param config 负载均衡配置，不能为 null
 * @return 负载均衡器实例，永远不会返回 null
 * @throws IllegalArgumentException 当配置类型不支持时
 * @throws ConfigurationException 当配置参数无效时
 * @since 1.0.0
 */
public LoadBalancer createLoadBalancer(LoadBalanceConfig config) {
    // 实现代码
}

public ServiceInstance selectByLeastConnections(List<ServiceInstance> instances) {
    // 使用最少连接算法选择实例
    // 1. 遍历所有可用实例
    // 2. 统计每个实例的当前连接数
    // 3. 选择连接数最少的实例
    // 4. 如果有多个实例连接数相同，则随机选择一个

    ServiceInstance selected = null;
    int minConnections = Integer.MAX_VALUE;

    for (ServiceInstance instance : instances) {
        int connections = connectionCounter.getConnections(instance);
        if (connections < minConnections) {
            minConnections = connections;
            selected = instance;
        }
    }

    return selected;
}