Java实现自定义工作流

最新推荐文章于 2024-06-16 21:22:23 发布

华容@学友张

最新推荐文章于 2024-06-16 21:22:23 发布

阅读量6.4k

点赞数 6

文章标签： java spring boot 后端 activiti

本文链接：https://blog.csdn.net/weixin_44615512/article/details/108444709

版权

这篇文章实现java自定义工作流程，对工作流不太熟悉的可以先看下工作流相关文章：
工作流

定义流程的方法,创建、执行、退回

	/**
     * 创建工作流
     */
    public ResponseResult create(CreateWorkflowVo createWorkflowVo) {
        // 同一个业务ID不能重复多线程创建流程
        synchronized (createWorkflowVo.getEntityId()) {
            return handleAction("/workflow/create", createWorkflowVo);
        }
    }

    /**
     * 执行工作流，往下一节点走
     */
    public ResponseResult execute(ExecuteWorkflowVo executeWorkflowVo) {
        // 同一条流程不能重复操作
        synchronized (executeWorkflowVo.getRequestId()) {
            return handleAction("/workflow/execute", executeWorkflowVo);
        }
    }

    /**
     * 退回工作流
     */
    public ResponseResult reject(RejectWorkflowVo rejectWorkflowVo) {
        // 同一条流程不能重复操作
        synchronized (rejectWorkflowVo.getRequestId()) {
            return handleAction("/workflow/reject", rejectWorkflowVo);
        }
    }

    private ResponseResult handleAction(String action, Object vo) {
        Asserts.notEmpty(uri, "请求地址");
        try {
            String res = restTemplate
                    .postForObject(uri + action, vo, String.class);
            if (!StringUtils.isEmpty(res)) {
                ResponseResult responseResult = JSONObject.parseObject(res, ResponseResult.class);
                return responseResult;
            }
        } catch (Exception ex) {
            log.error("调用工作流服务失败：action=" + action, ex);
        }
        throw new GlobalException("12000", "调用工作流服务失败,action=" + action + "：无法获取请求数据");
    }

执行对应流程创建、执行、退回的方法，会调用执行定义好的一个工作流工程的回调函数，把函数的指针（地址）作为参数传递给另一个函数，返回结果。uri=工程的ip+端口
如下：

 /**
     * 创建工作流
     *
     * @param createWorkflowVo
     * @return
     */
    @PostMapping("create")
    public ResponseResult<String> create(@RequestBody CreateWorkflowVo createWorkflowVo) {
        return processService.createFlow(createWorkflowVo);
    }

    /**
     * 流程往下走
     *
     * @param executeWorkflowVo
     * @return
     */
    @PostMapping("execute")
    public ResponseResult<String> execute(@RequestBody ExecuteWorkflowVo executeWorkflowVo) {
        return processService.executeFlow(executeWorkflowVo);
    }

    /**
     * 退回
     *
     * @param rejectWorkflowVo
     * @return
     */
    @RequestMapping("reject")
    public ResponseResult<String> reject(@RequestBody RejectWorkflowVo rejectWorkflowVo) {
        return processService.rejectFlow(rejectWorkflowVo);
    }

service代码实现:

	//创建工作流
	@Override
    @Transactional(propagation = Propagation.REQUIRED)
    public ResponseResult<String> createFlow(CreateWorkflowVo createWorkflowVo) {
        log.info("请求参数: {}", createWorkflowVo);
        assertNotNull(createWorkflowVo);

        WorkflowBase base = workflowBaseMapper
                .selectByPrimaryKey(createWorkflowVo.getWorkflowBaseId());
        if (base == null) {
            throw new GlobalException("120004", "找不到Workflow base配置表信息");
        }

        // 回调地址不能为空
        Asserts.notNull(base.getActionUrl(), "actionUrl");

        WorkflowRequestBase srchBase = new WorkflowRequestBase();
        srchBase.setEntityId(createWorkflowVo.getEntityId());
        srchBase.setStatus(0);
        Integer count = workflowRequestBaseMapper.selectCount(srchBase);
        if (count != null && count > 0) {
            throw new GlobalException("120011", "同一条业务不能重复创建流程");
        }

        WorkflowRequestBase requestBase = setRequestBase(createWorkflowVo);

        // 插入流程审批表
        workflowRequestBaseMapper.insertReturnKeys(requestBase);
        log.info("id = {}", requestBase.getRequestId());
        if (requestBase.getRequestId() != null && requestBase.getRequestId().length() > 0) {

            List<String> requestNodes = createWorkflowVo.getRequestNodes();

            // 插入流程节点表
            int sort = 0;
            requestNodes.add("0");// 归档节点
            List<WorkflowRequestNode> nodesList = new ArrayList<WorkflowRequestNode>();
            for (String userid : requestNodes) {
                WorkflowRequestNode node = new WorkflowRequestNode();
                node.setRequestId(requestBase.getRequestId());
                node.setOperatorId(userid);
                node.setNodeType("0".equalsIgnoreCase(userid) ? 1 : 0);
                node.setStatus(0);
                node.setSort(sort++);
                nodesList.add(node);
            }

            workflowRequestNodeMapper.batchInsert(nodesList);

        } else {
            throw new GlobalException("120005", "无法获取Request ID");
        }

        return ResponseResult.success(String.valueOf(requestBase.getRequestId()));
    }



    //执行流程
    /**
     * 流程往下走
     *
     * @param executeWorkflowVo
     * @return
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public ResponseResult executeFlow(ExecuteWorkflowVo executeWorkflowVo) {
        WorkflowRequestBase requestBase = getRequestBase(executeWorkflowVo.getRequestId());
        // 如果工作流的状态不对，不能继续操作
        if (requestBase.getStatus() != 0) {
            throw new GlobalException("120010", "该工作流可能已归档，无法继续操作");
        }
        // 只有当前操作人才能操作，防重复提交
        if (!requestBase.getCurrentOperatorId()
                .equalsIgnoreCase(String.valueOf(executeWorkflowVo.getCurrentOperatorId()))) {
            throw new GlobalException("120007", "当前操作人不合法");
        }
        WorkflowRequestNode nextNode = null;
        // 如果需要插入节点
        if (executeWorkflowVo.isInsertNode()) {
            if (CollectionUtils.isEmpty(executeWorkflowVo.getNodes())) {
                throw new GlobalException("120011", "插入的节点操作人不能为空");
            }
            // 获取当前操作人节点及以后的节点
           List<WorkflowRequestNode> afterNodes = workflowRequestNodeMapper.
           selectNextOperator(executeWorkflowVo.getRequestId(),
           executeWorkflowVo.getCurrentOperatorId());

            Integer initSort = afterNodes.get(0).getSort();
            List<String> nodes = executeWorkflowVo.getNodes();

            List<WorkflowRequestNode> insertNodes = Lists.newArrayList();
            for (int i = 0; i < nodes.size(); i ++) {
                initSort ++;
                WorkflowRequestNode eachNode = new WorkflowRequestNode();
                eachNode.setRequestId(executeWorkflowVo.getRequestId());
                eachNode.setNodeType(0);// 不是归档节点
                eachNode.setOperatorId(executeWorkflowVo.getNodes().get(0));
                eachNode.setStatus(0);
                eachNode.setSort(initSort);
                eachNode.setCreateTime(DateUtil.getCurrentDateTime());
                eachNode.setModifyTime(DateUtil.getCurrentDateTime());
                if (i == 0) {
                    nextNode = eachNode;
                }
                insertNodes.add(eachNode);
            }
            // 将当前操作人节点后面的节点sort都往后推移
            for (WorkflowRequestNode node : afterNodes) {
                initSort ++;
                node.setSort(initSort);
                // 更新
                workflowRequestNodeMapper.updateByPrimaryKeySelective(node);
            }
            // 插入节点
            workflowRequestNodeMapper.batchInsert(insertNodes);
        } else {

            // 查询下一节点操作人
            List<WorkflowRequestNode> nextNodes = workflowRequestNodeMapper
                    .selectNextOperator(executeWorkflowVo.getRequestId(),
                            executeWorkflowVo.getCurrentOperatorId());
            if (CollectionUtils.isEmpty(nextNodes)) {
                throw new GlobalException("120008", "流程下一节点为空！");
            }
            nextNode = nextNodes.get(0);
        }
        Integer nextNodeType = nextNode.getNodeType();
        String nextOperatorId = nextNode.getOperatorId();

        // 修改当前操作人的状态为审核通过
        WorkflowRequestNode requestNode = new WorkflowRequestNode();
        requestNode.setStatus(1);
        requestNode.setModifyTime(DateUtil.getCurrentDateTime());
        updateRequestNode(requestNode, executeWorkflowVo.getRequestId(),
                executeWorkflowVo.getCurrentOperatorId());

        // 修改流程审批表的当前操作人为查询出来的下一节点操作人
        WorkflowRequestBase updateBase = new WorkflowRequestBase();
        updateBase.setCurrentOperatorId(nextOperatorId);
        updateBase.setLastOperatorId(executeWorkflowVo.getCurrentOperatorId());
        updateBase.setLastOperateTime(DateUtil.currentDate());
        updateRequestBase(updateBase, executeWorkflowVo.getRequestId(),
                executeWorkflowVo.getCurrentOperatorId());

        // 记录一条操作日志
        recordRequestLog(executeWorkflowVo.getRequestId(), executeWorkflowVo.getCurrentOperatorId(),
                nextOperatorId, 1, "已审批");

        // 如果下一节点是归档节点，则直接归档
        if (nextNodeType == 1) {
            boolean flag = finish(requestBase.getWorkflowId(), requestBase.getEntityId(),
                    executeWorkflowVo.getRequestId());
            log.info("归档结果,{}", flag);
        }
        return ResponseResult.success();
    }

/**
     * 流程退回
     *
     * @param rejectWorkflowVo
     * @return
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public ResponseResult rejectFlow(RejectWorkflowVo rejectWorkflowVo) {
        WorkflowRequestBase requestBase = getRequestBase(rejectWorkflowVo.getRequestId());

        // 如果工作流的状态不对，不能继续操作
        if (requestBase.getStatus() != 0) {
            throw new GlobalException("120010", "该工作流可能已归档，无法继续操作");
        }
        // 只有当前操作人才能操作，防重复提交
        if (!requestBase.getCurrentOperatorId()
                .equalsIgnoreCase(String.valueOf(rejectWorkflowVo.getCurrentOperatorId()))) {
            throw new GlobalException("120007", "当前操作人不合法");
        }
        // 修改当前操作人的状态为审核通过
        WorkflowRequestNode requestNode = new WorkflowRequestNode();
        requestNode.setStatus(-1);
        requestNode.setModifyTime(DateUtil.getCurrentDateTime());
        updateRequestNode(requestNode, rejectWorkflowVo.getRequestId(),
                rejectWorkflowVo.getCurrentOperatorId());

        // 修改流程审批表的当前操作人为查询出来的下一节点操作人
        WorkflowRequestBase updateBase = new WorkflowRequestBase();
        updateBase.setStatus(-1);
        updateBase.setLastOperatorId(rejectWorkflowVo.getCurrentOperatorId());
        updateBase.setLastOperateTime(DateUtil.currentDate());
        updateRequestBase(updateBase, rejectWorkflowVo.getRequestId(),
                rejectWorkflowVo.getCurrentOperatorId());
        // 记录一条操作日志
        recordRequestLog(rejectWorkflowVo.getRequestId(), rejectWorkflowVo.getCurrentOperatorId(),
                null, 1, "已退回：" + rejectWorkflowVo.getRejectNote());
        boolean flag =
                callbackAction(requestBase.getWorkflowId(), requestBase.getEntityId(), -1, rejectWorkflowVo.getRejectNote());
        log.info("退回结果，{}", flag);
        return ResponseResult.success();
    }