【activiti 入门】activiti6.0之排他网关，涵盖工具类，具体代码以及大白话的讲解，不扯难理解的理论

最新推荐文章于 2021-05-03 19:10:30 发布
最新推荐文章于 2021-05-03 19:10:30 发布
阅读量993 收藏 2
点赞数
分类专栏： activiti 文章标签： activiti6.0排他网关 排他网关
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33333654/article/details/101269902
版权

环境搭建可参考之前的博客，直接上代码：

首先准备工具类：

package com.example.demo.utils;

import org.activiti.bpmn.model.*;
import org.activiti.bpmn.model.Process;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.history.HistoricActivityInstance;
import org.activiti.engine.history.HistoricProcessInstance;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.history.HistoricVariableInstance;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;

/**
 * @ProjectName: demo
 * @Package: com.example.demo.utils
 * @ClassName: ActivitiUtil
 * @Author: MC
 * @Description: ${description}
 * @Date: 2019/9/19 0019 18:17
 * @Version: 1.0
 */
@Service
public class ActivitiUtil {
    @Autowired
    private ProcessEngine processEngine;

    @Autowired
    private RuntimeService runtimeService ;

    @Autowired
    private TaskService taskService ;

    @Autowired
    private RepositoryService repositoryService;

    /**
     * @Method 部署流程
     * @Author MC

     * @Return
     * @Date 2019/9/19 0019 18:34
     */
    public void deploy(String filePath){
        if(!StringUtils.isEmpty(filePath)){
            repositoryService.createDeployment()
                    .addClasspathResource(filePath)
                    .deploy();
        }
    }

    /**
     * @Method 启动流程
     * @Author MC

     * @Return
     * @Date 2019/9/19 0019 18:35
     */
    public Map<String,Object> start(Map<String,Object> map ,String processId){
        ProcessInstance leave1 = runtimeService.startProcessInstanceByKey(processId, map);
        String processDefinitionId = leave1.getProcessDefinitionId();
        System.out.print("============processDefinitionId:" + processDefinitionId);//流程定义的ID
        System.out.print("============processInstanceId:" + leave1.getId());//流程实例的ID
        Map<String, Object> resultMap = new HashMap<>();
        resultMap.put("result",leave1);
        resultMap.put("processDefinitionId",processDefinitionId);
        resultMap.put("processInstanceId",leave1.getId());
        return resultMap;
    }

    /**
     * @Method 根据流程实例ID和用户ID查询任务ID
     * @Author MC
     用户ID必须设置为Assignee
     * @Return
     * @Date 2019/9/19 0019 19:01
     */
    public String getTaskIdByAssignee( String processInstanceId, String userId){
        TaskService taskService = processEngine.getTaskService();//获取任务的Service，设置和获取流程变量
        //查询当前办理人的任务ID
        Task task = taskService.createTaskQuery()
                .processInstanceId(processInstanceId)//使用流程实例ID
                .taskAssignee(userId)//任务办理人
                .singleResult();

        return  task.getId();
    }

    /**
     * @Method 根据流程实例ID和userTask标签体设置的ID获取当前任务对象
     * @Author MC

     * @Return
     * @Date 2019/9/24 0024 9:54
     */
    public String getTaskIdByDefinitionKey( String processInstanceId, String defKey){
        TaskService taskService = processEngine.getTaskService();//获取任务的Service，设置和获取流程变量
        //查询当前办理人的任务ID
        Task task = taskService.createTaskQuery()
                .processInstanceId(processInstanceId)//使用流程实例ID
                .taskDefinitionKey(defKey)//userTask标签体的id
                .singleResult();

        return  task.getId();
    }

    /**
     * @Method 获取流程实例列表
     * @Author MC

     * @Return
     * @Date 2019/9/19 0019 18:32
     */
    public List<ProcessInstance> queryProcessInstanceAllList(String processDefinitionKey){
        return runtimeService
                .createProcessInstanceQuery().processDefinitionKey(processDefinitionKey)
                .list();
    }


    /**
     * @Method 根据assignee来查询用户
     * @Author MC

     * @Return
     * @Date 2019/9/19 0019 18:29
     */
    public Task queryTask(String assignee) {
        //startProcessInstance();
        // taskService.createTaskQuery().taskCandidateGroup("sales").singleResult();

        Task task= taskService.createTaskQuery().taskAssignee(assignee).singleResult();
        if(task == null){
            return null;
        }

        System.out.println("审批人为【"+assignee+"】的任务有：任务编号为【" + task.getId() + "】"+ task.getTaskDefinitionKey());
        return task;
    }

    public Task queryTask(String assignee, String processInstanceId) {

        Task task=  taskService.createTaskQuery()
                .processInstanceId(processInstanceId)//使用流程实例ID
                .taskAssignee(assignee)//任务办理人
                .singleResult();
        if(task == null){
            return null;
        }

        System.out.println("审批人为【"+assignee+"】的任务有：任务编号为【" + task.getId() + "】"+ task.getTaskDefinitionKey());
        return task;
    }

    /**
     *
     * @param queryType  查询类型1 根据 assignee 查询  2 根据candidateuser查询
     * @param str
     */
    public String getNextNodeId(int queryType,String str) {


        Task task = null;
        if(queryType==1) {
            task = taskService.createTaskQuery().taskAssignee(str).singleResult();
        }else if(queryType==2){
            task = taskService.createTaskQuery().taskCandidateUser(str).singleResult();

        }else if(queryType==3){
            task = taskService.createTaskQuery().taskCandidateGroup(str).singleResult();

        }

//        List<FlowElement> list = getNextNode(task.getId());


        if(task==null) {
            return null;
        }

//        for(FlowElement e :list) {
//            //((org.activiti.bpmn.model.UserTask) e)
//        }
        return task.getId();

    }


    /**
     * 获取流程的下一个节点 且要经过规则引擎判断后的节点
     * @param taskId
     * @return
     */
    private List<FlowElement> getNextNode(String taskId) {

        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
        if(task==null) {
            return null;
        }
        List<FlowElement> list = new ArrayList<FlowElement>();
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(task.getProcessInstanceId()).singleResult();

        //当前活动节点
        String activitiId = processInstance.getActivityId();

        System.out.println("当前节点是【"+activitiId+"】");

        //pmmnModel 遍历节点需要它
        BpmnModel bpmnModel =  repositoryService.getBpmnModel(task.getProcessDefinitionId());

        List<Process> processList = bpmnModel.getProcesses();

        //循环多个物理流程
        for(Process process:processList) {

            //返回该流程的所有任务，事件
            Collection<FlowElement> cColl = process.getFlowElements();
            //遍历节点
            for(FlowElement f :cColl) {


                //如果改节点是当前节点 者 输出该节点的下一个节点
                if(f.getId().equals(activitiId)) {

                    List<SequenceFlow>  sequenceFlowList = new ArrayList<SequenceFlow>();
                    //通过反射来判断是哪种类型
                    if(f instanceof org.activiti.bpmn.model.StartEvent) {
                        //开始事件的输出路由
                        sequenceFlowList   = ((org.activiti.bpmn.model.StartEvent) f).getOutgoingFlows();
                    }else if(f instanceof org.activiti.bpmn.model.UserTask) {

                        sequenceFlowList   = ((org.activiti.bpmn.model.UserTask) f).getOutgoingFlows();


                        for(SequenceFlow sf :sequenceFlowList)  {

                            String targetRef = sf.getTargetRef();
                            FlowElement ref = process.getFlowElement(targetRef);

                            // nextActivitiIdList.add(ref.getId());

                            list.add(ref);
                        }

                    }else if(f instanceof org.activiti.bpmn.model.SequenceFlow) {


                    }else if(f instanceof org.activiti.bpmn.model.EndEvent) {
                        sequenceFlowList   = ((org.activiti.bpmn.model.EndEvent) f).getOutgoingFlows();
                    }
                    break;
                }

            }

        }
        return list;
    }


    /**
     * @Method 流程流转到下一步
     * @Author MC
根据 assignee 查询出任务，如果存在则设置当前任务的 assignee 为 nextUser
     * @Return 不存在下一个节点返回false;
     * @Date 2019/9/19 0019 18:23
     */
    public boolean completeByAssignee(String assignee,String nextUser) throws Exception {

        HashMap<String,Object> map = new HashMap<String,Object>();

        map.put("nextUser", nextUser);
        Task task = taskService.createTaskQuery().taskAssignee(assignee).singleResult();
        if(task == null){
            System.out.println("下一节点不存在");
            return false;
        }
        taskService.complete(task.getId(),map);
        System.out.println("完成任务 编号为【" + task.getId() + "】,名称为【"+task.getName()+"】的任务");
        return true;
    }

    /**
     * 设置某个节点的审批人员
     * @param taskId
     * @param user
     */
    public void setApproveUser(String taskId,String user) {
        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
        task.setAssignee(user);
        taskService.saveTask(task);
    }


    /**
     * 取下一个节点的审批人
     * @param taskId
     * @return
     */
    public List<String> getNextTaskUserByTaskId(String taskId) {
        List<String> list = new ArrayList<String>();
        List<FlowElement> fList = getNextNode(taskId);
        for(FlowElement u:fList){
            String str =  ((org.activiti.bpmn.model.UserTask) u).getAssignee();
            list.add(str);
        }
        return list ;
    }


    /**
     * 找当前节点的候选审批人  供流程实例start后调用
     * @param taskId
     * @return
     */
    public List<String> getThisTaskUser(String taskId) {
        List<String> list = new ArrayList<String>();
        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
        String taskUser = task.getAssignee();

        //*****************************根据taskUser的配置到自己的表里面去找数据

        list.add(taskUser);
        return list ;
    }

    /**
     * @Method 任务是否完结
     * @Author MC

     * @Return
     * @Date 2019/9/20 0020 11:20
     */
    public boolean isOverTask(String processInstanceId){
        ProcessInstance pi= runtimeService.createProcessInstanceQuery() // 创建流程实例查询
                .processInstanceId(processInstanceId) // 用流程实例id查询
                .singleResult();
        if(pi!=null){
            System.out.println("流程正在执行！");
            return false;
        }else{
            System.out.println("流程已经执行结束！");
        }
        return true;
    }


    /**
     * @Method 历史流程实例查询
     * @Author MC

     * @Return
     * @Date 2019/9/20 0020 11:22
     */
    public  List<HistoricProcessInstance>  queryHisProInstance(String processDefinitionKey){
        List<HistoricProcessInstance> historicProcessInstanceList = processEngine.getHistoryService().createHistoricProcessInstanceQuery()
                .processDefinitionKey(processDefinitionKey)
                .orderByProcessInstanceEndTime()
                .desc()
                .list();
        /*for(HistoricProcessInstance historicProcessInstance:historicProcessInstanceList){
            System.out.println("历史流程实例id: "+historicProcessInstance.getId());
            System.out.println("历史流程实例的完成时间: "+historicProcessInstance.getEndTime());
        }*/
        return historicProcessInstanceList;
    }


    /**
     * 查询历史流程变量
     */
    public List<HistoricVariableInstance> queryHisProVariable(String processInstanceId){
        List<HistoricVariableInstance> historicVariableInstanceList = processEngine.getHistoryService()
                .createHistoricVariableInstanceQuery()
                .processInstanceId(processInstanceId).list();
        /*for(HistoricVariableInstance historicVariableInstance: historicVariableInstanceList){
            System.out.println("历史流程变量id: "+historicVariableInstance.getId());
            System.out.println("历史流程变量名称: "+historicVariableInstance.getVariableName());
            System.out.println("历史流程变量值: "+historicVariableInstance.getValue());
            System.out.println("==================================================");
        }*/
        return historicVariableInstanceList;
    }


    /**
     * 根据办理人查询历史任务实例
     */
    public List<HistoricTaskInstance> queryHisTaskInstanceByAssignee(String processDefinitionKey,String taskAssignee){
        List<HistoricTaskInstance> historicTaskInstanceList = processEngine.getHistoryService().createHistoricTaskInstanceQuery()
                .processDefinitionKey(processDefinitionKey)
                .taskAssignee(taskAssignee).list();
        /*for(HistoricTaskInstance historicTaskInstance:historicTaskInstanceList){
            System.out.println("历史任务id: "+historicTaskInstance.getId());
            System.out.println("历史任务名称: "+historicTaskInstance.getName());
            System.out.println("历史任务结束时间: "+historicTaskInstance.getEndTime());
            System.out.println("办理人: "+historicTaskInstance.getAssignee());
            System.out.println("==================================================");
        }*/
        return historicTaskInstanceList;
    }



    /**
     * 历史任务查询
     * type: 0:未完成 1:已完成  "":all
     */
    public List<HistoricTaskInstance> historyTaskList(String processInstanceId,String type){
        List<HistoricTaskInstance> list=null;

        if(StringUtils.isEmpty(type)){
            list =  processEngine.getHistoryService() // 历史相关Service
                    .createHistoricTaskInstanceQuery() // 创建历史任务实例查询
                    .processInstanceId(processInstanceId) // 用流程实例id查询
                    .list();
        }else if("0".equals(type)){
            list =  processEngine.getHistoryService() // 历史相关Service
                    .createHistoricTaskInstanceQuery() // 创建历史任务实例查询
                    .processInstanceId(processInstanceId) // 用流程实例id查询
                    .unfinished()
                    .list();
        }else if("1".equals(type)){
            processEngine.getHistoryService() // 历史相关Service
                    .createHistoricTaskInstanceQuery() // 创建历史任务实例查询
                    .processInstanceId(processInstanceId) // 用流程实例id查询
                    .finished() // 查询已经完成的任务
                    .list();
        }
       /* for(HistoricTaskInstance hti:list){
            System.out.println("任务ID:"+hti.getId());
            System.out.println("流程实例ID:"+hti.getProcessInstanceId());
            System.out.println("任务名称："+hti.getName());
            System.out.println("办理人："+hti.getAssignee());
            System.out.println("开始时间："+hti.getStartTime());
            System.out.println("结束时间："+hti.getEndTime());
            System.out.println("=================================");
        }*/

       return list;
    }

    /**
     * 已完成的历史活动查询
     */
    public List<HistoricActivityInstance> historyActInstanceList(String processInstanceId){
        List<HistoricActivityInstance>  list=processEngine.getHistoryService() // 历史相关Service
                .createHistoricActivityInstanceQuery() // 创建历史活动实例查询
                .processInstanceId(processInstanceId) // 执行流程实例id
                .finished()
                .list();
       /* for(HistoricActivityInstance hai:list){
            System.out.println("活动ID:"+hai.getId());
            System.out.println("流程实例ID:"+hai.getProcessInstanceId());
            System.out.println("活动名称："+hai.getActivityName());
            System.out.println("办理人："+hai.getAssignee());
            System.out.println("开始时间："+hai.getStartTime());
            System.out.println("结束时间："+hai.getEndTime());
            System.out.println("=================================");
        }*/
       return list;
    }

}

 第二步：绘制流程图：

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:activiti="http://activiti.org/bpmn"
             xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:dc="http://www.omg.org/spec/DD/20100524/DC" xmlns:di="http://www.omg.org/spec/DD/20100524/DI" xmlns:tns="http://www.activiti.org/testm1539766523202" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" expressionLanguage="http://www.w3.org/1999/XPath" id="m1539766523202" name=""
             targetNamespace="http://www.activiti.org/testm1539766523202" typeLanguage="http://www.w3.org/2001/XMLSchema">
    <process id="leave1" name="leave1" isClosed="false" isExecutable="true" processType="None">
        <startEvent id="_2" name="start"/>
        <userTask activiti:assignee="${leave.userId}" activiti:exclusive="true" id="_3" name="submit"/>
        <exclusiveGateway gatewayDirection="Unspecified" id="_4" name="result"/>
        <userTask activiti:assignee="${leave.approver1}" activiti:exclusive="true" id="_5" name="approve1"/>
        <exclusiveGateway gatewayDirection="Unspecified" id="_6" name="result"/>
        <userTask activiti:assignee="${leave.approver2}" activiti:exclusive="true" id="_7" name="approve2"/>
        <exclusiveGateway gatewayDirection="Unspecified" id="_8" name="result"/>
        <endEvent id="_9" name="end"/>
        <sequenceFlow id="_10" sourceRef="_2" targetRef="_3"/>
        <sequenceFlow id="_11" sourceRef="_3" targetRef="_4"/>
        <sequenceFlow id="_12" name="y" sourceRef="_4" targetRef="_5">
            <conditionExpression xsi:type="tFormalExpression"><![CDATA[${leave.submit==true}]]></conditionExpression>
        </sequenceFlow>
        <sequenceFlow id="_13" name="n" sourceRef="_4" targetRef="_9">
            <conditionExpression xsi:type="tFormalExpression"><![CDATA[${leave.submit==false}]]></conditionExpression>
        </sequenceFlow>
        <sequenceFlow id="_14" sourceRef="_5" targetRef="_6"/>
        <sequenceFlow id="_15" name="n" sourceRef="_6" targetRef="_7">
            <conditionExpression xsi:type="tFormalExpression"><![CDATA[${leave.agree1==true}]]></conditionExpression>
        </sequenceFlow>
        <sequenceFlow id="_16" sourceRef="_7" targetRef="_8"/>
        <sequenceFlow id="_17" name="y" sourceRef="_6" targetRef="_3">
            <conditionExpression xsi:type="tFormalExpression"><![CDATA[${leave.agree1==false}]]></conditionExpression>
        </sequenceFlow>
        <sequenceFlow id="_18" name="n" sourceRef="_8" targetRef="_3">
            <conditionExpression xsi:type="tFormalExpression"><![CDATA[${leave.agree2==false}]]></conditionExpression>
        </sequenceFlow>
        <sequenceFlow id="_19" name="y" sourceRef="_8" targetRef="_9">
            <conditionExpression xsi:type="tFormalExpression"><![CDATA[${leave.agree2==true}]]></conditionExpression>
        </sequenceFlow>
    </process>
</definitions>

 bpmn图片：

 由于绘图中使用了表单对象，所需要创建表单对象bean。bean的名字为leave。

第三步，创建表单对象leave：

package com.example.demo.model;

import lombok.Data;

import java.io.Serializable;
import java.util.Date;

/**
 * @ProjectName: demo
 * @Package: com.example.demo.service.model
 * @ClassName: Leave
 * @Author: MC
 * @Description: ${description}
 * @Date: 2019/9/19 0019 13:14
 * @Version: 1.0
 */
@Data
public class Leave implements Serializable {
    private static final long serialVersionUID = 2248469053125414262L;

    private String userId;

    private Boolean submit;

    private Date startDate;

    private Date endDate;

    private float totalDay;

    private String desc;

    private String taskId;

    private String taskName;

    private String approver1;

    private Boolean agree1;

    private String approveDesc1;

    private String approver2;

    private Boolean agree2;

    private String approveDesc2;

    private Boolean agree3;

    private String approveDesc3;
}

 这里使用的是lombok,集成很简单，可自行百度。

讲解：

排他网关是一个菱形中间带一个X号，所谓排他，其实就是if else，在连接两个节点userTask时，进行条件限制，条件限制的关键就是连接线的属性设置，网上讲一堆理论感觉没有这个大白话来的实在，截图看下：

可以看到连接线的condition属性指定了节点跳转的方向，条件内容正好对应了我们刚才创建的bean(leave)， 按照上面提供的代码亲自测试一下，观察数据库中act_ru_task表中数据的变化。

注意一点：xml文件中userTask标签体中设置了属性为：activiti:assignee="${leave.userId}"     其实这个属性就是在设置act_ru_task表中assignee属性的值，这个一点下一节会提到。

下一节将下并行网关

冒菜-码农
关注
专栏目录
Activity工具类
ambitionLlll的博客
07-01 439
项目中有一个需求，当接收到语音的关闭应用广播时，需要关闭我们的应用。 即受到广播后遍历所有当前打开的Activity，将它们都杀掉。 解决思路就是每个Activity的oncreate方法中将该Activity加入一个栈，onDestroy方法中将该Activity移出栈，当最后受到关闭应用广播时遍历栈，将栈中的每一个Activity杀掉。 对于上面的操作，整理了一个Activity相关的工具类，以后可以直接COPY使用： import android.app.Activity; import java
Activiti流程判断之排他网关和并行网关
阳某的博客
11-24 3651
目录排他网关并行网关 排他网关 业务场景 某一家公司最近在给一个单位做一个财务审批的OA。具体需求是这样的：当部门申请的金额小于一万块的时候，财务部可以直接决策。当部分申请的金额大于一万块并且小于三十万的时候，财务部经理决策，当金额超出了或者等于三十万的时候，需要财务主管来决策。 当满足某一条件就能通过的业务，我们就能用排他网关来处理 我这个流程图就是模拟这个业务场景画的，第一个是money&l...
activiti工具类
03-03
驳回流程、取回流程、清空指定活动节点流向 、提交流程/流程转向、中止流程(特权人直接审批通过等)、挂起等核心操作
Activiti6.0（五）排他网关的使用
清茶的博客
02-05 5139
目录 一、前言 二、排他网关使用 1、绘制流程图 2、执行排他网关 3、复杂条件判断 一、前言 上一篇中有讲到在有多条出线时，可以在流程线上使用流程变量来控制，Activiti的排他网关本质上也是通过给网关后的每条出线设置条件，除去默认出线后然后从上至下进行判断，当条件为true或者无条件时则认为满足，直接执行该条出线，排他网关也允许设置默认出线，即当所有出线都不满足时执行该条默认出...
Activiti工具类
a8532156的博客
11-15 939
package com.netqin.kingviker; import java.io.InputStream; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import org.a...
activiti（六）排他网关ExclusiveGateWay
sdaujsj1的博客
03-29 1283
activiti排他网关ExclusiveGateWay package cn.panda.g_exclusiveGateWay; import java.io.InputStream; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.zip.ZipInputSt...
Activiti 学习笔记八：排他网关（ExclusiveGateWay）
09-08
在ActivitiStduy这个压缩包中，可能包含了一些示例代码或者流程图，帮助你更好地理解排他网关的用法。你可以通过这些资源来实践如何在实际项目中应用排他网关。 排他网关的应用场景广泛，例如在订单处理流程中，...
2019最详细Activiti6.0之BPMN2.0规范
02-24
是一套业务流程模型与符号建模标准精准的执行语义来描述元素的操作以XML为载体，以符号可视化业务BPMN2.0-流对象活动（Activities）【UserTask、Service、Task…】事件（Event）【StartEvent、EndEvent…】网关...
Activiti6.0工作流引擎入门Demo
03-18
Activiti源码看着太复杂了，于是从网上看了一些教程从零开始搭了一个简易demo版，个人主页有对其进行详细介绍，配合食用哦~ Activiti是一个工作流引擎， activiti可以将业务系统中复杂的业务流程抽取出来，使用专门...
Activiti7工作流程引擎之排他网关
喜羊羊love红太狼
05-03 2621
排他网关定义： 排他网关指当流程 执行到这个网关时，所有分支都会判断条件是否为 true，如果为 true 则执行该分支，如果分支都为true,只选择一个分支去执行。 注意，排他网关只会选择一个为 true 的分支执行(即使有两个分支条件都为 true，排他网关也会只 选择一条分支去执行) 场景： package org.wxy.com.activiti; import java.util.Date; import java.util.HashMap; import ...
ActivitiUtils.zip
05-12
这个是activiti7的封装工具类，是模仿activiti7新加的模块runtime写的，解耦了security，但结合了自己的权限。该工具类没有测试，如要学习请在合适的环境下使用测试，以防破坏原有数据库结构。该工具类旨在让大家更好地学习activiti，而并不是直接拿来使用，而且作者也没有学习几天，所以可能会有错误，所以希望能把这个只当为学习的目录，真正的学习在不断百度中进行，如在正式环境中使用出现问题，作者概不负责！
activiti6.0.0
02-11
学习activiti的部署war包，能快速通过页面来了解流程。能更快懂得activiti。
Activiti 实战工具包
06-29
是我自己整个activiti的搭建和使用过程，所有需要的jar包和插件都包括在里面。。满足activiti开发的一切需求
activiti6.0.rar
03-12
activiti 6.0 编辑器源码修改汉化版本，解压后使用jdk1.8+tomcat7.0即可使用，默认不需要配置数据库，如果需要持久化数据库，请按照官网配置步骤修改
Activiti-6.0.0
05-01
acitiviti6.0集成springboot2.0以上版本，修改之后的源码，下载源码报错
springboot整合activity6_Activiti之排他网关（无废话版）--------------------------------------------（十二）
hunheidaode的博客
05-24 634
1.源码地址：https://github.com/heidaodageshiwo/springbootactivity
Activiti工具包
u014542583的博客
09-24 8994
功能： 1.启动定时工作流 2.根据流程定义id返回流程name 3.根据任务id返回任务执行人 4.根据Assignee查询所有关联的流程实例（包含Comment） 5. 分页查询所有流程实例 6. 根据processInstanceId查询详情 7. 根据BusinessKey查询流程实例 <dependency> <groupId>com.github.appundefined</groupId> <artifactId>acti
activiti个人写的工具类（SpringMVC）
woailol930910的博客
05-10 2252
个人写的工具栏，继续完善中 ，写的有点乱，多多体谅package com.scnjwh.financial.modules.sys.service; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import org.activiti.engi
Activiti 6.0 用户指南：快速入门与配置详解
《Activiti 6.0 用户手册》是 Activiti 开发团队针对其版本 6.0.0 提供的一份详尽指南，旨在帮助用户深入了解和使用 Activiti 这个流程管理平台。该手册分为多个章节，涵盖了从入门到高级配置的全面内容。 1. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

冒菜-码农

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

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

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

打赏作者

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

抵扣说明：

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

余额充值