Activiti工作流教程

最新推荐文章于 2024-05-15 18:43:26 发布
最新推荐文章于 2024-05-15 18:43:26 发布
阅读量6.7k 收藏 61
点赞数 20
文章标签： java activiti
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YoungShuai1995/article/details/119087828
版权

这是篇关于Activiti工作流的教程，此教程通过编码的方式让大家快速掌握Activiti的使用方法，关于Activiti的理论性知识，大家可在学习这篇文章后，自行百度了解，此处不做赘述。

准备工作：IDEA需要安装actibpm插件，该插件在新版本IDEA中搜不到，需要去官网自行下载，然后导入。下载地址：actibpm下载地址，下载完成后是一个actibpm.jar，在IDEA的plugins中点击install plugin from Disk导入jar包即可。

  1. 使用Maven创建一个普通web项目，并导入Activiti及MySQL相关依赖（activiti需要数据库支持才能工作）。下面附上pom文件的相关代码。
	<!--定义版本号-->
    <properties>
        <java.version>1.8</java.version>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.12</log4j.version>
        <activiti.version>7.0.0.Beta1</activiti.version>
    </properties>
    <dependencies>
        <!--activiti核心包-->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-engine</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!--activiti与spring整合的包-->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!--bpmn模型处理-->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-model</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!--bpmn转换-->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-converter</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!--bpmn json数据转换-->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-json-converter</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!--bpmn布局-->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-layout</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!--bpmn云支持-->
        <dependency>
            <groupId>org.activiti.cloud</groupId>
            <artifactId>activiti-cloud-services-api</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.11</version>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <!--连接池-->
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.4</version>
        </dependency>
    </dependencies>
  1. 在resources目录下，创建一个名为log4j.properties的日志配置文件，用于监测activiti工作流的日志信息。log4j.properties的详情配置如下：
log4j.rootCategory=debug,CONSOLE,LOGFILE

log4j.logger.org.apache.axis.enterprise=FATAL,CONSOLE

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r[%15.15t] %-5p %30.30c %x - %m\n

log4j.appender.LOGFILE=org.apache.log4j.FileAppender
#日志的存放路径
log4j.appender.LOGFILE.File=d:\\SOFT\\activiti.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r[%15.15t] %-5p %30.30c %x - %m\n
  1. 使用activiti提供的默认方式来创建mysql的表。默认方式的要求是在resources下创建activiti.cfg.xml文件。具体配置如下所示：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org.schema/context/spring-context.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--dbcp连接池-->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <!--配置数据库相关的信息-->
        <!--数据库驱动-->
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <!--数据库连接-->
        <property name="url" value="jdbc:mysql:///activitidb?serverTimezone=GMT%2B8&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
        <!--数据库用户名-->
        <property name="username" value="root"/>
        <!--数据库密码-->
        <property name="password" value="root"/>
        <property name="maxActive" value="3"/>
        <property name="maxIdle" value="1"/>
    </bean>

    <!--在默认方式下，这个bean的id必须是processEngineConfiguration。配置完这些内容，activiti会到指定的数据库自动生成需要的表-->
    <bean id="processEngineConfiguration"  class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
        <!--引用数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!--activiti生成数据表时的策略 设置为true时：如果数据库存在相应的表，则直接使用，否则创建-->
        <property name="databaseSchemaUpdate" value="true"/>
    </bean>
  1. 在test目录下新建一个类，名字随便起。然后写入以下代码，用于生成activiti所需的25张表。
public class ActivitiUtil {

    /**
     *使用activiti提供的默认方式来创建mysql的表
     */
    @Test
    public void createTable(){
        //执行该方法，会在数据库自动生成activiti所需的25张表
        ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
        System.out.println(engine);
    }
}
  1. 代码执行后，去数据库可以发现已经生成了25张数据表，这些数据表都是以act为前缀的，表明是activiti所需的数据表。其中act_ge_*用于存放通用类型的数据；act_hi_*存放历史数据；act_re_*存放流程定义的内容和所需静态资源；act_ru_*存放activiti运行时所需的数据。
表名解释
act_ge_bytearray通用的流程定义和流程资源
act_ge_property系统相关属性
act_hi_actinst历史的流程实例
act_hi_attachment历史的流程附件
act_hi_comment历史的说明性信息
act_hi_detail历史的流程运行中的细节信息
act_hi_identitylink历史的流程运行过程中用户关系
act_hi_procinst历史的流程实例
act_hi_taskinst历史的任务实例
act_hi_varinst历史的流程运行中的变量信息
act_re_deployment部署单元信息
act_re_model模型信息
act_re_procdef已部署的流程定义
act_ru_event_subscr运行时事件
act_ru_execution运行时流程执行实例
act_ru_identitylink运行时用户关系信息，存储任务节点与参与者的相关信息
act_ru_job运行时作业
act_ru_task运行时任务
act_ru_variable运行时变量表

  1. 观察下面的类关系图，通过activiti.cfg.xml的配置，activiti会生成5个service，用于操作25张表。ReposituryService用来操作act_re_*表，HistoryService用来操作act_hi_*表，RuntimeService用来操作act_ru_*表。
    在这里插入图片描述

  2. 接下来介绍如何在IDEA中创建流程定义。不过在操作之前，大家需要设置IDEA的编码格式，不然在使用bpmn时会出现中文乱码。点击菜单栏Help->Edit Custom VM options，打开文件，在文件的最后一行加入编码格式，如下所示

-Dfile.encoding=UTF-8

准备完毕后，在resources目录下创建bpmn目录，然后在bpmn目录下新建一个bpmn文件，命名随意，但最好有意义。比如我要做请假流程，此处命名为Leave.bpmn。bpmn的内容如下图所示。此处我们设置了3个节点：提交流程申请、部门经理审批和财务审批，对应的执行人分别设置为worker、manager和money。
在这里插入图片描述
在这里插入图片描述

bpmn文件的内容本质为XML文件，我们可以把新建的Leave.bpmn复制并重命名为Leave.bpmn.xml，查看相关的xml内容。其次我们还可以将绘制的流程导出图片，可供业务人员理解。具体如下：右键Leave.bpmn.xml文件，选择Diagrams–Show BPMN 2.0 Designer，弹出的文件就是图片化的流程，然后点击Export to Image File按钮，选择存储路径，就可以将图片保存下来。
在这里插入图片描述

  1. bpmn定义好之后，我们需要把定义好的流程保存到数据库中，通过activiti提供的API即可。在你的test目录的java文件下写入以下代码：
    /**
     * 部署流程定义 文件上传方式
     * 就是把定义好的bpmn，保存到数据库中
     */
    @Test
    public void testDeployment() {
        //创建processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //得到RepositoryService实例
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //使用repositoryService进行部署
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource("bpmn/Leave.bpmn")//添加bpmn资源
                .addClasspathResource("bpmn/Leave.bpmn.png")//添加png资源
                .name("请假申请流程")
                .deploy();
        //输出部署信息
        System.out.println("流程部署Id：" + deployment.getId());
        System.out.println("流程部署名称：" + deployment.getName());
    }
  1. 流程定义好了，数据库也存好了，接下来就要启动定义好的流程了。通过下列代码即可开启一个流程实例：
    /*
     *启动流程实例,相当于开启一个流程
     */
    @Test
    public void testStartProcess() {
        //创建processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //获取RunTimeService
        RuntimeService runtimeService = processEngine.getRuntimeService();
        //启动流程，这个 key是当时定义Leave.bpmn时填写的id(即第一张bpmn图片，左侧蓝色框框中，id对应的值，这个是自定义的)
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("myLeave");
        //输出内容
        System.out.println("流程定义id：" + processInstance.getProcessDefinitionId());
        System.out.println("流程实例id：" + processInstance.getId());
        System.out.println("当前活动id：" + processInstance.getActivityId());
    }
  1. 流程启动成功后，就要查询当前个人待执行的任务，此次任务的执行人分别是worker->manager->money。
    /**
     * 查询当前个人待执行的任务
     */
    @Test
    public void testFindPersonalTaskList() {
        //任务负责人
        String assignee = "worker";
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //创建TaskService
        TaskService taskService = processEngine.getTaskService();
        //根据流程key和任务负责人查询任务。查询流程实例，有没有需要worker执行的节点
        List<Task> list = taskService.createTaskQuery()
                //.processDefinitionKey("myLeave") //可以通过流程的key来查询
                .processInstanceId("25001")        //可以通过某个流程实例的id查询
                .taskAssignee(assignee)
                .list();
        for (Task task : list) {
            System.out.println("流程实例id：" + task.getProcessInstanceId());
            System.out.println("任务id：" + task.getId());
            System.out.println("任务负责人：" + task.getAssignee());
            System.out.println("任务名称：" + task.getName());
        }
    }
  1. 上面代码执行完毕后，如果在控制台打印了内容（注：流程实例id是指这个流程的id，任务id是指当前节点的id），说明这个流程实例，有需要worker处理的节点，所以我们需要worker来完成当前节点，推动流程前进，所以，使用下面的代码，完成当前节点（需要worker执行的工作）。注意：下面代码执行完毕后，worker的工作就完成了，下一个节点需要由manager来完成。
    //完成任务。当worker的任务执行完毕时，该流程向前推进，到了manager需要完成的节点
    @Test
    public void completeTask() {
        //获取引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //获取taskService
        TaskService taskService = processEngine.getTaskService();
        //根据流程key和任务负责人 查询任务
        //返回一个任务对象，查询实例id是25001，执行者是worker的任务
        Task task = taskService.createTaskQuery()
//              .processDefinitionKey("myLeave")
                .processInstanceId("25001")
                .taskAssignee("worker")
                .singleResult();
        //完成任务，参数：任务Id
        taskService.complete(task.getId());
    }
  1. 到目前为止，我们已经学会了通过bpmn定义流程，然后开启一个流程实例，并由相关人员(worker、manager等)推动流程前进。其实在bpmn文件中，我们可以定义多个流程，（虽然可以定义多个流程，但是为了容易理解，最好别这么做。建议一个bpmn定义一个流程，便于理解），接下来，我们通过代码，来查看某个bpmn文件下，定义的所有流程。
    //查询流程定义,一个bpmn可以定义多个流程，该方法就是查询一个bpmn下定义的所有流程
    @Test
    public void queryProcessDefinition() {
        //获取引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //获取repositoryService
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //得到ProcessDefinitionQuery对象
        ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
        //查询出当前所有的流程定义，查询Leave.bpmn文件定义了哪些流程（注意：Leave.bpmn在创建时，我们给他的id是myLeave）
        List<ProcessDefinition> definitionList = processDefinitionQuery.processDefinitionKey("myLeave")
                .orderByProcessDefinitionVersion()
                .desc().list();
        //输出流程定义信息
        for (ProcessDefinition processDefinition : definitionList) {
            System.out.println("流程定义id=" + processDefinition.getId());
            System.out.println("流程定义name=" + processDefinition.getName());
            System.out.println("流程定义key=" + processDefinition.getKey());
            System.out.println("流程定义version=" + processDefinition.getVersion());
            System.out.println("流程部署id=" + processDefinition.getDeploymentId());
        }
    }
  1. 定义完流程后，我们可以开启一个流程实例，也可以同时开启多个流程实例。那么，我们怎么查看一个流程下有多少个正在执行的流程实例呢？可以通过下面的代码来实现：
    //查询某个流程下的所有进行中的流程实例
    @Test
    public void queryProcessInstance() {
        //流程定义key
        String processDefinitionKey = "myLeave";
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //获取RuntimeService
        RuntimeService runtimeService = processEngine.getRuntimeService();
        List<ProcessInstance> list = runtimeService.createProcessInstanceQuery()
                .processDefinitionKey(processDefinitionKey)
                .list();
        for (ProcessInstance processInstance : list) {
            System.out.println("------------------------");
            System.out.println("流程实例id：" + processInstance.getProcessInstanceId());
            System.out.println("所属流程定义id：" + processInstance.getProcessDefinitionId());
            System.out.println("是否执行完成：" + processInstance.isEnded());
            System.out.println("是否暂停：" + processInstance.isSuspended());
            System.out.println("当前活动标识：" + processInstance.getActivityId());
            System.out.println("业务关键字：" + processInstance.getBusinessKey());
        }
    }
  1. 如果后期发现某个流程定义得不对，要把它删除掉，该如何操作呢？注意，删除流程时要留意该流程有没有进行中的流程实例，如果存在流程实例，要使用级联删除才行。
    //删除流程定义
    @Test
    public void deleteDeployment() {
        //流程部署id
        String deploymentId = "2501";
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //通过流程引擎获取repositoryService
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //删除流程定义,如果该流程定义已有流程实例启动，则删除时会报错
        repositoryService.deleteDeployment(deploymentId);
        //设置为true，级联删除流程定义。即使该流程有流程实例启动，也可以删除
        //repositoryService.deleteDeployment(deploymentId, true);
    }
  1. 有时候我们还需要查看bpmn和png文件，观察某个流程包含哪些步骤，可是对于不懂开发的业务人员来说，总不能直接去代码中去看吧！因此，我们可以把bpmn和png从数据库中下载下来，保存在指定的服务器路径下。然后在页面中，通过img标签的形式，把下载的图片展示出来，这样就很方便了。此处只讲解如何从数据库下载文件。（将下载好的文件展示在页面，大家自行解决）。
    //下载bpmn和png文件
    @Test
    public void queryBpmnFile() throws IOException {
        //得到引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //获取repositoryService
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //得到查询器，设置查询条件，得到想要的流程定义
        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
                .processDefinitionKey("myLeave")
                .singleResult();
        //通过流程定义信息，得到部署Id
        String deploymentId = processDefinition.getDeploymentId();
        //通过repositoryService的方法，实现读取图片信息和bpmn信息
        //png图片的流
        InputStream pngInput = repositoryService.getResourceAsStream(deploymentId, processDefinition.getDiagramResourceName());
        //bpmn文件的流
        InputStream bpmnInput = repositoryService.getResourceAsStream(deploymentId, processDefinition.getResourceName());
        //构造OutputStream的流
        File file_png = new File("D:\\Leave.bpmn.png");
        File file_bpmn = new File("D:\\Leave.bpmn");
        FileOutputStream pngOut = new FileOutputStream(file_png);
        FileOutputStream bpmnOut = new FileOutputStream(file_bpmn);
        //输入流、输出流的转换
        IOUtils.copy(pngInput, pngOut);
        IOUtils.copy(bpmnInput, bpmnOut);
        //关闭流
        bpmnOut.close();
        bpmnOut.close();
        bpmnInput.close();
        pngInput.close();
    }
  1. 接下来我们介绍，怎么查看某个流程实例的执行情况，或者是某个流程下的所有实例的执行情况。这种功能很实用，我们可以把查询到的数据显示在页面，可以更直观地观察某个流程实例执行到了哪一步。关于查询流程的执行情况，这里提供了两种方式，第一种：如果查询条件中包含某个流程实例的id，那么就只查看这个流程实例的执行情况，这种情况更实用一些；第二种：如果查询条件中包含某个流程的定义id，那么就查看这个流程下所有流程实例的执行情况，这种情况或许不常用。
    //查询某个流程实例或者某个流程下的所有实例的执行情况
    @Test
    public void findHistoryInfo() {
        //得到引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //获取historyService
        HistoryService historyService = processEngine.getHistoryService();
        //获取actinst表的查询对象
        HistoricActivityInstanceQuery instanceQuery = historyService.createHistoricActivityInstanceQuery();
        //根据流程实例Id，查询单个流程实例的执行情况
        instanceQuery.processInstanceId("5001");
        //根据流程定义ID，查询该流程所有实例的执行情况
        //instanceQuery.processDefinitionId("myLeave:1:2504");
        instanceQuery.orderByHistoricActivityInstanceStartTime().asc();
        //查询所有内容
        List<HistoricActivityInstance> activityInstanceList = instanceQuery.list();
        //输出
        for (HistoricActivityInstance hi : activityInstanceList) {
            System.out.println(hi.getActivityId());
            System.out.println(hi.getActivityName());
            System.out.println(hi.getProcessDefinitionId());
            System.out.println(hi.getProcessInstanceId());
            System.out.println("-------------------------");
        }
    }

总结：到目前为止，我们已经学习了activiti的基础操作，对于activiti数据库那几张常用的表大家最好能够知道，了解表结构后，出了问题也是容易排查的。另外，activiti虽然提供了工作流引擎的能力，但是在前端页面的展示功能，activiti是没有提供的，如果想要在页面更直观的查看流程的执行情况，还是要和前端交互。网上有不少activiti与前端整合的案例，大家可以参考，搭建属于自己的工作流框架。废话不多说，接下来我们介绍下activiti更高级的使用。

  1. 在开始前，大家需要明白两个概念，ProcessDefinition代表流程定义，ProcessInstance代表流程实例。流程定义ProcessDefinition是以BPMN文件定义的一个工作流程，是一组工作规范，例如我们之前定义的请假流程。流程实例ProcessInstance则是指一个具体的业务流程。例如某个员工发起一次请假，就会实例化一个请假的流程实例，并且每个不同的流程实例之间是互不影响的。另外，activiti是一个专注于工作流程的框架，它和我们的业务是完全分离的，可是在实际应用中，一个流程必须要依赖于系统业务，因此，我们就需要把流程与业务整合在一起，说白了，就是把业务id存入流程实例表中，形成对应关系。
    //启动一个流程实例时，和业务绑定起来
    @Test
    public void addBusinessKey() {
        //获取流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //获取RuntimeService
        RuntimeService runtimeService = processEngine.getRuntimeService();
        //启动流程实例的过程中，添加businesskey
        //第一个参数：流程定义的key   第二个参数：业务关键字
        ProcessInstance instance = runtimeService.startProcessInstanceByKey("myLeave", "yeWuId");
        //输出
        System.out.println("businessKey:" + instance.getBusinessKey());
    }
  1. 挂起、激活流程实例：有很多时候，我们需要暂时停止一个流程，过一段时间就要恢复。例如月底不接受报销审批流程，年底不接受借贷审批流程，或者非工作日不接受售后报销流程等，这个时候，就可以将流程进行挂起操作。挂起后的流程就不会再继续执行。
    在挂起流程时，有两种操作方式：一种是挂起流程定义，此时该流程定义下的所有流程实例都不可执行；另一种是挂起某个流程实例，对其他流程实例是没有影响的。注意：如果流程定义或者流程实例挂起后，在挂起状态下推动流程实例是会抛出异常的。
    //全部流程实例的 挂起和激活
    @Test
    public void suspendAllProcessInstance() {
        //获取流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //获取repositoryService
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //查询流程定义，获取流程定义的查询对象
        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
                .processDefinitionKey("myLeave")
                .singleResult();
        //查询当前流程定义的实例是否都是挂起状态,true表示已挂起，false表示未挂起
        boolean suspended = processDefinition.isSuspended();
        //获取流程定义的id
        String definitionId = processDefinition.getId();
        //如果是挂起状态，改为激活状态
        if (suspended) {
            //如果是挂起，可以执行激活的操作。参数1：流程定义id;参数2:是否激活；参数3：激活时间
            repositoryService.activateProcessDefinitionById(definitionId, true, null);
            System.out.println("流程定义id：" + definitionId + "，已激活");
        } else {
            //如果是激活状态，改为挂起状态。参数1：流程定义id;参数2:是否暂停；参数3：暂停时间
            repositoryService.suspendProcessDefinitionById(definitionId, true, null);
            System.out.println("流程定义id：" + definitionId + "，已挂起");
        }
    }


    //挂起和激活单个流程实例
    @Test
    public void suspendSingleProcessInstance() {
        //获取流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //runtimeService
        RuntimeService runtimeService = processEngine.getRuntimeService();
        //查询流程实例，获取流程实例的查询对象
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
                .processInstanceId("5001")
                .singleResult();
        //查询当前流程定义的实例是否都是挂起状态,true表示已挂起，false表示未挂起
        boolean suspended = processInstance.isSuspended();
        //获取流程实例的id
        String instanceId = processInstance.getId();
        //如果是挂起状态，改为激活状态
        if (suspended) {
            //如果是挂起，可以执行激活的操作
            runtimeService.activateProcessInstanceById(instanceId);
            System.out.println("流程实例id：" + instanceId + "，已激活");
        } else {
            //如果是激活状态，改为挂起状态
            runtimeService.suspendProcessInstanceById(instanceId);
            System.out.println("流程实例id：" + instanceId + "，已挂起");
        }
    }
  1. 流程变量的概念
    流程变量是Activiti中非常重要的角色。我们之前定义的请假流程并没有用到流程变量，每个步骤都是非常固定的，但是，当我们需要实现一些复杂的业务流程，比如出差3天以内由部门经理审批，3天以上需要增加总经理审批这样的流程时，就需要用到流程变量了。流程变量不仅可以动态控制流程走势，还能通过变量动态地设置任务节点的负责人，这种情况在实际工作中是很常见的。

注：流程变量和之前介绍的业务关键字其实是有些相似的，都可以携带业务信息。并且也都可以通过activiti的api查询出来。但是通常在使用过程中，应该尽量减少流程变量中的业务信息，这样能够减少业务代码对activiti工作流的代码侵入。
流程变量的类型是Map<String,Object>。变量值不仅可以是字符串，也可以是POJO对象。但是当需要将一个POJO对象放入流程变量时，要注意这个对象必须实现序列化接口Serializable。流程变量的作用域有2种：Global变量和Local变量。Global是流程变量的默认作用域，作用范围是整个流程实例，Global变量中的变量名不能重复，如果设置了相同的变量名，后面设置的值会覆盖之前设置的变量值。Local的作用域只针对一个任务(节点)，Local变量名可以和Global变量名相同，不会有影响。
在介绍流程变量的使用方法之前，我们先定义一个有分支情况的请假流程，如下图所示。
在这里插入图片描述
在这里插入图片描述

  1. bpmn定义好流程之后，我们要使用代码，把流程部署到数据库。这个代码和之前部署流程的代码一样的。
    //部署流程
    @Test
    public void testDeployment() {
        //创建processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //得到RepositoryService实例
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //使用repositoryService进行部署
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource("bpmn/evection-global.bpmn")//添加bpmn资源
                .name("出差申请流程-variables")
                .deploy();
        //输出部署信息
        System.out.println("流程部署Id：" + deployment.getId());
        System.out.println("流程部署名称：" + deployment.getName());
    }
  1. 流程部署完毕后，就可以开启一个流程实例。要注意，此处开启流程实例时，和之前不同，此处使用了流程变量，流程变量的值，与bpmn中设置了UEL表达式的地方是对应的。开启流程后，完成任务(推动节点)等操作就与之前的代码是一样的，这里就不再写出来了。
    //启动实例
    @Test
    public void testStartProcess() {
        //创建processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //获取RunTimeService
        RuntimeService runtimeService = processEngine.getRuntimeService();
        //流程定义的key
        String key = "myEvection";
        //流程变量的map
        Map<String, Object> variables = new HashMap<String, Object>();
        //设置流程变量
        Evection evection = new Evection();
        //出差2天。这记得bpmn中定义的${evection.num}吗？用于控制流程的执行逻辑
        evection.setNum(2d);//这里的值如果大于等于3，就会走不同的分支
        //通过evection.num来判断执行流程
        variables.put("evection", evection);
        //bpmn文件中，使用uel定义的任务负责人。使用流程变量动态设置负责人
        variables.put("assignee0", "李四");
        variables.put("assignee1", "王经理");
        variables.put("assignee2", "杨总经理");
        variables.put("assignee3", "张财务");
        //启动流程
        runtimeService.startProcessInstanceByKey(key, variables);
    }
  1. 接下来我们学习网关。网关是用来控制流程流向的重要组件，通常都会结合流程变量来使用。 使用网关可以更好地控制流程走势，其优势比单纯使用连线的condition条件来控制走势更为显著。网关有4种类型：排他网关ExclusiveGateWay，并行网关ParallelGateway，包含网关InclusiveGateway和事件网关EventGateway，前三种网关比较常用，事件网关太过复杂，使用情况较少。下面分别介绍这几种网关：

注意： 排他网关只会选择一个为true的分支执行。如果有两个分支条件都为true，排他网关会选择id值(节点的id)较小的一条分支渠执行。如果从网关出去的线所有条件都不满足则系统抛出异常，排他网关的图片如下所示：在这里插入图片描述
这个流程定义和刚才定义的出差流程是一样的，只不过引入了网关这个组件。具体的流程定义细节如下所示，先从右侧组件栏拖出组件，画出各个流程节点，并给本次流程定义id和Name赋值：
在这里插入图片描述
然后点击流程节点，依次给流程节点的Name和Assignee属性赋值。此处的Assignee写死了，大家也可以使用流程变量，动态地设置节点负责人：
在这里插入图片描述
最后我们给连线添加判断条件来控制流程走势：
在这里插入图片描述
进行到这里，带网关的出差流程就定义完毕了。大家可以参考之前的代码，把定义的出差流程部署到数据库中，然后启动一个流程实例(不要忘记给evection.num赋值)，并推动流程节点前进就可以了，此处就不做赘述了。

  1. 并行网关
    并行网关允许将流程分成多条分支，也可以把多条分支汇聚到一起，并行网关的功能是基于进入和外出顺序流的：
    fork分支：并行后的所有外出顺序流，为每个顺序流都创建一个并发分支。
    join汇聚：所有到达并行网关，在此等待的进入分支，直到所有进入顺序流的分支都到达以后，流程才会通过汇聚网关。

注意：如果一个并行网关有多个进入和多个外出顺序流，它就同时具有分支和汇聚功能。这时，网关会先汇聚所有进入的顺序流，然后再切分成多个并行分支。与其他网关的主要区别是，并行网关不会解析条件。即使顺序流中定义了条件，也会被忽略。在这里插入图片描述

  1. 包含网关
    包含网关可以看做排他网关和并行网关的结合体。和排他网关一样，可以在外出顺序流上定义条件，包含网关会解析它们。但是主要区别在于包含网关可以选择多于一条顺序流，和并行网关一样。
    包含网关的功能是基于进入和外出顺序流的：
    分支：所有外出顺序流的条件都会被解析，结果为true的顺序流会以并行方式继续执行，会为每个顺序流创建一个分支。
    汇聚：所有并行分支到达网关，会进入等待状态，直到每个包含流程token的进入顺序流的分支都到达。这是与并行网关的最大不同，换句话说，包含网关只会等待被选中执行了的进入顺序流。在汇聚之后，流程会穿过包含网关继续执行。

在这里插入图片描述

  1. 结语：到这里我们就把activiti常用的功能介绍完毕了，还有一些其他的功能没有讲到，比如一个节点设置多个候选人，候选人认领、归还和交接任务等，这些功能在后期后进行完善。
小Y先生。
关注
  • 20
    点赞
  • 踩
  • 61
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 7
    评论
Activiti工作流
W2014200746的博客
06-26 975
Activiti工作流 一：Activiti第一天 1：工作流的概念 说明： 1) 假设：这两张图就是华谊兄弟的请假流程图 2) 图的组成部分： A. 人物：范冰冰 冯小刚 王中军 B. 事件（动作）：请假、批准、不批准 工作流(Workflow)，就是“业务过程的部分或整体在计算机应用环境下的自动化”，它主要解决的是“使在多个参与者之间按照某种预定义的规则传递文档、信息
activiti工作流教程视频+demo+文档
03-10
Activiti 是一个开源的工作流程引擎，它主要用于设计、部署和...总之，通过这个“Activiti 工作流教程视频+demo+文档”学习，你将能够熟练地使用 Activiti 构建和管理企业级的工作流系统，提升企业的业务自动化水平。
Activiti7-工作流教程
tangyb828的博客
12-26 468
一、工作流介绍 1.1 概念 工作流(Workflow)，就是通过计算机对业务流程自动化执行管理。它主要解决的是“使在多个参与者之间按照某种预定义的规则自动进行传递文档、信息或任务的过程，从而实现某个预期的业务目标，或者促使此目标的实现”。 案例: 出差费用报销 目标: 公司把出差费用转账到自己的账户中. 参与人: 申请人、部门主管、总经理、财务 传递文件/执行任务 什么是工作流系统？ 一个软件系统中具有工作流的功能，我们把它称为工作流系统。 1.2 适用行业 消费品行业，制造业，电信服务业，银证险等金
2024全网最全Activiti7教程03(Activiti7基本操作-欢迎收藏)
最新发布
2401_83977696的博客
05-15 263
1、看视频进行系统学习这几年的Crud经历，让我明白自己真的算是菜鸡中的战斗机，也正因为Crud，导致自己技术比较零散，也不够深入不够系统，所以重新进行学习是很有必要的。我差的是系统知识，差的结构框架和思路，所以通过视频来学习，效果更好，也更全面。关于视频学习，个人可以推荐去B站进行学习，B站上有很多学习视频，唯一的缺点就是免费的容易过时。2、读源码，看实战笔记，学习大神思路“编程语言是程序员的表达的方式，而架构是程序员对世界的认知”。所以，程序员要想快速认知并学习架构，读源码是必不可少的。
Activiti7工作流—从零到实战
热门推荐
东风麦芽糖
03-26 2万+
Activity7、工作流实现方式、工作流实现原理、BPM、BPMN、部署 activity、IDEA配置activity、eclipse配置activity、Activiti Designer 流程设计器、Activiti 服务架构、流程定义、流程实例、流程变量、组任务、排他网关、并行网关
Activiti 工作流简介
小石潭记丶
03-16 8082
工作流(Workflow)，就是通过计算机对业务流程自动化执行管理。它主要解决的是“使在多个参与者之间按照某种预定义的规则自动进行传递文档、信息或任务的过程，从而实现某个预期的业务目标，或者促使此目标的实现”。
Activiti 工作流使用快速入门
weixin_61757095的博客
09-02 1990
Activiti 是一个针对业务人员、开发人员和系统管理员的轻量级工作流和业务流程管理 (BPM) 平台。 它的核心是一个用于 Java 的超快速和坚如磐石的 BPMN 2 流程引擎。 它是开源的，并在 Apache 许可下分发。 Activiti 可以在任何 Java 应用程序、服务器、集群或云中运行。 它与 Spring 完美集成，非常轻量级，基于简单的概念。
Activity工作流学习笔记
weixin_51306597的博客
07-03 2556
本文章为博主在学习Activity工作流的一些笔记，便于后期复习等
Activit7 工作流应用+实战（全网最详细最全，篇幅巨长，蹲坑别看）
增强分享精神，维护良好的编程环境，传递你我他
06-19 7970
应公司要求，需要研究项目中的框架 activiti7 ，所以有了下面这些内容。本文篇幅巨长，觉得想简单点儿的可以从下面的链接去专题查看：下面流程中涉及两个人和三个人的大致所需步骤： 报销流程和请假流程、采购—>入库 以下是工作流各节点各状态的示意图： Activiti 是一套使用人数最多的、技术成熟的、适应多种数据库的工作流框架。所有需要流程管理的地方都要用到工作流。下面是一些相关的官方地址，点击进入即可获得：Activiti 官网Activiti 官方入门教程：Activiti User Guide在线
Activiti工作流视频教程
08-28
activiti工作流视频教程，对学习工作流的小伙伴来说。非常不错。
Activiti工作流详解完整教程
10-10
Activiti工作流详解完整教程, 1) JDK1.6或者更高版本 2) 支持的数据库有:h2,mysql,oracle,mysql,db2等 3) 支持Activiti运行的jar包，可以通过maven依赖引入 4) 开发环境为Eclipse3.7或者以上版本，myeclipse为8.6版本
工作流简单教程,很详细
11-12
工作流简单教程,很详细工作流简单教程,很详细工作流简单教程,很详细工作流简单教程,很详细工作流简单教程,很详细工作流简单教程,很详细
Activiti工作流基础教程
01-22
Activiti工作流基础教程 eclipse 一步步实现。有截图
activity工作流
10-14
activety工作流，用于复杂的状态改变，适合复杂的流程。
Activiti工作流详细讲解完整教程.pdf
07-02
Activiti工作流详细讲解完整教程.pdf
传智播客Activiti工作流教程
09-01
这是传智播客教师主讲的Activiti工作流视频教程，学习这套视频，可以对工作流有一个全面了解。
activiti工作流教程
05-12
Activiti 是一个基于 Java 的开源工作流引擎，可以用来设计、部署和执行各种工作流和业务流程。以下是 Activiti 工作流的基础教程： 1. 安装 Activiti 首先，你需要下载 Activiti 的安装包，并按照安装指南进行安装。你可以在 Activiti 官网上下载最新版本的安装包。 2. 创建工作流 使用 Activiti Designer 工具来创建工作流。Activiti Designer 是一个 Eclipse 插件，可以轻松地创建 BPMN 2.0 标准的工作流。 3. 部署工作流 使用 Activiti Explorer 工具来部署工作流。Activiti Explorer 是一个基于 Web 的用户界面，可以帮助你管理工作流程定义和实例，以及任务列表和历史记录。 4. 执行工作流 使用 Activiti Engine 来执行工作流。Activiti Engine 是一个 Java 库，可以用来启动和执行工作流实例。 5. 监控工作流 使用 Activiti Explorer 或 Activiti Engine 来监控工作流。你可以查看工作流程实例的状态和活动，以及任务列表和历史记录。 以上是 Activiti 工作流的基础教程，你可以通过阅读 Activiti 官方文档来深入了解 Activiti 工作流的更多功能和用法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小Y先生。

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

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

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

打赏作者

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

抵扣说明：

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

余额充值