springboot项目集成dolphinscheduler调度器 可拖拽spark任务管理

已于 2022-07-22 20:21:15 修改
阅读量2.7k 收藏 9
点赞数
分类专栏： DolphineScheduler 文章标签： java 大数据 spark 可视化 spring boot
于 2021-05-22 16:32:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a924382407/article/details/117119831
版权
本文详细介绍了如何使用Dolphinscheduler调度器进行Spark任务的管理，包括创建、更新和删除可拖拽模型Spark任务的步骤和关键代码。涉及HTTP请求、配置文件、工作流管理和事务处理等多个方面。
摘要由CSDN通过智能技术生成

在这里插入图片描述

dolphinscheduler调度器接入注意事项等信息可参考我的上一篇博客进行了解，地址在这里 ->

文章目录

一、功能清单

在这里插入图片描述

二、可拖拽spark任务管理

说明：任务管理实际是操作dolphinscheduler调度器中的项目中的用户下唯一工作流中的各种类型节点的管理操作

共用的依赖

<!--httpclient-->
<dependency>
    <groupId>commons-httpclient</groupId>
    <artifactId>commons-httpclient</artifactId>
    <version>3.1</version>
</dependency>

共用配置文件

dolphinscheduler.token=xxx
dolphinscheduler.address=http://IP:12345

共用代码

@Autowired
private RestTemplate restTemplate;
@Value("${dolphinscheduler.token}")
String token;
@Value("${dolphinscheduler.address}")
String address;
public static final int ZERO = 0;
public static final int SUCCESS = 200;
@Autowired
private DragSparkTaskService dragSparkTaskService;
@Value("${spark.main.class}")
String mainClass;
public static final String CREATE = "create";
public static final String UPDATE = "update";
public static final String ADD = "add";
public static final String DELETE = "delete";
public static final String ONLINE = "ONLINE";
public static final String OFFLINE = "OFFLINE";
public static final int ONE_THOUSAND_AND_FIVE_HUNDRED = 1500;
public static final int SIX = 6;
public static final int EIGHTY = 80;
public static final int THREE = 3;
@Autowired
private StringRedisTemplate redisTemplate;
@Value("${drag.task.state}")
String dragTaskState;
@Autowired
private DragSparkTaskMapper dragSparkTaskMapper;

1.创建可拖拽模型spark任务

在这里插入图片描述
在这里插入图片描述
请求参数举例：

{
  "name": "测试任务模型1",
  "describeInfo": "测试任务模型1",
  "projectName": "spark线性回归模型",
  "task": {
    "edges": [
      {
        "id": "13889c99",
        "index": 2,
        "source": "356bc2be",
        "target": "33838a0d",
        "sourceAnchor": 2,
        "targetAnchor": 0
      }
    ],
    "nodes": [
      {
        "x": 482.671875,
        "y": 89.125,
        "id": "356bc2be",
        "size": "72*72",
        "type": "node",
        "color": "#1890FF",
        "index": 0,
        "label": "数据源",
        "shape": "flow-circle",
        "config": {
          "sourceType": "mysql",
          "targetTable": "machine_learning_house_info2"
        },
        "inputs": [],
        "outputs": [],
        "modelType": "dataSource"
      },
      {
        "x": 502.171875,
        "y": 269.125,
        "id": "33838a0d",
        "size": "110*42",
        "type": "node",
        "color": "#66C35D",
        "index": 1,
        "label": "全表统计",
        "shape": "flow-capsule",
        "config": {
          "selectColumns": "*"
        },
        "inputs": [],
        "outputs": [],
        "modelType": "fullTableStatistics"
      }
    ]
  }
}

在这里插入图片描述
代码

/**
     * 创建任务-创建用户下唯一工作流，无则创建有则并排添加
     * @param request request
     * @param vo 任务参数
     * @author liudz
     * @date 2021/5/8
     * @return 执行结果
     **/
    @PostMapping("/project/process")
    @Transactional(rollbackFor = Exception.class)
    public Response operatorDragSparkTask(HttpServletRequest request, @RequestBody DragSparkTaskVo vo) {
        Long userId = Long.valueOf(request.getUserPrincipal().getName());
        vo.setCreateId(userId);
        vo.setUpdateId(userId);
        if (vo == null || org.apache.commons.lang3.StringUtils.isBlank(vo.getName()) || vo.getDescribeInfo() == null
            || vo.getCreateId() == null) {
            log.error("--DragSparkTaskController--addDragSparkTask--PARAM_ERROR!--");
            return Response.error(Msg.PARAM_ERROR);
        }
        Response<DragSparkTaskVo> dragSparkTaskResponse = dragSparkTaskService.addDragSparkTask(vo);
        log.info("--(1)addDragSparkTask--success");
        if (dragSparkTaskResponse.getCode() == SUCCESS) {
            Boolean verifyResult = verifyProcessExist(userId + "-dragSparkTask", vo.getProjectName());
            log.info("--(2)verifyProcessExist--success:{}", verifyResult);
            if (!verifyResult) {
                ProcessDto processDto = packageProcessParam(
                        "create", userId + "-dragSparkTask", vo, null);
                log.info("--(3)packageProcessParam--success");
                dragSparkTaskResponse =  createProcess(vo, processDto);
            } else {
                //获取用户下唯一工作流ID
                DolphinschedulerResponse processInfoList = getUserProcess(vo.getProjectName());
                JSONObject processJson = new JSONObject();
                log.info("--(3)getUserProcess--success:{}", processInfoList);
                List<Map<String, Object>> list = (List<Map<String, Object>>) processInfoList.getData();
                for (Map<String, Object> map : list) {
                    if (map.get("name").equals(userId + "-dragSparkTask")) {
                        processJson.fluentPutAll(map);
                    }
                }
                ProcessDto processDto = packageProcessParam(
                        "add", userId + "-dragSparkTask", vo, processJson);
                processDto.setId(processJson.getInteger("id"));
                log.info("--(4)packageProcessParam--success");
                if (processJson.getString(DictionaryEnum.RELEASE_STATE.getFiledString()).equals(ONLINE)) {
                    releaseProcessDefinition(vo.getProjectName(), userId + "-dragSparkTask",
                            processDto.getId(), 0);
                    log.info("--(5)releaseProcessDefinition--OFFLINE--success");
                }
                dragSparkTaskResponse =  updateProcess(vo, processDto);
            }
        }
        return dragSparkTaskResponse;
    }

/**
     * 校验工作流是否存在
     * 
     * @param processName
     *            工作流名称
     * @param projectName 项目名称
     * @author liudz
     * @date 2021/5/8
     * @return boolean
     **/
    public Boolean verifyProcessExist(String processName, String projectName) {
        HttpHeaders headers = new HttpHeaders();
        headers.set("token", token);
        headers.set("Content-Type", "application/json");
        HttpEntity requestEntity = new HttpEntity(headers);
        ResponseEntity<DolphinschedulerResponse> response =
            restTemplate.exchange(address + "/dolphinscheduler/projects/" + projectName
                            + "/process/verify-name?name=" + processName,
                HttpMethod.GET, requestEntity, DolphinschedulerResponse.class);
        if (response.getBody().getCode() == ZERO) {
            return false;
        }
        return true;
    }

/**
     * 获取dolphinscheduler上的某用户下唯一工作流
     * @param projectName 项目名称
     * @author liudz
     * @date 2021/5/8
     * @return id
     **/
    public DolphinschedulerResponse getUserProcess(String projectName) {
        HttpHeaders headers = new HttpHeaders();
        headers.set("token", token);
        headers.set("Content-Type", "application/json");
        HttpEntity requestEntity = new HttpEntity(headers);
        ResponseEntity<DolphinschedulerResponse> response =
            restTemplate.exchange(address + "/dolphinscheduler/projects/" + projectName + "/process/list",
                HttpMethod.GET, requestEntity, DolphinschedulerResponse.class);
        return response.getBody();
    }

/**
     *  封装参数
     * @param type 操作类型
     * @param processName 用户工作流名称
     * @param vo 任务参数
     * @param processJson 工作流json
     * @author liudz
     * @date 2021/5/13
     * @return ProcessDto
     **/
    public ProcessDto packageProcessParam(String type, String processName, DragSparkTaskVo vo, JSONObject processJson) {
        ProcessDto processDto = new ProcessDto();
        processDto.setConnects("[]");
        processDto.setName(processName);
        JSONObject locationsOne = new JSONObject();
        JSONObject locationsTwo = new JSONObject();
        locationsTwo.fluentPut("name", "spark-" + vo.getId()).fluentPut("targetarr", "").fluentPut("nodenumber", "0");
        locationsTwo.fluentPut("x", 0).fluentPut("y", 0);
        locationsOne.put("tasks-" + vo.getId(), locationsTwo);

        // 创建工作流
        if (CREATE.equals(type)) {
            processDto = packageProcessParamOfCreate(processDto, vo, locationsOne);
         } else if (ADD.equals(type)) {
            //工作流添加节点
            processDto = packageProcessParamOfAdd(processDto, vo, processJson, locationsOne, locationsTwo);
        } else if (UPDATE.equals(type)) {
            //更新工作流-只更新参数processDefinitionJson的tasks参数
            processDto = packageProcessParamOfUpdate(processDto, processJson, vo);
        } else if (DELETE.equals(type)) {
            //更新工作流或删除工作流-更新则删除参数processDefinitionJson的tasks参数
            processDto = packageProcessParamOfDelete(processDto, processJson, vo);
        }
        return processDto;
    }

/**
     * packageProcessParamOfCreate
     * @param processDto 工作流参数
     * @param vo 任务参数
     * @param locationsOne locationsOne
     * @author liudz
     * @date 2021/5/7
     * @return ProcessDto
     **/
    public ProcessDto packageProcessParamOfCreate(ProcessDto processDto, DragSparkTaskVo vo, JSONObject locationsOne) {
        processDto.setLocations(locationsOne.toString());
        JSONObject processOne = new JSONObject();
        processOne.fluentPut("globalParams", new ArrayList<>()).fluentPut("tenantId", THREE).fluentPut("timeout", 0);
        JSONObject processTwo = new JSONObject();
        processTwo.fluentPut("type", "SPARK").fluentPut("id", "tasks-" + vo.getId());
        processTwo.fluentPut("name", "spark-" + vo.getId()).fluentPut("description", "");
        JSONArray nodesArray = parseLineAndNode(vo.getTask());
        JSONObject json = new JSONObject();
        json.put("id", vo.getId());
        json.put("name", vo.getName());
        json.put("describeInfo", vo.getDescribeInfo());
        json.put("nodes", nodesArray);
        String taskJsonString = json.toString().replace("}}", "} }").replace("{{", "{ {");
        processTwo.put("params", JSONObject.parseObject("{\"mainClass\":\"" + mainClass + "\","
               + "\"mainJar\":{\"id\":" + getSparkResourceJarId() + "},\"deployMode\":\"cluster\","
               + "\"resourceList\":[],\"localParams\":[],\"driverCores\":1,\"driverMemory\":\"1G\","
               + "\"numExecutors\":\"1\",\"executorMemory\":\"1G\",\"executorCores\":\"1\",\"mainArgs\":\"\\\""
               + taskJsonString.replace("\"", "\\\\\\\"") + "\\\"\",\"others\":\"\","
               + "\"programType\":\"JAVA\",\"sparkVersion\":\"SPARK2\"}"));
        JSONObject jsonTimeout = new JSONObject();
        jsonTimeout.fluentPut("strategy", "").fluentPut("interval", null).fluentPut("enable", false);
        processTwo.fluentPut("timeout", jsonTimeout).fluentPut("runFlag", "NORMAL");
        JSONObject processTree = new JSONObject();
        processTree.fluentPut("successNode", new ArrayList<>()).fluentPut("failedNode", new ArrayList<>());
        JSONObject jsonconditionResult = new JSONObject();
        jsonconditionResult.put("successNode", new ArrayList<>());
        jsonconditionResult.put("failedNode", new ArrayList<>());
        processTwo.fluentPut("conditionResult", jsonconditionResult).fluentPut("dependence", new JSONObject());
        processTwo.fluentPut("maxRetryTimes", "0").fluentPut("retryInterval", "1");
        processTwo.fluentPut("taskInstancePriority", "MEDIUM").fluentPut("workerGroup", "default");
        processTwo.fluentPut("preTasks", new ArrayList<>());
        JSONArray processTaskArray = new JSONArray();
        processTaskArray.add(processTwo);
        processOne.put("tasks", processTaskArray);
        processDto.setProcessDefinitionJson(processOne.toString());
        return processDto;
    }

/**
     * packageProcessParamOfAdd
     * @param processDto 工作流参数
     * @param locationsOne locationsOne
     * @param locationsTwo locationsTwo
     * @param vo 任务参数
     * @param processJson 工作流json
     * @author liudz
     * @date 2021/5/7
     * @return ProcessDto
     **/
    public ProcessDto packageProcessParamOfAdd(ProcessDto processDto, DragSparkTaskVo vo, JSONObject processJson,
                                               JSONObject locationsOne, JSONObject locationsTwo) {
        String maxTaskKey = JsonTools.getJsonStringMaxKey(processJson.getString("locations"));
        Integer x = processJson.getJSONObject("locations").getJSONObject(maxTaskKey).getInteger("x");
        Integer y = processJson.getJSONObject("locations").getJSONObject(maxTaskKey).getInteger("y");
        if (x < ONE_THOUSAND_AND_FIVE_HUNDRED) {
            locationsTwo.fluentPut("x", x + EIGHTY).fluentPut("y", y);
        } else if (x >= ONE_THOUSAND_AND_FIVE_HUNDRED) {
            locationsTwo.fluentPut("y", y + EIGHTY).fluentPut("x", 0);
        }
        locationsOne = processJson.getJSONObject("locations").fluentPut("tasks-" + vo.getId(), locationsTwo);
        processDto.setLocations(locationsOne.toString());
        processDto.setId(processJson.getInteger("id"));
        JSONObject processTwo = new JSONObject();
        processTwo.fluentPut("type", "SPARK").fluentPut("id", "tasks-" + vo.getId());
        processTwo.fluentPut("name", "spark-" + vo.getId()).fluentPut("description", "");
        JSONArray nodesArray = parseLineAndNode(vo.getTask());
        JSONObject json = new JSONObject();
        json.put("id", vo.getId());
        json.put("name", vo.getName());
        json.put("describeInfo", vo.getDescribeInfo());
        json.put("nodes", nodesArray);
        String taskJsonString = json.toString().replace("}}", "} }").replace("{{", "{ {");
        processTwo.put("params", JSONObject.parseObject("{\"mainClass\":\"" + mainClass + "\","
               + "\"mainJar\":{\"id\":" + getSparkResourceJarId() + "},\"deployMode\":\"cluster\","
               + "\"resourceList\":[],\"localParams\":[],\"driverCores\":1,\"driverMemory\":\"1G\","
               + "\"numExecutors\":\"1\",\"executorMemory\":\"1G\",\"executorCores\":\"1\",\"mainArgs\":\"\\\""
               + taskJsonString.replace("\"", "\\\\\\\"") + "\\\"\",\"others\":\"\","
               + "\"programType\":\"JAVA\",\"sparkVersion\":\"SPARK2\"}"));
        JSONObject jsonTimeout = new JSONObject();
        jsonTimeout.fluentPut("strategy", "").fluentPut("interval", null).fluentPut("enable", false);
        processTwo.fluentPut("timeout", jsonTimeout).fluentPut("runFlag", "NORMAL");
        JSONObject processTree = new JSONObject();
        processTree.fluentPut("successNode", new ArrayList<>()).fluentPut("failedNode", new ArrayList<>());
        JSONObject jsonconditionResult = new JSONObject();
        jsonconditionResult.put("successNode", new ArrayList<>());
        jsonconditionResult.put("failedNode", new ArrayList<>());
        processTwo.fluentPut("conditionResult", jsonconditionResult).fluentPut("dependence", new JSONObject());
        processTwo.fluentPut("maxRetryTimes", "0").fluentPut("retryInterval", "1");
        processTwo.fluentPut("taskInstancePriority", "MEDIUM").fluentPut("workerGroup", "default");
        processTwo.fluentPut("preTasks", new ArrayList<>());
        JSONObject jsonNew = processJson.getJSONObject("processDefinitionJson");
        JSONArray jsonArray = jsonNew.getJSONArray("tasks");
        jsonArray.add(processTwo);
        jsonNew.put("tasks", jsonArray);
        processDto.setProcessDefinitionJson(jsonNew.toString());
        return processDto;
    }

/**
     * 工作流【上线或者下线】
     * @param projectName 项目名称
     * @param processName 用户工作流名称
     * @param processId 工作流ID
     * @param releaseState 上下线状态操作【0：下线，1：上线】
     * @author liudz
     * @date 2021/5/7
     * @return 执行结果
     **/
    public Response releaseProcessDefinition(String projectName, String processName, Integer processId,
                  Integer releaseState) {
        try {
            String postURL = address + "/dolphinscheduler/projects/"
                   + URLEncoder.encode(projectName, "utf-8") + "/process/release";
            PostMethod postMethod = new PostMethod(postURL);
            postMethod.setRequestHeader("Content-Type",
                    "application/x-www-form-urlencoded;charset=utf-8");
            postMethod.setRequestHeader("token", token);
            // 参数设置，需要注意的就是里边不能传NULL，要传空字符串
            NameValuePair[] data = {new NameValuePair("name", processName),
                    new NameValuePair("processId", processId.toString()),
                    new NameValuePair("releaseState", releaseState.toString())};
            postMethod.setRequestBody(data);
            org.apache.commons.httpclient.HttpClient httpClient = new org.apache.commons.httpclient.HttpClient();
            httpClient.executeMethod(postMethod);
            JSONObject result = JSONObject.parseObject(postMethod.getResponseBodyAsString());
            if (!result.get(DictionaryEnum.CODE.getFiledString()).equals(ZERO)) {
                return Response.error(result.getInteger("code"), result.getString("msg"));
            }
        } catch (Exception e) {
            log.info("请求异常:{}", e);
        }
        return Response.success();
    }

2.更新可拖拽模型spark任务

在这里插入图片描述
在这里插入图片描述
请求参数举例：

{
  "name": "测试任务模型1",
  "describeInfo": "测试任务模型1",
  "projectName": "spark线性回归模型",
"id": 111,
  "task": {
    "edges": [
      {
        "id": "13889c99",
        "index": 2,
        "source": "356bc2be",
        "target": "33838a0d",
        "sourceAnchor": 2,
        "targetAnchor": 0
      }
    ],
    "nodes": [
      {
        "x": 482.671875,
        "y": 89.125,
        "id": "356bc2be",
        "size": "72*72",
        "type": "node",
        "color": "#1890FF",
        "index": 0,
        "label": "数据源",
        "shape": "flow-circle",
        "config": {
          "sourceType": "mysql",
          "targetTable": "machine_learning_house_info2"
        },
        "inputs": [],
        "outputs": [],
        "modelType": "dataSource"
      },
      {
        "x": 502.171875,
        "y": 269.125,
        "id": "33838a0d",
        "size": "110*42",
        "type": "node",
        "color": "#66C35D",
        "index": 1,
        "label": "全表统计",
        "shape": "flow-capsule",
        "config": {
          "selectColumns": "*"
        },
        "inputs": [],
        "outputs": [],
        "modelType": "fullTableStatistics"
      }
    ]
  }
}

在这里插入图片描述
代码：

/**
     * 更新任务
     * @param request request
     * @param vo 任务参数
     * @author liudz
     * @date 2021/5/8
     * @return 执行结果
     **/
    @PutMapping("/project/process")
    @Transactional(rollbackFor = Exception.class)
    public Response updateDragSparkTask(HttpServletRequest request, @RequestBody DragSparkTaskVo vo) {
        Long userId = Long.valueOf(request.getUserPrincipal().getName());
        vo.setCreateId(userId);
        vo.setUpdateId(userId);
        if (vo == null || org.apache.commons.lang3.StringUtils.isBlank(vo.getName()) || vo.getDescribeInfo() == null
            || vo.getCreateId() == null) {
            log.error("--DragSparkTaskController--updateDragSparkTask--PARAM_ERROR!--");
            return Response.error(Msg.PARAM_ERROR);
        }
        Response<DragSparkTaskVo> dragSparkTaskResponse = dragSparkTaskService.updateDragSparkTask(vo);
        log.info("--(1)updateDragSparkTask--mysql--success");
        if (dragSparkTaskResponse.getCode() == SUCCESS) {
            //获取用户下唯一工作流ID
            DolphinschedulerResponse processInfoList = getUserProcess(vo.getProjectName());
            JSONObject processJson = new JSONObject();
            log.info("--(2)getUserProcess--success:{}", processInfoList);
            List<Map<String, Object>> list = (List<Map<String, Object>>) processInfoList.getData();
            for (Map<String, Object> map : list) {
                if (map.get("name").equals(userId + "-dragSparkTask")) {
                    processJson.fluentPutAll(map);
                }
            }
            ProcessDto processDto = packageProcessParam(
                    "update", userId + "-dragSparkTask", vo, processJson);
            processDto.setId(processJson.getInteger("id"));
            log.info("--(3)packageProcessParam--success");
            if (processJson.getString(DictionaryEnum.RELEASE_STATE.getFiledString()).equals(ONLINE)) {
                releaseProcessDefinition(vo.getProjectName(), userId + "-dragSparkTask",
                        processDto.getId(), 0);
                log.info("--(4)releaseProcessDefinition--OFFLINE--success");
            }
            return updateProcess(vo, processDto);
        }
        return dragSparkTaskResponse;
    }

/**
     * packageProcessParamOfUpdate
     * @param processDto 工作流参数
     * @param vo 任务参数
     * @param processJson 工作流json
     * @author liudz
     * @date 2021/5/7
     * @return ProcessDto
     **/
    public ProcessDto packageProcessParamOfUpdate(ProcessDto processDto, JSONObject processJson, DragSparkTaskVo vo) {
        processDto.setLocations(processJson.getString("locations"));
        processDto.setId(processJson.getInteger("id"));
        JSONArray jsonTasksArray = processJson.getJSONObject("processDefinitionJson").getJSONArray("tasks");
        JSONArray copyJsonTasksArray = new JSONArray();
        copyJsonTasksArray.addAll(jsonTasksArray);
        JSONObject processDefinitionJson = new JSONObject();
        JSONArray nodesArray = parseLineAndNode(vo.getTask());
        JSONObject json = new JSONObject();
        json.put("id", vo.getId());
        json.put("name", vo.getName());
        json.put("describeInfo", vo.getDescribeInfo());
        json.put("nodes", nodesArray);
        String taskJsonString = json.toString().replace("}}", "} }").replace("{{", "{ {");
        for (Object object : jsonTasksArray) {
            JSONObject jsonObject = JSONObject.parseObject(object.toString());
            if (Long.valueOf(jsonObject.getString("id").substring(SIX)) == vo.getId()) {
                String mainArgs = jsonObject.getString("mainArgs");
                mainArgs = "\"" + taskJsonString.replace("\"", "\\\"") + "\"";
                copyJsonTasksArray.remove(jsonObject);
                jsonObject.getJSONObject("params").put("mainArgs", mainArgs);
                copyJsonTasksArray.add(jsonObject);
                processDefinitionJson = processJson.getJSONObject("processDefinitionJson");
                processDefinitionJson.put("tasks", copyJsonTasksArray);
            }
        }
        processDto.setProcessDefinitionJson(processDefinitionJson.toString());
        return processDto;
    }

 /**
     * 更新工作流
     * @param vo vo
     * @param processDto processDto
     * @author liudz
     * @date 2021/5/7
     * @return 执行结果
     **/
    public Response updateProcess(DragSparkTaskVo vo, ProcessDto processDto) {
        try {

            String postURL = address + "/dolphinscheduler/projects/"
                   + URLEncoder.encode(vo.getProjectName(), "utf-8") + "/process/update";
            PostMethod postMethod = new PostMethod(postURL);
            postMethod.setRequestHeader("Content-Type",
                    "application/x-www-form-urlencoded;charset=utf-8");
            postMethod.setRequestHeader("token", token);
            // 参数设置，需要注意的就是里边不能传NULL，要传空字符串
            NameValuePair[] data = {new NameValuePair("connects", processDto.getConnects()),
                new NameValuePair("name", processDto.getName()),
                new NameValuePair("locations", processDto.getLocations()),
                new NameValuePair("id", processDto.getId().toString()),
                new NameValuePair("processDefinitionJson", processDto.getProcessDefinitionJson())};
            postMethod.setRequestBody(data);
            org.apache.commons.httpclient.HttpClient httpClient = new org.apache.commons.httpclient.HttpClient();
            httpClient.executeMethod(postMethod);
            JSONObject result = JSONObject.parseObject(postMethod.getResponseBodyAsString());
            log.info("--(5)httpUpdateProcess:{}", result);
            if (!result.get(DictionaryEnum.CODE.getFiledString()).equals(ZERO)) {
                return Response.error(result.getInteger("code"), result.getString("msg"));
            }
        } catch (Exception e) {
            log.info("请求异常:{}", e);
        }
        return Response.success();
    }

3.删除可拖拽模型spark任务

在这里插入图片描述
代码：

/**
     * 删除任务
     * @param request request
     * @param projectName 项目名称
     * @param id 任务ID
     * @author liudz
     * @date 2021/5/8
     * @return 执行结果
     **/
    @DeleteMapping("/project/process/{projectName}/{id}")
    @Transactional(rollbackFor = Exception.class)
    public Response deleteDragSparkTask(HttpServletRequest request, @PathVariable("projectName") String projectName,
                                        @PathVariable("id") Long id) {
        DragSparkTaskVo vo = new DragSparkTaskVo();
        Long userId = Long.valueOf(request.getUserPrincipal().getName());
        vo.setId(id);
        vo.setCreateId(userId);
        vo.setProjectName(projectName);
        if (vo == null || vo.getId() == null || vo.getCreateId() == null) {
            log.error("--deleteDragSparkTask--PARAM_ERROR!--");
            return Response.error(Msg.PARAM_ERROR);
        }
        Response<DragSparkTaskVo> dragSparkTaskResponse = dragSparkTaskService.deleteDragSparkTask(vo);
        log.info("--(1)deleteDragSparkTask--mysql--success");
        if (dragSparkTaskResponse.getCode() == SUCCESS) {
            //获取用户下唯一工作流ID
            DolphinschedulerResponse processInfoList = getUserProcess(vo.getProjectName());
            JSONObject processJson = new JSONObject();
            log.info("--(2)getUserProcess--success:{}", processInfoList);
            List<Map<String, Object>> list = (List<Map<String, Object>>) processInfoList.getData();
            for (Map<String, Object> map : list) {
                if (map.get("name").equals(userId + "-dragSparkTask")) {
                    processJson.fluentPutAll(map);
                }
            }
            ProcessDto processDto = packageProcessParam(
                    "delete", userId + "-dragSparkTask", vo, processJson);
            processDto.setId(processJson.getInteger("id"));
            log.info("--(3)packageProcessParam--success");
            if (processJson.getString(DictionaryEnum.RELEASE_STATE.getFiledString()).equals(ONLINE)) {
                releaseProcessDefinition(vo.getProjectName(), userId + "-dragSparkTask",
                        processDto.getId(), 0);
                log.info("--(4)releaseProcessDefinition--OFFLINE--success");
            }
            if (JSONObject.parseObject(processDto.getLocations()).keySet().size() == 0) {
                //删除工作流
                deleteProcess(vo, processDto);
            } else {
                //更新工作流
                updateProcess(vo, processDto);
            }
        }
        return dragSparkTaskResponse;
    }

/**
     * 删除工作流
     * @param vo vo
     * @param processDto processDto
     * @author liudz
     * @date 2021/5/7
     * @return 执行结果
     **/
    public DolphinschedulerResponse deleteProcess(DragSparkTaskVo vo, ProcessDto processDto) {
            HttpHeaders headers = new HttpHeaders();
            headers.set("token", token);
            headers.set("Content-Type", "application/json");
            HttpEntity requestEntity = new HttpEntity(headers);
            ResponseEntity<DolphinschedulerResponse> response =
                    restTemplate.exchange(address + "/dolphinscheduler/projects/" + vo.getProjectName()
                                   + "/process/delete?processDefinitionId=" + processDto.getId(),
                            HttpMethod.GET, requestEntity, DolphinschedulerResponse.class);
            log.info("--(5)httpDeleteProcess:{}", response);
        return response.getBody();
    }

三、本人相关其他文章链接

1.springboot项目集成dolphinscheduler调度器 可拖拽spark任务管理：
https://blog.csdn.net/a924382407/article/details/117119831

2.springboot项目集成dolphinscheduler调度器 实现datax数据同步任务：
https://blog.csdn.net/a924382407/article/details/120951230

3.springboot项目集成dolphinscheduler调度器 项目管理：
https://blog.csdn.net/a924382407/article/details/117118931

4.springboot项目集成大数据第三方dolphinscheduler调度器 执行/停止任务
https://blog.csdn.net/a924382407/article/details/117121181

5.springboot项目集成大数据第三方dolphinscheduler调度器
https://blog.csdn.net/a924382407/article/details/117113848

刘大猫.
关注
专栏目录
springboot与scheduler结合的定时任务工具、实例项目
04-15
springboot与scheduler结合的定时任务工具、实例项目，一个比较实用的demo，适合已经学习理论需要进行代码时间的初级程序员学习实用，项目比较简单......
Springboot 整合 DolphinScheduler（一）：初识海豚调度
原名：@程序员大禹
06-25 1690
Apache DolphinScheduler 是一个分布式易扩展的可视化 DAG 工作流任务调度开源系统。适用于企业级场景，提供了一个可视化操作任务、工作流和全生命周期数据处理过程的解决方案。
DolphinScheduler应用实战笔记
最新发布
qq_40623672的博客
09-10 1032
DolphinScheduler（后文简称DS）在项目中的应用实战笔记，包含DS执行SQL或存储过程、DS调用DataX同步数据、DS调用HTTP接口
dolphinscheduler-springboot集成
qq_45502554的博客
07-04 895
dolphinscheduler
springboot项目集成大数据第三方dolphinscheduler调度器
刘大猫
05-22 5966
摘要 ①dolphinscheduler调度器可视化画面地址： http://192.168.20.43:12345/dolphinscheduler/ui/view/login/index.html 用户名：admin 密码：dolphinscheduler123 ②Dolphin Scheduler Api Docs 文档API地址： http://192.168.20.43:12345/dolphinscheduler/doc.html ③Dolphin Scheduler 官网地址可查看文档及E.
springboot项目集成dolphinscheduler调度器 项目管理
刘大猫
05-22 3347
dolphinscheduler调度器接入注意事项等信息可参考我的上一篇博客进行了解，地址在这里 -> 一、功能清单 二、项目管理 说明：项目管理统一用dolphinscheduler调度器的admin用户token执行 共用的依赖 <!--httpclient--> <dependency> <groupId>commons-httpclient</groupId> <artifactId>commons-httpclie
dolphinScheduler海豚调度器动态传递任务执行参数
02-23
### dolphinScheduler海豚调度器动态传递任务执行参数 #### 一、重要性及应用场景 **dolphinScheduler**（简称DS）是一款强大的分布式任务调度平台，支持多种类型的作业执行，如Shell、Python、Spark等。它能够...
dolphinscheduler配置
07-13
DolphinScheduler是一款强大的分布式工作流调度系统，用于大数据处理任务的编排和管理。在这个配置过程中，我们将探讨如何将Dolphinscheduler与Hadoop、Spark、Hive、DataX、Python和Scala集成，以实现高效的数据...
虚拟机单节点dolphinscheduler调度安装部署
02-02
根据提供的标题、描述、标签及部分内容，我们可以详细探讨如何在虚拟机单节点上进行DolphinScheduler调度系统的安装与部署。此过程不仅涉及基础环境的准备，还包含了多个依赖组件的安装配置，如JDK、MySQL、...
DolphinScheduler任务调度系统 v1.3.3
11-25
为您提供DolphinScheduler任务调度系统下载，Apache DolphinScheduler(incubator,原EasyScheduler）是一个大数据分布式工作流任务调度系统，主要解决大数据研发过程中ETL处理错综复杂的依赖关系，而不能直观监控任务...
springboot项目集成大数据第三方dolphinscheduler调度器 执行/停止任务
刘大猫
05-22 2958
dolphinscheduler调度器接入注意事项等信息可参考我的上一篇博客进行了解，地址在这里 -> 一、功能清单 二、执行/停止任务 说明： 大数据平台执行可拖拽spark任务实际实行的是dolphinscheduler调度器中项目下工作流下的某一节点而已，不是执行整个工作流。 共用的依赖 <!--httpclient--> <dependency> <groupId>commons-httpclient</groupId> &l.
web管理spark任务
11-15
web管理spark任务。scala代码编写.可视化。web管理spark任务。scala代码编写.可视化。
springboot项目集成dolphinscheduler调度器 实现datax数据同步任务
刘大猫
10-25 3125
Datax概述 1.概述 2.功能清单 功能清单 CRUD增删改查 、启动任务、停止任务 3.说明：本项目只支持mysql及hbase之间的数据同步 代码模块 配置文件 pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchem.
Springboot 整合 DolphinScheduler（二）：UI页面上的主要功能介绍
原名：@程序员大禹
06-25 983
UI页面上的主要功能介绍
Dolphinscheduler3.0.0使用（三）spark任务的工作流使用
nhm_lxy的专栏
04-26 1219
Dolphinscheduler3.0.0使用（三）spark任务的工作流使用 1.11. 创建spark任务工作流定义。1.13. 查看spark工作流任务日志。1.12. Spark工作流上线运行。
StreamAnalytix Visual Spark Studio （二）！Spark开发史上最强大的神器，只需拖拽控件即可完成Spark开发，造福国内的Spark开发者!
段智华的博客
02-28 2203
StreamAnalytix Visual Spark Studio （二）！Spark开发史上最强大的神器，只需拖拽控件即可完成Spark开发，造福国内的Spark开发者!StreamAnalytix Visual Spark Studio （一）简介：http://blog.csdn.net/duan_zhihua/article/details/79373167接下来进行StreamAnal...
海豚调度系列之：任务类型——SPARK节点
zhengzaifeidelushang的博客
03-13 1899
本案例为创建一个视图表 terms 并写入三行数据和一个格式为 parquet 的表 wc 并判断该表是否存在。程序类型为 SQL。将视图表 terms 的数据插入到格式为 parquet 的表 wc。本案例为大数据生态中常见的入门案例，常应用于 MapReduce、Flink、Spark 等计算框架。主要为统计输入的文本中，相同的单词的数量有多少。若生产环境中要是使用到 Spark 任务类型，则需要先配置好所需的环境。在使用 Spark 任务节点时，需要利用资源中心上传执行程序的 jar 包。
flex4 spark DataGrid 拖放drag drop实现
iteye_13889的博客
08-01 156
转自：http://www.riafan.com/article/flex/spark-datagrid-with-support-for-drag-and-drop.html 上面的网址有源码，是在上面做了dragMove修复，修复了 drop到一个 button时 datagrid的 selecteditem数据会被移除的问题 和 新增 dragsouce 的 items...
Dolphinscheduler调度spark任务踩坑记录
快乐星球
11-16 8712
1、关于spark调度的worker部署 我在测试Dolphinscheduler时采用的是集群模式，两台机器部署master，两台机器部署worker，而hadoop和spark则是在其他的机器上部署的。在配置dolphinscheduler_env.sh文件时对如何设置spark环境地址就很疑惑。测试调度时果然第一个问题就是找不到spark-submit文件 command: line 5: /bin/spark-submit: No such file or directory 通过日志查看调度过
SpringBoot集成dolphinscheduler
09-24
SpringBoot集成dolphinscheduler是将dolphinscheduler调度器与SpringBoot项目进行整合的过程。整合后，我们可以实现可拖拽的spark任务管理和项目管理等功能。具体的步骤和方法可以参考以下引用内容： 引用: 在这篇文章中，作者详细介绍了如何使用SpringBoot来集成dolphinscheduler调度器，并实现可拖拽的spark任务管理。文章提供了具体的代码示例和配置步骤，帮助读者快速搭建集成环境和实现功能。 引用: 这篇文章介绍了如何在SpringBoot项目中集成dolphinscheduler调度器，并实现项目管理功能。作者详细解释了如何配置相关依赖和属性，以及如何使用接口与dolphinscheduler进行交互，实现项目的创建、修改和删除等操作。 引用: 这篇文章重点介绍了如何将dolphinscheduler调度器整合到SpringBoot项目中，并实现大数据第三方调度功能。作者分享了自己的实践经验，包括如何配置调度器和任务、如何与大数据平台进行对接等。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

刘大猫.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值