交易市场平台（供应商）

baqing-admin/src/main/java/com/ruoyi/web/kb/service/impl/KnowledgeBaseClientImpl.java

@@ -3,9 +3,12 @@ package com.ruoyi.web.kb.service.impl;
 import java.io.File;
 import java.net.URI;
 import java.nio.charset.StandardCharsets;
+import java.util.function.Supplier;
 
 import com.ruoyi.web.kb.support.KbApiProperties;
 import com.ruoyi.web.kb.service.KnowledgeBaseClient;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.core.io.FileSystemResource;
 import org.springframework.http.HttpEntity;
@@ -16,6 +19,7 @@ import org.springframework.stereotype.Service;
 import org.springframework.util.LinkedMultiValueMap;
 import org.springframework.util.MultiValueMap;
 import org.springframework.web.client.HttpStatusCodeException;
+import org.springframework.web.client.ResourceAccessException;
 import org.springframework.web.client.RestTemplate;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
@@ -28,6 +32,8 @@ import com.ruoyi.common.utils.StringUtils;
 @Service
 public class KnowledgeBaseClientImpl implements KnowledgeBaseClient
 {
+    private static final Logger log = LoggerFactory.getLogger(KnowledgeBaseClientImpl.class);
+
     private static final String[] FILE_ID_KEYS = { "file_id", "fileId", "kbDocId", "kb_doc_id", "docId", "id" };
 
     private final KbApiProperties properties;
@@ -100,21 +106,18 @@ public class KnowledgeBaseClientImpl implements KnowledgeBaseClient
         HttpHeaders headers = new HttpHeaders();
         headers.add(properties.getAuthHeaderName(), properties.authHeaderValue());
         HttpEntity<MultiValueMap<String, Object>> entity = new HttpEntity<>(body, headers);
-        String raw;
-        try
-        {
-            ResponseEntity<String> resp = restTemplate.exchange(URI.create(url), HttpMethod.POST, entity, String.class);
-            raw = resp.getBody();
-        }
-        catch (HttpStatusCodeException e)
-        {
-            String b = e.getResponseBodyAsString(StandardCharsets.UTF_8);
-            throw new ServiceException("知识库上传失败 HTTP " + e.getRawStatusCode() + "：" + abbreviate(b));
-        }
-        catch (Exception e)
-        {
-            throw new ServiceException("知识库上传异常：" + e.getMessage());
-        }
+        String raw = executeWithRetry("知识库上传", () -> {
+            try
+            {
+                ResponseEntity<String> resp = restTemplate.exchange(URI.create(url), HttpMethod.POST, entity, String.class);
+                return resp.getBody();
+            }
+            catch (HttpStatusCodeException e)
+            {
+                String b = e.getResponseBodyAsString(StandardCharsets.UTF_8);
+                throw new ServiceException("知识库上传失败 HTTP " + e.getRawStatusCode() + "：" + abbreviate(b));
+            }
+        });
         return parseUploadResponse(raw);
     }
 
@@ -149,27 +152,153 @@ public class KnowledgeBaseClientImpl implements KnowledgeBaseClient
         HttpHeaders headers = new HttpHeaders();
         headers.add(properties.getAuthHeaderName(), properties.authHeaderValue());
         HttpEntity<Void> entity = new HttpEntity<>(headers);
-        try
-        {
-            ResponseEntity<String> resp = restTemplate.exchange(URI.create(url), HttpMethod.DELETE, entity, String.class);
-            if (!resp.getStatusCode().is2xxSuccessful())
+        executeWithRetry("知识库删除", () -> {
+            try
             {
-                throw new ServiceException("知识库删除失败 HTTP " + resp.getStatusCodeValue());
+                ResponseEntity<String> resp = restTemplate.exchange(URI.create(url), HttpMethod.DELETE, entity, String.class);
+                if (!resp.getStatusCode().is2xxSuccessful())
+                {
+                    throw new ServiceException("知识库删除失败 HTTP " + resp.getStatusCodeValue());
+                }
+                return null;
             }
-        }
-        catch (HttpStatusCodeException e)
+            catch (HttpStatusCodeException e)
+            {
+                if (e.getRawStatusCode() == 404)
+                {
+                    return null;
+                }
+                String b = e.getResponseBodyAsString(StandardCharsets.UTF_8);
+                throw new ServiceException("知识库删除失败 HTTP " + e.getRawStatusCode() + "：" + abbreviate(b));
+            }
+        });
+    }
+
+    /**
+     * 超时或 transient 失败时重试，最多 {@link KbApiProperties#getMaxRetries()} 次（不含首次请求）。
+     */
+    private <T> T executeWithRetry(String operation, Supplier<T> action)
+    {
+        int maxRetries = Math.max(0, properties.getMaxRetries());
+        Exception last = null;
+        for (int attempt = 0; attempt <= maxRetries; attempt++)
         {
-            if (e.getRawStatusCode() == 404)
+            try
+            {
+                return action.get();
+            }
+            catch (ServiceException e)
+            {
+                if (attempt >= maxRetries || !isRetryable(e))
+                {
+                    throw e;
+                }
+                last = e;
+                log.warn("{}失败，第 {}/{} 次重试：{}", operation, attempt + 1, maxRetries, e.getMessage());
+                sleepBeforeRetry();
+            }
+            catch (Exception e)
             {
-                return;
+                ServiceException wrapped = wrapUnexpected(operation, e);
+                if (attempt >= maxRetries || !isRetryable(wrapped, e))
+                {
+                    throw wrapped;
+                }
+                last = wrapped;
+                log.warn("{}异常，第 {}/{} 次重试：{}", operation, attempt + 1, maxRetries, e.getMessage());
+                sleepBeforeRetry();
             }
-            String b = e.getResponseBodyAsString(StandardCharsets.UTF_8);
-            throw new ServiceException("知识库删除失败 HTTP " + e.getRawStatusCode() + "：" + abbreviate(b));
         }
-        catch (Exception e)
+        if (last instanceof ServiceException)
+        {
+            throw (ServiceException) last;
+        }
+        throw wrapUnexpected(operation, last);
+    }
+
+    private static boolean isRetryable(ServiceException e)
+    {
+        String msg = e.getMessage();
+        if (msg == null)
+        {
+            return false;
+        }
+        if (msg.contains("HTTP 404"))
+        {
+            return false;
+        }
+        if (msg.contains("HTTP 408") || msg.contains("HTTP 429"))
+        {
+            return true;
+        }
+        if (msg.matches(".*HTTP [45]\\d\\d.*"))
+        {
+            int code = extractHttpStatus(msg);
+            return code >= 500 || code == 408 || code == 429;
+        }
+        return false;
+    }
+
+    private static boolean isRetryable(ServiceException wrapped, Exception cause)
+    {
+        if (cause instanceof ResourceAccessException)
+        {
+            return true;
+        }
+        return isRetryable(wrapped);
+    }
+
+    private static int extractHttpStatus(String msg)
+    {
+        int idx = msg.indexOf("HTTP ");
+        if (idx < 0)
+        {
+            return 0;
+        }
+        int start = idx + 5;
+        int end = start;
+        while (end < msg.length() && Character.isDigit(msg.charAt(end)))
+        {
+            end++;
+        }
+        if (end == start)
+        {
+            return 0;
+        }
+        try
+        {
+            return Integer.parseInt(msg.substring(start, end));
+        }
+        catch (NumberFormatException e)
+        {
+            return 0;
+        }
+    }
+
+    private void sleepBeforeRetry()
+    {
+        int interval = Math.max(0, properties.getRetryIntervalMs());
+        if (interval <= 0)
+        {
+            return;
+        }
+        try
+        {
+            Thread.sleep(interval);
+        }
+        catch (InterruptedException e)
+        {
+            Thread.currentThread().interrupt();
+        }
+    }
+
+    private static ServiceException wrapUnexpected(String operation, Exception e)
+    {
+        if (e instanceof ServiceException)
         {
-            throw new ServiceException("知识库删除异常：" + e.getMessage());
+            return (ServiceException) e;
         }
+        return new ServiceException(operation + "异常：" + e.getMessage());
     }
 
     private static String encodePathSegment(String id)

baqing-admin/src/main/java/com/ruoyi/web/kb/support/KbApiProperties.java

@@ -40,6 +40,12 @@ public class KbApiProperties
     /** 对话流式 SSE（/v1/chat/completions stream=true）读超时 */
     private int streamReadTimeoutMs = 300000;
 
+    /** 知识库同步/移出失败或超时时的最大重试次数（不含首次请求） */
+    private int maxRetries = 2;
+
+    /** 重试间隔（毫秒） */
+    private int retryIntervalMs = 500;
+
     public boolean isEnabled()
     {
         return enabled;
@@ -167,6 +173,26 @@ public class KbApiProperties
         this.streamReadTimeoutMs = streamReadTimeoutMs;
     }
 
+    public int getMaxRetries()
+    {
+        return maxRetries;
+    }
+
+    public void setMaxRetries(int maxRetries)
+    {
+        this.maxRetries = maxRetries;
+    }
+
+    public int getRetryIntervalMs()
+    {
+        return retryIntervalMs;
+    }
+
+    public void setRetryIntervalMs(int retryIntervalMs)
+    {
+        this.retryIntervalMs = retryIntervalMs;
+    }
+
     public String baseUrl()
     {
         return scheme + "://" + host + ":" + port;

baqing-admin/src/main/resources/application.yml

@@ -22,6 +22,9 @@ ruoyi:
     file-url-base: ""
     connect-timeout-ms: 15000
     read-timeout-ms: 120000
+    # 知识库同步/移出失败或超时重试次数（不含首次请求）
+    max-retries: 2
+    retry-interval-ms: 500
     # 对话流式 SSE（/v1/chat/completions stream=true）读超时
     stream-read-timeout-ms: 300000
   # 获取ip地址开关

baqing-admin/src/test/java/com/ruoyi/web/kb/service/impl/KnowledgeBaseClientImplTest.java

@@ -0,0 +1,110 @@
+package com.ruoyi.web.kb.service.impl;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.net.URI;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+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.http.HttpEntity;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.client.HttpClientErrorException;
+import org.springframework.web.client.HttpServerErrorException;
+import org.springframework.web.client.ResourceAccessException;
+import org.springframework.web.client.RestTemplate;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.ruoyi.common.exception.ServiceException;
+import com.ruoyi.web.kb.support.KbApiProperties;
+
+@ExtendWith(MockitoExtension.class)
+@DisplayName("KnowledgeBaseClientImpl 重试")
+class KnowledgeBaseClientImplTest
+{
+    @Mock
+    private RestTemplate restTemplate;
+
+    private KbApiProperties properties;
+
+    private KnowledgeBaseClientImpl client;
+
+    @BeforeEach
+    void setUp()
+    {
+        properties = new KbApiProperties();
+        properties.setEnabled(true);
+        properties.setApiKey("test-key");
+        properties.setHost("localhost");
+        properties.setPort(9107);
+        properties.setMaxRetries(2);
+        properties.setRetryIntervalMs(0);
+        client = new KnowledgeBaseClientImpl(properties, restTemplate, new ObjectMapper());
+    }
+
+    @Test
+    @DisplayName("上传超时后重试2次，第3次成功")
+    void uploadFileByUrl_retriesOnTimeoutThenSucceeds()
+    {
+        when(restTemplate.exchange(any(URI.class), eq(HttpMethod.POST), any(HttpEntity.class), eq(String.class)))
+                .thenThrow(new ResourceAccessException("Read timed out"))
+                .thenThrow(new ResourceAccessException("Read timed out"))
+                .thenReturn(ResponseEntity.ok("{\"code\":200,\"data\":{\"file_id\":\"DOC-1\"}}"));
+
+        String fileId = client.uploadFileByUrl("http://localhost/a.pdf", "分类", "描述");
+
+        assertEquals("DOC-1", fileId);
+        verify(restTemplate, times(3)).exchange(any(URI.class), eq(HttpMethod.POST), any(HttpEntity.class), eq(String.class));
+    }
+
+    @Test
+    @DisplayName("上传5xx后重试2次仍失败则抛出异常")
+    void uploadFileByUrl_retriesExhausted()
+    {
+        when(restTemplate.exchange(any(URI.class), eq(HttpMethod.POST), any(HttpEntity.class), eq(String.class)))
+                .thenThrow(HttpServerErrorException.create(HttpStatus.BAD_GATEWAY, "bad gateway", null, null, null));
+
+        ServiceException ex = assertThrows(ServiceException.class,
+                () -> client.uploadFileByUrl("http://localhost/a.pdf", "分类", "描述"));
+
+        assertEquals(true, ex.getMessage().contains("502"));
+        verify(restTemplate, times(3)).exchange(any(URI.class), eq(HttpMethod.POST), any(HttpEntity.class), eq(String.class));
+    }
+
+    @Test
+    @DisplayName("删除超时后重试2次，第3次成功")
+    void deleteFile_retriesOnTimeoutThenSucceeds()
+    {
+        when(restTemplate.exchange(any(URI.class), eq(HttpMethod.DELETE), any(HttpEntity.class), eq(String.class)))
+                .thenThrow(new ResourceAccessException("connect timed out"))
+                .thenThrow(new ResourceAccessException("connect timed out"))
+                .thenReturn(ResponseEntity.ok("{\"code\":200}"));
+
+        client.deleteFile("DOC-9");
+
+        verify(restTemplate, times(3)).exchange(any(URI.class), eq(HttpMethod.DELETE), any(HttpEntity.class), eq(String.class));
+    }
+
+    @Test
+    @DisplayName("删除404不重试")
+    void deleteFile_notFoundNoRetry()
+    {
+        when(restTemplate.exchange(any(URI.class), eq(HttpMethod.DELETE), any(HttpEntity.class), eq(String.class)))
+                .thenThrow(HttpClientErrorException.create(HttpStatus.NOT_FOUND, "not found", null, null, null));
+
+        client.deleteFile("DOC-MISSING");
+
+        verify(restTemplate, times(1)).exchange(any(URI.class), eq(HttpMethod.DELETE), any(HttpEntity.class), eq(String.class));
+    }
+}