Code Quality Standards¶

// Class name: PascalCase
public class LoadBalancerFactory { }

// Method name: camelCase
public ServiceInstance selectInstance() { }

// Constants: UPPER_SNAKE_CASE
public static final int DEFAULT_TIMEOUT = 30;

// Package name: lowercase, dot-separated
package org.unreal.modelrouter.adapter;

// Correct import order
import java.util.List;           // Java standard library
import java.util.concurrent.*;   // Java standard library

import org.springframework.*;    // Third-party libraries

import org.unreal.modelrouter.*; // Project internal packages

// Good example: Single responsibility
public class TokenBucketRateLimiter implements RateLimiter {
    // Only responsible for token bucket rate limiting logic
}

// Bad example: Confused responsibilities
public class ServiceManager {
    // Manages services, handles rate limiting, and monitoring
}

// Good example: Open for extension, closed for modification
public abstract class BaseAdapter {
    public final Mono<String> processRequest(String serviceType, String requestBody, ServiceInstance instance) {
        // Template method, subclasses extend specific implementation
        return doProcessRequest(serviceType, requestBody, instance);
    }

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

// Good example: Concise method with clear responsibility
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) {
    // Specific selection logic
}

// Good example: Using configuration object
public LoadBalancer createLoadBalancer(LoadBalanceConfig config) {
    // Implementation logic
}

// Bad example: Too many parameters
public LoadBalancer createLoadBalancer(String type, int weight, boolean enabled, 
                                     long timeout, String strategy, Map<String, Object> properties) {
    // Too many parameters, difficult to maintain
}

// Business exception: Recoverable errors
public class ServiceUnavailableException extends RuntimeException {
    public ServiceUnavailableException(String message, Throwable cause) {
        super(message, cause);
    }
}

// System exception: Irrecoverable errors
public class ConfigurationException extends RuntimeException {
    public ConfigurationException(String message) {
        super(message);
    }
}

// Good example: Specific exception handling
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));
}

// Good example: Structured logging
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);

// Bad example: Insufficient information
log.info("Selected instance");
log.error("Error occurred", ex);

// Good example: Data masking
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);
}

/**
 * Load balancer factory class
 * 
 * <p>Responsible for creating and managing different types of load balancer instances. Supports the following load balancing strategies:
 * <ul>
 *   <li>Random selection (random)</li>
 *   <li>Round-robin scheduling (round-robin)</li>
 *   <li>Least connections (least-connections)</li>
 *   <li>IP hash (ip-hash)</li>
 * </ul>
 * 
 * <p>This class is thread-safe and can be used in multi-threaded environments.
 * 
 * @author Developer Name
 * @since 1.0.0
 * @see LoadBalancer
 * @see LoadBalanceConfig
 */
public class LoadBalancerFactory {
    // Implementation code
}

/**
 * Create load balancer instance based on configuration
 * 
 * <p>Creates a load balancer of the corresponding type based on the provided configuration. 
 * Throws IllegalArgumentException if the type specified in the configuration is not supported.
 * 
 * @param config Load balancing configuration, cannot be null
 * @return Load balancer instance, never returns null
 * @throws IllegalArgumentException When configuration type is not supported
 * @throws ConfigurationException When configuration parameters are invalid
 * @since 1.0.0
 */
public LoadBalancer createLoadBalancer(LoadBalanceConfig config) {
    // Implementation code
}

public ServiceInstance selectByLeastConnections(List<ServiceInstance> instances) {
    // Select instance using least connections algorithm
    // 1. Iterate through all available instances
    // 2. Count current connections for each instance
    // 3. Select the instance with the fewest connections
    // 4. If multiple instances have the same connection count, randomly select one

    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;
}