feat: (1)修复调用复杂度较高的warning问题

Author: dabai827

volcengine-java-sdk-ark-runtime/src/main/java/com/volcengine/ark/runtime/interceptor/EncryptionInterceptor.java

@@ -100,7 +100,6 @@ private Response proceedWithEncryption(Chain chain, Request request, Map<String,
 
         Response originalResponse = chain.proceed(encryptedRequest);
 
-
         // 处理失败响应
         if (!originalResponse.isSuccessful()) {
             return handleErrorResponse(originalResponse);
@@ -136,7 +135,6 @@ private Response proceedWithoutEncryption(Chain chain, Request request, Map<Stri
         return chain.proceed(modifiedRequest);
     }
 
-
     /**
      * 加密请求体内容
      */
@@ -183,8 +181,7 @@ private Object processMessageContent(Object content, byte[] e2eKey, byte[] e2eNo
         if (content instanceof String) {
             // text
             return encryptStringWithKey(e2eKey, e2eNonce, (String) content);
-        }
-        else if (content instanceof Iterable) {
+        } else if (content instanceof Iterable) {
             // multiParts
             List<Object> processedParts = new ArrayList<>();
             for (Object part : (Iterable<?>) content) {
@@ -197,8 +194,7 @@ else if (content instanceof Iterable) {
                 }
             }
             return processedParts;
-        }
-        else {
+        } else {
             throw new IOException("encryption is not supported for content type " + content.getClass().getSimpleName());
         }
     }
@@ -239,11 +235,9 @@ private void processImageUrl(Map<String, Object> imageUrl, byte[] e2eKey, byte[]
             if ("data".equals(scheme)) {
                 // 加密data URL
                 imageUrl.put("url", encryptStringWithKey(e2eKey, e2eNonce, url));
-            }
-            else if ("http".equals(scheme) || "https".equals(scheme)) {
+            } else if ("http".equals(scheme) || "https".equals(scheme)) {
                 System.err.println("encryption is not supported for image url, please use base64 image if you want encryption");
-            }
-            else {
+            } else {
                 throw new IOException("encryption is not supported for image url scheme " + scheme);
             }
 
@@ -450,34 +444,60 @@ private String decryptStreamContent(byte[] key, byte[] nonce, String streamConte
      */
     private Map<String, Object> decryptStreamChunk(byte[] key, byte[] nonce, Map<String, Object> chunkData) {
         try {
-            if (chunkData.containsKey("choices") && chunkData.get("choices") instanceof List) {
-                @SuppressWarnings("unchecked")
-                List<Map<String, Object>> choices = (List<Map<String, Object>>) chunkData.get("choices");
-
-                for (Map<String, Object> choice : choices) {
-                    if (shouldDecryptStreamChoice(choice)) {
-                        String encryptedContent = getEncryptedContentFromStreamChoice(choice);
-                        if (encryptedContent != null && !encryptedContent.isEmpty()) {
-                            try {
-                                String decryptedContent = aesGcmDecryptBase64String(key, nonce, encryptedContent);
-                                @SuppressWarnings("unchecked")
-                                Map<String, Object> delta = (Map<String, Object>) choice.get("delta");
-                                delta.put("content", decryptedContent);
-                            } catch (Exception e) {
-                                @SuppressWarnings("unchecked")
-                                Map<String, Object> delta = (Map<String, Object>) choice.get("delta");
-                                delta.put("content", "");
-                            }
-                        }
-                    }
-                }
+            if (!hasValidChoices(chunkData)) {
+                return chunkData;
             }
+
+            @SuppressWarnings("unchecked")
+            List<Map<String, Object>> choices = (List<Map<String, Object>>) chunkData.get("choices");
+
+            for (Map<String, Object> choice : choices) {
+                decryptStreamChoiceContent(key, nonce, choice);
+            }
+
             return chunkData;
         } catch (Exception e) {
             return chunkData;
         }
     }
 
+    /**
+     * 检查chunk数据是否包含有效的choices
+     */
+    private boolean hasValidChoices(Map<String, Object> chunkData) {
+        return chunkData.containsKey("choices") && chunkData.get("choices") instanceof List;
+    }
+
+    /**
+     * 解密流式choice内容
+     */
+    private void decryptStreamChoiceContent(byte[] key, byte[] nonce, Map<String, Object> choice) {
+        if (!shouldDecryptStreamChoice(choice)) {
+            return;
+        }
+
+        String encryptedContent = getEncryptedContentFromStreamChoice(choice);
+        if (encryptedContent == null || encryptedContent.isEmpty()) {
+            return;
+        }
+
+        try {
+            String decryptedContent = aesGcmDecryptBase64String(key, nonce, encryptedContent);
+            updateStreamChoiceContent(choice, decryptedContent);
+        } catch (Exception e) {
+            updateStreamChoiceContent(choice, "");
+        }
+    }
+
+    /**
+     * 更新流式choice的内容
+     */
+    private void updateStreamChoiceContent(Map<String, Object> choice, String content) {
+        @SuppressWarnings("unchecked")
+        Map<String, Object> delta = (Map<String, Object>) choice.get("delta");
+        delta.put("content", content);
+    }
+
     /**
      * 判断是否为流式响应
      */

volcengine-java-sdk-ark-runtime/src/main/java/com/volcengine/ark/runtime/service/CertificateManager.java

@@ -22,7 +22,6 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.regex.Pattern;
 
-
 public class CertificateManager {
     // 证书缓存
     private static final ConcurrentHashMap<String, ServerCertificateInfo> certificateCache = new ConcurrentHashMap<>();
@@ -52,8 +51,6 @@ public String getRingId() {
         public String getKeyId() {
             return keyId;
         }
-
-
     }
 
     private static List<String> getDnsNamesFromExtension(Extension sanExtension) {
@@ -79,7 +76,6 @@ private static List<String> getDnsNamesFromExtension(Extension sanExtension) {
      * 检查内存缓存中是否存在证书
      */
     public static boolean hasCertificateInCache(String ep) {
-        // 假设有一个静态的ConcurrentHashMap来存储证书缓存
         return certificateCache.containsKey(ep);
     }
 
@@ -93,7 +89,6 @@ public static ServerCertificateInfo getServerCertificateFromCache(String ep) {
     public static ServerCertificateInfo getServerCertificate(String apiKey, String baseUrl, String ep) throws IOException {
         // 首先检查内存缓存，用ep作为key
         if (hasCertificateInCache(ep)) {
-
             return getServerCertificateFromCache(ep);
         }
 
@@ -207,92 +202,139 @@ public static String loadCertificateLocally(String ep) throws IOException {
         return null;
     }
 
-
     /**
-     * 使用API Key方式获取证书
+     * 使用API Key方式获取证书 - 重构后降低复杂度
      */
     public static String loadCertificateByApiKey(String baseUrl, String apiKey, String ep, boolean aiccEnabled) throws IOException {
         HttpURLConnection connection = null;
         try {
-            // 修复URI构建问题
-            String certificateUrl;
-            if (baseUrl.endsWith("/")) {
-                certificateUrl = baseUrl + "e2e/get/certificate";
-            } else {
-                certificateUrl = baseUrl + "/e2e/get/certificate";
+            connection = createHttpConnection(baseUrl, apiKey);
+            sendCertificateRequest(connection, ep, aiccEnabled);
+            return processCertificateResponse(connection);
+        } catch (IOException e) {
+            throw e;
+        } catch (Exception e) {
+            String errMsg = "通过API Key获取证书失败: " + e.getMessage();
+            throw new IOException(errMsg, e);
+        } finally {
+            if (connection != null) {
+                connection.disconnect();
             }
+        }
+    }
 
+    /**
+     * 创建HTTP连接
+     */
+    private static HttpURLConnection createHttpConnection(String baseUrl, String apiKey) throws IOException {
+        String certificateUrl = buildCertificateUrl(baseUrl);
+        URL url = URI.create(certificateUrl).toURL();
+        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
 
-            URL url = URI.create(certificateUrl).toURL();
-            connection = (HttpURLConnection) url.openConnection();
+        connection.setRequestMethod("POST");
+        connection.setRequestProperty("Content-Type", "application/json");
+        connection.setRequestProperty("Authorization", "Bearer " + apiKey);
+        connection.setRequestProperty("X-Session-Token", "/e2e/get/certificate");
 
-            // 设置请求头
-            connection.setRequestMethod("POST");
-            connection.setRequestProperty("Content-Type", "application/json");
-            connection.setRequestProperty("Authorization", "Bearer " + apiKey);
-            connection.setRequestProperty("X-Session-Token", "/e2e/get/certificate");
+        return connection;
+    }
 
-            // 构建请求体
-            Map<String, Object> requestBody = new HashMap<>();
-            requestBody.put("model", ep);
-            if (aiccEnabled) {
-                requestBody.put("type", "AICCv0.1");
-            }
-            ObjectMapper mapper = new ObjectMapper();
-            String jsonBody = mapper.writeValueAsString(requestBody);
+    /**
+     * 构建证书请求URL
+     */
+    private static String buildCertificateUrl(String baseUrl) {
+        if (baseUrl.endsWith("/")) {
+            return baseUrl + "e2e/get/certificate";
+        } else {
+            return baseUrl + "/e2e/get/certificate";
+        }
+    }
+
+    /**
+     * 发送证书请求
+     */
+    private static void sendCertificateRequest(HttpURLConnection connection, String ep, boolean aiccEnabled) throws IOException {
+        String jsonBody = buildRequestBody(ep, aiccEnabled);
 
+        connection.setDoOutput(true);
+        try (OutputStream os = connection.getOutputStream()) {
+            byte[] input = jsonBody.getBytes(StandardCharsets.UTF_8);
+            os.write(input, 0, input.length);
+        }
+    }
 
-            // 发送请求
-            connection.setDoOutput(true);
-            try (OutputStream os = connection.getOutputStream()) {
-                byte[] input = jsonBody.getBytes(StandardCharsets.UTF_8);
-                os.write(input, 0, input.length);
-            }
+    /**
+     * 构建请求体
+     */
+    private static String buildRequestBody(String ep, boolean aiccEnabled) throws IOException {
+        Map<String, Object> requestBody = new HashMap<>();
+        requestBody.put("model", ep);
+        if (aiccEnabled) {
+            requestBody.put("type", "AICCv0.1");
+        }
+        ObjectMapper mapper = new ObjectMapper();
+        return mapper.writeValueAsString(requestBody);
+    }
 
-            // 处理响应
-            int responseCode = connection.getResponseCode();
+    /**
+     * 处理证书响应
+     */
+    private static String processCertificateResponse(HttpURLConnection connection) throws IOException {
+        int responseCode = connection.getResponseCode();
 
+        if (!isSuccessfulResponse(responseCode)) {
+            handleErrorResponse(connection, responseCode);
+        }
 
-            if (responseCode >= 200 && responseCode < 300) {
-                String responseBody = readResponseBody(connection);
+        return extractCertificateFromResponse(connection);
+    }
 
+    /**
+     * 检查响应是否成功
+     */
+    private static boolean isSuccessfulResponse(int responseCode) {
+        return responseCode >= 200 && responseCode < 300;
+    }
 
-                Map<String, Object> responseJson = mapper.readValue(
-                        responseBody,
-                        new TypeReference<HashMap<String, Object>>() {
-                        }
-                );
+    /**
+     * 处理错误响应
+     */
+    private static void handleErrorResponse(HttpURLConnection connection, int responseCode) throws IOException {
+        String errorResponse = readErrorResponse(connection);
+        String errorMsg = "证书请求失败，状态码: " + responseCode + ", 响应: " + errorResponse;
+        throw new IOException(errorMsg);
+    }
 
-                // 检查错误
-                if (responseJson.containsKey("error")) {
-                    Object error = responseJson.get("error");
-                    String errorMsg = "获取证书失败: " + error;
-                    throw new IOException(errorMsg);
-                }
+    /**
+     * 从响应中提取证书
+     */
+    private static String extractCertificateFromResponse(HttpURLConnection connection) throws IOException {
+        String responseBody = readResponseBody(connection);
+        ObjectMapper mapper = new ObjectMapper();
 
-                if (responseJson.containsKey("Certificate")) {
-                    return (String) responseJson.get("Certificate");
-                } else {
-                    String errorMsg = "响应中未找到Certificate字段";
-                    throw new IOException(errorMsg);
+        Map<String, Object> responseJson = mapper.readValue(
+                responseBody,
+                new TypeReference<HashMap<String, Object>>() {
                 }
-            } else {
-                String errorResponse = readErrorResponse(connection);
-                String errorMsg = "证书请求失败，状态码: " + responseCode + ", 响应: " + errorResponse;
-                throw new IOException(errorMsg);
-            }
+        );
 
-        } catch (Exception e) {
-            if (e instanceof IOException) {
-                throw (IOException) e;
-            } else {
-                String errMsg = "通过API Key获取证书失败: " + e.getMessage();
-                throw new IOException(errMsg, e);
-            }
-        } finally {
-            if (connection != null) {
-                connection.disconnect();
-            }
+        validateResponse(responseJson);
+
+        if (responseJson.containsKey("Certificate")) {
+            return (String) responseJson.get("Certificate");
+        } else {
+            throw new IOException("响应中未找到Certificate字段");
+        }
+    }
+
+    /**
+     * 验证响应数据
+     */
+    private static void validateResponse(Map<String, Object> responseJson) throws IOException {
+        if (responseJson.containsKey("error")) {
+            Object error = responseJson.get("error");
+            String errorMsg = "获取证书失败: " + error;
+            throw new IOException(errorMsg);
         }
     }
 
@@ -342,7 +384,6 @@ public static void cacheServerCertificate(String cacheKey, PublicKey publicKey,
 
     /**
      * 从PEM格式的X.509证书中提取公钥
-     *
      */
     public static PublicKey extractPublicKeyFromCertificate(String certificate) throws GeneralSecurityException {
         try {
@@ -422,5 +463,4 @@ public static String readErrorResponse(HttpURLConnection connection) throws IOEx
             return errorResponse.toString();
         }
     }
-
 }