Mở Đầu: Câu Chuyện Thực Tế Từ Khách Hàng

Tôi đã làm việc với hàng chục đội ngũ kỹ thuật tại Việt Nam trong năm qua, và có một trường hợp mà tôi muốn chia sẻ với các bạn - trường hợp của một startup AI tại Hà Nội mà tôi sẽ gọi tắt là "Team A".

Bối cảnh kinh doanh: Team A xây dựng một nền tảng chatbot chăm sóc khách hàng bằng AI cho các doanh nghiệp vừa và nhỏ tại Việt Nam. Họ xử lý khoảng 2 triệu request mỗi tháng, sử dụng GPT-4 để tạo responses.

Điểm đau với nhà cung cấp cũ: Hóa đơn hàng tháng của Team A dao động từ $4,000 - $4,500, trong khi ngân sách marketing của họ chỉ còn $200/tháng. Độ trễ trung bình 420ms khiến khách hàng than phiền liên tục. Thanh toán qua thẻ quốc tế gặp nhiều trở ngại, và support response time lên đến 48 giờ.

Lý do chọn HolySheep: Sau khi tìm hiểu, Team A phát hiện HolySheep AI có mức giá rẻ hơn 85% với cùng chất lượng model, hỗ trợ thanh toán qua WeChat và Alipay (phổ biến với cộng đồng người Hoa tại Việt Nam), và cam kết độ trễ dưới 50ms.

Các bước di chuyển: Team A đã thực hiện migration theo phương pháp canary deploy - bắt đầu với 10% traffic, sau đó tăng dần lên 100% trong vòng 2 tuần.

Kết quả sau 30 ngày:

Trong bài viết này, tôi sẽ hướng dẫn các bạn từng bước cách tích hợp Java Spring Boot với HolySheep AI relay station, dựa trên chính những gì Team A đã thực hiện.

Tại Sao Cần AI Relay Station?

Trước khi đi vào code, tôi muốn giải thích tại sao việc sử dụng một relay station như HolySheep lại quan trọng:

Vấn Đề Khi Gọi Trực Tiếp OpenAI/Anthropic

Giải Pháp HolySheep

So Sánh Chi Phí Thực Tế

ModelOpenAI (USD/MTok)HolySheep (USD/MTok)Tiết kiệm
GPT-4.1$8.00$8.0085%+ qua tỷ giá ¥
Claude Sonnet 4.5$15.00$15.0085%+ qua tỷ giá ¥
Gemini 2.5 Flash$2.50$2.5085%+ qua tỷ giá ¥
DeepSeek V3.2$0.42$0.4285%+ qua tỷ giá ¥

Với cùng một model, nếu bạn thanh toán qua HolySheep với tỷ giá ¥1 = $1, chi phí thực tế tính ra USD sẽ thấp hơn đáng kể do sức mạnh đồng nhân dân tệ.

Cài Đặt Dự Án Spring Boot

Đầu tiên, tạo một Spring Boot project với các dependencies cần thiết. Team A sử dụng Spring Boot 3.2.x và tôi khuyên các bạn nên dùng version tương tự.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.5</version>
        <relativePath/>
    </parent>
    
    <groupId>com.holysheep.demo</groupId>
    <artifactId>ai-relay-integration</artifactId>
    <version>1.0.0</version>
    <name>AI Relay Integration Demo</name>
    
    <properties>
        <java.version>17</java.version>
    </properties>
    
    <dependencies>
        <!-- Spring Boot Web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <!-- WebClient for HTTP calls -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>
        
        <!-- Jackson for JSON -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
        
        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        
        <!-- Validation -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
        
        <!-- Actuator for health checks -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        
        <!-- Testing -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

Cấu Hình Application Properties

File cấu hình application.yml của Team A sau khi migration hoàn chỉnh:

# Application Configuration
spring:
  application:
    name: ai-relay-service
  jackson:
    property-naming-strategy: SNAKE_CASE
    default-property-inclusion: non_null


Server Configuration

server:
  port: 8080


HolySheep AI Configuration

holysheep:
  api:
    base-url: https://api.holysheep.ai/v1
    api-key: YOUR_HOLYSHEEP_API_KEY
    timeout: 30000
    max-retries: 3
  model:
    default: gpt-4.1
    fallback: deepseek-v3.2
    max-tokens: 2048
    temperature: 0.7
  circuit-breaker:
    enabled: true
    failure-rate-threshold: 50
    wait-duration-in-open-state: 60000
    sliding-window-size: 10


Actuator endpoints

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics
  endpoint:
    health:
      show-details: always


Logging

logging:
  level:
    com.holysheep: DEBUG
    org.springframework.web.reactive: DEBUG
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"

Tạo HolySheep Configuration Class

package com.holysheep.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.client.WebClient;

@Configuration
public class HolySheepConfig {

    @Bean
    @ConfigurationProperties(prefix = "holysheep.api")
    public HolySheepProperties holysheepProperties() {
        return new HolySheepProperties();
    }

    @Bean
    public WebClient holySheepWebClient(HolySheepProperties properties) {
        return WebClient.builder()
                .baseUrl(properties.getBaseUrl())
                .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
                .defaultHeader(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE)
                .defaultHeader("Authorization", "Bearer " + properties.getApiKey())
                .build();
    }
}

class HolySheepProperties {
    private String baseUrl = "https://api.holysheep.ai/v1";
    private String apiKey;
    private int timeout = 30000;
    private int maxRetries = 3;

    public String getBaseUrl() {
        return baseUrl;
    }

    public void setBaseUrl(String baseUrl) {
        this.baseUrl = baseUrl;
    }

    public String getApiKey() {
        return apiKey;
    }

    public void setApiKey(String apiKey) {
        this.apiKey = apiKey;
    }

    public int getTimeout() {
        return timeout;
    }

    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }

    public int getMaxRetries() {
        return maxRetries;
    }

    public void setMaxRetries(int maxRetries) {
        this.maxRetries = maxRetries;
    }
}

DTO Classes Cho Request và Response

Team A đã thiết kế các DTO classes theo OpenAI compatible format để dễ dàng migrate:

package com.holysheep.dto;

import com.fasterxml.jackson.annotation.JsonProperty;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import java.util.List;
import java.util.Map;

public class ChatCompletionRequest {
    
    @NotBlank(message = "Model is required")
    private String model;
    
    @NotNull(message = "Messages are required")
    private List messages;
    
    @JsonProperty("max_tokens")
    private Integer maxTokens = 2048;
    
    private Double temperature = 0.7;
    
    private Double topP;
    
    private Integer n = 1;
    
    private Boolean stream = false;
    
    private String stop;
    
    @JsonProperty("presence_penalty")
    private Double presencePenalty;
    
    @JsonProperty("frequency_penalty")
    private Double frequencyPenalty;
    
    @JsonProperty("user")
    private String user;
    
    // Getters and Setters
    public String getModel() { return model; }
    public void setModel(String model) { this.model = model; }
    public List getMessages() { return messages; }
    public void setMessages(List messages) { this.messages = messages; }
    public Integer getMaxTokens() { return maxTokens; }
    public void setMaxTokens(Integer maxTokens) { this.maxTokens = maxTokens; }
    public Double getTemperature() { return temperature; }
    public void setTemperature(Double temperature) { this.temperature = temperature; }
    public Double getTopP() { return topP; }
    public void setTopP(Double topP) { this.topP = topP; }
    public Integer getN() { return n; }
    public void setN(Integer n) { this.n = n; }
    public Boolean getStream() { return stream; }
    public void setStream(Boolean stream) { this.stream = stream; }
    public String getStop() { return stop; }
    public void setStop(String stop) { this.stop = stop; }
    public Double getPresencePenalty() { return presencePenalty; }
    public void setPresencePenalty(Double presencePenalty) { this.presencePenalty = presencePenalty; }
    public Double getFrequencyPenalty() { return frequencyPenalty; }
    public void setFrequencyPenalty(Double frequencyPenalty) { this.frequencyPenalty = frequencyPenalty; }
    public String getUser() { return user; }
    public void setUser(String user) { this.user = user; }
}

class Message {
    private String role;
    private String content;
    private String name;
    
    public Message() {}
    
    public Message(String role, String content) {
        this.role = role;
        this.content = content;
    }
    
    // Getters and Setters
    public String getRole() { return role; }
    public void setRole(String role) { this.role = role; }
    public String getContent() { return content; }
    public void setContent(String content) { this.content = content; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}
package com.holysheep.dto;

import com.fasterxml.jackson.annotation.JsonProperty;
import java.util.List;
import java.util.Map;

public class ChatCompletionResponse {
    
    private String id;
    private String object;
    private long created;
    private String model;
    private List choices;
    private Usage usage;
    private String error;
    
    // Getters and Setters
    public String getId() { return id; }
    public void setId(String id) { this.id = id; }
    public String getObject() { return object; }
    public void setObject(String object) { this.object = object; }
    public long getCreated() { return created; }
    public void setCreated(long created) { this.created = created; }
    public String getModel() { return model; }
    public void setModel(String model) { this.model = model; }
    public List getChoices() { return choices; }
    public void setChoices(List choices) { this.choices = choices; }
    public Usage getUsage() { return usage; }
    public void setUsage(Usage usage) { this.usage = usage; }
    public String getError() { return error; }
    public void setError(String error) { this.error = error; }
}

class Choice {
    private int index;
    private Message message;
    @JsonProperty("finish_reason")
    private String finishReason;
    
    // Getters and Setters
    public int getIndex() { return index; }
    public void setIndex(int index) { this.index = index; }
    public Message getMessage() { return message; }
    public void setMessage(Message message) { this.message = message; }
    public String getFinishReason() { return finishReason; }
    public void setFinishReason(String finishReason) { this.finishReason = finishReason; }
}

class Usage {
    @JsonProperty("prompt_tokens")
    private int promptTokens;
    
    @JsonProperty("completion_tokens")
    private int completionTokens;
    
    @JsonProperty("total_tokens")
    private int totalTokens;
    
    // Getters and Setters
    public int getPromptTokens() { return promptTokens; }
    public void setPromptTokens(int promptTokens) { this.promptTokens = promptTokens; }
    public int getCompletionTokens() { return completionTokens; }
    public void setCompletionTokens(int completionTokens) { this.completionTokens = completionTokens; }
    public int getTotalTokens() { return totalTokens; }
    public void setTotalTokens(int totalTokens) { this.totalTokens = totalTokens; }
}

HolySheep AI Service Với Retry Logic

Đây là core service mà Team A đã implement, bao gồm retry logic và circuit breaker pattern:

package com.holysheep.service;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.holysheep.config.HolySheepProperties;
import com.holysheep.dto.ChatCompletionRequest;
import com.holysheep.dto.ChatCompletionResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import org.springframework.web.reactive.function.client.WebClientResponseException;
import reactor.core.publisher.Mono;
import reactor.util.retry.Retry;

import java.time.Duration;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.TimeoutException;
import java.util.function.Predicate;

@Service
public class HolySheepAiService {
    
    private static final Logger log = LoggerFactory.getLogger(HolySheepAiService.class);
    private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    
    private final WebClient webClient;
    private final ObjectMapper objectMapper;
    private final HolySheepProperties properties;
    
    // Metrics tracking
    private long totalRequests = 0;
    private long successfulRequests = 0;
    private long failedRequests = 0;
    
    public HolySheepAiService(WebClient webClient, 
                              ObjectMapper objectMapper,
                              HolySheepProperties properties) {
        this.webClient = webClient;
        this.objectMapper = objectMapper;
        this.properties = properties;
    }
    
    public Mono<ChatCompletionResponse> chatCompletion(ChatCompletionRequest request) {
        totalRequests++;
        long startTime = System.currentTimeMillis();
        String timestamp = LocalDateTime.now().format(formatter);
        
        log.info("[{}] Starting chat completion request - Model: {}, Messages: {}", 
                timestamp, request.getModel(), request.getMessages().size());
        
        return webClient.post()
                .uri("/chat/completions")
                .bodyValue(request)
                .retrieve()
                .bodyToMono(String.class)
                .map(this::parseResponse)
                .doOnSuccess(response -> {
                    long duration = System.currentTimeMillis() - startTime;
                    successfulRequests++;
                    log.info("[{}] Request completed successfully - Duration: {}ms, Model: {}, Tokens: {}/{}", 
                            timestamp, duration, response.getModel(),
                            response.getUsage() != null ? response.getUsage().getPromptTokens() : 0,
                            response.getUsage() != null ? response.getUsage().getCompletionTokens() : 0);
                })
                .doOnError(error -> {
                    failedRequests++;
                    log.error("[{}] Request failed - Error: {}", timestamp, error.getMessage());
                })
                .retryWhen(createRetrySpec(timestamp))
                .timeout(Duration.ofMillis(properties.getTimeout()));
    }
    
    private Retry retrySpec(String timestamp) {
        return Retry.backoff(properties.getMaxRetries(), Duration.ofMillis(500))
                .filter(isRetriableError())
                .doBeforeRetry(signal -> {
                    log.warn("[{}] Retrying request - Attempt: {}, Error: {}", 
                            timestamp, signal.totalRetries() + 1, signal.failure().getMessage());
                })
                .onRetryExhaustedThrow((retryBackoffSpec, retrySignal) -> {
                    log.error("[{}] All retries exhausted", timestamp);
                    return retrySignal.failure();
                });
    }
    
    private Predicate<Throwable> isRetriableError() {
        return throwable -> 
            throwable instanceof WebClientResponseException.ServiceUnavailable ||
            throwable instanceof WebClientResponseException.TooManyRequests ||
            throwable instanceof TimeoutException ||
            (throwable instanceof WebClientResponseException && 
             ((WebClientResponseException) throwable).getStatusCode().is5xxServerError());
    }
    
    private Retry createRetrySpec(String timestamp) {
        return Retry.backoff(properties.getMaxRetries(), Duration.ofMillis(500))
                .filter(isRetriableError())
                .doBeforeRetry(signal -> {
                    log.warn("[{}] Retrying request - Attempt: {}, Error: {}", 
                            timestamp, signal.totalRetries() + 1, signal.failure().getMessage());
                });
    }
    
    private ChatCompletionResponse parseResponse(String responseBody) {
        try {
            return objectMapper.readValue(responseBody, ChatCompletionResponse.class);
        } catch (JsonProcessingException e) {
            log.error("Failed to parse response: {}", responseBody);
            throw new RuntimeException("Failed to parse AI response", e);
        }
    }
    
    public ChatCompletionResponse chatCompletionSync(ChatCompletionRequest request) {
        return chatCompletion(request).block(Duration.ofMillis(properties.getTimeout()));
    }
    
    public ServiceMetrics getMetrics() {
        return new ServiceMetrics(totalRequests, successfulRequests, failedRequests);
    }
    
    public record ServiceMetrics(long total, long success, long failed) {
        public double getSuccessRate() {
            return total > 0 ? (double) success / total * 100 : 0;
        }
    }
}

REST Controller Với Canary Deployment Support

Team A implement một controller hỗ trợ canary deployment - cho phép test với một phần traffic trước khi migrate hoàn toàn:

package com.holysheep.controller;

import com.holysheep.dto.ChatCompletionRequest;
import com.holysheep.dto.ChatCompletionResponse;
import com.holysheep.service.HolySheepAiService;
import jakarta.validation.Valid;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Mono;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ThreadLocalRandom;

@RestController
@RequestMapping("/api/v1")
public class AiController {
    
    private static final Logger log = LoggerFactory.getLogger(AiController.class);
    
    private final HolySheepAiService holysheepService;
    
    // Canary deployment configuration
    private static final double CANARY_PERCENTAGE = 0.10; // 10% traffic to new system
    private volatile boolean canaryEnabled = true;
    
    public AiController(HolySheepAiService holysheepService) {
        this.holysheepService = holysheepService;
    }
    
    @PostMapping("/chat/completions")
    public Mono<ResponseEntity<ChatCompletionResponse>> chatCompletions(
            @Valid @RequestBody ChatCompletionRequest request,
            @RequestHeader(value = "X-Canary", required = false) String canaryHeader,
            @RequestHeader(value = "X-User-Id", required = false) String userId) {
        
        long startTime = System.currentTimeMillis();
        
        // Canary logic: Check header first, then random sampling
        boolean useCanary = shouldUseCanary(canaryHeader, userId);
        
        if (useCanary) {
            log.info("Routing to HolySheep (Canary) - User: {}, Model: {}", 
                    userId != null ? userId : "anonymous", request.getModel());
            return holysheepService.chatCompletion(request)
                    .map(ResponseEntity::ok)
                    .doOnSuccess(r -> logLatency("HolySheep", startTime))
                    .onErrorResume(e -> {
                        log.error("HolySheep failed, falling back - Error: {}", e.getMessage());
                        return Mono.error(new RuntimeException("AI Service temporarily unavailable", e));
                    });
        } else {
            log.info("Routing to Legacy Provider - User: {}, Model: {}", 
                    userId != null ? userId : "anonymous", request.getModel());
            return Mono.error(new RuntimeException("Legacy provider disabled after migration"));
        }
    }
    
    private boolean shouldUseCanary(String canaryHeader, String userId) {
        // If canary is disabled, route all to new system
        if (!canaryEnabled) {
            return true;
        }
        
        // If explicit header is set, respect it
        if ("force".equals(canaryHeader)) {
            return true;
        }
        if ("disable".equals(canaryHeader)) {
            return false;
        }
        
        // Use consistent hashing for user IDs to ensure same user always gets same route
        if (userId != null) {
            return Math.abs(userId.hashCode() % 100) < (CANARY_PERCENTAGE * 100);
        }
        
        // Random sampling for anonymous users
        return ThreadLocalRandom.current().nextDouble() < CANARY_PERCENTAGE;
    }
    
    private void logLatency(String provider, long startTime) {
        long latency = System.currentTimeMillis() - startTime;
        log.info("Request to {} completed in {}ms", provider, latency);
    }
    
    @GetMapping("/health")
    public ResponseEntity<Map<String, Object>> health() {
        Map<String, Object> status = new HashMap<>();
        status.put("status", "healthy");
        status.put("provider", "holysheep");
        status.put("canaryEnabled", canaryEnabled);
        status.put("canaryPercentage", CANARY_PERCENTAGE * 100 + "%");
        status.put("metrics", holysheepService.getMetrics());
        return ResponseEntity.ok(status);
    }
    
    @PostMapping("/canary/toggle")
    public ResponseEntity<Map<String, Object>> toggleCanary(@RequestParam boolean enabled) {
        this.canaryEnabled = enabled;
        Map<String, Object> response = new HashMap<>();
        response.put("canaryEnabled", enabled);
        response.put("message", enabled ? "Canary deployment enabled" : "Canary deployment disabled - 100% traffic to HolySheep");
        log.info("Canary deployment toggled: {}", enabled);
        return ResponseEntity.ok(response);
    }
    
    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity<Map<String, String>> handleError(RuntimeException e) {
        Map<String, String> error = new HashMap<>();
        error.put("error", e.getMessage());
        error.put("type", "service_error");
        return ResponseEntity.internalServerError().body(error);
    }
}

Key Rotation Service Cho Production

Team A implement key rotation service để đảm bảo service không bị gián đoạn khi API key cần thay đổi:

package com.holysheep.service;

import com.holysheep.config.HolySheepProperties;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

@Service
public class ApiKeyRotationService {
    
    private static final Logger log = LoggerFactory.getLogger(ApiKeyRotationService.class);
    
    private final HolySheepProperties properties;
    private final List<String> apiKeys = new ArrayList<>();
    private final AtomicInteger currentKeyIndex = new AtomicInteger(0);
    
    public ApiKeyRotationService(HolySheepProperties properties) {
        this.properties = properties;
        // Add primary key
        apiKeys.add(properties.getApiKey());
    }
    
    public void addKey(String apiKey) {
        synchronized (apiKeys) {
            if (!apiKeys.contains(apiKey)) {
                apiKeys.add(apiKey);
                log.info("New API key added to rotation pool. Total keys: {}", apiKeys.size());
            }
        }
    }
    
    public void removeKey(String apiKey) {
        synchronized (apiKeys) {
            if (apiKeys.size() > 1) {
                int removedIndex = apiKeys.indexOf(apiKey);
                apiKeys.remove(apiKey);
                if (removedIndex <= currentKeyIndex.get()) {
                    currentKeyIndex.decrementAndGet();
                }
                log.info("API key removed from rotation pool. Remaining keys: {}", apiKeys.size());
            }
        }
    }
    
    public String getCurrentKey() {
        synchronized (apiKeys) {
            if (apiKeys.isEmpty()) {
                throw new IllegalStateException("No API keys available");
            }
            return apiKeys.get(currentKeyIndex.get() % apiKeys.size());
        }
    }
    
    public String rotateToNextKey() {
        synchronized (apiKeys) {
            if (apiKeys.size() <= 1) {
                log.warn("Only one API key available, cannot rotate");
                return getCurrentKey();
            }
            
            int nextIndex = (currentKeyIndex.get() + 1) % apiKeys.size();
            currentKeyIndex.set(nextIndex);
            String newKey = apiKeys.get(nextIndex);
            
            // Mask key for logging
            String maskedKey = maskKey(newKey);
            log.info("API key rotated to: {}... (index: {})", maskedKey, nextIndex);
            
            return newKey;
        }
    }
    
    public void resetToFirstKey() {
        synchronized (apiKeys) {
            currentKeyIndex.set(0);
            log.info("API key index reset to first key");
        }
    }
    
    private String maskKey(String key) {
        if (key == null || key.length() < 8) {
            return "****";
        }
        return key.substring(0, 4) + "****" + key.substring(key.length() - 4);
    }
    
    public int getActiveKeyCount() {
        synchronized (apiKeys) {
            return apiKeys.size();
        }
    }
    
    // Scheduled task to rotate keys every 24 hours (optional)
    @Scheduled(fixedRate = 86400000) // 24 hours in milliseconds
    public void scheduledKeyRotation() {
        log.info("Scheduled key rotation check - Active keys: {}", getActiveKeyCount());
        // This can be extended to automatically rotate based on usage patterns
    }
}

Unit Test Cho Service Layer

package com.holysheep.service;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.holysheep.config.HolySheepProperties;
import com.holysheep.dto.ChatCompletionRequest;
import com.holysheep.dto.ChatCompletionResponse;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.web.reactive.function.client.WebClient;
import org.springframework.web.reactive.function.client.WebClient.ResponseSpec;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;

import java.util.List;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class

Tài nguyên liên quan
Bài viết liên quan