新增文档翻译

src/main/java/com/bw/translate/cache/ConfigCache.java

@@ -17,7 +17,8 @@ public class ConfigCache {
 	public static boolean isStart = true;
 	/*****任务队列*****/
 	public static LinkedBlockingDeque<Map<String, Object>> textTaskQueue = new LinkedBlockingDeque<Map<String,Object>>();
-	public static LinkedBlockingDeque<Map<String, Object>> documentTaskQueue = new LinkedBlockingDeque<Map<String,Object>>();
+	public static LinkedBlockingDeque<Map<String, Object>> createDocumentTaskQueue = new LinkedBlockingDeque<Map<String,Object>>();
+	public static LinkedBlockingDeque<Map<String, Object>> queryDocumentTaskQueue = new LinkedBlockingDeque<Map<String,Object>>();
 
 
 	/**

src/main/java/com/bw/translate/controller/DocumentTranslateController.java

@@ -0,0 +1,37 @@
+package com.bw.translate.controller;
+
+import javax.annotation.Resource;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import com.bw.translate.service.DocumentTranslateService;
+
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * 文本翻译任务控制层
+ * @author jian.mao
+ * @date 2025年1月16日
+ * @description 
+ */
+@Controller
+@RequestMapping("/document")
+@Slf4j
+public class DocumentTranslateController {
+
+	@Resource
+	public DocumentTranslateService documentTranslateService;
+	@PostMapping("/put")
+	@ResponseBody
+	public String put(@RequestBody String dataJson)	{
+		return documentTranslateService.put(dataJson);
+	}
+	@RequestMapping(value = "/hello", method = RequestMethod.GET)
+	@ResponseBody
+	public String hello(String param, String token) {
+		return "123";
+	}
+}

src/main/java/com/bw/translate/entity/Constants.java

@@ -158,6 +158,8 @@ public class Constants {
 	public static final String SECRETKEY = "secretKey";
 	public static final String TOKENURL = "tokenUrl";
 	public static final String TEXTURL = "textUrl";
+	public static final String CREATEDOCUMENTURL = "createDocumentUrl";
+	public static final String QUERYDOCUMENTURL = "queryDocumentUrl";
 	public static final String SPEECH_URL = "speech_url";
 	public static final String FORMAT = "format";
 	public static final String RATE = "rate";
@@ -168,7 +170,8 @@ public class Constants {
 	public static final String QUERYURL = "queryUrl";
 	public static final String TASKS_INFO = "tasks_info";
 	public static final String TASK_STATUS = "task_status";
-	public static final String SUCCESS = "Success";
+	public static final String SUCCEEDED = "Succeeded";
+	public static final String FAILED = "Failed";
 	public static final String RUNNING = "Running";
 	public static final String TASK_RESULT = "task_result";
 	public static final String ISLAST = "isLast";
@@ -182,4 +185,13 @@ public class Constants {
 	public static final String TRANS_FIAL = "翻译失败";
 	public static final String ERROR_CODE = "error_code";
 	public static final String SRCCONTENT = "srcContent";
+	public static final String FILEURL = "fileUrl";
+	public static final String FORMATS = "formats";
+	public static final String TRANS_FORMAT = "trans_format";
+	public static final String FILENAME_PREFIX = "filename_prefix";
+	public static final String FILENAME = "filename";
+	public static final String DOC_ID = "doc_id";
+	public static final String FILES = "files";
+	public static final String URL = "url";
+	public static final String PATH = "path";
 }

src/main/java/com/bw/translate/handler/MainHandler.java

@@ -41,8 +41,10 @@ public class MainHandler implements ApplicationRunner {
 
     @Value("${task.text-task-queue-path}")
     private String textTaskPath;
-    @Value("${task.document-task-queue-path}")
-    private String documentTaskPath;
+    @Value("${task.create-document-task-queue-path}")
+    private String createDocumentTaskPath;
+    @Value("${task.query-document-task-queue-path}")
+    private String queryDocumentTaskPath;
     @Value("${zookeeper.connection-string}")
     private String connectionString;
     @Value("${zookeeper.publish-node}")
@@ -69,7 +71,7 @@ public class MainHandler implements ApplicationRunner {
         PauseTool pauseTool = new PauseTool();
         pauseTool.initializeRedisCache(stringRedisTemplate);
         pauseTool.setupZookeeperListener(connectionString, nodePath);
-        //线程池方式
+        //文本翻译线程池方式
         ThreadPoolExecutor executor = new ThreadPoolExecutor(
         		corePoolSize,
         		maximumPoolSize, 
@@ -78,7 +80,7 @@ public class MainHandler implements ApplicationRunner {
                 new LinkedBlockingQueue<>(queueSize),
                 new ThreadPoolExecutor.CallerRunsPolicy()
         );
-        //消费创建任务队列数据
+        //消费文本翻译任务队列数据
         Thread textConsumerThread = new Thread(() -> {
             while (true) {
                 try {
@@ -97,14 +99,43 @@ public class MainHandler implements ApplicationRunner {
         textConsumerThread.start();
         log.info("文本翻译任务消费线程启动-----");
         
-        //消费查询任务队列数据
-        Thread documentConsumerThread = new Thread(() -> {
+      //文档翻译线程池方式
+        ThreadPoolExecutor documentExecutor = new ThreadPoolExecutor(
+        		corePoolSize,
+        		maximumPoolSize, 
+        		keepAliveTime, 
+                TimeUnit.SECONDS, 
+                new LinkedBlockingQueue<>(queueSize),
+                new ThreadPoolExecutor.CallerRunsPolicy()
+        );
+        
+        //消费创建任务队列数据
+        Thread createDocumentConsumerThread = new Thread(() -> {
             while (true) {
                 try {
                     // 从队列中获取任务
-                    Map<String, Object> task = ConfigCache.documentTaskQueue.take();
+                    Map<String, Object> task = ConfigCache.createDocumentTaskQueue.take();
                     // 提交给线程池执行
-                    executor.execute(() -> documentTranslate(task)); 
+                    documentExecutor.execute(() -> createDocumentTranslate(task)); 
+                } catch (InterruptedException e) {
+                	// 恢复中断状态
+                    Thread.currentThread().interrupt(); 
+                    log.error("查询任务消费线程被中断");
+                    break;
+                }
+            }
+        });
+        createDocumentConsumerThread.start();
+        log.info("创建文档翻译任务消费线程启动-----");
+        
+        //消费查询任务队列
+        Thread queryDocumentConsumerThread = new Thread(() -> {
+            while (true) {
+                try {
+                    // 从队列中获取任务
+                    Map<String, Object> task = ConfigCache.queryDocumentTaskQueue.take();
+                    // 提交给线程池执行
+                    documentExecutor.execute(() -> queryDocumentTranslate(task)); 
                 } catch (InterruptedException e) {
                 	// 恢复中断状态
                     Thread.currentThread().interrupt(); 
@@ -115,18 +146,18 @@ public class MainHandler implements ApplicationRunner {
                 DateUtil.sleep(5000);
             }
         });
-        documentConsumerThread.start();
-        log.info("文档翻译任务消费线程启动-----");
-        
+        queryDocumentConsumerThread.start();
+        log.info("查询文档翻译任务消费线程启动-----");
         //启动加载缓存任务
         readTask(textTaskPath, ConfigCache.textTaskQueue);
-        readTask(documentTaskPath, ConfigCache.documentTaskQueue);
+        readTask(createDocumentTaskPath, ConfigCache.createDocumentTaskQueue);
+        readTask(queryDocumentTaskPath, ConfigCache.queryDocumentTaskQueue);
         //停止处理
         waitDown();
     }
 
     /**
-     * 创建任务执行方法
+     * 文本翻译任务执行方法
      * @param task
      */
     private void textTranslate(Map<String, Object> task) {
@@ -134,14 +165,20 @@ public class MainHandler implements ApplicationRunner {
     }
     
     /**
-     * 查询任务执行方法
+     * 创建文档翻译任务执行方法
      * @param task
      */
-    private void documentTranslate(Map<String, Object> task) {
-    	execTranslateService.documentTranslate(task);
+    private void createDocumentTranslate(Map<String, Object> task) {
+    	execTranslateService.createDocumentTranslate(task);
     }
     
-    
+    /**
+     * 查询文档翻译任务执行方法
+     * @param task
+     */
+    private void queryDocumentTranslate(Map<String, Object> task) {
+    	execTranslateService.queryDocumentTranslate(task);
+    }
     /****************************************************************load******************************************************************************/
     /**
      * 加载文件中的任务
@@ -206,10 +243,23 @@ public class MainHandler implements ApplicationRunner {
             }
         }
         while (true) {
-            if (ConfigCache.documentTaskQueue.size() > 0) {
+            if (ConfigCache.createDocumentTaskQueue.size() > 0) {
+                try {
+                    Map<String, Object> task = ConfigCache.createDocumentTaskQueue.take();
+                    FileUtil.writeFile(createDocumentTaskPath, JSONObject.toJSONString(task));
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            } else {
+                log.info("taskQueue write is file end");
+                break;
+            }
+        }
+        while (true) {
+            if (ConfigCache.queryDocumentTaskQueue.size() > 0) {
                 try {
-                    Map<String, Object> task = ConfigCache.documentTaskQueue.take();
-                    FileUtil.writeFile(documentTaskPath, JSONObject.toJSONString(task));
+                    Map<String, Object> task = ConfigCache.queryDocumentTaskQueue.take();
+                    FileUtil.writeFile(queryDocumentTaskPath, JSONObject.toJSONString(task));
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }

src/main/java/com/bw/translate/service/DocumentTranslateService.java

@@ -0,0 +1,17 @@
+package com.bw.translate.service;
+
+/**
+ * 文档翻译任务接口
+ * @author jian.mao
+ * @date 2025年2月13日
+ * @description 
+ */
+public interface DocumentTranslateService { 
+	
+	/**
+	 * 任务插入排队
+	 * @param dataJson
+	 * @return
+	 */
+	public String put(String dataJson);
+}

src/main/java/com/bw/translate/service/ExecTranslateService.java

@@ -16,8 +16,14 @@ public interface ExecTranslateService {
 	 */
 	public void textTranslate(Map<String, Object> task);
 	/**
-	 * 文档翻译方法
+	 * 创建文档翻译方法
 	 * @param task
 	 */
-	public void documentTranslate(Map<String, Object> task);
+	public void createDocumentTranslate(Map<String, Object> task);
+	
+	/**
+	 * 查询文档翻译方法
+	 * @param task
+	 */
+	public void queryDocumentTranslate(Map<String, Object> task);
 }

src/main/java/com/bw/translate/service/impl/DocumentTranslateServiceImpl.java

@@ -0,0 +1,55 @@
+package com.bw.translate.service.impl;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.springframework.stereotype.Service;
+
+import com.alibaba.fastjson.JSONObject;
+import com.bw.translate.cache.ConfigCache;
+import com.bw.translate.entity.Constants;
+import com.bw.translate.service.DocumentTranslateService;
+
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * 文档翻译任务接口实现类
+ * @author jian.mao
+ * @date 2025年2月13日
+ * @description 
+ */
+@Service
+@Slf4j
+public class DocumentTranslateServiceImpl implements DocumentTranslateService {
+
+	@Override
+	public String put(String dataJson) {
+		Map<String, Object> response = new HashMap<>(16);
+		int code = 200;
+		String message = "success";
+		Map<String, Object> task = null;
+		try {
+			task = JSONObject.parseObject(dataJson);
+		} catch (Exception e) {
+			log.error("参数结构不合法，", e);
+			code = 100010;
+			message = "参数不合法";
+		}
+		// 写入队列
+		try {
+ 			if(task.containsKey(Constants.TRACE) && (boolean)task.get(Constants.TRACE)){
+ 				ConfigCache.createDocumentTaskQueue.putFirst(task);
+ 			}else{
+ 				ConfigCache.createDocumentTaskQueue.put(task);
+ 			}
+		} catch (InterruptedException e) {
+			log.error("文档任务写入队列异常，", e);
+			code = 100011;
+			message = "任务写入队列失败";
+		}
+		response.put(Constants.CODE, code);
+		response.put(Constants.MESSAGE, message);
+		return JSONObject.toJSONString(response);
+	}
+
+}

src/main/java/com/bw/translate/service/impl/ExecTranslateServiceImpl.java

@@ -1,7 +1,11 @@
 package com.bw.translate.service.impl;
 
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
 import java.text.BreakIterator;
 import java.util.ArrayList;
+import java.util.Base64;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -13,10 +17,12 @@ import org.springframework.stereotype.Service;
 
 import com.alibaba.fastjson.JSONObject;
 import com.bfd.util.PauseTool;
+import com.bw.translate.cache.ConfigCache;
 import com.bw.translate.entity.Constants;
 import com.bw.translate.service.ExecTranslateService;
 import com.bw.translate.utils.DataUtil;
 import com.bw.translate.utils.DownLoadUtil;
+import com.bw.translate.utils.FileUtil;
 import com.bw.translate.utils.SpringBootKafka;
 
 import lombok.extern.slf4j.Slf4j;
@@ -33,6 +39,12 @@ public class ExecTranslateServiceImpl implements ExecTranslateService {
     private SpringBootKafka springBootKafka;
     @Value("${customize-kafka.producer.topic}")
     private String topic;
+    @Value("${file.path-prefix}")
+    private String downloadFilePathPrefix;
+    @Value("${gofast.host}")
+	private String gofastHost;
+    @Value("${gofast.path}")
+    private String gofastPath;
 	@Override
 	public void textTranslate(Map<String, Object> task) {
 		// TODO Auto-generated method stub
@@ -119,11 +131,194 @@ public class ExecTranslateServiceImpl implements ExecTranslateService {
 	}
 
 	@Override
-	public void documentTranslate(Map<String, Object> task) {
-		// TODO Auto-generated method stub
+	public void createDocumentTranslate(Map<String, Object> task) {
+		Map<String, Object> data = (Map<String, Object>) task.get(Constants.DATA);
+		Map<String, Object> input = (Map<String, Object>) task.get(Constants.INPUT);
+		int scenesId = (int) task.get(Constants.SCENES_ID);
+        int version = (int) task.get(Constants.VERSION);
+        String pauseKey = scenesId + "_" + version;
+        if (!PauseTool.CACHE.containsKey(pauseKey)) {
+            log.info("流程:{}的版本:{}已失效,任务跳过", scenesId, version);
+            return;
+        }
+		//源文件链接
+        String fileUrl = DataUtil.getValue(input.get(Constants.FILEURL).toString(), data).toString();	
+        try {
+        	//下载源文件
+        	String format = fileUrl.replaceAll(".*\\.", Constants.EMPTY);	
+        	String downloadFilePath = downloadFilePathPrefix+ UUID.randomUUID().toString() + "." + format;
+			DownLoadUtil.downloadFile(fileUrl, downloadFilePath);
+			//加载文件以base64编码
+			String fileContent = encodeFileToBase64(downloadFilePath);
+			//构建文档翻译请求体
+			Map<String, Object> param = new HashMap<String, Object>(16);
+			String fromLanguage = input.get(Constants.FROM).toString();	
+			String toLanguage = input.get(Constants.TO).toString().toString();	
+			param.put(Constants.FROM, fromLanguage);
+			param.put(Constants.TO, toLanguage);
+			Map<String, Object> paramInput = new HashMap<String, Object>(16);
+			paramInput.put(Constants.FORMAT, format);
+			paramInput.put(Constants.CONTENT, fileContent);
+			param.put(Constants.INPUT, paramInput);
+			Map<String, Object> paramOutput = new HashMap<String, Object>(16);
+			List<String> formats = new ArrayList<String>();
+			formats.add(format);
+			paramOutput.put(Constants.FORMATS, formats);
+			paramOutput.put(Constants.FILENAME_PREFIX, UUID.randomUUID().toString());
+			param.put(Constants.OUTPUT, paramOutput);
+			String token = getToken(input);
+			String createDocumentUrl = (String) input.get(Constants.CREATEDOCUMENTURL);
+			String url = createDocumentUrl + token;
+			String createResStr = DownLoadUtil.doPost(url, JSONObject.toJSONString(param));
+			JSONObject createRes = JSONObject.parseObject(createResStr);
+			if(createRes.containsKey(Constants.RESULT)) {
+				Map<String, Object> result = (Map<String, Object>) createRes.get(Constants.RESULT);
+				String id = (String) result.get(Constants.ID);
+				input.put(Constants.DOC_ID, id);
+				//文档翻译任务创建成功，发送到查询队列
+				ConfigCache.queryDocumentTaskQueue.put(task);
+			}else {
+				//异常
+				log.error("翻译接口返回失败，失败内容：{}",createResStr);
+				Map<String, Object> result = new HashMap<String, Object>(16);
+	            Map<String, Object> results = new HashMap<String, Object>(16);
+	            //遍历入库返回结果，拼接响应内容
+	            results.put(Constants.ISLAST, 1);
+	            results.put(Constants.CONTENT, Constants.TRANS_FIAL);
+	            results.put(Constants.ID, UUID.randomUUID().toString());
+	            result.put(Constants.RESULTS, JSONObject.toJSONString(results));
+	            result.put(Constants.MESSAGE, Constants.TRANS_FIAL);
+	            result.put(Constants.STATUS, 2);
+	            task.put(Constants.RESULT, result);
+	            //发送kafka
+	            springBootKafka.send(topic, JSONObject.toJSONString(task));
+	            log.info("数据流转至下游-------");
+			}
+		} catch (Exception e) {
+			log.error("文档翻译异常。task:{},e:",JSONObject.toJSONString(task),e);
+			//返回失败的结果
+			Map<String, Object> result = new HashMap<String, Object>(16);
+            Map<String, Object> results = new HashMap<String, Object>(16);
+            //遍历入库返回结果，拼接响应内容
+            results.put(Constants.ISLAST, 1);
+            results.put(Constants.CONTENT, Constants.TRANS_FIAL);
+            results.put(Constants.ID, UUID.randomUUID().toString());
+            result.put(Constants.RESULTS, JSONObject.toJSONString(results));
+            result.put(Constants.MESSAGE, Constants.TRANS_FIAL);
+            result.put(Constants.STATUS, 2);
+            task.put(Constants.RESULT, result);
+            //发送kafka
+            springBootKafka.send(topic, JSONObject.toJSONString(task));
+            log.info("数据流转至下游-------");
+		}
 		
 	}
 	
+	@Override
+	public void queryDocumentTranslate(Map<String, Object> task) {
+		// TODO Auto-generated method stub
+		Map<String, Object> input = (Map<String, Object>) task.get(Constants.INPUT);
+		int scenesId = (int) task.get(Constants.SCENES_ID);
+        int version = (int) task.get(Constants.VERSION);
+        String pauseKey = scenesId + "_" + version;
+        if (!PauseTool.CACHE.containsKey(pauseKey)) {
+            log.info("流程:{}的版本:{}已失效,任务跳过", scenesId, version);
+            return;
+        }
+        String docId = (String) input.get(Constants.DOC_ID);
+        Map<String, Object> param = new HashMap<String, Object>(16);
+        param.put(Constants.ID, docId);
+        String token = getToken(input);
+		String queryDocumentUrl = (String) input.get(Constants.QUERYDOCUMENTURL);
+		String url = queryDocumentUrl + token;
+		try {
+			String queryResStr = DownLoadUtil.doPost(url, JSONObject.toJSONString(param));
+			JSONObject queryRes = JSONObject.parseObject(queryResStr);
+			if(queryRes.containsKey(Constants.RESULT)) {
+				//判断翻译状态
+				Map<String, Object> resResult = (Map<String, Object>) queryRes.get(Constants.RESULT);
+				Map<String, Object> resData = (Map<String, Object>) resResult.get(Constants.DATA);
+				String transStatus = (String) resData.get(Constants.STATUS);
+				if(Constants.SUCCEEDED.equals(transStatus)) {
+					//翻译成功
+					Map<String, Object> resOutput = (Map<String, Object>) resData.get(Constants.OUTPUT);
+					List<Map<String, Object>> files = (List<Map<String, Object>>) resOutput.get(Constants.FILES);
+					String transFileUrl = (String) files.get(0).get(Constants.URL);
+					String fileName = (String) files.get(0).get(Constants.FILENAME);
+					//下载文件
+					String tempFilePath = downloadFilePathPrefix + fileName;
+					DownLoadUtil.downloadFile(transFileUrl, tempFilePath);
+					//上传文件
+					String uploadStr = DownLoadUtil.upLoadFile(tempFilePath, gofastHost + gofastPath);
+					JSONObject uploadRes = JSONObject.parseObject(uploadStr);
+					String uploadFileUrl = gofastHost + ((String) uploadRes.get(Constants.PATH));
+					//删除源文件
+					FileUtil.delFile(tempFilePath);
+					//结果响应
+					Map<String, Object> result = new HashMap<String, Object>(16);
+		            Map<String, Object> results = new HashMap<String, Object>(16);
+		            //遍历入库返回结果，拼接响应内容
+		            results.put(Constants.ISLAST, 1);
+		            results.put(Constants.CONTENT, uploadFileUrl);
+		            results.put(Constants.ID, UUID.randomUUID().toString());
+		            result.put(Constants.RESULTS, JSONObject.toJSONString(results));
+		            result.put(Constants.MESSAGE, "成功");
+		            result.put(Constants.STATUS, 1);
+		            task.put(Constants.RESULT, result);
+		            //发送kafka
+		            springBootKafka.send(topic, JSONObject.toJSONString(task));
+		            log.info("数据流转至下游-------");
+				}else if(Constants.FAILED.equals(transStatus)) {
+					//翻译失败
+					log.error("查询文档翻译结果显示失败----");
+					Map<String, Object> result = new HashMap<String, Object>(16);
+		            Map<String, Object> results = new HashMap<String, Object>(16);
+		            //遍历入库返回结果，拼接响应内容
+		            results.put(Constants.ISLAST, 1);
+		            results.put(Constants.CONTENT, Constants.TRANS_FIAL);
+		            results.put(Constants.ID, UUID.randomUUID().toString());
+		            result.put(Constants.RESULTS, JSONObject.toJSONString(results));
+		            result.put(Constants.MESSAGE, Constants.TRANS_FIAL);
+		            result.put(Constants.STATUS, 2);
+		            task.put(Constants.RESULT, result);
+		            //发送kafka
+		            springBootKafka.send(topic, JSONObject.toJSONString(task));
+		            log.info("数据流转至下游-------");
+				}else {
+					log.info("文档翻译未翻译完，重新放回队列等待---{}",queryResStr);
+					ConfigCache.queryDocumentTaskQueue.put(task);
+				}
+			}
+		} catch (Exception e) {
+			// TODO: handle exception
+			log.error("查询文档翻译结果异常，task:{},e:",JSONObject.toJSONString(task),e);
+			//返回失败的结果
+			Map<String, Object> result = new HashMap<String, Object>(16);
+            Map<String, Object> results = new HashMap<String, Object>(16);
+            //遍历入库返回结果，拼接响应内容
+            results.put(Constants.ISLAST, 1);
+            results.put(Constants.CONTENT, Constants.TRANS_FIAL);
+            results.put(Constants.ID, UUID.randomUUID().toString());
+            result.put(Constants.RESULTS, JSONObject.toJSONString(results));
+            result.put(Constants.MESSAGE, Constants.TRANS_FIAL);
+            result.put(Constants.STATUS, 2);
+            task.put(Constants.RESULT, result);
+            //发送kafka
+            springBootKafka.send(topic, JSONObject.toJSONString(task));
+            log.info("数据流转至下游-------");
+		}
+		
+	}
+	/**
+	 * 读取文件 base64格式
+	 * @param filePath 文件地址
+	 * @return
+	 * @throws IOException
+	 */
+	private String encodeFileToBase64(String filePath) throws IOException {
+        byte[] fileContent = Files.readAllBytes(Paths.get(filePath));
+        return Base64.getEncoder().encodeToString(fileContent);
+    }
 	
 	/**
      * 将多个短句拼接成不超过maxLength的段落
@@ -204,4 +399,5 @@ public class ExecTranslateServiceImpl implements ExecTranslateService {
 		String accessToken = (String) res.get(Constants.ACCESS_TOKEN);
 		return accessToken;
 	}
+
 }

src/main/java/com/bw/translate/utils/DownLoadUtil.java

@@ -1,12 +1,17 @@
 package com.bw.translate.utils;
 
+import java.io.File;
+import java.io.FileOutputStream;
 import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
 import java.security.KeyManagementException;
 import java.security.NoSuchAlgorithmException;
 import java.security.cert.CertificateException;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.TimeUnit;
 
 import javax.net.ssl.SSLContext;
 import javax.net.ssl.TrustManager;
@@ -53,6 +58,15 @@ import org.slf4j.LoggerFactory;
 
 import com.bw.translate.entity.Constants;
 
+import okhttp3.Call;
+import okhttp3.Headers;
+import okhttp3.MediaType;
+import okhttp3.MultipartBody;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okhttp3.Response;
+
 
 
 
@@ -910,6 +924,79 @@ public class DownLoadUtil {
 		return html;
 		
 	}
+	
+	/**
+	 * 文件下载
+	 * @param fileURL 文件链接
+	 * @param destinationFilePath 文件存储地址
+	 * @throws IOException
+	 */
+	public static void downloadFile(String fileURL, String destinationFilePath) throws IOException {
+        // 设置连接超时和读取超时
+        RequestConfig config = RequestConfig.custom()
+        		// 设置连接超时为10秒
+                .setConnectTimeout(10000)  
+                // 设置读取超时为30秒
+                .setSocketTimeout(30000)   
+                .build();
+        
+        // 创建 HttpClient 实例
+        try (CloseableHttpClient httpClient = HttpClients.custom()
+                .setDefaultRequestConfig(config)
+                .build()) {
+
+            // 创建 HttpGet 请求
+            HttpGet request = new HttpGet(URI.create(fileURL));
+
+            // 执行请求
+            try (CloseableHttpResponse response = httpClient.execute(request)) {
+                // 获取响应的输入流
+                InputStream inputStream = response.getEntity().getContent();
+                try (FileOutputStream outputStream = new FileOutputStream(destinationFilePath)) {
+                    byte[] buffer = new byte[4096];
+                    int bytesRead;
+                    while ((bytesRead = inputStream.read(buffer)) != -1) {
+                        outputStream.write(buffer, 0, bytesRead);
+                    }
+                }
+                log.info("文件下载成功---{}" , destinationFilePath);
+            }
+        }
+    }
+
+	/**
+	 * 文件上传
+	 * @param filePath
+	 * @param gofastUrl
+	 * @return
+	 */
+	public static  String upLoadFile(String filePath,String gofastUrl) {
+        File file = new File(filePath);
+        String realFilename = filePath.substring(filePath.lastIndexOf(File.separator) + 1);
+        MultipartBody.Builder builder = new MultipartBody.Builder().setType(MultipartBody.FORM);
+        builder.addPart(Headers.of("Content-Disposition", "form-data; name=\"file\";filename=\"" + realFilename + "\""),
+                RequestBody.create(MediaType.parse("image/png"), file)
+
+        ).addFormDataPart("output", "json").build();
+        RequestBody body = builder.build();
+        Request request = new Request.Builder().url(gofastUrl).post(body).header("Expect", "100-continue").build();
+        OkHttpClient.Builder okBuilder = new OkHttpClient.Builder();
+        OkHttpClient client = okBuilder.connectTimeout(600, TimeUnit.MILLISECONDS)
+                .readTimeout(600, TimeUnit.SECONDS).build();
+        Call call = client.newCall(request);
+        String html = "";
+        Response response = null;
+        try {
+            response = call.execute();
+            html = response.body().string();
+        } catch (IOException e) {
+            log.info("upload fail:{}", filePath);
+            e.printStackTrace();
+        } finally {
+            response.close();
+        }
+        return html;
+    }
 	public static void main(String[] args) throws Exception {
 
 	}

src/main/java/com/bw/translate/utils/FileUtil.java

@@ -1,13 +1,8 @@
 package com.bw.translate.utils;
 
+import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 
 /**
  * 文件工具类
@@ -33,4 +28,14 @@ public class FileUtil {
 			e.printStackTrace();
 		}
 	}
+	
+	public static void delFile(String path) {
+		try {
+			File file = new File(path);
+			file.delete();
+		} catch (Exception e) {
+			// TODO: handle exception
+			e.printStackTrace();
+		}
+	}
 }

src/main/resources/application.yml

@@ -92,9 +92,15 @@ customize-kafka:
     topic: produce_analyze
 task:
   text-task-queue-path: ../data/textTaskQueue.txt
-  document-task-queue-path: ../data/documentTaskQueue.txt
+  create-document-task-queue-path: ../data/createDocumentTaskQueue.txt
+  query-document-task-queue-path: ../data/queryDocumentTaskQueue.txt
 threadPool:
   corePoolSize: 5
   maximumPoolSize: 20
   keepAliveTime: 60
-  queueSize: 100
+  queueSize: 100
+file:
+  path-prefix: ../file/
+gofast:
+  host: http://10.8.0.10:8081
+  path: /group1/upload