Flowable入门讲解

最新推荐文章于 2024-05-20 14:45:01 发布
置顶 最新推荐文章于 2024-05-20 14:45:01 发布
阅读量3.2k 收藏 16
点赞数
分类专栏： Flowable相关 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44150993/article/details/121099006
版权

Flowable入门讲解

一、springboot项目整合Flowable6.4.2

1、导入相关做标：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.monkey_wang</groupId>
    <artifactId>monkey_wang</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <flowable.version>6.4.2</flowable.version>
    </properties>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.8.RELEASE</version>
    </parent>


    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <!--<scope>runtime</scope>-->
        </dependency>
        <!--web开发的起步依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- 工作流 -->
        <dependency>
            <groupId>org.flowable</groupId>
            <artifactId>flowable-spring-boot-starter</artifactId>
            <version>${flowable.version}</version>
        </dependency>
        <dependency>
            <groupId>org.flowable</groupId>
            <artifactId>flowable-json-converter</artifactId>
            <version>${flowable.version}</version>
        </dependency>
    </dependencies>

</project>

2、配置文件中加入一下属性：

server.port=89
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://192.168.113.35:3306/flow
spring.datasource.username=root
spring.datasource.password=root
#关闭定时任务JOB
flowable.async-executor-activate=false
#将databaseSchemaUpdate设置为true。当Flowable发现库与数据库表结构不一致时，会自动将数据库表结构升级至新版本。
flowable.database-schema-update=true

二、部署定义好的流程

（1）、如果你的流程设计器和你当前的项目连的是同一个数据库的话：
controller层：

    /**
     * 部署流程
     */
    @GetMapping(value = "/deployByKey")
    @ApiOperationSupport(order = 4)
    @ApiOperation(value = "部署流程", notes = "部署流程")
    public R<String> deployByKey(@ApiParam(value = "流程定义的key", required = true) @RequestParam String processDefinitionKey) {
        try {
            processService.deployByKey(processDefinitionKey);
            return R.data("部署成功。");
        } catch (Exception e) {
            e.printStackTrace();
            return R.fail("服务器异常！");
        }
    }

service层：

    //需要注入的Flowable相关service：
    private final ModelRepository modelRepository;
    private final RepositoryService repositoryService;


    @Override
   public void deployByKey(String processDefinitionKey) {
       List<Model> models = modelRepository.findByKeyAndType(processDefinitionKey, 0);
       if (models.size() > 0) {
           for (Model model : models) {
               String id = model.getId();
               this.deployModel(id, "flow_2", null);
           }
       }
   }

   public boolean deployModel(String modelId, String category, List<String> tenantIdList) {
       FlowModel model = this.getById(modelId);
       if (model == null) {
           throw new ServiceException("No model found with the given id: " + modelId);
       }
       byte[] bytes = getBpmnXml(model);
       String processName = model.getName();
       if (!StringUtil.endsWithIgnoreCase(processName, FlowEngineConstant.SUFFIX)) {
           processName += FlowEngineConstant.SUFFIX;
       }
       String finalProcessName = processName;
       if (Func.isNotEmpty(tenantIdList)) {
           tenantIdList.forEach(tenantId -> {
               Deployment deployment = repositoryService.createDeployment().addBytes(finalProcessName, bytes).name(model.getName()).key(model.getModelKey()).tenantId(tenantId).deploy();
               deploy(deployment, category);
           });
       } else {
           Deployment deployment = repositoryService.createDeployment().addBytes(finalProcessName, bytes).name(model.getName()).key(model.getModelKey()).deploy();
           deploy(deployment, category);
       }
       return true;
   }

（2）、如果你的流程设计器和项目连的不是一个库：
首先你需要把你的流程图下载下来保存到本地，然后利用代码找到这个bpmn文件进行部署。

service层代码：

     /**
     * 部署流程
     * filePath 文件路径 name 流程名字
     */
    public Map<String, Object> deploymentFlow(String filePath, String name) {
        try {
            DeploymentBuilder deploymentBuilder = repositoryService.createDeployment()
                    .addClasspathResource(filePath).name(name);
            Deployment deployment = deploymentBuilder.deploy();
            logger.info("成功：部署工作流程：" + filePath);
            //acr_re_deployment表的id
            String id = deployment.getId();
            ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery();
            //搜索条件deploymentId
            query.deploymentId(id);
            //最新版本过滤
            query.latestVersion();
            //查询
            ProcessDefinition definition = query.singleResult();
            //act_re_procdef表的key和id
            String key = definition.getKey();
            String definitionId = definition.getId();
            Map<String, Object> map = new HashMap<>();
            map.put("流程定义的key", key);
            map.put("流程定义的的id", definitionId);
            return map;
        } catch (Exception e) {
            logger.error("失败：部署工作流：" + e);
            return null;
        }
    }

部署完成后，数据会保存在act_re_procdef和act_re_deployment表中

三、启动流程

注意： 后边讲解中会频繁调用RuntimeService、TaskService、HistoryService；这仨都是Flowable包下的服务类

  • RuntimeService ：用于查询运行中的流程实例相关信息。
  • TaskService：用于查询代办、代签、签收、办理等操作。
  • HistoryService：顾名思义，查询流程相关历史数据。
    @PostMapping("/start")
    @ApiOperationSupport(order = 1)
    @ApiOperation(value = "启动流程", notes = "启动流程")
    @Transactional(rollbackFor = Exception.class)
    public R start(@ApiParam(value = "key", required = true) @RequestParam String key) {
        try {
            //构建流程启动需要的参数信息
            Map<String, Object> param = new HashMap<>();
            //param内封装的参数根据流程定义时的来
            //举个简单的栗子：比如流程线上定义了不同请假天数走不同的人审批；
            //请假天数参数名为day


            Integer day = 1;
            param.put("day", day);

            // 设置流程启动用户
            identityService.setAuthenticatedUserId(AuthUtil.getUserId().toString());
            ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(key, param);
            String processInstanceId = processInstance.getProcessInstanceId();
            return R.data(processInstanceId);
        } catch (Exception e) {
            e.printStackTrace();
            return R.fail("启动失败！");
        }
    }

启动完成之后，运行中的流程数据会保存到act_ru_actinst、act_ru_execution、act_ru_identitylink、act_ru_task

  • act_ru_actinst：存储运行中各个节点的信息：

  • act_ru_identitylink: 存储候选用户、处理人相关数据

  • act_ru_task ：存储审批代办相关信息

四、查询审批代办

    @GetMapping("/getTask")
    @ApiOperationSupport(order = 2)
    @ApiOperation(value = "获取代办", notes = "获取代办")
    @Transactional(rollbackFor = Exception.class)
    public R getTask(@ApiParam(value = "processInstanceId", required = true) @RequestParam String processInstanceId) {
        //获取当前登录用户ID
        Long userId = AuthUtil.getUserId();
        //根据流程实例id和当前登录用户的id查询审批代办
        //注意： taskCandidateOrAssigned 表示不管是任务的候选人还是直接分配的人都可以查到
        //生产环境中可以不用结合流程实例查询;具体怎么查要结合具体业务来定。
        List<Task> tasks = taskService.createTaskQuery().processInstanceId(processInstanceId).taskCandidateOrAssigned(userId.toString()).list();
        if (!tasks.isEmpty()) {
            List<Map<String, Object>> list = new ArrayList<>();
            for (Task task : tasks) {
                Map<String, Object> map = new HashMap<>();
                //代办id
                String taskId = task.getId();
                //代办节点名称
                String taskName = task.getName();
                //创建时间
                Date createTime = task.getCreateTime();
                map.put("taskId", taskId);
                map.put("taskName", taskName);
                map.put("createTime", createTime);
                list.add(map);
            }
            return R.data(list);
        }
        return R.data("当前用户在当前流程实例中并无待办！");
    }

五、审批并跳转流程：

    @GetMapping("/audit")
    @ApiOperationSupport(order = 2)
    @ApiOperation(value = "审批并跳转流程", notes = "审批并跳转流程")
    @Transactional(rollbackFor = Exception.class)
    public R audit(@ApiParam(value = "taskId", required = true) @RequestParam String taskId) {
        try {
            //构建参数
            Map<String, Object> param = new HashMap<>();
            /*
            这个参数和启动流程时讲的参数是一个用法，这里不做过多的描述
            参数详情可以在表act_hi_varinst看到
            需要注意的是，它们都是全局的参数;可以通过
            historyService.createHistoricVariableInstanceQuery().processInstanceId(processInstanceId).list()或
            processInstance.getProcessVariables()获取
            */
            //跳转流程
            taskService.complete(taskId, param);
            return R.data("已审批");
        } catch (Exception e) {
            e.printStackTrace();
            return R.fail("跳转失败！");
        }
    }

ps : 流程跳转成功只后或流程结束后；对应的act_ru_task、act_ru_actinst等act_ru_打头的表数据会被删除。想要获取流程相关历史数据可以到act_hi_打头的表中查询，其结构和act_ru__打头的表结构大差不差甚至可以说相同；这样做主要是为了查询审批代办等运行中的流程数据时尽可能快。

六、转办

1、如果是候选人（candidaUser）发起的转办：

	@Override
	@Transactional(rollbackFor = Exception.class)
	public void turnTaskToOthers(String taskId, String userId) {
		Task task = taskService.createTaskQuery(taskId).taskId().singleResult();
		if (task == null) {
			return;
		}
		BladeUser user = AuthUtil.getUser();
		String userNickName = user.getNickName();
		User user1 = userMapper.selectById(Long.parseLong(userId));
		String realName = user1.getRealName();
		String comment = userNickName + "把该审批转办给了" + realName;
		//生成历史记录
		TaskEntity task1 = (TaskEntity) taskService.newTask(UUID.randomUUID().toString());
		task1.setParentTaskId(task.getParentTaskId());
		task1.setName(task.getName());
		task1.setAssignee(user.getUserId().toString());
		task1.setProcessInstanceId(task.getProcessInstanceId());
		task1.setProcessDefinitionId(task.getProcessDefinitionId());
		task1.setCategory(task.getCategory());
		task1.setTaskDefinitionKey(task.getTaskDefinitionKey());
		task1.setTaskDefinitionId(task.getTaskDefinitionId());
		taskService.saveTask(task1);
		taskService.addComment(task1.getId(), processInstanceId, comment);
		taskService.complete(task1.getId());
		//转办
		String taskId = task.getId();
		Boolean isAdmin = this.booleanAdmin();
		if (!isAdmin) {
			taskService.deleteCandidateUser(taskId, AuthUtil.getUserId().toString());
		}
		taskService.addCandidateUser(taskId, userId);
	}

2、如果是签收人（assign）发起的代办：

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void turnTaskToOthers(String taskId, String userId) {
        //获取源task
        Task task = taskService.createTaskQuery(taskId).taskId().singleResult();
        if (task == null) {
            return;
        }
        //获取流程名称
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(tas.getProcessInstanceId).singleResult();
        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionKey(processInstance.getProcessDefinitionKey()).latestVersion().singleResult();
        //获取任务接受用户账号用于发送通知
        User user = userService.getById(Long.parseLong(userId));
        String userAccount = user.getAccount();
        //获取任务源用户姓名
        BladeUser firstUser = AuthUtil.getUser();
        String userNickName = firstUser.getNickName();
        //获取任务名称
        String comment = userNickName + "把该审批转办给了" + user.getRealName();
        //生成历史记录
        TaskEntity task1 = (TaskEntity) taskService.newTask(UUID.randomUUID().toString());
        task1.setParentTaskId(task.getParentTaskId());
        task1.setName(task.getName());
        task1.setAssignee(task.getAssignee());
        task1.setProcessInstanceId(task.getProcessInstanceId());
        task1.setProcessDefinitionId(task.getProcessDefinitionId());
        task1.setCategory(task.getCategory());
        task1.setTaskDefinitionKey(task.getTaskDefinitionKey());
        task1.setTaskDefinitionId(task.getTaskDefinitionId());
        taskService.saveTask(task1);
        taskService.addComment(task1.getId(), processInstanceId, comment);
        taskService.complete(task1.getId());
        //转办
        taskService.unclaim(taskId);
        taskService.claim(taskId, userId);
    }

七、强制终止流程（作废）

    @Override
    public void stopProcessInstanceById(String processInstanceId) {
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
        if (processInstance != null) {
            //1、获取终止节点
            List<EndEvent> endNodes = findEndFlowElement(processInstance.getProcessDefinitionId());
            String endId = endNodes.get(0).getId();
            List<Execution> executions = runtimeService.createExecutionQuery().parentId(processInstanceId).list();
            List<String> executionIds = new ArrayList<>();
            executions.forEach(execution -> executionIds.add(execution.getId()));
            runtimeService.createChangeActivityStateBuilder().moveExecutionsToSingleActivityId(executionIds, endId).changeState();
        }
    }

八、删除流程数据

    @Override
    public boolean deleteProcessInstance(String processInstanceId, String deleteReason) {
        //判断流程是否结束
        boolean finished = isFinished(processInstanceId);
        //删除运行中的流程实例
        if (!finished) {
            runtimeService.deleteProcessInstance(processInstanceId, deleteReason);
        }
        //删除历史实例
        historyService.deleteHistoricProcessInstance(processInstanceId);
        return true;
    }

    private boolean isFinished(String processInstanceId) {
        return historyService.createHistoricProcessInstanceQuery().finished()
                .processInstanceId(processInstanceId).count() > 0;
    }

九、流程跳转信息和节点进程图

流程跳转信息：

	@Override
	public List<BladeFlow> historyFlowList(String processInstanceId, String startActivityId, String endActivityId) {
		List<BladeFlow> flowList = new LinkedList<>();
		List<HistoricActivityInstance> historicActivityInstanceList = historyService.createHistoricActivityInstanceQuery().processInstanceId(processInstanceId).orderByHistoricActivityInstanceStartTime().asc().orderByHistoricActivityInstanceEndTime().asc().list();
		boolean start = false;
		Map<String, Integer> activityMap = new HashMap<>(16);
		for (int i = 0; i < historicActivityInstanceList.size(); i++) {
			HistoricActivityInstance historicActivityInstance = historicActivityInstanceList.get(i);
			if (historicActivityInstance.getActivityName() == null) {
				continue;
			}
			// 过滤开始节点前的节点
			if (StringUtil.isNotBlank(startActivityId) && startActivityId.equals(historicActivityInstance.getActivityId())) {
				start = true;
			}
			if (StringUtil.isNotBlank(startActivityId) && !start) {
				continue;
			}
			// 显示开始节点和结束节点，并且执行人不为空的任务
			if ("userTask".equals(historicActivityInstance.getActivityType())
				|| FlowEngineConstant.START_EVENT.equals(historicActivityInstance.getActivityType())
				|| FlowEngineConstant.END_EVENT.equals(historicActivityInstance.getActivityType())) {
				// 给节点增加序号
				Integer activityNum = activityMap.get(historicActivityInstance.getActivityId());
				if (activityNum == null) {
					activityMap.put(historicActivityInstance.getActivityId(), activityMap.size());
				}
				BladeFlow flow = new BladeFlow();
				flow.setHistoryActivityId(historicActivityInstance.getActivityId());
				flow.setHistoryActivityName(historicActivityInstance.getActivityName());
				flow.setCreateTime(historicActivityInstance.getStartTime());
				Date endTime = historicActivityInstance.getEndTime();
				if (endTime != null) {
					flow.setFlag("ok");
					flow.setPass(true);
				}
				flow.setEndTime(endTime);
				String durationTime = DateUtil.secondToTime(Func.toLong(historicActivityInstance.getDurationInMillis(), 0L) / 1000);
				flow.setHistoryActivityDurationTime(durationTime);
				// 获取流程发起人名称
				this.getStartUser(historicActivityInstance, flow, processInstanceId);
				// 获取任务执行人名称
				if (StringUtil.isNotBlank(historicActivityInstance.getAssignee())) {
					this.getTaskAssign(historicActivityInstance, flow);
				} else {
					this.setCandidateUsers(historicActivityInstance, flow);
				}
				if (!StringUtil.isEmpty(flow.getTaskId()) && StringUtil.isEmpty(flow.getAssigneeName())) {
					continue;
				}
				// 获取意见评论内容
				if (StringUtil.isNotBlank(historicActivityInstance.getTaskId())) {
					List<Comment> commentList = taskService.getTaskComments(historicActivityInstance.getTaskId());
					if (commentList.size() > 0) {
						flow.setComment(commentList.get(0).getFullMessage());
					}
				}
				flowList.add(flow);
			}
			// 过滤结束节点后的节点
			if (StringUtils.isNotBlank(endActivityId) && endActivityId.equals(historicActivityInstance.getActivityId())) {
				boolean temp = false;
				Integer activityNum = activityMap.get(historicActivityInstance.getActivityId());
				// 该活动节点，后续节点是否在结束节点之前，在后续节点中是否存在
				for (int j = i + 1; j < historicActivityInstanceList.size(); j++) {
					HistoricActivityInstance hi = historicActivityInstanceList.get(j);
					Integer activityNumA = activityMap.get(hi.getActivityId());
					boolean numberTemp = activityNumA != null && activityNumA < activityNum;
					boolean equalsTemp = StringUtils.equals(hi.getActivityId(), historicActivityInstance.getActivityId());
					if (numberTemp || equalsTemp) {
						temp = true;
					}
				}
				if (!temp) {
					break;
				}
			}
		}
		return flowList;
	}

	private void getStartUser(HistoricActivityInstance historicActivityInstance, BladeFlow flow, String processInstanceId) {
		if (FlowEngineConstant.START_EVENT.equals(historicActivityInstance.getActivityType())) {
			List<HistoricProcessInstance> processInstanceList = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).orderByProcessInstanceStartTime().asc().list();
			if (processInstanceList.size() > 0) {
				if (StringUtil.isNotBlank(processInstanceList.get(0).getStartUserId())) {
					String taskUser = processInstanceList.get(0).getStartUserId();
					User user = UserCache.getUser(TaskUtil.getUserId(taskUser));
					if (user != null) {
						flow.setAssignee(historicActivityInstance.getAssignee());
						flow.setAssigneeName(user.getName());
					}
				}
			}
		}

	}

	private void setCandidateUsers(HistoricActivityInstance historicActivityInstance, BladeFlow flow) {
		String taskId = historicActivityInstance.getTaskId();
		if (StringUtils.isNotEmpty(taskId)) {
			flow.setTaskId(taskId);
			List<Task> list = taskService.createTaskQuery().taskId(taskId).list();
			if (list.isEmpty()) {
				return;
			}
			List<IdentityLink> identityLinksForTask = taskService.getIdentityLinksForTask(taskId);
			if (!identityLinksForTask.isEmpty()) {
				List<String> names = new ArrayList<>();
				for (IdentityLink identityLink : identityLinksForTask) {
					String type = identityLink.getType();
					String userId = identityLink.getUserId();
					if (StringUtils.isNotEmpty(type) && "candidate".equals(type) && StringUtils.isNotEmpty(userId)) {
						User user = userMapper.selectById(Long.parseLong(userId));
						if (user != null) {
							String realName = user.getRealName();
							if (StringUtils.isNotEmpty(realName)) {
								names.add(realName);
							}
						}
					}
				}
				if (!names.isEmpty()) {
					String substring = names.toString().substring(1, names.toString().length() - 1);
					flow.setAssigneeName(substring);
				}
			}
		}
	}

节点进程图：

    /**
     * 根据流程节点绘图
     *
     * @param processInstanceId   流程实例id
     * @param httpServletResponse http响应
     */
    private void diagram(String processInstanceId, HttpServletResponse httpServletResponse) {
        // 获得当前活动的节点
        String processDefinitionId;
        // 如果流程已经结束，则得到结束节点
        if (this.isFinished(processInstanceId)) {
            HistoricProcessInstance pi = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
            processDefinitionId = pi.getProcessDefinitionId();
        } else {
            // 如果流程没有结束，则取当前活动节点
            // 根据流程实例ID获得当前处于活动状态的ActivityId合集
            ProcessInstance pi = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
            processDefinitionId = pi.getProcessDefinitionId();
        }
        List<String> highLightedActivities = new ArrayList<>();
        List<String> flows = new ArrayList<>();
        // 获得活动的节点
        List<HistoricActivityInstance> highLightedActivityList = historyService.createHistoricActivityInstanceQuery().processInstanceId(processInstanceId).orderByHistoricActivityInstanceStartTime().desc().list();
        if (!highLightedActivityList.isEmpty()) {
            for (HistoricActivityInstance activityInstance : highLightedActivityList) {
                highLightedActivities.add(activityInstance.getActivityId());
                if ("sequenceFlow".equals(activityInstance.getActivityType())) {
                    flows.add(activityInstance.getActivityId());
                }

            }
        }

        // 获取流程图
        BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefinitionId);
        ProcessEngineConfiguration engConf = processEngine.getProcessEngineConfiguration();
        ProcessDiagramGenerator diagramGenerator = engConf.getProcessDiagramGenerator();
        InputStream in = diagramGenerator.generateDiagram(bpmnModel, "bmp", highLightedActivities, flows, engConf.getActivityFontName(),
                engConf.getLabelFontName(), engConf.getAnnotationFontName(), engConf.getClassLoader(), 1.0, true);
        OutputStream out = null;
        byte[] buf = new byte[1024];
        int length;
        try {
            out = httpServletResponse.getOutputStream();
            while ((length = in.read(buf)) != -1) {
                out.write(buf, 0, length);
            }
        } catch (IOException e) {
            log.error("操作异常", e);
        } finally {
            IoUtil.closeSilently(out);
            IoUtil.closeSilently(in);
        }
    }

    /**
     * 是否已完结
     *
     * @param processInstanceId 流程实例id
     * @return bool
     */
    private boolean isFinished(String processInstanceId) {
        return historyService.createHistoricProcessInstanceQuery().finished()
                .processInstanceId(processInstanceId).count() > 0;
    }

效果图：

在这里插入图片描述

十、流程节点回退

类似于回滚，只能回退到用户任务节点；

举个简单的栗子：

流程：开始→A审批→B审批→C审批→结束

如果现在到B审批了，则只能回退到A审批；如果现在到了C审批，则可以回退到A审批或B审批

注：回退成功后，会生成新的代办（类似于事务回滚）。

@Override
	public void rollBackProcess(String proInstanceId, List<String> currTaskKeys, String targetKey) {
		runtimeService.createChangeActivityStateBuilder()
			.processInstanceId(proInstanceId)
			.moveActivityIdsToSingleActivityId(currTaskKeys, targetKey)
			.changeState();
	}
CoderWang@China
关注
  • 0
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Flowable深入浅出-12 Flowable-BPMN操作流程之用户任务UserTask
01-13
Flowable深入浅出-12 Flowable-BPMN操作流程之用户任务UserTask，请参考专栏https://blog.csdn.net/houyj1986/column/info/31755第12篇
flowable 6.7.2 源码压缩包
10-20
流程引擎flowable 6.7.2的源码，内含中文文档，源码地址：https://github.com/flowable/flowable-engine/releases/tag/flowable-6.7.2 由于在github上下载太慢了，放在这里做备份
Activiti6 Task查询API 映射 SQL
u014295903的博客
11-09 2421
Activiti6 Task查询API 映射 SQL一、前言二、查询接口2.1 taskAssignee2.2 taskCandidateGroup2.3 taskCandidateGroupIn2.4 taskCandidateOrAssigned2.5 taskCandidateUser2.6 taskOwner三、说明 一、前言 Activiti 自身提供了一套用户管理，但是在开发中业务系统本身就有一套用户管理系统，这时候就要把业务系统中的部分用户数据同步到 Activiti 用户表管理中。那么，如果
三.Flowable流程关系及数据表详细说明
最新发布
东天里的冬天
05-20 1069
通过本篇文章你能够学习到如下知识点： 1.流程的概念以及流程之间的关系； 2.Flowable数据表的命名规则； 3.数据表的分类以及相关表的功能； 4.数据表详细字段的含义以及表关联关系；
flowable-task使用
热门推荐
分享牛
02-04 1万+
上文讲解了如何启动和flowable-task模块。本文重点讲解一下flowable-task模块提供的操作。flowable-task模块用于动态的生成任务、完成任务、转办任务、指派任务、对任务进行评论、指定任务的到期时间等。接下来一睹为快吧。创建任务flowable-task模块创建任务的操作如下图所示：点击create-task按钮，弹出如下的界面：上图中Name为任务的名称，本文的名字为h
flowable笔记 - 简单的通用流程
anlei2999的博客
11-01 1484
简介 通用流程可以用于一些基本的申请，例如请假、加班。 大致过程是: 1. 创建申请 2. 分配给审批人（需要审批人列表，当前审批人） -> 有下一个审批人 -> 3 -> 无 -> 4 3. 审批人审批 -> 同意 -> 2 -> 拒绝 -> 5 4. 存储数据，发送通知 5...
Flowable源码注释（十五）事件日志类
jinyangjie的博客
02-03 506
Flowable源码地址：https://github.com/flowable/flowable-engine 包路径： org.flowable.engine.impl.event.logger EventLogger 事件日志类 package org.flowable.engine.impl.event.logger; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.u
Flowable面试题
yangzhihua的专栏
05-04 3027
本试题从浅入深地考察不同候选人掌握flowable的情况，题型覆盖日常使用、二次开发、源码优化得不同主题。
Flowable从入门到精通源码
05-20
从基础讲起，结合应用场景，由浅到深细化讲解BPMN和Flowable的相关组件，并结合具体实例，演示功能的使用和注意事项。最终结合Springboot搭建一套工作流系统，囊括一般项目中所需要的知识点，理论结合实际，让真正...
Flowable BPMN 用户手册
02-08
Flowable BPMN是一款开源的工作流引擎，用于实现业务流程管理（Business Process Management）和业务规则管理。本用户手册是Flowable BPMN的官方中文版，旨在帮助开发者和业务分析师更好地理解和利用这一强大的工具...
flowable6.0官方在线设计
05-31
Flowable是一款强大的、开源的工作流和业务自动化引擎，它提供了高度灵活的流程定义和执行能力。在Flowable 6.0版本中，引入了在线设计功能，极大地提升了用户友好性和工作效率，使得流程设计变得更加直观和易用。在...
Flowable入门系列文章128 - 任务 02
分享牛
01-27 388
flowable入门、flowable现状、flowable开源产品、flwoable入门系列、flowable课程、flowable与activiti区别Flowable是用Java编写的轻量级业务流程引擎。 Flowable流程引擎允许您部署BPMN 2.0流程定义（用于定义流程的行业XML标准），创建流程定义的流程实例，运行查询，访问活动或历史流程实例以及相关数据等等。本节将逐步介绍各种概念和API，通过您可以在自己的开发机器上进行的实例进行实现。
工作流框架Flowable
靖节先生的博客
04-03 6377
工作流框架Flowable1. Flowable概述1.1 Flowable简介1.2 Flowable与Activiti的区别2. Flowable说明 1. Flowable概述 1.1 Flowable简介 Flowable是一个使用Java编写的轻量级业务流程引擎。Flowable流程引擎可用于部署BPMN 2.0流程定义（用于定义流程的行业XML标准）， 创建这些流程定义的流程实例，进行查询，访问运行中或历史的流程实例与相关数据，等等。 TKJohn.github.io：https://tkjoh
Flowable 之基础教程
qq15035899256的博客
09-06 3595
本文是对Flowable的学习，认识了工作流的用途，学习了flowable部署流程的操作，以及FlowableUI流程设计器的使用。之后的学习内容将持续更新！！！
springboot+flowable第二节（流程基本操作）
悢七的CSDN博客
03-18 4041
mysql数据库 目录1.部署流程2.引入流程引擎3.启动流程4.查询待办列表5.审批通过6.查询已办列表7.查询发起列表 1.部署流程 举例：部署一个如下图的流程 在src/main/resources下创建processes文件夹，然后新建bpmn20.xml文件 添加如下内容： <?xml version="1.0" encoding="UTF-8"?> <definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL
activiti taskService.claim(String var1, String var2)方法介绍
大家都叫我菜鸡刘
09-18 5845
ACT_RU_EXECUTION 实例表 ACT_RE_PROF 流程定义表 ACT_GE_BYTE_ARRAY bpmn的xml和普片存储 ACT_RE_DEPLOYMENT 部署表 ACT_RU_VARIABLE 各个步骤传入的valueable值 ACT_RU_IDENTITYLINK 创建者,参与者,候选人等步骤处理流程记录表 ACT_ID_USER 用户表 ACT_ID_GROUP 分组表 ACT_ID_MEMBERSHIP 用户分组关系对照...
flowable初始化表报错的问题
p393975269的博客
02-26 5667
flowable初始化表的时候一直报一下错误 mismatch: library version is '6.6.0.0', db version is 5.99.0.0 Hint: Set <property name="databaseSchemaUpdate" to value="true" or value="create-drop" (use create-drop for testing only!) in bean processEngineConfiguration in flowab
Flowable6.8(6.x版本通用)整合集成达梦8数据库(DM8)详解，解决自动生成表时dmn相关表语法报错问题。
TangBoBoa的博客
04-26 6195
本文章解决了Flowable 6.x版本集成DM8数据库中遇到的疑难问题。
flowable 入门
08-21
以下是Flowable入门的一些建议步骤： 1. 安装Flowable：你可以通过Maven或Gradle将Flowable引入到你的项目中。在pom.xml（或build.gradle）文件中添加Flowable的依赖项。 2. 创建Flowable引擎：在你的应用程序中，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值