java-activiti笔记

已于 2024-08-20 09:11:40 修改
阅读量300 收藏 3
点赞数 10
分类专栏： java 文章标签： java
于 2024-08-13 09:44:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22071421/article/details/141137021
版权

版本：activiti7

 <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-json-converter</artifactId>
            <version>7.0.0.Beta2</version>
            <exclusions>
                <exclusion>
                    <groupId>org.mybatis</groupId>
                    <artifactId>mybatis</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--activiti与springboot整合包-->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring-boot-starter</artifactId>
            <version>7.0.0.Beta2</version>
            <exclusions>
                <exclusion>
                    <groupId>org.mybatis</groupId>
                    <artifactId>mybatis</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

发布

流程图

会签

这里是将流程图通过bpmn.io插件设计好流程图，存放到服务器端

  public AjaxResult publishBpm(BpmFormVo bpmFormVo) {
        FileInputStream bpmnfileInputStream = null;
        try{
            BpmForm byId = getById(bpmFormVo.getId());
            xml=BpmFormManager.xmlnsActivitiEmpty(xml);
            xml=BpmFormManager.gatewaySupply(xml);
            activitiFlowService.delFlowByDefKey(bpmFormVo.getCode());
            repositoryService.createDeployment().addString(code+ ProcessConstants.SUFFIX, xml)
                    .name(code).key(code).deploy();
            bpmFormVo.setPublishTime(new Date());
            bpmFormVo.setState(1);
            bpmFormMapper.publishBpm(bpmFormVo);
            if("1".equals(byId.getCountersignature())){
                bpmCountersignService.bpmPublishHandle(byId,xml);
            }
        }catch (Exception e){
            e.printStackTrace();
            return AjaxResult.error("部署失败");
        }finally {
            try {
                if(bpmnfileInputStream!=null){
                    bpmnfileInputStream.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }

        }

        return AjaxResult.success("部署成功");
    }

重新发布需要做如下处理

    @SneakyThrows
    public void delFlowByDefKey(String code) {
        List<String> deploymentIdByName = activitiFlowMapper.getDeploymentIdByName(code+ ProcessConstants.SUFFIX);
        if(CollUtil.isEmpty(deploymentIdByName)){
            return;
        }
        for(String did:deploymentIdByName){
            repositoryService.deleteDeployment(did);
        }
    }

启动

    @Override
    public ProcessInstance startProcess(String definitionKey, String bussinessId,String userId,String userName, String projectId) {
        String bpmCode=definitionKey;
        Authentication.setAuthenticatedUserId(userId);
        Map<String, Object> map=new HashMap<>();
        map.put("state",ProcessConstants.AUDIT_YES);
        map.put("assignee",userId);
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(definitionKey, bussinessId, map);

        Task task = taskService.createTaskQuery()
                .processDefinitionKey(definitionKey)
                .taskAssignee(userId) //设置任务的负责人
                .orderByTaskCreateTime().desc().list().get(0);
        if (task!=null){
            taskService.addComment(task.getId(), task.getProcessInstanceId(), "流程提交","流程提交成功！");
            startTaskComplete(bpmCode,projectId,task.getId(),null);
        }


        startLogProcessHandle(bpmCode,definitionKey,bussinessId,projectId,userId,userName,processInstance,task);
        return processInstance;
    }

将会签中的占位的数据赋值

    @Override
    public void startTaskComplete(String bpmCode,String projectId,String taskId, Map<String, Object> variables) {

        BpmForm bpmForm = bpmFormService.queryInfoByCode(bpmCode, projectId);
        if(variables==null){
            variables=new HashMap<>();
        }
        if(bpmForm!=null&&"1".equals(bpmForm.getCountersignature())){
            //会签模式
            Object xmlByKey = activitiFlowMapper.getXmlByKey(bpmForm.getResCode() + ".bpmn");
            Map<String, List<String>> stringListMap = bpmUtil.collectionUseMap(bpmForm, (byte[]) xmlByKey);
            variables.putAll(stringListMap);
        }
        if(CollUtil.isEmpty(variables)){
            taskService.complete(taskId);
        }else{
            taskService.complete(taskId,variables);
        }
    }

    @SneakyThrows
    public Map<String,List<String>> collectionUseMap(BpmForm bpmForm,byte[] resByte){
        Map<String,List<String>> result=new HashMap<>();
        if("0".equals(bpmForm.getCountersignature())){
            return result;
        }
        String resStr = new String(resByte);
        BpmnModel bpmnModel = ModelUtil.getBpmnModel(resStr);
        Collection<UserTask> allUserTaskEvent = ModelUtil.getAllUserTaskEvent(bpmnModel);
        if(CollUtil.isEmpty(allUserTaskEvent)){
            return result;
        }

        SysRoleVo sysRoleVo=new SysRoleVo();
        sysRoleVo.setProjectId(bpmForm.getProjectId());
        List<SysRoleVo> sysRoleVos = sysRoleService.queryList(sysRoleVo);

        SysDept sysDept=new SysDept();
        sysDept.setProjectId(bpmForm.getProjectId());
        List<SysDept> sysDepts = sysDeptService.queryList(sysDept);

        for(UserTask userTask:allUserTaskEvent){
            if(userTask.hasMultiInstanceLoopCharacteristics()){
                MultiInstanceLoopCharacteristics loopCharacteristics = userTask.getLoopCharacteristics();
                String inputDataItem = loopCharacteristics.getInputDataItem();
                String coll = inputDataItem.replace("${", "").replace("}", "");
                String[] groups = coll.split("_");
                if("ROLE".equals(groups[0])){
                    List<String> idListByRoleId = getIdListByRoleId(groups[1], sysRoleVos).getUserIdList();
                    if(CollUtil.isNotEmpty(idListByRoleId)){
                        result.put(coll,idListByRoleId);
                    }
                }else if("DEPT".equals(groups[0])){
                    List<String> idListByDeptId = getIdListByDeptId(groups[1], sysDepts).getUserIdList();
                    if(CollUtil.isNotEmpty(idListByDeptId)){
                        result.put(coll,idListByDeptId);
                    }
                }
            }
        }
        return result;
    }

流程审批

    @SneakyThrows
    public CompletResultVo orSignCompletHandle(String taskId, String result, String remark, String definitionKey, Map<String, Object> variables, String userName){
        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
        taskService.addComment(taskId, task.getProcessInstanceId(), result,remark);
        if(variables==null){
            variables=new HashMap<>();
        }
        variables.put("state",result);
        taskService.complete(taskId,variables);
        CompletResultVo completResultVo=new CompletResultVo();
        boolean afterHandle = afterHandle(task, userName, remark, result);
        completResultVo.setAuditEndState(afterHandle);
        return completResultVo;
    }

    boolean afterHandle(Task task,String userName,String remark,String result){
        //存储审核日志信息
        QueryWrapper queryWrapper=new QueryWrapper<>();
        queryWrapper.eq("process_instance_id",task.getProcessInstanceId());
        BussTask bussTask = bussTaskMapper.selectOne(queryWrapper);
        //日志记录
completByTaskLogHandle(bussTask,task,task.getProcessInstanceId(),userName,remark, result);
        //更新结束记录
        return endHandle(task.getProcessInstanceId(),bussTask,userName);
    }

判断流程结束后相关操作

    boolean endHandle(String piid,BussTask bussTask,String userName){
        List<Task> task1 = taskService.createTaskQuery().processInstanceId(piid).list();
        bussTaskMapper.updateById(bussTask);
        if(CollUtil.isEmpty(task1)){
            bussTaskMapper.updateStatus(piid,ProcessConstants.AUDIT_NO);
            endLogHandle(bussTask);
            return true;
        }
        return false;
    }

会签审批

    @SneakyThrows
    public CompletResultVo countersignCompletHandle(String taskId, String result, String remark,String definitionKey,String projectId,
                                         String userName,Long userId,BpmForm bpmForm){
        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
        String taskDefinitionKey = task.getTaskDefinitionKey();
        UserTask userTask = getUserTaskByNodeId(bpmForm.getResCode(), taskDefinitionKey);
        if(userTask==null){
            return orSignCompletHandle(taskId,result,remark,definitionKey,projectId,null,userName);
        }
        if(!userTask.hasMultiInstanceLoopCharacteristics()){
            return orSignCompletHandle(taskId,result,remark,definitionKey,projectId,null,userName);
        }

        MultiInstanceLoopCharacteristics loopCharacteristics = userTask.getLoopCharacteristics();
        String completionCondition = loopCharacteristics.getCompletionCondition();
        String codeByInfo = BpmCountersignTypeEnum.getCodeByInfo(completionCondition);

        Map<String,Object> variables=new HashMap<>();

        QueryWrapper queryWrapper=new QueryWrapper<>();
        queryWrapper.eq("process_instance_id",task.getProcessInstanceId());
        BussTask bussTask = bussTaskMapper.selectOne(queryWrapper);
        List<LogProcess> bussList = getLogs(bussTask.getBussId(), task.getProcessInstanceId());

        List<BpmCountersignRecord> bpmCountersignRecords=new ArrayList<>();
        if(CollUtil.isNotEmpty(bussList)){
            BpmCountersignRecord bpmCountersignRecord=new BpmCountersignRecord();
            bpmCountersignRecord.setExecutionId(bussList.get(0).getExecutionId());
            bpmCountersignRecords= bpmCountersignService.queryListByExeId(bpmCountersignRecord);
        }


        BpmCountersign bpmCountersignByTaskInfo = bpmCountersignService.getBpmCountersignByTaskInfo(task.getTaskDefinitionKey(), bussTask.getDefinitionKey());
        String[] user_split = bpmCountersignByTaskInfo.getUids().split(",");

        if("all".equals(codeByInfo)){
            if(ProcessConstants.AUDIT_NO.equals(result)){
                variables.put("pass",true);
                variables.put("state",ProcessConstants.AUDIT_NO);
                taskService.complete(taskId,variables);
                countersignRecordHandle(task,bpmForm,userName,userId,bpmCountersignByTaskInfo,result,remark,bussTask,false,true,bussList);
            }else{
                if(user_split.length<=(bpmCountersignRecords.size()+1)){
                    variables.put("pass",true);
                    variables.put("state",ProcessConstants.AUDIT_YES);
                    taskService.complete(taskId,variables);
                    countersignRecordHandle(task,bpmForm,userName,userId,bpmCountersignByTaskInfo,result,remark,bussTask,true,true,bussList);
                }else{
                    variables.put("pass",false);
                    taskService.complete(taskId,variables);
                    countersignRecordHandle(task,bpmForm,userName,userId,bpmCountersignByTaskInfo,result,remark,bussTask,false,false,bussList);
                }
            }
        }else if("half".equals(codeByInfo)){
            if(user_split.length<=(bpmCountersignRecords.size()+1)){
                int ok_users=0;
                for(BpmCountersignRecord bpm:bpmCountersignRecords){
                    if(ProcessConstants.AUDIT_YES.equals(bpm.getAuditResult())){
                        ok_users+=1;
                    }
                }
                if(ProcessConstants.AUDIT_YES.equals(result)){
                    ok_users+=1;
                }
                String state=null;
                BigDecimal divide = new BigDecimal(ok_users).divide(new BigDecimal(user_split.length), 2, BigDecimal.ROUND_HALF_UP)
                double doubleValue = divide.doubleValue();
                if(doubleValue>=0.5){
                    state=ProcessConstants.AUDIT_YES;
                }else{
                    state=ProcessConstants.AUDIT_NO;
                }
                variables.put("state",state);
                variables.put("pass",true);
                taskService.complete(taskId,variables);
                countersignRecordHandle(task,bpmForm,userName,userId,bpmCountersignByTaskInfo,result,remark,bussTask,state.equals(ProcessConstants.AUDIT_YES)?true:false,true,bussList);
            }else{
                variables.put("pass",false);
                taskService.complete(taskId,variables);
                countersignRecordHandle(task,bpmForm,userName,userId,bpmCountersignByTaskInfo,result,remark,bussTask,false,false,bussList);
            }
        }else if("single".equals(codeByInfo)){
            if(ProcessConstants.AUDIT_YES.equals(result)) {
                variables.put("pass",true);
                variables.put("state",ProcessConstants.AUDIT_YES);
                taskService.complete(taskId,variables);
                countersignRecordHandle(task,bpmForm,userName,userId,bpmCountersignByTaskInfo,result,remark,bussTask,true,true,bussList);
            }else{
                if(user_split.length<=(bpmCountersignRecords.size()+1)){
                    variables.put("pass",true);
                    variables.put("state",ProcessConstants.AUDIT_NO);
                    taskService.complete(taskId,variables);
                    countersignRecordHandle(task,bpmForm,userName,userId,bpmCountersignByTaskInfo,result,remark,bussTask,false,true,bussList);
                }else{
                    variables.put("pass",false);
                    taskService.complete(taskId,variables);
                    countersignRecordHandle(task,bpmForm,userName,userId,bpmCountersignByTaskInfo,result,remark,bussTask,false,false,bussList);
                }
            }
        }
        CompletResultVo completResultVo=new CompletResultVo();
        List<LogProcess> bussList2 = getLogs(bussTask.getBussId(), task.getProcessInstanceId());
        String aname="";
        if(CollUtil.isNotEmpty(bussList2)){
            aname=bussList2.get(0).getAssigneeName();
        }else{
            aname= bussList.get(0).getAssigneeName();
        }
        boolean endHandle = endHandle(task.getProcessInstanceId(), bussTask, aname);
        completResultVo.setAuditEndState(endHandle);
        return completResultVo;
    }

//日志及操作记录
 /**
     *
     * @param task
     * @param bpmForm
     * @param userName
     * @param userId
     * @param bpmCountersignByTaskInfo
     * @param result 当前人的审核状态
     * @param remark
     * @param auditState 最终审核状态（会签）
     * @param isEnd 当前节点是否全部完成
     */
    void countersignRecordHandle(Task task,BpmForm bpmForm,String userName,Long userId,BpmCountersign bpmCountersignByTaskInfo,
                           String result,String remark,BussTask bussTask,boolean auditState,boolean isEnd,List<LogProcess> bussList){
        LogProcess logRecord=null;
        if(CollUtil.isEmpty(bussList)){
            logRecord=new LogProcess();
            logRecord.setProjectId(bpmForm.getProjectId());
            String myExeId=UUID.randomUUID().toString();
            logRecord.setExecutionId(myExeId);
            logRecord.setBusinessId(bussTask.getBussId());
            logRecord.setTaskId(task.getId());
            logRecord.setAssigneeName(bpmCountersignByTaskInfo.getUnames());
            logRecord.setAssignee(bpmCountersignByTaskInfo.getUids());
            logRecord.setInstanceId(task.getProcessInstanceId());
            logRecord.setDefinitionKey(bpmForm.getResCode());
            if(isEnd){
                logRecord.setStepType(auditState?ActivitiStepType.approved.getCode():ActivitiStepType.reject.getCode());
            }else{
                logRecord.setStepType(ActivitiStepType.unapproved.getCode());
            }

            logProcessMapper.insert(logRecord);
        }else{
            if(isEnd){
                logRecord = bussList.get(0);
                logRecord.setStepType(auditState?ActivitiStepType.approved.getCode():ActivitiStepType.reject.getCode());
                logProcessMapper.updateById(logRecord);
            }
        }

        BpmCountersignRecord bcr=new BpmCountersignRecord();
        bcr.setNodeId(task.getTaskDefinitionKey());
        bcr.setBpmCode(bpmForm.getCode());
        bcr.setUserId(userId+"");
        bcr.setUserName(userName);
        if(logRecord!=null){
            bcr.setLogId(logRecord.getId());
        }else{
            bcr.setLogId(bussList.get(0).getId());
        }
        bcr.setBusinessId(bussTask.getBussId());
        bcr.setAuditRemark(remark);
        bcr.setAuditResult(result);
        bcr.setExecutionId(logRecord.getExecutionId());
        bcr.setProcessInstanceId(task.getProcessInstanceId());
        bpmCountersignRecordMapper.insert(bcr);
    }

会签流程表达式枚举，全部通过即通过，半数通过即通过，一人通过即通过：

public enum BpmCountersignTypeEnum {
    all("all", "${nrOfCompletedInstances==nrOfInstances||pass==true}"),
    half("half", "${nrOfCompletedInstances/nrOfInstances&gt;=0.5&&pass==true}"),
    single("single", "${nrOfCompletedInstances>=1&&pass==true}");

    private final String code;
    private final String info;

    BpmCountersignTypeEnum(String code, String info)
    {
        this.code = code;
        this.info = info;
    }

    public static String getCodeByInfo(String info){
        if(StringUtils.isBlank(info)){
            return null;
        }
        for(BpmCountersignTypeEnum bct:BpmCountersignTypeEnum.values()){
            String elEscape = EscapeUtil.elEscape(bct.info);
            if(info.equals(elEscape)){
                return bct.code;
            }
        }
        return null;
    }

    public String getCode()
    {
        return code;
    }

    public String getInfo()
    {
        return info;
    }
}

这里：

nrOfInstances：总实例数

nrOfCompletedInstances：已完成实例数

nrOfActiviteInstances：未完成的实例数

全部通过即通过和一人通过即通过直接处理即可，state是流线走向，按比例通过时，我这里用一张表记录了每次操作，即BpmCountersignRecord，将此次记录作为流程操作记录的子关联表，executionId作为关联键。

其他

每次流程启动表act_ge_bytearray中会出现如下图的数据，这就是会签流程里面的变量数据

当流程审批结束后，var-开头的数据就会消失，hist开头的是act_hi表中相关数据

暮雪...
关注
专栏目录
activiti笔记
shuangmu9768的博客
09-02 1万+
【1】常用类 【2】部署后乱码问题 【3】流程变量设置与获取 【4】formService 【5】流程步骤 【1】常用类 ProcessEngineConfiguration processEngineConfiguration = ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration(); ProcessEngine processEngine = processEngineConfiguration.buildPro
Java整合activiti工作流，项目案例分享（源码分享）
2301_81867536的博客
04-09 1391
activiti工作流引擎项目，企业erp、oa、hr、crm等企事业办公系统轻松落地，一套完整并且实际运用在多套项目中的案例，满足日常业务流程审批需求。
在Java中使用Activiti工作流引擎：全面指南
最新发布
weixin_46372265的博客
07-15 1080
在信息化飞速发展的今天，工作流管理系统（Workflow Management System，WfMS）已成为企业信息化建设中的重要组成部分。通过引入工作流管理系统，可以显著提高企业的业务流程管理水平，实现业务流程的自动化和优化。而Activiti作为一款高性能、可扩展的开源工作流引擎，凭借其灵活性和易用性，成为了众多开发者的首选。Activiti是一个基于Java的开源工作流和业务流程管理（BPM）平台，支持BPMN 2.0规范。
【Camunda五】Camunda常用接口整合
菜鸟逆袭之路
01-15 1万+
Camunda流程引擎常用功能
repositoryService 流程存储服务组件
夜飛雪的博客
10-26 3110
1.流程文件的部署 act_re_deployment-->act_ge_bytearray(两条数据：流程图片的文件数据和流程的描述文件数据)--> act_re_procdef(流程定义表) a.classpath资源 //创建DeploymentBuilder实例 DeploymentBuilder builder = repositoryService.createDe
camunda工作流学习笔记（2）：发布流程
weixin_41767691的博客
12-31 4558
集成camunda编辑工具 进入camunda官方网站https://camunda.com/下载camunda modeler流程编辑器 打开idea集成编辑工具，File->Settings->Tools0>External Tools 启动camunda modeler绘制流程 打开camunda modeler工具，绘制一个最简单的流程，并将流程文件保存到文件夹内...
Activiti笔记，很全面
12-28
Activiti 是一个开源的工作流和业务流程管理（BPM）平台，主要用Java语言开发，广泛应用于Web应用中。这个压缩包包含两份文档，分别提供了关于Activiti的基础知识和一个具体的请假流程项目的实践。 首先，让我们...
activiti笔记.zip
04-25
标题“activiti笔记.zip”表明这是一个关于 Activiti 的学习资料包，可能包含了作者在学习过程中整理的笔记、代码示例和相关资源。 描述中的“activiti笔记”简洁地表达了内容主题，意味着这些笔记将涵盖 Activiti ...
activiti笔记1
06-22
在使用自动建表功能时，需要配置相应的Java项目和jar包，配置文件名称通常是`activiti-context.xml`或`activiti.cfg.xml`。 【Activiti数据库表结构】 Activiti的表以`ACT_`开头，后接两个字母标识表的用途。例如...
activiti入门九(repositoryService介绍)
jonathan的专栏
10-31 1万+
在activiti入门一(简单介绍中),简单介绍了repositoryService的主要作用是管理流程仓库，例如部署，删除，读取流程资源等。本文就repositoryService再做下详细的说明
【Camunda 三】Camunda模型文件部署
justlpf的专栏
09-23 4865
Camunda SpringBoot工程启动时会自动扫描resource文件夹下的bpmn文件，也可以禁止扫描，并自定义部署扫描bpmn。spring:url: jdbc:mysql://127.0.0.1:3306/数据库名?
Activiti 流程部署方式 activi 动态部署（高级源码篇）
热门推荐
分享牛
04-16 6万+
欢迎加入我们的学习提升群523988350，里面有京东、美团网的技术人员，可以相互交流 Activiti的流程 部署方式有很多种方式，我们可以根据activit工作流引擎提供的ap方式进行部署。 当然了实际需求决定你要使用哪一种api操作，后面的总结详细介绍了使用场景。 下面看一下部署方式。 流程部署的方式在类org.activiti.engine.repository.Deplo
Java整合activiti工作流，项目案例分享（完整源码和配套文档）
2301_81867536的博客
03-04 1408
springboot+vue+activiti集成了activiti在线编辑器，流行的前后端分离部署开发模式，快速开发平台，可插拔工作流服务。工作流表单可平滑的接入自定义表单，接入后进行业务审批流转。本项目集成了工作流所有的功能，并做了一个测试的表单进行审批演示。工作流部分功能含：流程图在线绘制，在线发布，工作流权限设置，审批节点设置（角色，直接指定人，部门等），业务表单关联，提交，撤回，与签或签，同意，驳回（支持驳回到任意岗），审批委托，流程挂起，流程图实时跟踪，审批提醒，可接入钉钉进行钉钉通知，企业微信
Deployment deployment
weixin_36873225的博客
08-29 195
请注意，这段代码中的repositoryService是Activiti框架中的RepositoryService接口的实例，需要根据具体的应用程序环境进行初始化和配置。它的作用是将一个BPMN 2.0的流程定义文件添加到流程引擎中，并进行部署。使用.name(modelData.getName())方法设置部署的名称，modelData.getName()是流程模型的名称。2.0的流程定义文件以字符串的形式添加到部署中。processName是流程定义的名称，bpmnBytes是BPMN文件的字节数组。
web mvc整合activiti-modeler在线流程设计器
天地人的博客
11-30 3928
web mvc整合activiti-modeler在线流程设计器1、背景2、整合2.1 添加maven依赖2.2 从官网下载示例2.3 添加配置文件2.4 添加页面 1、背景 一直以来，activity工作流的流程设计任务都托付给开发人员，普通人参与不进来。但是我们的客户则提出更高的要求，要求普通的人员也可以参与流程的设计要求。那么，activiti有没有这项功能呢？答案是肯定的。如此，activ...
flowable实战（二）flowable流程模型管理接口
Gblfy_Blog
11-14 3398
文章目录一、流程模型资源二、流程模型资源的部署：2.1. 流程资源xml部署：2.2. zip/bar打包，多个流程资源文件部署：2.3. Model部署三、部署有关的数据库表四、流程模型的常见管理接口4.1. 部署api4.2.验证部署4.3.获取所有部署api4.4.删除部署api4.5.部署的挂起与激活 一、流程模型资源 流程定义文件：文件的命名必须是XXXXbpmn20.xml，注意命名规...
flowable部署流程的6种方式
weixin_42467369的博客
01-15 5274
一、部署工作流6中方式 使用文件流stream，部署工作流 使用classpath，部署工作流 使用压缩文件格式（zip）ZipStream，部署工作流 使用纯文本格式text，部署工作流 使用字节数组，部署工作流 使用动态创建的流程图，部署工作流 1. 使用文件流stream，部署工作流 上传的文件必须是XXXbpmn20.xml格式的。resourceName的后缀格式必须是XXXbpmn20.xml。 /**【1】使用文件流stream，部署工作流*/ //假设不是null，忽略此处赋值为nu
Activiti5学习笔记：入门与关键概念解析
"activiti5学习笔记.pdf 是一本关于Activiti5的工作流引擎学习资料，涵盖了从准备环境到实际使用的全过程。" Activiti5是一个开源的工作流引擎，它基于Java，广泛应用于业务流程管理（BPM）系统。该学习笔记详细...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

暮雪...

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

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

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

打赏作者

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

抵扣说明：

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

余额充值