前端核心发布: 8.2.80

基础框架发布: 8.2.18
  1) 规则引擎中，修复资源深度复制时, 选项参数不应该加 NEW。

io.sc.engine.rule.core/src/main/java/io/sc/engine/rule/core/code/ExecuteUnit4Resource.java

@@ -1,16 +1,18 @@
 package io.sc.engine.rule.core.code;
 
 import com.fasterxml.jackson.annotation.JsonPropertyOrder;
+import com.fasterxml.jackson.core.JsonProcessingException;
 import io.sc.engine.rule.core.po.lib.Indicator;
 import io.sc.engine.rule.core.po.lib.IndicatorLib;
+import io.sc.engine.rule.core.po.lib.IndicatorProcessor;
 import io.sc.engine.rule.core.po.lib.Lib;
 import io.sc.engine.rule.core.po.model.Model;
 import io.sc.engine.rule.core.po.model.Parameter;
-import io.sc.engine.rule.core.po.model.ParameterProcessor;
 import io.sc.engine.rule.core.po.model.parameter.IndicatorParameter;
 import io.sc.engine.rule.core.po.resource.ModelResource;
 import io.sc.engine.rule.core.po.resource.Resource;
 import io.sc.engine.rule.core.util.PlaceHolder;
+import io.sc.platform.util.ObjectMapperUtil;
 
 import java.util.*;
 
@@ -41,19 +43,7 @@ public class ExecuteUnit4Resource extends ExecuteUnit{
     }
 
     public void optimize(){
-        if(1==1) return;
-        if(resource instanceof ModelResource){
-            ModelResource modelResource =(ModelResource) resource;
-            Model model =modelResource.getModel();
-            List<ParameterProcessor> processors =model.getAllParameterProcessors();
-            PlaceHolder placeHolder =new PlaceHolder();
-            for(ParameterProcessor processor : processors){
-                placeHolder.add(processor.extractPlaceHolder());
-            }
-            for(String s : placeHolder.getVariableRefs()){
-                System.out.println(s);
-            }
-        }
+        //optimizeLibs();
     }
 
     private void optimizeLibs(){
@@ -64,52 +54,127 @@ public class ExecuteUnit4Resource extends ExecuteUnit{
             if(parameters==null || parameters.isEmpty()){
                 return;
             }
-            List<IndicatorLib> requiredLibs =new ArrayList<>();
+            Map<LibId,Set<String>> cache =new HashMap<>();
             for(Parameter parameter : parameters){
                 if(parameter instanceof IndicatorParameter){
                     IndicatorParameter indicatorParameter =(IndicatorParameter)parameter;
                     String libCode =indicatorParameter.getLibCode();
                     Integer libVersion =indicatorParameter.getLibVersion();
-                    String indicatorCode =indicatorParameter.getIndicatorCode();
 
-                    findRefIndicators(requiredLibs,indicatorParameter.getLibCode(),indicatorParameter.getLibVersion(),indicatorParameter.getIndicatorCode());
+                    LibId libId =new LibId(libCode,libVersion);
+                    String indicatorCode =indicatorParameter.getIndicatorCode();
 
-                }
+                    Set<String> requiredIndicatorCodes =cache.get(libId);
+                    if(requiredIndicatorCodes==null){
+                        requiredIndicatorCodes =new LinkedHashSet<>();
+                        cache.put(libId,requiredIndicatorCodes);
                     }
 
+                    IndicatorLib lib =findLib(libCode,libVersion);
+                    if(lib!=null) {
+                        findRefIndicators(lib, indicatorCode, requiredIndicatorCodes);
                     }
                 }
-
-    private void optimizeDictionaries(){
-
             }
-
-    private void optimizeFunctions(){
-
+            resetLibs(cache);
+        }
     }
 
-    private Lib findLib(String code, Integer version){
+    private IndicatorLib findLib(String code, Integer version){
         if(libs==null && libs.isEmpty()){ return null; }
         for(Lib lib : libs) {
-            if(lib.getCode().equals(code) && lib.getVersion().equals(version)){ return lib; }
+            if(lib.getCode().equals(code) && lib.getVersion().equals(version)){
+                if(lib instanceof IndicatorLib) {
+                    return (IndicatorLib)lib;
+                }
+            }
         }
         return null;
     }
 
-    private List<Indicator> findIndicatorsByLib(String libCode, Integer libVersion){
-        if(libs==null && libs.isEmpty()){
-            return Collections.emptyList();
+    private void findRefIndicators(IndicatorLib lib, String indicatorCode, Set<String> requiredCodes){
+        List<Indicator> indicators =lib.getIndicators();
+        if(indicators!=null && !indicators.isEmpty()){
+            for(Indicator indicator : indicators){
+                if(indicator.getCode().equals(indicatorCode)){
+                    if(requiredCodes.contains(indicatorCode)){
+                        continue;
+                    }
+                    requiredCodes.add(indicatorCode);
+                    List<IndicatorProcessor> processors =indicator.getProcessors();
+                    if(processors!=null && !processors.isEmpty()){
+                        for(IndicatorProcessor processor : processors){
+                            PlaceHolder placeHolder =processor.extractPlaceHolder();
+                            Set<String> refs =placeHolder.getVariableRefs();
+                            for(String ref : refs){
+                                findRefIndicators(lib,ref,requiredCodes);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private void resetLibs(Map<LibId,Set<String>> requiredMap){
+        if(libs==null || libs.isEmpty()){
+            return;
         }
         for(Lib lib : libs){
             if(lib instanceof IndicatorLib){
+                List<Indicator> minIndicators =new ArrayList<>(); // 需要的最小化指标集
+                Set<String> minIndicatorCodes =requiredMap.get(new LibId(lib.getCode(),lib.getVersion()));
+
                 IndicatorLib indicatorLib =(IndicatorLib)lib;
-                return indicatorLib.getIndicators();
+                List<Indicator> indicators =indicatorLib.getIndicators();
+                if(indicators!=null && !indicators.isEmpty()){
+                    for(Indicator indicator : indicators){
+                        if(minIndicatorCodes.contains(indicator.getCode())){
+                            minIndicators.add(indicator);
+                        }
+                    }
                 }
+                indicatorLib.setIndicators(minIndicators);
             }
-        return Collections.emptyList();
         }
+    }
+
+    static class LibId {
+        private String code;
+        private Integer version;
+
+        public LibId(String code, Integer version){
+            this.code =code;
+            this.version =version;
+        }
+
 
-    private void findRefIndicators(List<IndicatorLib> requiredLibs, String libCode, Integer libVersion, String indicatorCode){
+        public String getCode() {
+            return code;
+        }
 
+        public void setCode(String code) {
+            this.code = code;
+        }
+
+        public Integer getVersion() {
+            return version;
+        }
+
+        public void setVersion(Integer version) {
+            this.version = version;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (o == null || getClass() != o.getClass()) return false;
+            LibId libID = (LibId) o;
+            return Objects.equals(code, libID.code) && Objects.equals(version, libID.version);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(code, version);
+        }
     }
 }

io.sc.engine.rule.server/src/main/java/io/sc/engine/rule/server/executable/controller/ExecuteUnitWebController.java

@@ -61,7 +61,6 @@ public class ExecuteUnitWebController {
 
 	@PostMapping(value="validateGroovySourceCode")
 	public void validateGroovySourceCode(@RequestBody Map<String,String> body) throws Exception{
-		System.out.println(body.get("script"));
 		executableUnitService.validateGroovySourceCode(body.get("script"));
 	}
 }