// 錯誤示例：硬編碼Token，無過期處理、無異常捕獲
public class DeepSeekClient {
    // 寫死的 Token，過期直接失效
    private static final String DEEPSEEK_TOKEN = "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
    private static final String API_URL = "https://api.deepseek.com/v1/chat/completions";

    public String callApi(String prompt) {
        // 直接拼 Token，不管過沒過期
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer " + DEEPSEEK_TOKEN);
        headers.setContentType(MediaType.APPLICATION_JSON);

        // 拼請求體
        Map<String, Object> requestBody = new HashMap<>();
        requestBody.put("model", "deepseek-chat");
        requestBody.put("messages", Collections.singletonList(
                Map.of("role", "user", "content", prompt)
        ));

        RestTemplate restTemplate = new RestTemplate();
        // 鑒權(quán)失敗直接拋異常，服務(wù)跟著崩
        ResponseEntity<String> response = restTemplate.postForEntity(API_URL, new HttpEntity<>(requestBody, headers), String.class);
        return response.getBody();
    }
}

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

// 讀取配置文件的工具
public class PropertiesUtils {
    private static final Properties props = new Properties();

    static {
        try (InputStream in = PropertiesUtils.class.getClassLoader().getResourceAsStream("deepseek.properties")) {
            props.load(in);
        } catch (IOException e) {
            throw new RuntimeException("加載deepseek配置文件失敗", e);
        }
    }

    public static String getProperty(String key) {
        String value = props.getProperty(key);
        if (value == null) {
            throw new RuntimeException("配置項[" + key + "]不存在");
        }
        return value;
    }
}

import org.springframework.http.*;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestTemplate;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantLock;

// Token 管理工具，自動刷新，線程安全
public class DeepSeekTokenManager {
    // 從配置文件讀
    private static final String REFRESH_TOKEN = PropertiesUtils.getProperty("deepseek.refresh.token");
    private static final String TOKEN_REFRESH_URL = "https://api.deepseek.com/v1/auth/refresh";
    // 30天有效期，提前1天刷新，單位都是毫秒
    private static final long TOKEN_VALID_PERIOD = 30 * 24 * 60 * 60 * 1000L;
    private static final long REFRESH_ADVANCE = 24 * 60 * 60 * 1000L;

    // 當(dāng)前能用的Token、過期時間、刷新用的鎖
    private volatile String currentToken;
    private volatile long expireTime;
    private final ReentrantLock refreshLock = new ReentrantLock();
    private final RestTemplate restTemplate = new RestTemplate();

    // 單例模式
    private static class SingletonHolder {
        private static final DeepSeekTokenManager INSTANCE = new DeepSeekTokenManager();
    }

    public static DeepSeekTokenManager getInstance() {
        return SingletonHolder.INSTANCE;
    }

    // 初始化的時候就加載第一個Token
    private DeepSeekTokenManager() {
        refreshToken();
    }

    // 拿能用的Token，自動判斷要不要刷新
    public String getValidToken() {
        long now = System.currentTimeMillis();
        // 現(xiàn)在的時間加提前量，快到過期時間就刷新
        if (now + REFRESH_ADVANCE >= expireTime) {
            refreshToken();
        }
        return currentToken;
    }

    // 刷新Token
    private void refreshToken() {
        if (System.currentTimeMillis() + REFRESH_ADVANCE < expireTime) {
            return;
        }

        // 加鎖后再檢查一遍，防止剛釋放鎖別人又進來了
        refreshLock.lock();
        try {
            if (System.currentTimeMillis() + REFRESH_ADVANCE < expireTime) {
                return;
            }

            // 拼刷新Token的請求
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            Map<String, String> requestBody = new HashMap<>();
            requestBody.put("refresh_token", REFRESH_TOKEN);

            ResponseEntity<Map> response = restTemplate.postForEntity(
                    TOKEN_REFRESH_URL,
                    new HttpEntity<>(requestBody, headers),
                    Map.class
            );

            if (response.getStatusCode() == HttpStatus.OK) {
                Map<String, Object> resBody = response.getBody();
                this.currentToken = (String) resBody.get("access_token");
                this.expireTime = System.currentTimeMillis() + TOKEN_VALID_PERIOD;
                System.out.println("Token刷新成功，新的過期時間：" + expireTime);
            } else {
                throw new RuntimeException("Token刷新失敗，響應(yīng)碼：" + response.getStatusCode());
            }
        } catch (Exception e) {
            System.err.println("Token刷新出問題了：" + e.getMessage());
            // 臨時延長10分鐘，給運維留時間處理
            this.expireTime = System.currentTimeMillis() + 10 * 60 * 1000L;
            throw new RuntimeException("Token刷新失敗，已臨時續(xù)命10分鐘，趕緊查！", e);
        } finally {
            refreshLock.unlock();
        }
    }
}

// DeepSeek API 調(diào)用客戶端（集成Token管理）
public class DeepSeekApiClient {
    private static final String API_URL = "https://api.deepseek.com/v1/chat/completions";
    private final RestTemplate restTemplate = new RestTemplate();
    private final DeepSeekTokenManager tokenManager = DeepSeekTokenManager.getInstance();

    public String callDeepSeek(String prompt) {
        // 獲取有效Token
        String token = tokenManager.getValidToken();
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer " + token);
        headers.setContentType(MediaType.APPLICATION_JSON);

        // 構(gòu)建請求體
        Map<String, Object> requestBody = new HashMap<>();
        requestBody.put("model", "deepseek-chat");
        requestBody.put("messages", Collections.singletonList(
                Map.of("role", "user", "content", prompt)
        ));
        requestBody.put("timeout", 30000); // 30秒超時

        HttpEntity<Map<String, Object>> request = new HttpEntity<>(requestBody, headers);

        try {
            ResponseEntity<String> response = restTemplate.postForEntity(API_URL, request, String.class);
            return response.getBody();
        } catch (HttpClientErrorException.Unauthorized e) {
            System.err.println("鑒權(quán)失敗，強制刷新Token重試：" + e.getMessage());
            tokenManager.refreshToken();
            // 重試請求
            headers.set("Authorization", "Bearer " + tokenManager.getValidToken());
            HttpEntity<Map<String, Object>> retryReq = new HttpEntity<>(requestBody, headers);
            return restTemplate.postForEntity(API_URL, retryReq, String.class).getBody();
        } catch (Exception e) {
            System.err.println("API調(diào)用出錯：" + e.getMessage());
            return "{\"choices\":[{\"message\":{\"content\":\"稍等一下，請求有點問題~\"}}]}";
        }
    }
}

// 錯誤示例：共享非線程安全對象，無連接池，無線程池隔離
public class UnsafeDeepSeekClient {
    // 錯誤：RestTemplate未配置連接池，高并發(fā)下連接泄漏
    private static final RestTemplate restTemplate = new RestTemplate();
    // 錯誤：共享HttpHeaders，多線程下數(shù)據(jù)錯亂
    private static final HttpHeaders sharedHeaders = new HttpHeaders();

    static {
        sharedHeaders.set("Authorization", "Bearer sk-xxxxxxxx");
        sharedHeaders.setContentType(MediaType.APPLICATION_JSON);
    }

    // 錯誤：無線程池，直接同步調(diào)用，超時阻塞主線程
    public String concurrentCall(String prompt) {
        Map<String, Object> requestBody = new HashMap<>(); // HashMap也不是線程安全的
        requestBody.put("model", "deepseek-chat");
        requestBody.put("messages", Collections.singletonList(
                Map.of("role", "user", "content", prompt)
        ));

        // 多線程下sharedHeaders可能被篡改
        HttpEntity<Map<String, Object>> request = new HttpEntity<>(requestBody, sharedHeaders);
        // 無超時配置，調(diào)用超時阻塞線程
        ResponseEntity<String> response = restTemplate.postForEntity(API_URL, request, String.class);
        return response.getBody();
    }
}

import org.apache.http.client.config.RequestConfig;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

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

// 線程安全的DeepSeek API客戶端（含連接池、線程池配置）
public class ThreadSafeDeepSeekClient {
    // 帶連接池的RestTemplate
    private static final RestTemplate restTemplate;
    //  配置線程池：隔離DeepSeek API調(diào)用，避免影響核心業(yè)務(wù)
    private static final ExecutorService deepSeekExecutor;

    static {
        // 1. 先配HTTP連接池，控制最大連接數(shù)
        PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager();
        connManager.setMaxTotal(100); // 總共最多100個連接
        connManager.setDefaultMaxPerRoute(50); // 同一個地址最多50個連接

        // 超時配置，別卡太久
        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectTimeout(5000) // 連服務(wù)器5秒超時
                .setConnectionRequestTimeout(3000) // 從連接池拿連接3秒超時
                .setSocketTimeout(30000) // 讀數(shù)據(jù)30秒超時
                .build();

        CloseableHttpClient httpClient = HttpClientBuilder.create()
                .setConnectionManager(connManager)
                .setDefaultRequestConfig(requestConfig)
                .build();

        // 把連接池配置給RestTemplate
        HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);
        restTemplate = new RestTemplate(requestFactory);

        // 2. 再配個專用線程池
        deepSeekExecutor = new ThreadPoolExecutor(
                10, // 平時保持10個活線程
                50, // 最多擴到50個線程
                60L, TimeUnit.SECONDS, // 空閑線程60秒沒人用就關(guān)掉
                new LinkedBlockingQueue<>(1000), // 任務(wù)排隊最多1000個
                new ThreadFactory() {
                    private int count = 0;
                    @Override
                    public Thread newThread(Runnable r) {
                        Thread thread = new Thread(r);
                        thread.setName("deepseek-api-thread-" + count++);
                        thread.setDaemon(true); // 守護線程，程序關(guān)的時候不用等它
                        return thread;
                    }
                },
                new ThreadPoolExecutor.CallerRunsPolicy() // 任務(wù)滿了就讓調(diào)用者自己執(zhí)行，別丟任務(wù)
        );
    }

    private final DeepSeekTokenManager tokenManager = DeepSeekTokenManager.getInstance();

    // 異步調(diào)用DeepSeek API（線程安全）
    public CompletableFuture<String> asyncCall(String prompt) {
        // 把任務(wù)丟到專用線程池里
        return CompletableFuture.supplyAsync(() -> {
            // 關(guān)鍵：每個請求自己建請求頭，別共享
            HttpHeaders headers = new HttpHeaders();
            headers.set("Authorization", "Bearer " + tokenManager.getValidToken());
            headers.setContentType(MediaType.APPLICATION_JSON);

            // 關(guān)鍵：每個請求獨立創(chuàng)建請求體，避免HashMap線程不安全問題
            Map<String, Object> requestBody = new HashMap<>();
            requestBody.put("model", "deepseek-chat");
            requestBody.put("messages", Collections.singletonList(
                    Map.of("role", "user", "content", prompt)
            ));
            requestBody.put("temperature", 0.7); // 隨機性調(diào)中等
            requestBody.put("max_tokens", 2000); // 最多返回2000個Token

            HttpEntity<Map<String, Object>> request = new HttpEntity<>(requestBody, headers);

            try {
                ResponseEntity<String> response = restTemplate.postForEntity(API_URL, request, String.class);
                return response.getBody();
            } catch (Exception e) {
                System.err.println("線程" + Thread.currentThread().getName() + "調(diào)用出錯：" + e.getMessage());
                return "{\"choices\":[{\"message\":{\"content\":\"請求失敗，稍后再試~\"}}]}";
            }
        }, deepSeekExecutor);
    }

    // 關(guān)閉線程池（應(yīng)用關(guān)閉時調(diào)用）
    public void shutdownExecutor() {
        deepSeekExecutor.shutdown();
        try {
            // 等10秒，還沒關(guān)完就強制關(guān)
            if (!deepSeekExecutor.awaitTermination(10, TimeUnit.SECONDS)) {
                deepSeekExecutor.shutdownNow();
            }
        } catch (InterruptedException e) {
            deepSeekExecutor.shutdownNow();
        }
    }
}

// 錯誤示例：直接傳入超長文本，無分塊、無Token計算
public class LongTextErrorClient {
    public String callLongText(String longContent) {
        Map<String, Object> requestBody = new HashMap<>();
        requestBody.put("model", "deepseek-chat");
        // 直接把超長文本丟進去，不管長度
        requestBody.put("messages", Collections.singletonList(
                Map.of("role", "user", "content", longContent)
        ));

        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer " + DeepSeekTokenManager.getInstance().getValidToken());
        HttpEntity<Map<String, Object>> request = new HttpEntity<>(requestBody, headers);
        RestTemplate restTemplate = new RestTemplate();
        return restTemplate.postForEntity(API_URL, request, String.class).getBody();
    }
}

<dependency>
    <groupId>com.knuddels</groupId>
    <artifactId>jtokkit</artifactId>
    <version>1.0.0</version>
</dependency>

import com.knuddels.jtokkit.Encodings;
import com.knuddels.jtokkit.api.Encoding;
import com.knuddels.jtokkit.api.EncodingRegistry;
import com.knuddels.jtokkit.api.ModelType;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

// 長文本處理工具，算Token、分塊、拼結(jié)果一條龍
public class LongTextProcessor {
    // 初始化Token計算器，DeepSeek用的編碼和GPT-4一樣
    private static final EncodingRegistry registry = Encodings.newDefaultEncodingRegistry();
    private static final Encoding encoding = registry.getEncodingForModel(ModelType.GPT_4);
    // 單輪最大Token數(shù)8192，留2000給模型回復(fù)，所以請求最多6192個Token
    private static final int MAX_REQUEST_TOKENS = 8192 - 2000;

    private final ThreadSafeDeepSeekClient deepSeekClient = new ThreadSafeDeepSeekClient();

    // 算文本的Token數(shù)，比按字數(shù)準多了
    public int countTokens(String text) {
        return encoding.countTokens(text);
    }

    // 超長文本分塊，盡量不切句子
    public List<String> splitLongText(String longText) {
        List<String> chunks = new ArrayList<>();
        int totalTokens = countTokens(longText);

        // 沒超限制就直接返回
        if (totalTokens <= MAX_REQUEST_TOKENS) {
            chunks.add(longText);
            return chunks;
        }

        // 按中文和英文的句號分割句子，保持意思完整
        String[] sentences = longText.split("(?<=[。?。??!])");
        StringBuilder currentChunk = new StringBuilder();
        int currentTokens = 0;

        for (String sentence : sentences) {
            int sentenceTokens = countTokens(sentence);
            // 極端情況：一個句子就超了，那就按Token硬切
            if (sentenceTokens > MAX_REQUEST_TOKENS) {
                chunks.addAll(splitOverLengthSentence(sentence, MAX_REQUEST_TOKENS));
                continue;
            }
            // 加當(dāng)前句子會超的話，先把之前的存起來
            if (currentTokens + sentenceTokens > MAX_REQUEST_TOKENS) {
                chunks.add(currentChunk.toString().trim());
                currentChunk = new StringBuilder();
                currentTokens = 0;
            }
            currentChunk.append(sentence);
            currentTokens += sentenceTokens;
        }

        // 把最后一塊加進去
        if (currentChunk.length() > 0) {
            chunks.add(currentChunk.toString().trim());
        }

        return chunks;
    }

    // 單個句子超Token限制，按Token硬切
    private List<String> splitOverLengthSentence(String sentence, int maxTokens) {
        List<String> subChunks = new ArrayList<>();
        char[] chars = sentence.toCharArray();
        StringBuilder subChunk = new StringBuilder();
        int currentTokens = 0;

        for (char c : chars) {
            String charStr = String.valueOf(c);
            int charTokens = countTokens(charStr);
            if (currentTokens + charTokens > maxTokens) {
                subChunks.add(subChunk.toString().trim());
                subChunk = new StringBuilder();
                currentTokens = 0;
            }
            subChunk.append(c);
            currentTokens += charTokens;
        }

        if (subChunk.length() > 0) {
            subChunks.add(subChunk.toString().trim());
        }
        return subChunks;
    }

    // 分塊調(diào)用API，最后拼結(jié)果
    public String processLongText(String longText) {
        List<String> chunks = splitLongText(longText);
        // 就一塊的話直接調(diào)
        if (chunks.size() == 1) {
            return deepSeekClient.asyncCall(chunks.get(0)).join();
        }

        // 多塊的話異步調(diào)用，效率高
        List<CompletableFuture<String>> futures = chunks.stream()
                .map(chunk -> {
                    // 告訴模型這是第幾塊，總共多少塊，讓它有上下文
                    String prompt = "請?zhí)幚硪韵挛谋酒危ㄒ还? + chunks.size() + "段，這是第" + (chunks.indexOf(chunk) + 1) + "段）：\n" + chunk;
                    return deepSeekClient.asyncCall(prompt);
                })
                .collect(Collectors.toList());

        // 等所有調(diào)用都完成
        CompletableFuture<Void> allDone = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
        allDone.join();

        // 拼結(jié)果
        StringBuilder finalResult = new StringBuilder();
        finalResult.append("超長文本處理結(jié)果（按片段拼接）：\n");
        for (CompletableFuture<String> future : futures) {
            try {
                String chunkRes = future.get();
                // 提取回復(fù)內(nèi)容，實際項目里用FastJSON或者Jackson解析更靠譜
                String content = extractContent(chunkRes);
                finalResult.append(content).append("\n");
            } catch (Exception e) {
                finalResult.append("【這段處理失敗】：").append(e.getMessage()).append("\n");
            }
        }

        return finalResult.toString();
    }

    // 從API響應(yīng)里把回復(fù)內(nèi)容摳出來（簡化版，實際用JSON庫）
    private String extractContent(String response) {
        int contentStart = response.indexOf("\"content\":\"") + 10;
        int contentEnd = response.indexOf("\"}", contentStart);
        if (contentStart > 0 && contentEnd > contentStart) {
            return response.substring(contentStart, contentEnd);
        }
        return response;
    }
}

// DeepSeek模型名枚舉，直接拿過來用
public class DeepSeekModelEnum {
    // 通用對話、代碼生成、推理增強，常用的就這三個
    public static final String DEEPSEEK_CHAT = "deepseek-chat";
    public static final String DEEPSEEK_CODER = "deepseek-coder";
    public static final String DEEPSEEK_R1 = "deepseek-r1";

    // 如果你之前用別的模型，用這個方法轉(zhuǎn)成DeepSeek的
    public static String convertFromOtherModel(String otherModelName) {
        switch (otherModelName.toLowerCase()) {
            // 之前用其他AI的對話場景，轉(zhuǎn)成deepseek-chat
            case "gpt-3.5-turbo":
            case "ernie-bot":
                return DEEPSEEK_CHAT;
            // 之前用代碼模型的，轉(zhuǎn)成deepseek-coder
            case "code-davinci-002":
                return DEEPSEEK_CODER;
            // 其他情況默認用通用對話模型
            default:
                return DEEPSEEK_CHAT;
        }
    }
}

// 調(diào)用示例
public class ModelClient {
    public String callWithRightModel(String prompt) {
        Map<String, Object> requestBody = new HashMap<>();
        // 直接用枚舉里的模型名，肯定不會錯
        requestBody.put("model", DeepSeekModelEnum.DEEPSEEK_CHAT);
        // 其他參數(shù)...
        return "";
    }
}

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

// DeepSeek響應(yīng)解析工具類（適配字段差異）
public class DeepSeekResponseParser {
    // 提取回復(fù)內(nèi)容
    public static String getContent(String responseJson) {
        try {
            JSONObject root = JSON.parseObject(responseJson);
            // 兼容DeepSeek和OpenAI的響應(yīng)結(jié)構(gòu)
            if (root.containsKey("choices") && !root.getJSONArray("choices").isEmpty()) {
                JSONObject choice = root.getJSONArray("choices").getJSONObject(0);
                // DeepSeek的message字段與OpenAI一致，但需判空
                if (choice.containsKey("message")) {
                    return choice.getJSONObject("message").getString("content");
                }
            }
            // 要是有error字段，直接拋異常
            if (root.containsKey("error")) {
                throw new RuntimeException("API報錯：" + root.getJSONObject("error").getString("message"));
            }
            return "沒拿到有效回復(fù)";
        } catch (Exception e) {
            throw new RuntimeException("解析響應(yīng)失敗：" + e.getMessage());
        }
    }

    // 解析Token使用量（適配DeepSeek的usage字段）
    public static int getUsedTokens(String responseJson) {
        JSONObject root = JSON.parseObject(responseJson);
        if (root.containsKey("usage")) {
            return root.getJSONObject("usage").getIntValue("total_tokens");
        }
        return 0;
    }
}

// 調(diào)用示例
public class ParserClient {
    public void parseResponse(String response) {
        // 直接拿回復(fù)內(nèi)容，不用自己處理JSON
        String content = DeepSeekResponseParser.getContent(response);
        // 看看用了多少Token
        int usedTokens = DeepSeekResponseParser.getUsedTokens(response);
        System.out.println("回復(fù)：" + content);
        System.out.println("消耗Token：" + usedTokens);
    }
}

// 動態(tài)超時配置工具
public class TimeoutConfig {
    // 不同模型的基礎(chǔ)超時時間（毫秒）
    private static final int CHAT_TIMEOUT = 30000; // 對話模型30秒
    private static final int CODER_TIMEOUT = 60000; // 代碼模型60秒
    private static final int R1_TIMEOUT = 45000; // 推理模型45秒

    // 按模型拿基礎(chǔ)超時
    public static int getBaseTimeout(String modelName) {
        switch (modelName) {
            case DeepSeekModelEnum.DEEPSEEK_CODER:
                return CODER_TIMEOUT;
            case DeepSeekModelEnum.DEEPSEEK_R1:
                return R1_TIMEOUT;
            default:
                return CHAT_TIMEOUT;
        }
    }

    // 按文本長度加超時，長文本給更多時間
    public static int getDynamicTimeout(String modelName, String text) {
        int baseTimeout = getBaseTimeout(modelName);
        int textLen = text.length();
        // 每1000字加5秒，最多不超過基礎(chǔ)超時的2倍（別無限加）
        int extraTimeout = Math.min((textLen / 1000) * 5000, baseTimeout);
        return baseTimeout + extraTimeout;
    }
}

// 調(diào)用示例
public class TimeoutClient {
    public String callWithDynamicTimeout(String prompt) {
        String model = DeepSeekModelEnum.DEEPSEEK_CODER;
        // 按模型和文本長度算超時
        int timeout = TimeoutConfig.getDynamicTimeout(model, prompt);

        Map<String, Object> requestBody = new HashMap<>();
        requestBody.put("model", model);
        requestBody.put("messages", Collections.singletonList(Map.of("role", "user", "content", prompt)));
        requestBody.put("timeout", timeout); // 把算好的超時傳進去

        // 其他請求邏輯...
        return "";
    }
}

import java.util.HashMap;
import java.util.List;
import java.util.Map;

// 請求參數(shù)適配工具
public class ParamsAdapter {
    // DeepSeek不支持的參數(shù)列表
    private static final List<String> UNSUPPORTED_PARAMS = List.of(
            "frequency_penalty", "presence_penalty", "logit_bias"
    );

    // 適配參數(shù)，保證傳過去的都能用
    public static Map<String, Object> adapt(Map<String, Object> originalParams) {
        Map<String, Object> adaptedParams = new HashMap<>(originalParams);

        // 1. 把不支持的參數(shù)刪掉
        UNSUPPORTED_PARAMS.forEach(adaptedParams::remove);

        // 2. 修正temperature：只能0-1
        if (adaptedParams.containsKey("temperature")) {
            double temp = (double) adaptedParams.get("temperature");
            // 小于0取0，大于1取1，中間的不變
            adaptedParams.put("temperature", Math.min(Math.max(temp, 0.0), 1.0));
        }

        // 3. 修正max_tokens：最少10，最多4096
        if (adaptedParams.containsKey("max_tokens")) {
            int maxTokens = (int) adaptedParams.get("max_tokens");
            adaptedParams.put("max_tokens", Math.min(Math.max(maxTokens, 10), 4096));
        }

        return adaptedParams;
    }
}

// 調(diào)用示例
public class ParamsClient {
    public String callWithRightParams(String prompt) {
        // 原來的參數(shù)，可能有無效的
        Map<String, Object> originalParams = new HashMap<>();
        originalParams.put("model", DeepSeekModelEnum.DEEPSEEK_CHAT);
        originalParams.put("temperature", 1.5); // 超出DeepSeek的范圍
        originalParams.put("frequency_penalty", 0.5); // DeepSeek不支持
        originalParams.put("messages", Collections.singletonList(Map.of("role", "user", "content", prompt)));

        // 適配后再傳
        Map<String, Object> adaptedParams = ParamsAdapter.adapt(originalParams);
        // 其他請求邏輯...
        return "";
    }
}

import org.springframework.web.client.HttpClientErrorException;

// 錯誤碼適配工具類
public class DeepSeekErrorHandler {
    // DeepSeek常見錯誤碼說明
    public enum ErrorCode {
        TOKEN_EXPIRED(401, "Token過期或無效，該刷新了"),
        RATE_LIMIT(429, "請求太頻繁，歇會兒再試"),
        TOO_LONG(400, "文本太長，超過Token限制了"),
        MODEL_NOT_FOUND(404, "模型名填錯了"),
        SERVER_ERROR(500, "DeepSeek服務(wù)端出問題了");

        private final int code;
        private final String desc;

        ErrorCode(int code, String desc) {
            this.code = code;
            this.desc = desc;
        }

        public int getCode() {
            return code;
        }

        public String getDesc() {
            return desc;
        }
    }

    // 處理DeepSeek錯誤，返回適配的重試策略
    public static boolean needRetry(Exception e) {
        if (e instanceof HttpClientErrorException) {
            int statusCode = ((HttpClientErrorException) e).getStatusCode().value();
            // 限流和服務(wù)端錯誤可以重試，其他的別瞎試
            return statusCode == ErrorCode.RATE_LIMIT.getCode()
                    || statusCode == ErrorCode.SERVER_ERROR.getCode();
        }
        // 網(wǎng)絡(luò)超時、連接失敗這些也可以重試
        return e instanceof java.net.SocketTimeoutException
                || e instanceof java.net.ConnectException;
    }

    // 獲取錯誤描述，適配不同模型的錯誤碼
    public static String getErrorMsg(Exception e) {
        if (e instanceof HttpClientErrorException) {
            HttpClientErrorException ex = (HttpClientErrorException) e;
            int statusCode = ex.getStatusCode().value();
            // 匹配錯誤碼
            for (ErrorCode errorCode : ErrorCode.values()) {
                if (errorCode.getCode() == statusCode) {
                    return errorCode.getDesc() + "，詳情：" + ex.getResponseBodyAsString();
                }
            }
        }
        // 其他錯誤直接返回信息
        return "未知錯誤：" + e.getMessage();
    }
}

// 調(diào)用示例，帶重試邏輯
public class RetryClient {
    private static final int MAX_RETRY = 3; // 最多重試3次

    public String callWithRetry(String prompt) {
        int retryCount = 0;
        while (retryCount < MAX_RETRY) {
            try {
                // 調(diào)用API的邏輯
                DeepSeekApiClient client = new DeepSeekApiClient();
                return client.callDeepSeek(prompt);
            } catch (Exception e) {
                retryCount++;
                String errorMsg = DeepSeekErrorHandler.getErrorMsg(e);
                System.err.println("第" + retryCount + "次調(diào)用失敗：" + errorMsg);

                // 不該重試就直接退出
                if (!DeepSeekErrorHandler.needRetry(e)) {
                    break;
                }

                // 指數(shù)退避重試：第1次等2秒，第2次等4秒，第3次等8秒
                try {
                    Thread.sleep((long) (Math.pow(2, retryCount) * 1000));
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        }
        return "{\"choices\":[{\"message\":{\"content\":\"試了好幾次都不行，稍后再試吧~\"}}]}";
    }
}