Using Jackson instead of Fastjson (#2850)

* Using Jackson instead of Fastjson

* Fix some json bugs
Co-authored-by: Ndailidong <dailidong66@gmail.com>

dolphinscheduler-alert/src/test/java/org/apache/dolphinscheduler/alert/utils/JSONUtilsTest.java

@@ -17,6 +17,7 @@
 
 package org.apache.dolphinscheduler.alert.utils;
 
+import com.fasterxml.jackson.databind.JsonNode;
 import org.junit.Before;
 import org.junit.Test;
 import org.slf4j.Logger;
@@ -109,4 +110,5 @@ public class JSONUtilsTest {
 
     }
 
+
 }

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/ProcessInstanceService.java

@@ -504,9 +504,8 @@ public class ProcessInstanceService extends BaseDAGService {
      *
      * @param processInstanceId process instance id
      * @return variables data
-     * @throws Exception exception
      */
-    public Map<String, Object> viewVariables( Integer processInstanceId) throws Exception {
+    public Map<String, Object> viewVariables(Integer processInstanceId) {
         Map<String, Object> result = new HashMap<>(5);
 
         ProcessInstance processInstance = processInstanceMapper.queryDetailById(processInstanceId);
@@ -537,7 +536,7 @@ public class ProcessInstanceService extends BaseDAGService {
         List<TaskNode> taskNodeList = workflowData.getTasks();
 
         // global param string
-        String globalParamStr = JSON.toJSONString(globalParams);
+        String globalParamStr = JSONUtils.toJson(globalParams);
         globalParamStr = ParameterUtils.convertParameterPlaceholders(globalParamStr, timeParams);
         globalParams = JSON.parseArray(globalParamStr, Property.class);
         for (Property property : globalParams) {

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/utils/exportprocess/DataSourceParam.java

@@ -16,9 +16,9 @@
  */
 package org.apache.dolphinscheduler.api.utils.exportprocess;
 
-import com.alibaba.fastjson.JSONObject;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import org.apache.dolphinscheduler.common.enums.TaskType;
-import org.apache.dolphinscheduler.common.utils.JSONUtils;
 import org.apache.dolphinscheduler.dao.entity.DataSource;
 import org.apache.dolphinscheduler.dao.mapper.DataSourceMapper;
 import org.springframework.beans.factory.InitializingBean;
@@ -33,6 +33,7 @@ import java.util.List;
 @Service
 public class DataSourceParam implements ProcessAddTaskParam, InitializingBean {
 
+    private static final String PARAMS = "params";
     @Autowired
     private DataSourceMapper dataSourceMapper;
 
@@ -42,14 +43,14 @@ public class DataSourceParam implements ProcessAddTaskParam, InitializingBean {
      * @return task node json object
      */
     @Override
-    public JSONObject addExportSpecialParam(JSONObject taskNode) {
+    public JsonNode addExportSpecialParam(JsonNode taskNode) {
         // add sqlParameters
-        JSONObject sqlParameters = JSONUtils.parseObject(taskNode.getString("params"));
-        DataSource dataSource = dataSourceMapper.selectById((Integer) sqlParameters.get("datasource"));
+        ObjectNode sqlParameters = (ObjectNode) taskNode.path(PARAMS);
+        DataSource dataSource = dataSourceMapper.selectById(sqlParameters.get("datasource").asInt());
         if (null != dataSource) {
             sqlParameters.put("datasourceName", dataSource.getName());
         }
-        taskNode.put("params", sqlParameters);
+        ((ObjectNode)taskNode).set(PARAMS, sqlParameters);
 
         return taskNode;
     }
@@ -60,14 +61,14 @@ public class DataSourceParam implements ProcessAddTaskParam, InitializingBean {
      * @return task node json object
      */
     @Override
-    public JSONObject addImportSpecialParam(JSONObject taskNode) {
-        JSONObject sqlParameters = JSONUtils.parseObject(taskNode.getString("params"));
-        List<DataSource> dataSources = dataSourceMapper.queryDataSourceByName(sqlParameters.getString("datasourceName"));
+    public JsonNode addImportSpecialParam(JsonNode taskNode) {
+        ObjectNode sqlParameters = (ObjectNode) taskNode.path(PARAMS);
+        List<DataSource> dataSources = dataSourceMapper.queryDataSourceByName(sqlParameters.path("datasourceName").asText());
         if (!dataSources.isEmpty()) {
             DataSource dataSource = dataSources.get(0);
             sqlParameters.put("datasource", dataSource.getId());
         }
-        taskNode.put("params", sqlParameters);
+        ((ObjectNode)taskNode).set(PARAMS, sqlParameters);
         return taskNode;
     }
 

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/utils/exportprocess/DependentParam.java

@@ -16,8 +16,9 @@
  */
 package org.apache.dolphinscheduler.api.utils.exportprocess;
 
-import com.alibaba.fastjson.JSONArray;
-import com.alibaba.fastjson.JSONObject;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import org.apache.dolphinscheduler.common.enums.TaskType;
 import org.apache.dolphinscheduler.common.utils.JSONUtils;
 import org.apache.dolphinscheduler.dao.entity.ProcessDefinition;
@@ -34,6 +35,7 @@ import org.springframework.stereotype.Service;
 @Service
 public class DependentParam implements ProcessAddTaskParam, InitializingBean {
 
+    private static final String DEPENDENCE = "dependence";
 
     @Autowired
     ProcessDefinitionMapper processDefineMapper;
@@ -47,18 +49,18 @@ public class DependentParam implements ProcessAddTaskParam, InitializingBean {
      * @return task node json object
      */
     @Override
-    public JSONObject addExportSpecialParam(JSONObject taskNode) {
+    public JsonNode addExportSpecialParam(JsonNode taskNode) {
         // add dependent param
-        JSONObject dependentParameters = JSONUtils.parseObject(taskNode.getString("dependence"));
+        ObjectNode dependentParameters = JSONUtils.parseObject(taskNode.path(DEPENDENCE).asText());
 
         if (null != dependentParameters) {
-            JSONArray dependTaskList = (JSONArray) dependentParameters.get("dependTaskList");
+            ArrayNode dependTaskList = (ArrayNode) dependentParameters.get("dependTaskList");
             for (int j = 0; j < dependTaskList.size(); j++) {
-                JSONObject dependentTaskModel = dependTaskList.getJSONObject(j);
-                JSONArray dependItemList = (JSONArray) dependentTaskModel.get("dependItemList");
+                JsonNode dependentTaskModel = dependTaskList.path(j);
+                ArrayNode dependItemList = (ArrayNode) dependentTaskModel.get("dependItemList");
                 for (int k = 0; k < dependItemList.size(); k++) {
-                    JSONObject dependentItem = dependItemList.getJSONObject(k);
-                    int definitionId = dependentItem.getInteger("definitionId");
+                    ObjectNode dependentItem = (ObjectNode) dependItemList.path(k);
+                    int definitionId = dependentItem.path("definitionId").asInt();
                     ProcessDefinition definition = processDefineMapper.queryByDefineId(definitionId);
                     if (null != definition) {
                         dependentItem.put("projectName", definition.getProjectName());
@@ -66,7 +68,7 @@ public class DependentParam implements ProcessAddTaskParam, InitializingBean {
                     }
                 }
             }
-            taskNode.put("dependence", dependentParameters);
+            ((ObjectNode)taskNode).set(DEPENDENCE, dependentParameters);
         }
 
         return taskNode;
@@ -78,18 +80,18 @@ public class DependentParam implements ProcessAddTaskParam, InitializingBean {
      * @return
      */
     @Override
-    public JSONObject addImportSpecialParam(JSONObject taskNode) {
-        JSONObject dependentParameters =  JSONUtils.parseObject(taskNode.getString("dependence"));
+    public JsonNode addImportSpecialParam(JsonNode taskNode) {
+        ObjectNode dependentParameters =  JSONUtils.parseObject(taskNode.path(DEPENDENCE).asText());
         if(dependentParameters != null){
-            JSONArray dependTaskList = (JSONArray) dependentParameters.get("dependTaskList");
+            ArrayNode dependTaskList = (ArrayNode) dependentParameters.path("dependTaskList");
             for (int h = 0; h < dependTaskList.size(); h++) {
-                JSONObject dependentTaskModel = dependTaskList.getJSONObject(h);
-                JSONArray dependItemList = (JSONArray) dependentTaskModel.get("dependItemList");
+                ObjectNode dependentTaskModel = (ObjectNode) dependTaskList.path(h);
+                ArrayNode dependItemList = (ArrayNode) dependentTaskModel.get("dependItemList");
                 for (int k = 0; k < dependItemList.size(); k++) {
-                    JSONObject dependentItem = dependItemList.getJSONObject(k);
-                    Project dependentItemProject = projectMapper.queryByName(dependentItem.getString("projectName"));
+                    ObjectNode dependentItem = (ObjectNode) dependItemList.path(k);
+                    Project dependentItemProject = projectMapper.queryByName(dependentItem.path("projectName").asText());
                     if(dependentItemProject != null){
-                        ProcessDefinition definition = processDefineMapper.queryByDefineName(dependentItemProject.getId(),dependentItem.getString("definitionName"));
+                        ProcessDefinition definition = processDefineMapper.queryByDefineName(dependentItemProject.getId(),dependentItem.path("definitionName").asText());
                         if(definition != null){
                             dependentItem.put("projectId",dependentItemProject.getId());
                             dependentItem.put("definitionId",definition.getId());
@@ -97,7 +99,7 @@ public class DependentParam implements ProcessAddTaskParam, InitializingBean {
                     }
                 }
             }
-            taskNode.put("dependence", dependentParameters);
+            ((ObjectNode)taskNode).set(DEPENDENCE, dependentParameters);
         }
         return taskNode;
     }

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/utils/exportprocess/ProcessAddTaskParam.java

@@ -16,7 +16,7 @@
  */
 package org.apache.dolphinscheduler.api.utils.exportprocess;
 
-import com.alibaba.fastjson.JSONObject;
+import com.fasterxml.jackson.databind.JsonNode;
 
 /**
  * ProcessAddTaskParam
@@ -28,12 +28,12 @@ public interface ProcessAddTaskParam {
      * @param taskNode task node json object
      * @return task node json object
      */
-    JSONObject addExportSpecialParam(JSONObject taskNode);
+    JsonNode addExportSpecialParam(JsonNode taskNode);
 
     /**
      * add task special param: sql task dependent task
      * @param taskNode task node json object
      * @return task node json object
      */
-    JSONObject addImportSpecialParam(JSONObject taskNode);
+    JsonNode addImportSpecialParam(JsonNode taskNode);
 }

dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/ProcessDefinitionServiceTest.java

@@ -16,8 +16,8 @@
  */
 package org.apache.dolphinscheduler.api.service;
 
-import com.alibaba.fastjson.JSONArray;
-import com.alibaba.fastjson.JSONObject;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import org.apache.dolphinscheduler.api.ApiApplicationServer;
 import org.apache.dolphinscheduler.api.dto.ProcessMeta;
 import org.apache.dolphinscheduler.api.enums.Status;
@@ -621,8 +621,8 @@ public class ProcessDefinitionServiceTest {
                 "\"preTasks\":[]}],\"tenantId\":1,\"timeout\":0}";
 
 
-        JSONObject jsonObject = JSONUtils.parseObject(topProcessJson);
-        JSONArray jsonArray = (JSONArray) jsonObject.get("tasks");
+        ObjectNode jsonObject = JSONUtils.parseObject(topProcessJson);
+        ArrayNode jsonArray = (ArrayNode) jsonObject.path("tasks");
 
         String originSubJson = jsonArray.toString();
 

dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/utils/exportprocess/DataSourceParamTest.java

@@ -16,7 +16,8 @@
  */
 package org.apache.dolphinscheduler.api.utils.exportprocess;
 
-import com.alibaba.fastjson.JSONObject;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import org.apache.dolphinscheduler.api.ApiApplicationServer;
 import org.apache.dolphinscheduler.common.utils.JSONUtils;
 import org.apache.dolphinscheduler.common.utils.StringUtils;
@@ -48,13 +49,13 @@ public class DataSourceParamTest {
                 "\"preTasks\":[\"dependent\"]}";
 
 
-        JSONObject taskNode = JSONUtils.parseObject(sqlJson);
-        if (StringUtils.isNotEmpty(taskNode.getString("type"))) {
-            String taskType = taskNode.getString("type");
+        ObjectNode taskNode = JSONUtils.parseObject(sqlJson);
+        if (StringUtils.isNotEmpty(taskNode.path("type").asText())) {
+            String taskType = taskNode.path("type").asText();
 
             ProcessAddTaskParam addTaskParam = TaskNodeParamFactory.getByTaskType(taskType);
 
-            JSONObject sql = addTaskParam.addExportSpecialParam(taskNode);
+            JsonNode sql = addTaskParam.addExportSpecialParam(taskNode);
 
             JSONAssert.assertEquals(taskNode.toString(), sql.toString(), false);
         }
@@ -72,13 +73,13 @@ public class DataSourceParamTest {
                 "\"taskInstancePriority\":\"MEDIUM\",\"name\":\"mysql\",\"dependence\":{}," +
                 "\"retryInterval\":\"1\",\"preTasks\":[\"dependent\"],\"id\":\"tasks-8745\"}";
 
-        JSONObject taskNode = JSONUtils.parseObject(sqlJson);
-        if (StringUtils.isNotEmpty(taskNode.getString("type"))) {
-            String taskType = taskNode.getString("type");
+        ObjectNode taskNode = JSONUtils.parseObject(sqlJson);
+        if (StringUtils.isNotEmpty(taskNode.path("type").asText())) {
+            String taskType = taskNode.path("type").asText();
 
             ProcessAddTaskParam addTaskParam = TaskNodeParamFactory.getByTaskType(taskType);
 
-            JSONObject sql = addTaskParam.addImportSpecialParam(taskNode);
+            JsonNode sql = addTaskParam.addImportSpecialParam(taskNode);
 
             JSONAssert.assertEquals(taskNode.toString(), sql.toString(), false);
         }

dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/utils/exportprocess/DependentParamTest.java

@@ -17,6 +17,8 @@
 package org.apache.dolphinscheduler.api.utils.exportprocess;
 
 import com.alibaba.fastjson.JSONObject;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import org.apache.dolphinscheduler.api.ApiApplicationServer;
 import org.apache.dolphinscheduler.common.utils.JSONUtils;
 import org.apache.dolphinscheduler.common.utils.StringUtils;
@@ -43,13 +45,13 @@ public class DependentParamTest {
                 "\"dependItemList\":[{\"projectId\":2,\"definitionId\":46,\"depTasks\":\"ALL\"," +
                 "\"cycle\":\"day\",\"dateValue\":\"today\"}]}]}}";
 
-        JSONObject taskNode = JSONUtils.parseObject(dependentJson);
-        if (StringUtils.isNotEmpty(taskNode.getString("type"))) {
-            String taskType = taskNode.getString("type");
+        ObjectNode taskNode = JSONUtils.parseObject(dependentJson);
+        if (StringUtils.isNotEmpty(taskNode.path("type").asText())) {
+            String taskType = taskNode.path("type").asText();
 
             ProcessAddTaskParam addTaskParam = TaskNodeParamFactory.getByTaskType(taskType);
 
-            JSONObject dependent = addTaskParam.addExportSpecialParam(taskNode);
+            JsonNode dependent = addTaskParam.addExportSpecialParam(taskNode);
 
             JSONAssert.assertEquals(taskNode.toString(), dependent.toString(), false);
         }
@@ -57,13 +59,13 @@ public class DependentParamTest {
         String dependentEmpty = "{\"type\":\"DEPENDENT\",\"id\":\"tasks-33787\"," +
                 "\"name\":\"dependent\",\"params\":{},\"description\":\"\",\"runFlag\":\"NORMAL\"}";
 
-        JSONObject taskEmpty = JSONUtils.parseObject(dependentEmpty);
-        if (StringUtils.isNotEmpty(taskEmpty.getString("type"))) {
-            String taskType = taskEmpty.getString("type");
+        ObjectNode taskEmpty = JSONUtils.parseObject(dependentEmpty);
+        if (StringUtils.isNotEmpty(taskEmpty.path("type").asText())) {
+            String taskType = taskEmpty.path("type").asText();
 
             ProcessAddTaskParam addTaskParam = TaskNodeParamFactory.getByTaskType(taskType);
 
-            JSONObject dependent = addTaskParam.addImportSpecialParam(taskEmpty);
+            JsonNode dependent = addTaskParam.addImportSpecialParam(taskEmpty);
 
             JSONAssert.assertEquals(taskEmpty.toString(), dependent.toString(), false);
         }
@@ -81,13 +83,13 @@ public class DependentParamTest {
                 "\"projectId\":1,\"cycle\":\"day\",\"definitionId\":7}],\"relation\":\"AND\"}]," +
                 "\"relation\":\"AND\"},\"retryInterval\":\"1\",\"preTasks\":[],\"id\":\"tasks-55485\"}";
 
-        JSONObject taskNode = JSONUtils.parseObject(dependentJson);
-        if (StringUtils.isNotEmpty(taskNode.getString("type"))) {
-            String taskType = taskNode.getString("type");
+        ObjectNode taskNode = JSONUtils.parseObject(dependentJson);
+        if (StringUtils.isNotEmpty(taskNode.path("type").asText())) {
+            String taskType = taskNode.path("type").asText();
 
             ProcessAddTaskParam addTaskParam = TaskNodeParamFactory.getByTaskType(taskType);
 
-            JSONObject dependent = addTaskParam.addImportSpecialParam(taskNode);
+            JsonNode dependent = addTaskParam.addImportSpecialParam(taskNode);
 
             JSONAssert.assertEquals(taskNode.toString(), dependent.toString(), false);
         }
@@ -97,13 +99,13 @@ public class DependentParamTest {
                 "\"strategy\":\"\"},\"maxRetryTimes\":\"0\",\"taskInstancePriority\":\"MEDIUM\"" +
                 ",\"name\":\"dependent\",\"retryInterval\":\"1\",\"preTasks\":[],\"id\":\"tasks-55485\"}";
 
-        JSONObject taskNodeEmpty = JSONUtils.parseObject(dependentEmpty);
-        if (StringUtils.isNotEmpty(taskNodeEmpty.getString("type"))) {
-            String taskType = taskNodeEmpty.getString("type");
+        JsonNode taskNodeEmpty = JSONUtils.parseObject(dependentEmpty);
+        if (StringUtils.isNotEmpty(taskNodeEmpty.path("type").asText())) {
+            String taskType = taskNodeEmpty.path("type").asText();
 
             ProcessAddTaskParam addTaskParam = TaskNodeParamFactory.getByTaskType(taskType);
 
-            JSONObject dependent = addTaskParam.addImportSpecialParam(taskNode);
+            JsonNode dependent = addTaskParam.addImportSpecialParam(taskNode);
 
             JSONAssert.assertEquals(taskNodeEmpty.toString(), dependent.toString(), false);
         }

dolphinscheduler-common/src/main/java/org/apache/dolphinscheduler/common/utils/JSONUtils.java

@@ -16,13 +16,12 @@
  */
 package org.apache.dolphinscheduler.common.utils;
 
-import com.alibaba.fastjson.JSON;
-import com.alibaba.fastjson.JSONArray;
-import com.alibaba.fastjson.JSONObject;
-import com.alibaba.fastjson.TypeReference;
 import com.fasterxml.jackson.core.JsonGenerator;
 import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.*;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import org.apache.commons.lang.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -35,230 +34,233 @@ import java.util.*;
  */
 public class JSONUtils {
 
-  private static final Logger logger = LoggerFactory.getLogger(JSONUtils.class);
-
-  /**
-   * can use static singleton, inject: just make sure to reuse!
-   */
-  private static final ObjectMapper objectMapper = new ObjectMapper();
-
-  private JSONUtils() {
-    //Feature that determines whether encountering of unknown properties, false means not analyzer unknown properties
-    objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false).setTimeZone(TimeZone.getDefault());
-  }
-
-  /**
-   * json representation of object
-   * @param object object
-   * @return object to json string
-   */
-  public static String toJson(Object object) {
-    try{
-      return JSON.toJSONString(object,false);
-    } catch (Exception e) {
-      logger.error("object to json exception!",e);
+    private static final Logger logger = LoggerFactory.getLogger(JSONUtils.class);
+
+    /**
+     * can use static singleton, inject: just make sure to reuse!
+     */
+    private static final ObjectMapper objectMapper = new ObjectMapper();
+
+    private JSONUtils() {
     }
 
-    return null;
-  }
-
-
-  /**
-   *
-   * This method deserializes the specified Json into an object of the specified class. It is not
-   * suitable to use if the specified class is a generic type since it will not have the generic
-   * type information because of the Type Erasure feature of Java. Therefore, this method should not
-   * be used if the desired type is a generic type. Note that this method works fine if the any of
-   * the fields of the specified object are generics, just the object itself should not be a
-   * generic type.
-   *
-   * @param json the string from which the object is to be deserialized
-   * @param clazz the class of T
-   * @param <T> T
-   * @return an object of type T from the string
-   * classOfT
-   */
-  public static <T> T parseObject(String json, Class<T> clazz) {
-    if (StringUtils.isEmpty(json)) {
-      return null;
+    static {
+        //Feature that determines whether encountering of unknown properties, false means not analyzer unknown properties
+        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false).setTimeZone(TimeZone.getDefault());
+        objectMapper.configure(DeserializationFeature.ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT, true).setTimeZone(TimeZone.getDefault());
     }
 
-    try {
-      return JSON.parseObject(json, clazz);
-    } catch (Exception e) {
-      logger.error("parse object exception!",e);
+    /**
+     * json representation of object
+     *
+     * @param object object
+     * @return object to json string
+     */
+    public static String toJson(Object object) {
+        try {
+            return objectMapper.writeValueAsString(object);
+        } catch (Exception e) {
+            logger.error("object to json exception!", e);
+        }
+
+        return null;
     }
-    return null;
-  }
-
-
-  /**
-   * json to list
-   *
-   * @param json json string
-   * @param clazz class
-   * @param <T> T
-   * @return list
-   */
-  public static <T> List<T> toList(String json, Class<T> clazz) {
-    if (StringUtils.isEmpty(json)) {
-      return new ArrayList<>();
+
+
+    /**
+     * This method deserializes the specified Json into an object of the specified class. It is not
+     * suitable to use if the specified class is a generic type since it will not have the generic
+     * type information because of the Type Erasure feature of Java. Therefore, this method should not
+     * be used if the desired type is a generic type. Note that this method works fine if the any of
+     * the fields of the specified object are generics, just the object itself should not be a
+     * generic type.
+     *
+     * @param json  the string from which the object is to be deserialized
+     * @param clazz the class of T
+     * @param <T>   T
+     * @return an object of type T from the string
+     * classOfT
+     */
+    public static <T> T parseObject(String json, Class<T> clazz) {
+        if (StringUtils.isEmpty(json)) {
+            return null;
+        }
+
+        try {
+            return objectMapper.readValue(json, clazz);
+        } catch (Exception e) {
+            logger.error("parse object exception!", e);
+        }
+        return null;
     }
-    try {
-      return JSONArray.parseArray(json, clazz);
-    } catch (Exception e) {
-      logger.error("JSONArray.parseArray exception!",e);
+
+
+    /**
+     * json to list
+     *
+     * @param json  json string
+     * @param clazz class
+     * @param <T>   T
+     * @return list
+     */
+    public static <T> List<T> toList(String json, Class<T> clazz) {
+        if (StringUtils.isEmpty(json)) {
+            return new ArrayList<>();
+        }
+        try {
+            return objectMapper.readValue(json, new TypeReference<List<T>>() {
+            });
+        } catch (Exception e) {
+            logger.error("JSONArray.parseArray exception!", e);
+        }
+
+        return new ArrayList<>();
     }
 
-    return new ArrayList<>();
-  }
 
+    /**
+     * check json object valid
+     *
+     * @param json json
+     * @return true if valid
+     */
+    public static boolean checkJsonValid(String json) {
 
+        if (StringUtils.isEmpty(json)) {
+            return false;
+        }
 
-  /**
-   * check json object valid
-   *
-   * @param json json
-   * @return true if valid
-   */
-  public static boolean checkJsonValid(String json) {
+        try {
+            objectMapper.readTree(json);
+            return true;
+        } catch (IOException e) {
+            logger.error("check json object valid exception!", e);
+        }
 
-    if (StringUtils.isEmpty(json)) {
-      return false;
+        return false;
     }
 
-    try {
-      objectMapper.readTree(json);
-      return true;
-    } catch (IOException e) {
-      logger.error("check json object valid exception!",e);
-    }
 
-    return false;
-  }
-
-
-  /**
-   * Method for finding a JSON Object field with specified name in this
-   * node or its child nodes, and returning value it has.
-   * If no matching field is found in this node or its descendants, returns null.
-   *
-   * @param jsonNode json node
-   * @param fieldName Name of field to look for
-   *
-   * @return Value of first matching node found, if any; null if none
-   */
-  public static String findValue(JsonNode jsonNode, String fieldName) {
-    JsonNode node = jsonNode.findValue(fieldName);
-
-    if (node == null) {
-      return null;
-    }
+    /**
+     * Method for finding a JSON Object field with specified name in this
+     * node or its child nodes, and returning value it has.
+     * If no matching field is found in this node or its descendants, returns null.
+     *
+     * @param jsonNode  json node
+     * @param fieldName Name of field to look for
+     * @return Value of first matching node found, if any; null if none
+     */
+    public static String findValue(JsonNode jsonNode, String fieldName) {
+        JsonNode node = jsonNode.findValue(fieldName);
 
-    return node.toString();
-  }
-
-
-  /**
-   * json to map
-   *
-   * {@link #toMap(String, Class, Class)}
-   *
-   * @param json json
-   * @return json to map
-   */
-  public static Map<String, String> toMap(String json) {
-    if (StringUtils.isEmpty(json)) {
-      return null;
-    }
+        if (node == null) {
+            return null;
+        }
 
-    try {
-      return JSON.parseObject(json, new TypeReference<HashMap<String, String>>(){});
-    } catch (Exception e) {
-      logger.error("json to map exception!",e);
+        return node.toString();
     }
 
-    return null;
-  }
-
-  /**
-   *
-   * json to map
-   *
-   * @param json json
-   * @param classK classK
-   * @param classV classV
-   * @param <K> K
-   * @param <V> V
-   * @return to map
-   */
-  public static <K, V> Map<K, V> toMap(String json, Class<K> classK, Class<V> classV) {
-    if (StringUtils.isEmpty(json)) {
-      return null;
+
+    /**
+     * json to map
+     * <p>
+     * {@link #toMap(String, Class, Class)}
+     *
+     * @param json json
+     * @return json to map
+     */
+    public static Map<String, String> toMap(String json) {
+        if (StringUtils.isEmpty(json)) {
+            return null;
+        }
+
+        try {
+            return objectMapper.readValue(json, new TypeReference<Map<String, String>>() {});
+        } catch (Exception e) {
+            logger.error("json to map exception!", e);
+        }
+
+        return null;
     }
 
-    try {
-      return JSON.parseObject(json, new TypeReference<HashMap<K, V>>() {});
-    } catch (Exception e) {
-      logger.error("json to map exception!",e);
+    /**
+     * json to map
+     *
+     * @param json   json
+     * @param classK classK
+     * @param classV classV
+     * @param <K>    K
+     * @param <V>    V
+     * @return to map
+     */
+    public static <K, V> Map<K, V> toMap(String json, Class<K> classK, Class<V> classV) {
+        if (StringUtils.isEmpty(json)) {
+            return null;
+        }
+
+        try {
+            return objectMapper.readValue(json, new TypeReference<Map<K, V>>() {
+            });
+        } catch (Exception e) {
+            logger.error("json to map exception!", e);
+        }
+
+        return null;
     }
 
-    return null;
-  }
-
-  /**
-   * object to json string
-   * @param object object
-   * @return json string
-   */
-  public static String toJsonString(Object object) {
-    try{
-      return JSON.toJSONString(object,false);
-    } catch (Exception e) {
-      throw new RuntimeException("Object json deserialization exception.", e);
+    /**
+     * object to json string
+     *
+     * @param object object
+     * @return json string
+     */
+    public static String toJsonString(Object object) {
+        try {
+            return objectMapper.writeValueAsString(object);
+        } catch (Exception e) {
+            throw new RuntimeException("Object json deserialization exception.", e);
+        }
     }
-  }
 
-  public static JSONObject parseObject(String text) {
-    try{
-      return JSON.parseObject(text);
-    } catch (Exception e) {
-      throw new RuntimeException("String json deserialization exception.", e);
+    public static ObjectNode parseObject(String text) {
+        try {
+            return (ObjectNode) objectMapper.readTree(text);
+        } catch (Exception e) {
+            throw new RuntimeException("String json deserialization exception.", e);
+        }
     }
-  }
 
-  public static JSONArray parseArray(String text) {
-    try{
-      return JSON.parseArray(text);
-    } catch (Exception e) {
-      throw new RuntimeException("Json deserialization exception.", e);
+    public static ArrayNode parseArray(String text) {
+        try {
+            return (ArrayNode) objectMapper.readTree(text);
+        } catch (Exception e) {
+            throw new RuntimeException("Json deserialization exception.", e);
+        }
     }
-  }
 
 
+    /**
+     * json serializer
+     */
+    public static class JsonDataSerializer extends JsonSerializer<String> {
 
-  /**
-   * json serializer
-   */
-  public static class JsonDataSerializer extends JsonSerializer<String> {
+        @Override
+        public void serialize(String value, JsonGenerator gen, SerializerProvider provider) throws IOException {
+            gen.writeRawValue(value);
+        }
 
-    @Override
-    public void serialize(String value, JsonGenerator gen, SerializerProvider provider) throws IOException {
-      gen.writeRawValue(value);
     }
 
-  }
+    /**
+     * json data deserializer
+     */
+    public static class JsonDataDeserializer extends JsonDeserializer<String> {
 
-  /**
-   * json data deserializer
-   */
-  public static class JsonDataDeserializer extends JsonDeserializer<String> {
+        @Override
+        public String deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
+            JsonNode node = p.getCodec().readTree(p);
+            return node.toString();
+        }
 
-    @Override
-    public String deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
-      JsonNode node = p.getCodec().readTree(p);
-      return node.toString();
     }
-
-  }
 }

dolphinscheduler-common/src/main/java/org/apache/dolphinscheduler/common/utils/ParameterUtils.java

@@ -196,7 +196,7 @@ public class ParameterUtils {
         property.setValue(val);
       }
     }
-    return JSON.toJSONString(globalParamList);
+    return JSONUtils.toJson(globalParamList);
   }
 
 

dolphinscheduler-common/src/main/java/org/apache/dolphinscheduler/common/utils/StreamUtils.java

+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.dolphinscheduler.common.utils;
+
+import java.util.Iterator;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+public class StreamUtils {
+
+    private StreamUtils() { }
+
+    public static <T> Stream<T> asStream(Iterator<T> sourceIterator) {
+        return asStream(sourceIterator, false);
+    }
+
+    public static <T> Stream<T> asStream(Iterator<T> sourceIterator, boolean parallel) {
+        Iterable<T> iterable = () -> sourceIterator;
+        return StreamSupport.stream(iterable.spliterator(), parallel);
+    }
+
+}

dolphinscheduler-common/src/test/java/org/apache/dolphinscheduler/common/utils/JSONUtilsTest.java

@@ -17,6 +17,8 @@
 package org.apache.dolphinscheduler.common.utils;
 
 import com.alibaba.fastjson.JSON;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import org.apache.dolphinscheduler.common.enums.DataType;
 import org.apache.dolphinscheduler.common.enums.Direct;
 import org.apache.dolphinscheduler.common.process.Property;
@@ -101,9 +103,6 @@ public class JSONUtilsTest {
 
     @Test
     public void testParseObject() {
-        Assert.assertEquals("{\"foo\":\"bar\"}", JSONUtils.parseObject(
-                "{\n" + "\"foo\": \"bar\",\n" + "}", String.class));
-
         Assert.assertNull(JSONUtils.parseObject("", null));
         Assert.assertNull(JSONUtils.parseObject("foo", String.class));
     }
@@ -134,15 +133,19 @@ public class JSONUtilsTest {
         map.put("foo","bar");
 
         Assert.assertTrue(map.equals(JSONUtils.toMap(
-                "{\n" + "\"foo\": \"bar\",\n" + "}")));
+                "{\n" + "\"foo\": \"bar\"\n" + "}")));
 
         Assert.assertFalse(map.equals(JSONUtils.toMap(
-                "{\n" + "\"bar\": \"foo\",\n" + "}")));
+                "{\n" + "\"bar\": \"foo\"\n" + "}")));
 
         Assert.assertNull(JSONUtils.toMap("3"));
         Assert.assertNull(JSONUtils.toMap(null));
         Assert.assertNull(JSONUtils.toMap("3", null, null));
         Assert.assertNull(JSONUtils.toMap(null, null, null));
+
+        String str = "{\"resourceList\":[],\"localParams\":[],\"rawScript\":\"#!/bin/bash\\necho \\\"shell-1\\\"\"}";
+        Map<String, String> m = JSONUtils.toMap(str);
+        Assert.assertNotNull(m);
     }
 
     @Test
@@ -155,4 +158,27 @@ public class JSONUtilsTest {
         Assert.assertEquals(String.valueOf((Object) null),
                 JSONUtils.toJsonString(null));
     }
+
+    @Test
+    public void parseObject() {
+        String str = "{\"color\":\"yellow\",\"type\":\"renault\"}";
+        ObjectNode node = JSONUtils.parseObject(str);
+
+        Assert.assertEquals("yellow", node.path("color").asText());
+
+        node.put("price", 100);
+        Assert.assertEquals(100, node.path("price").asInt());
+
+        node.put("color", "red");
+        Assert.assertEquals("red", node.path("color").asText());
+    }
+
+    @Test
+    public void parseArray() {
+        String str = "[{\"color\":\"yellow\",\"type\":\"renault\"}]";
+        ArrayNode node = JSONUtils.parseArray(str);
+
+        Assert.assertEquals("yellow", node.path(0).path("color").asText());
+    }
+
 }

dolphinscheduler-common/src/test/java/org/apache/dolphinscheduler/common/utils/ParameterUtilsTest.java

@@ -91,13 +91,13 @@ public class ParameterUtilsTest {
         globalParamList.add(property);
 
         String result2 =  ParameterUtils.curingGlobalParams(null,globalParamList,CommandType.START_CURRENT_TASK_PROCESS,scheduleTime);
-        Assert.assertEquals(result2, JSON.toJSONString(globalParamList));
+        Assert.assertEquals(result2, JSONUtils.toJson(globalParamList));
 
         String result3 =  ParameterUtils.curingGlobalParams(globalParamMap,globalParamList,CommandType.START_CURRENT_TASK_PROCESS,null);
-        Assert.assertEquals(result3, JSON.toJSONString(globalParamList));
+        Assert.assertEquals(result3, JSONUtils.toJson(globalParamList));
 
         String result4 = ParameterUtils.curingGlobalParams(globalParamMap, globalParamList, CommandType.START_CURRENT_TASK_PROCESS, scheduleTime);
-        Assert.assertEquals(result4, JSON.toJSONString(globalParamList));
+        Assert.assertEquals(result4, JSONUtils.toJson(globalParamList));
 
         //test var $ startsWith
         globalParamMap.put("bizDate","${system.biz.date}");
@@ -113,7 +113,7 @@ public class ParameterUtilsTest {
         globalParamList.add(property4);
 
         String result5 = ParameterUtils.curingGlobalParams(globalParamMap, globalParamList, CommandType.START_CURRENT_TASK_PROCESS, scheduleTime);
-        Assert.assertEquals(result5,JSONUtils.toJsonString(globalParamList));
+        Assert.assertEquals(result5, JSONUtils.toJson(globalParamList));
     }
 
     /**

dolphinscheduler-common/src/test/java/org/apache/dolphinscheduler/common/utils/StreamUtilsTest.java

+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.dolphinscheduler.common.utils;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.*;
+
+public class StreamUtilsTest {
+
+    @Test
+    public void asStream() {
+        List<String> list = Arrays.asList("a", "b", "c");
+        List<String> ret = StreamUtils.asStream(list.iterator())
+                .filter(item -> item.equals("a"))
+                .collect(Collectors.toList());
+        Assert.assertEquals("a", ret.get(0));
+    }
+
+}
\ No newline at end of file