update

src/main/java/com/scbfkj/uni/api/FileApi.java

@@ -0,0 +1,4 @@
+package com.scbfkj.uni.api;
+
+public class FileApi {
+}

src/main/java/com/scbfkj/uni/api/GenericApi.java

@@ -1,14 +1,11 @@
 package com.scbfkj.uni.api;
 
-import com.scbfkj.uni.library.DataFormatUtil;
 import com.scbfkj.uni.library.RequestUtil;
 import com.scbfkj.uni.process.DataBase;
-import com.scbfkj.uni.service.DataProcessService;
 import com.scbfkj.uni.system.Config;
+import com.scbfkj.uni.system.ProcessUtil;
 import org.springframework.http.HttpStatusCode;
 import org.springframework.http.ResponseEntity;
-import org.springframework.messaging.handler.annotation.MessageMapping;
-import org.springframework.messaging.handler.annotation.SendTo;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
@@ -40,7 +37,7 @@ public class GenericApi {
         body.put("event", event);
         body.put("headers", RequestUtil.getHeaders());
 
-        Map<String, Object> process = new DataProcessService().process(body);
+        Map<String, Object> process = new ProcessUtil().process(body);
         return ResponseEntity.ok(process);
     }
 
@@ -64,7 +61,7 @@ public class GenericApi {
         }
         Object serviceid = serviceinfoList.get(0).get("serviceid");
         body.put("serviceid", serviceid);
-        return ResponseEntity.ok(new DataProcessService().process(body));
+        return ResponseEntity.ok(new ProcessUtil().process(body));
     }
 
 }

src/main/java/com/scbfkj/uni/api/LogAop.java

@@ -87,7 +87,7 @@ public class LogAop {
                 return ResponseEntity.ok(UniReturnUtil.fail(message));
             }
 
-            util.addFilter(body, serviceid,uri,true);
+            Util.addFilter(body, serviceid,uri,true);
 
             ResponseEntity<Map<String, Object>> responseEntity = (ResponseEntity<Map<String, Object>>) joinPoint.proceed(args);
             if (!responseEntity.getStatusCode().is2xxSuccessful()) {

src/main/java/com/scbfkj/uni/api/WebSocketServer.java

@@ -2,13 +2,14 @@ package com.scbfkj.uni.api;
 
 import com.scbfkj.uni.library.DataFormatUtil;
 import com.scbfkj.uni.library.UniReturnUtil;
-import com.scbfkj.uni.service.DataProcessService;
+import com.scbfkj.uni.system.ProcessUtil;
 import jakarta.websocket.*;
 import jakarta.websocket.server.ServerEndpoint;
 import org.springframework.stereotype.Component;
 
 import java.io.IOException;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
 import java.util.concurrent.CopyOnWriteArrayList;
 
@@ -37,6 +38,13 @@ public class WebSocketServer {
         sessions.add(session);
         // 建立连接
         this.session = session;
+
+        HashSet<Session> sessions1 = new HashSet<>(sessions);
+        for (Session session1 : sessions1) {
+            if (!session1.isOpen()) {
+                sessions.remove(session1);
+            }
+        }
     }
 
     /**
@@ -55,6 +63,12 @@ public class WebSocketServer {
     @OnClose
     public void onClose() {
         sessions.remove(session);
+        HashSet<Session> sessions1 = new HashSet<>(sessions);
+        for (Session session1 : sessions1) {
+            if (!session1.isOpen()) {
+                sessions.remove(session1);
+            }
+        }
     }
 
     /**
@@ -70,7 +84,7 @@ public class WebSocketServer {
             Map<?, ?> body = DataFormatUtil.toMap(message);
             try {
 
-                result = new DataProcessService().process((Map<String, Object>) body);
+                result = new ProcessUtil().process((Map<String, Object>) body);
             } catch (Exception e) {
                 result = UniReturnUtil.fail(e);
             }

src/main/java/com/scbfkj/uni/library/DataFormatUtil.java

@@ -113,11 +113,23 @@ public final class DataFormatUtil {
         ArrayList<Object> result = new ArrayList<>();
         if (value instanceof Iterable<?> iterable) {
             iterable.forEach(result::add);
-            return result;
+            return result.stream().map(it->{
+                if (it instanceof JsonNode){
+                    return it.toString();
+                }else{
+                    return it;
+                }
+            }).toList();
         }
         if (value.getClass().isArray()) {
             result.addAll(Arrays.asList(((Object[]) value)));
-            return result;
+            return result.stream().map(it->{
+                if (it instanceof JsonNode){
+                    return it.toString();
+                }else{
+                    return it;
+                }
+            }).toList();
         }
         if (value instanceof String) {
             try {

src/main/java/com/scbfkj/uni/service/DataProcessService.java

@@ -27,7 +27,7 @@ public class DataProcessService {
 // 创建一个固定大小的线程池，包含2个线程
     private static final ExecutorService executor = Executors.newWorkStealingPool();
     private final DataBase DATA_BASE = new DataBase();
-    private final DatabaseScriptUtil DATABASE_SCRIPT_UTIL = new DatabaseScriptUtil();
+    private static final DatabaseScriptUtil DATABASE_SCRIPT_UTIL = new DatabaseScriptUtil();
 
     public Map<String, Object> process(Map<String, Object> inData) {
         String lifecycleid = null;
@@ -358,7 +358,7 @@ public class DataProcessService {
      * @return 处理结果
      * @throws Exception
      */
-    public Map<String, Object> processByAlgorithm(Object type, List<Object> parameters) throws Exception {
+    public static Map<String, Object> processByAlgorithm(Object type, List<Object> parameters) throws Exception {
 
         switch (type.toString().toUpperCase()) {
             // java反射

src/main/java/com/scbfkj/uni/service/LoggerService.java

@@ -43,7 +43,7 @@ public class LoggerService {
                 if (!new File(filePath).exists()) {
                     try {
                         DATA_BASE.exec(connectionStr, """
-                                create table logs
+                                create table if not exists logs
                                 (
                                     logid         Integer
                                         primary key autoincrement,
@@ -60,25 +60,23 @@ public class LoggerService {
                 fileNames.add(filename);
                 fileNames.removeIf(it -> it + 1000 < filename);
             }
-        }
-        try {
-            List<Object[]> datas = new ArrayList<>();
-            List<Map<String, Object>> targets = DATA_BASE.query(Config.getCenterConnectionStr(), "select * from systeminfo where keyname=?", type.getName());
-            for (Map<String, Object> targetconnection : targets) {
-                datas.add(new Object[]{type.getName(), filePath, targetconnection.get("datasourceid"), targetconnection.get("expression"), DataFormatUtil.toString(data)});
-            }
-            DATA_BASE.updateBatch(connectionStr, "insert into logs (target,currentfile,datasourceid,expression,datacontent) values(?,?,?,?,?)", datas);
-        } catch (Exception e) {
-            if (Config.isDebug()) {
-                e.printStackTrace();
+            try {
+                List<Object[]> datas = new ArrayList<>();
+                List<Map<String, Object>> targets = DATA_BASE.query(Config.getCenterConnectionStr(), "select * from systeminfo where keyname=?", type.getName());
+                for (Map<String, Object> targetconnection : targets) {
+                    datas.add(new Object[]{type.getName(), filePath, targetconnection.get("datasourceid"), targetconnection.get("expression"), DataFormatUtil.toString(data)});
+                }
+                DATA_BASE.updateBatch(connectionStr, "insert into logs (target,currentfile,datasourceid,expression,datacontent) values(?,?,?,?,?)", datas);
+            } catch (Exception e) {
+                if (Config.isDebug()) {
+                    e.printStackTrace();
+                }
             }
         }
     }
 
     public static void sendMessage() {
 
-        long filename = System.currentTimeMillis() / Config.getSplitCount();
-        currentFileName = filename + ".sqlite";
 //        判断目录
 
         File file = new File(DIR);
@@ -169,7 +167,7 @@ public class LoggerService {
                                         put("datacontent", datacontentStream.map(DataFormatUtil::toMap).map(dataContent -> ((Map<String, Object>) dataContent)).toList());
                                         put("event", "1");
                                     }});
-                                    new DataProcessService().processByAlgorithm("3", parameters);
+                                    DataProcessService.processByAlgorithm("3", parameters);
                                 }
                             }
 

src/main/java/com/scbfkj/uni/system/ProcessUtil.java

@@ -0,0 +1,418 @@
+package com.scbfkj.uni.system;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.scbfkj.uni.dtos.Expression;
+import com.scbfkj.uni.library.DataAliasGetUtil;
+import com.scbfkj.uni.library.DataFormatUtil;
+import com.scbfkj.uni.library.UniReturnUtil;
+import com.scbfkj.uni.library.script.DatabaseScriptUtil;
+import com.scbfkj.uni.library.script.JavaScriptEngineUtil;
+import com.scbfkj.uni.library.script.JsScriptEngineUtil;
+import com.scbfkj.uni.process.DataBase;
+import com.scbfkj.uni.service.LoggerService;
+
+import java.io.File;
+import java.text.NumberFormat;
+import java.text.ParseException;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class ProcessUtil {
+
+    //    添加一个线程池
+// 创建一个固定大小的线程池，包含2个线程
+    private static final ExecutorService executor = Executors.newWorkStealingPool();
+    private final DataBase DATA_BASE = new DataBase();
+
+
+    public Map<String, Object> process(Map<String, Object> inData) {
+        String lifecycleid = null;
+        List<Map<String, Object>> resource = new ArrayList<>();
+        List<Map<String, Object>> tempResult = new ArrayList<>();
+        List<Map<String, Object>> preResource = new ArrayList<>();
+        tempResult.add(inData);
+        resource.add(inData);
+        String serviceId = null;
+        LocalDateTime startDateTime = LocalDateTime.now();
+        Optional<String> serviceIdOpt;
+        String message = null;
+        Object algorithmlibraryid;
+
+        Map<String, Object> serviceInfo = null;
+
+        try {
+            serviceIdOpt = DataAliasGetUtil.getValue("serviceid", inData);
+            if (serviceIdOpt.isEmpty()) {
+                throw new RuntimeException("服务编号不能为空");
+            }
+            serviceId = serviceIdOpt.get();
+
+//        熔断
+//            查询服务运行状态
+            List<Map<String, Object>> serviceState = DATA_BASE.query(Config.getCenterConnectionStr(), """
+                    select  runstate
+                    from servicestate
+                    where serviceid =? and runstate = '1' and containercode=? order by servicestateid desc""", serviceId, Config.getContainerCode());
+            if (serviceState.isEmpty() || serviceState.get(0).get("runstate").equals("0")) {
+                throw new RuntimeException("服务没有运行");
+            }
+            List<Map<String, Object>> serviceInfoList = DATA_BASE.query(Config.getCenterConnectionStr(), """
+                    select * from serviceinfo where serviceid = ?""", serviceId);
+            if (!serviceInfoList.isEmpty()) {
+                serviceInfo = serviceInfoList.get(0);
+            }
+
+
+            Optional<String> lifecycleidOpt = DataAliasGetUtil.getValue("lifecycleid", inData);
+
+            if (lifecycleidOpt.isEmpty()) {
+                lifecycleid = DataAliasGetUtil.createLifeCycleCol(Config.getContainerCode(), serviceId);
+                inData.put("lifecycleid", lifecycleid);
+            } else {
+                lifecycleid = lifecycleidOpt.get();
+            }
+            HashMap<String, Object> source = new HashMap<>();
+
+            Map<String, Integer> algorithmLibrariesOrders = new HashMap<>();
+
+            List<Map<String, Object>> algorithmLibraries = DATA_BASE.query(Config.getCenterConnectionStr(), """
+                    select *
+                    from algorithmlibrary
+                    where serviceid = ? order by executionorder""", serviceId);
+            for (int i = 0; i < algorithmLibraries.size(); i++) {
+                Map<String, Object> algorithmLibrary = algorithmLibraries.get(i);
+                String id = algorithmLibrary.get("algorithmlibraryid").toString();
+                algorithmLibrariesOrders.put(id, i + 1);
+            }
+
+            List<AgorithmLibraryGroup> groups = algorithmLibraries.stream().map(it -> {
+                Object groupNameObj = it.get("groupname");
+                if (Objects.isNull(groupNameObj)) {
+                    groupNameObj = "N" + it.get("algorithmlibraryid");
+                }
+                Object loopcountObj = it.get("loopcount");
+                if (Objects.isNull(loopcountObj)) {
+                    loopcountObj = 1;
+                }
+                int count = Integer.parseInt(loopcountObj.toString());
+                return new AgorithmLibraryGroup(groupNameObj.toString(), count);
+            }).distinct().toList();
+
+
+            String preCode = "0";
+            for (AgorithmLibraryGroup group : groups) {
+                List<Map<String, Object>> list = algorithmLibraries.stream().filter(it -> {
+                    Object groupNameObj = it.get("groupname");
+                    if (Objects.isNull(groupNameObj)) {
+                        groupNameObj = "N" + it.get("algorithmlibraryid");
+                    }
+                    return groupNameObj.toString().equalsIgnoreCase(group.groupName);
+                }).toList();
+
+                for (int g = 0; g < group.count; g++) {
+                    for (Map<String, Object> algorithmLibrary : list) {
+
+
+                        startDateTime = LocalDateTime.now();
+                        long startTime = System.currentTimeMillis();
+                        algorithmlibraryid = algorithmLibrary.get("algorithmlibraryid");
+                        HashMap<String, Object> data = new HashMap<>();
+                        Object preConditions = algorithmLibrary.get("preconditions");
+
+                        source.put("args", resource);
+                        source.put("algorithm", algorithmLibrary);
+                        if (Objects.nonNull(preConditions)) {
+                            Map<String, Object> eval = JsScriptEngineUtil.eval(preConditions.toString(), tempResult);
+                            HashMap<String, Object> preData = new HashMap<>();
+                            preResource.add(preData);
+
+                            preData.put("algorithmlibraryid", algorithmlibraryid);
+                            preData.put("preResult", eval);
+                            preCode = eval.get("code").toString();
+                        }
+
+                        if ("1".equalsIgnoreCase(preCode) || "2".equalsIgnoreCase(preCode) || "3".equalsIgnoreCase(preCode)) {
+                            break;
+                        }
+
+                        Object algorithmsourcelibraryid = algorithmLibrary.get("algorithmsourcelibraryid");
+
+                        List<Map<String, Object>> algorithmsourcelibraryList = DATA_BASE.query(Config.getCenterConnectionStr(), "select * from algorithmsourcelibrary where id=? ", algorithmsourcelibraryid);
+                        Map<String, Object> algorithmsourcelibrary = algorithmsourcelibraryList.get(0);
+
+                        HashMap<String, Object> configMap = new HashMap<>();
+                        Object methodName = algorithmsourcelibrary.get("code");
+                        configMap.put("methodName", methodName);
+                        configMap.put("path", algorithmsourcelibrary.get("filepath"));
+                        Object className = algorithmsourcelibrary.get("library");
+                        configMap.put("className", className);
+                        Map<String, Object> result = null;
+//        获取入参列表
+                        List<Object> parameters = new ArrayList<>();
+                        if ("com.scbfkj.uni.library.script.JsScriptEngineUtil".equals(className) && "eval".equals(methodName)) {
+                            String expressionStr = algorithmLibrary.get("computingexpression").toString();
+                            result = JsScriptEngineUtil.eval(expressionStr, tempResult);
+                        } else {
+                            List<Map<String, Object>> params = DATA_BASE.query(Config.getCenterConnectionStr(), """
+                                    select
+                                    algorithmparametersid, algorithmlibraryid, parametername, subscriptionexpressions, parametertype, datasource
+                                    from algorithmparameters where algorithmlibraryid =?""", algorithmlibraryid.toString());
+
+                            for (Map<String, Object> param : params) {
+                                Object o = param.get("datasource");
+                                Object subscriptionExpressions = param.get("subscriptionexpressions");
+                                Object parameterType = param.get("parametertype");
+                                if ("0".equals(o)) {
+
+
+                                } else if ("1".equals(o)) {
+                                    Object o1 = algorithmLibrary.get(subscriptionExpressions);
+                                    parseData(parameterType, parameters, o1);
+                                } else if ("2".equals(o)) {
+                                    parseData(parameterType, parameters, subscriptionExpressions);
+                                } else if ("3".equals(o)) {
+                                    parameters.add(getParams(parameterType.toString(), "/args", subscriptionExpressions.toString(), source));
+                                }
+                            }
+                            result = JavaScriptEngineUtil.invoke(configMap, methodName.toString(), parameters.toArray());
+                            if (!result.isEmpty() && result.containsKey("code") && result.containsKey("returnData") && "0".equalsIgnoreCase(result.get("code").toString())) {
+                                Object returnData = result.get("returnData");
+                                if (returnData instanceof Map<?, ?> map) {
+                                    if (!map.isEmpty() && map.containsKey("code") && map.containsKey("returnData") && "0".equalsIgnoreCase(map.get("code").toString())) {
+                                        result = (Map<String, Object>) map;
+                                    }
+                                }
+                            }
+                        }
+
+                        data.put("lifecycleid", lifecycleid);
+                        data.put("algorithmlibraryid", algorithmlibraryid);
+                        data.put("result", result);
+                        data.put("parameters", parameters);
+//                    执行时长
+                        data.put("execTime", System.currentTimeMillis() - startTime);
+
+//                    执行成功与否
+                        Object code = Optional.ofNullable(result.get("code")).map(DataFormatUtil::toString).orElse(null);
+                        message = Optional.ofNullable(result.get("message")).map(DataFormatUtil::toString).orElse(null);
+                        data.put("resultCode", code);
+
+                        tempResult.add(algorithmLibrariesOrders.get(algorithmlibraryid.toString()), data);
+                        resource.add(data);
+                    }
+
+
+                    if ("2".equalsIgnoreCase(preCode) || "3".equalsIgnoreCase(preCode)) {
+                        break;
+                    }
+                }
+                if ("3".equalsIgnoreCase(preCode)) {
+                    break;
+                }
+            }
+
+            Object data = null;
+            if (!resource.isEmpty()) {
+                data = resource.get(resource.size() - 1);
+
+                if (Objects.nonNull(data)) {
+                    data = ((Map<?, ?>) data).get("result");
+                }
+                if (Objects.nonNull(data)) {
+                    data = ((Map<?, ?>) data).get("returnData");
+                }
+            }
+            return UniReturnUtil.success(data);
+        } catch (Exception e) {
+            message = e.getMessage();
+            if (Config.isDebug()) {
+                e.printStackTrace();
+            }
+            return UniReturnUtil.fail(e);
+        } finally {
+
+//                    不管成功还是失败都记录日志
+            if (serviceInfo != null) {
+                Object enablelog = serviceInfo.get("enablelog");
+                if (Config.isDebug() || Objects.nonNull(serviceInfo) && Objects.equals("1", Objects.nonNull(enablelog) ? enablelog.toString() : null)) {
+                    String finalMessage = message;
+                    LocalDateTime finalStartDateTime = startDateTime;
+                    String finalServiceId = serviceId;
+                    String finalLifecycleid = lifecycleid;
+//                使用线程不阻塞
+                    executor.execute(() -> {
+                        LoggerService.LogType target = LoggerService.LogType.SERVICE;
+                        if (Objects.nonNull(finalMessage)) {
+                            target = LoggerService.LogType.SERVICE_ERR;
+                        }
+                        HashMap<String, Object> logData = new HashMap<>();
+                        logData.put("begintime", finalStartDateTime);
+                        LocalDateTime dateTime = LocalDateTime.now();
+                        logData.put("endtime", dateTime);
+                        logData.put("serviceid", finalServiceId);
+                        String string = DataFormatUtil.toString(resource);
+                        if (Config.isDebug()) {
+                            System.out.println("resources:" + string);
+                        }
+                        logData.put("inputdata", string);
+                        logData.put("prepesource", DataFormatUtil.toString(preResource));
+                        logData.put("returnmessage", finalMessage);
+                        logData.put("lifecycleid", finalLifecycleid);
+                        try {
+                            LoggerService.log(target, logData);
+                        } catch (Exception exception) {
+                            if (Config.isDebug()) {
+                                exception.printStackTrace();
+                            }
+                        }
+                    });
+
+                }
+//                使用线程不阻塞
+            }
+            String finalServiceId1 = serviceId;
+            executor.execute(() -> {
+                try {
+                    DATA_BASE.update(Config.getCenterConnectionStr(), """
+                            update servicestate
+                            set lasttime = ?,workpath = ?
+                            where serviceid=? and containercode=?""", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyy-MM-dd HH:mm:ss")), new File(".").getAbsolutePath(), finalServiceId1, Config.getContainerCode());
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            });
+        }
+
+    }
+
+    private static void parseData(Object parameterType, List<Object> parameters, Object subscriptionExpressions) throws ParseException {
+        switch (parameterType.toString()) {
+            case "String" -> {
+                parameters.add(DataFormatUtil.toString(subscriptionExpressions));
+            }
+            case "Array" -> {
+                parameters.add(DataFormatUtil.toList(subscriptionExpressions));
+            }
+            case "Map" -> {
+                parameters.add(DataFormatUtil.toMap(subscriptionExpressions));
+            }
+            case "Number" -> {
+                parameters.add(NumberFormat.getInstance().parse(subscriptionExpressions.toString()));
+            }
+            case "Boolean" -> {
+                parameters.add(Boolean.parseBoolean(subscriptionExpressions.toString()));
+            }
+            default -> {
+                throw new RuntimeException("参数数据类型错误");
+            }
+        }
+    }
+
+
+    public Object getParams(String type, String root, String parameterSet, Object source) throws JsonProcessingException {
+
+
+        if (Objects.isNull(source)) {
+            return null;
+        }
+
+        JsonNode jsonNode = DataFormatUtil.toJsonNode(source);
+        if (root == null) {
+            root = "";
+        }
+        if (parameterSet == null) parameterSet = "";
+        String jsonPtrExpr = (root + parameterSet.replaceAll("[\\[\\]$.]", "/")).replaceAll("/+", "/");
+        if (!jsonPtrExpr.startsWith("/")) {
+            jsonPtrExpr = "/" + jsonPtrExpr;
+        }
+        JsonNode node = "/".equalsIgnoreCase(jsonPtrExpr) ? jsonNode : jsonNode.at(jsonPtrExpr);
+        if (!List.of("string", "list", "map", "array", "long", "integer", "boolean", "double", "float", "datetime").contains(type.toLowerCase())) {
+            if ("null".equalsIgnoreCase(type)) {
+                return null;
+            } else {
+                throw new RuntimeException("数据类型错误: " + type);
+            }
+        }
+        if ("String".equalsIgnoreCase(type)) {
+            return node.toString();
+        } else if ("List".equalsIgnoreCase(type)) {
+            return DataFormatUtil.toList(node);
+        } else if ("Array".equalsIgnoreCase(type)) {
+            return DataFormatUtil.toArray(node);
+        } else if ("Map".equalsIgnoreCase(type)) {
+            return DataFormatUtil.toMap(node);
+        } else if ("Long".equalsIgnoreCase(type)) {
+            return node.asLong();
+        } else if ("Integer".equalsIgnoreCase(type)) {
+            return node.asInt();
+        } else if ("Double".equalsIgnoreCase(type)) {
+            return node.asDouble();
+        } else if ("Float".equalsIgnoreCase(type)) {
+            return node.floatValue();
+        } else if ("Boolean".equalsIgnoreCase(type)) {
+            return node.asBoolean();
+        } else if ("Datetime".equalsIgnoreCase(type)) {
+            String string = node.asText();
+            String patten = "yyyy-MM-dd HH:mm:ss";
+            if (string.contains("(")) {
+                patten = string.substring(string.indexOf("(") + 1, string.length() - 1);
+                string = string.substring(0, string.indexOf("("));
+            }
+            return LocalDateTime.parse(string, DateTimeFormatter.ofPattern(patten));
+        }
+        return node;
+    }
+
+
+    public static class AgorithmLibraryGroup {
+        private String groupName;
+        private int count;
+
+        public String getGroupName() {
+            return groupName;
+        }
+
+        public void setGroupName(String groupName) {
+            this.groupName = groupName;
+        }
+
+        public int getCount() {
+            return count;
+        }
+
+        public void setCount(int count) {
+            this.count = count;
+        }
+
+        public AgorithmLibraryGroup(String groupName, int count) {
+            this.groupName = groupName;
+            this.count = count;
+        }
+
+        @Override
+        public String toString() {
+            return "AgorithmLibraryGroup{" +
+                   "groupName='" + groupName + '\'' +
+                   ", count=" + count +
+                   '}';
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            AgorithmLibraryGroup that = (AgorithmLibraryGroup) o;
+            return count == that.count && Objects.equals(groupName, that.groupName);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(groupName, count);
+        }
+    }
+
+}

src/main/java/com/scbfkj/uni/system/ScheduleTask.java

@@ -1,7 +1,6 @@
 package com.scbfkj.uni.system;
 
 import com.scbfkj.uni.library.UniReturnUtil;
-import com.scbfkj.uni.service.DataProcessService;
 
 import java.util.HashMap;
 import java.util.Objects;
@@ -29,7 +28,7 @@ public class ScheduleTask implements Runnable {
             count++;
         }
         try {
-            new DataProcessService().process(new HashMap<>() {{
+            new ProcessUtil().process(new HashMap<>() {{
                 put("serviceid", id);
             }});
         } catch (Exception e) {

src/main/java/com/scbfkj/uni/utils/Util.java

@@ -10,23 +10,32 @@ import com.scbfkj.uni.system.Config;
 import jakarta.annotation.Resource;
 import org.springframework.stereotype.Component;
 
+import java.net.InetAddress;
+import java.net.NetworkInterface;
+import java.net.SocketException;
+import java.net.UnknownHostException;
 import java.util.*;
 
 @Component
 public class Util {
-    @Resource
-    private SecurityService securityService;
+
+    public Util(SecurityService securityService) {
+        Util.securityService = securityService;
+    }
+
+    private static SecurityService securityService = null;
+
 
     private static final DataBase DATA_BASE = new DataBase();
 
 
-    public  void addFilter(Map<String, Object> body, Optional<String> serviceid,String uri,boolean checkToken) throws Exception {
+    public static void addFilter(Map<String, Object> body, Optional<String> serviceid, String uri, boolean check) throws Exception {
 
 
         List<Map<String, Object>> permission = (List<Map<String, Object>>) securityService.permission().get("returnData");
 
 
-        if(checkToken) {
+        if (check) {
             checkToken(uri);
         }
         if (Objects.nonNull(body) && uri.startsWith("/openApi")) {
@@ -76,7 +85,7 @@ public class Util {
         }
     }
 
-    public  void checkToken(String uri) throws Exception {
+    public static void checkToken(String uri) throws Exception {
         if (Config.isSecurityEnable()) {
             List<Map<String, Object>> apiInfos = DATA_BASE.query(Config.getSecurityConnectionStr(), "select * from apiinfo");
 
@@ -118,4 +127,28 @@ public class Util {
             }
         }
     }
+
+    /**
+     * 获取当前机器的MAC地址
+     */
+    public static String mac() throws UnknownHostException, SocketException {
+        InetAddress localHost = InetAddress.getLocalHost();
+        NetworkInterface networkInterface = NetworkInterface.getByInetAddress(localHost);
+        byte[] macAddressBytes = networkInterface.getHardwareAddress();
+
+        StringBuilder macAddressBuilder = new StringBuilder();
+        for (byte b : macAddressBytes) {
+            macAddressBuilder.append(String.format("%02X:", b));
+        }
+
+        String macAddress = macAddressBuilder.toString();
+        if (!macAddress.isEmpty()) {
+            macAddress = macAddress.substring(0, macAddress.length() - 1);
+        }
+
+        return macAddress;
+
+    }
+
+
 }

src/test/java/com/scbfkj/uni/library/JsonPathTest.java

@@ -1,25 +1,28 @@
 package com.scbfkj.uni.library;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.scbfkj.uni.system.ProcessUtil;
+import com.scbfkj.uni.utils.Util;
 import org.junit.jupiter.api.Test;
 
+import java.net.SocketException;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.List;
+
 public class JsonPathTest {
     @Test
-    void test1() throws JsonProcessingException {
-        ObjectMapper objectMapper = new ObjectMapper();
-        JsonNode jsonNode = objectMapper.readTree("""
-                                [{
-                  "serviceid": "133",
-                  "datacontent": [{
-                    "datasourceid": "13",
-                    "tableName": "datasource"
-                  }],
-                  "event": "0",
-                  "page": 1,
-                  "size": 9999
-                }]""");
-        System.out.println(jsonNode.at("/0/datacontent/0/datasourceid"));
+    void test1() throws SocketException, UnknownHostException {
+        String mac = Util.mac();
+        System.out.println(mac);
+        List<ProcessUtil.AgorithmLibraryGroup> list = new ArrayList<>();
+        list.add(new ProcessUtil.AgorithmLibraryGroup("a",10));
+        list.add(new ProcessUtil.AgorithmLibraryGroup("a",10));
+        list.add(new ProcessUtil.AgorithmLibraryGroup("a",10));
+        list.add(new ProcessUtil.AgorithmLibraryGroup("a",10));
+        for (ProcessUtil.AgorithmLibraryGroup agorithmLibraryGroup : list.stream().distinct().toList()) {
+            System.out.println(agorithmLibraryGroup);
+        }
     }
 }