• Activiti工作流入门

    1.创建activiti项目

    2.导包+配置文件

    1.     
    2.     <properties>
    3.         <slf4j.version>1.6.6slf4j.version>
    4.         <log4j.versoin>1.2.12log4j.versoin>
    5.         <activiti.version>7.0.0.Beta1activiti.version>
    6.     properties>
    7.  
    8.     <dependencies>
    9.         <dependency>
    10.             <groupId>org.activitigroupId>
    11.             <artifactId>activiti-engineartifactId>
    12.             <version>${activiti.version}version>
    13.         dependency>
    14.         <dependency>
    15.             <groupId>org.activitigroupId>
    16.             <artifactId>activiti-springartifactId>
    17.             <version>${activiti.version}version>
    18.         dependency>
    19.         
    20.         <dependency>
    21.             <groupId>org.activitigroupId>
    22.             <artifactId>activiti-bpmn-modelartifactId>
    23.             <version>${activiti.version}version>
    24.         dependency>
    25.         
    26.         <dependency>
    27.             <groupId>org.activitigroupId>
    28.             <artifactId>activiti-bpmn-converterartifactId>
    29.             <version>${activiti.version}version>
    30.         dependency>
    31.         
    32.         <dependency>
    33.             <groupId>org.activitigroupId>
    34.             <artifactId>activiti-json-converterartifactId>
    35.             <version>${activiti.version}version>
    36.         dependency>
    37.         
    38.         <dependency>
    39.             <groupId>org.activitigroupId>
    40.             <artifactId>activiti-bpmn-layoutartifactId>
    41.             <version>${activiti.version}version>
    42.         dependency>
    43.         
    44.         <dependency>
    45.             <groupId>org.activiti.cloudgroupId>
    46.             <artifactId>activiti-cloud-services-apiartifactId>
    47.             <version>${activiti.version}version>
    48.         dependency>
    49.         
    50.         <dependency>
    51.             <groupId>mysqlgroupId>
    52.             <artifactId>mysql-connector-javaartifactId>
    53.             <version>5.1.47version>
    54.         dependency>
    55.         
    56.         <dependency>
    57.             <groupId>org.mybatisgroupId>
    58.             <artifactId>mybatisartifactId>
    59.             <version>3.4.5version>
    60.         dependency>
    61.         
    62.         <dependency>
    63.             <groupId>commons-dbcpgroupId>
    64.             <artifactId>commons-dbcpartifactId>
    65.             <version>1.4version>
    66.         dependency>
    67.         <dependency>
    68.             <groupId>junitgroupId>
    69.             <artifactId>junitartifactId>
    70.             <version>4.12version>
    71.         dependency>
    72.         
    73.         <dependency>
    74.             <groupId>log4jgroupId>
    75.             <artifactId>log4jartifactId>
    76.             <version>${log4j.versoin}version>
    77.         dependency>
    78.         <dependency>
    79.             <groupId>org.slf4jgroupId>
    80.             <artifactId>slf4j-apiartifactId>
    81.             <version>1.6.6version>
    82.         dependency>
    83.         <dependency>
    84.             <groupId>org.slf4jgroupId>
    85.             <artifactId>slf4j-log4j12artifactId>
    86.             <version>1.6.6version>
    87.         dependency>
    88.         <dependency>
    89.             <groupId>commons-iogroupId>
    90.             <artifactId>commons-ioartifactId>
    91.             <version>2.6version>
    92.         dependency>
    93.     dependencies>

     activiti.cfg.xml

    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xmlns:context="http://www.springframework.org/schema/context"
    5.        xmlns:tx="http://www.springframework.org/schema/tx"
    6.        xsi:schemaLocation="http://www.springframework.org/schema/beans
    7.                     http://www.springframework.org/schema/beans/spring-beans.xsd
    8. http://www.springframework.org/schema/contex
    9. http://www.springframework.org/schema/context/spring-context.xsd
    10. http://www.springframework.org/schema/tx
    11. http://www.springframework.org/schema/tx/spring-tx.xsd">
    12.  
    13.     
    14.     
    15.         
    16.         
    17.         
    18.         
    19.         
    20.         
    21.     
    22.     
    23.  
    24.     <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
    25.         
    26.         <property name="jdbcDriver" value="com.mysql.jdbc.Driver" />
    27.          <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/activiti" />
    28.          <property name="jdbcUsername" value="root" />
    29.          <property name="jdbcPassword" value="root" />
    30.  
    31.         
    32.  
    33.         
    34.         <property name="databaseSchemaUpdate" value="true"/>
    35.  
    36.     bean>
    37. beans>

    3. 安装bpmn插件

    4.创建mysql的25张表

    1.     /**
    2.      * 使用activiti提供的默认方式来创建mysql表
    3.      */
    4.     @Test
    5.     public void testCreateDbtable() {
    6.         //需使用acti提供的工具类
    7.         //getDefaultProcessEngine会默认从resource中读取名为activiti.cfg.xml的文件
    8.         //创建processEngine时，就会创建mysql的表
    9.  
    10.         /**
    11.          * 2种创建方式
    12.          */
    13.         //默认方式
    14.         //ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();  //工作流引擎创建
    15.         //System.out.println(processEngine);
    16.  
    17.         //使用自定义方式
    18.         //配置文件的名字可以自定义,bean的名字也可以自定义
    19.         ProcessEngineConfiguration processEngineConfigurationFromResource =
    20.                 ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml", "processEngineConfiguration");
    21.         //获取流程引擎
    22.         ProcessEngine processEngine = processEngineConfigurationFromResource.buildProcessEngine();
    23.         System.out.println(processEngine);
    24.  
    25.         /**
    26.          * 通过processEngine创建service
    27.          * repositoryService: acti资源管理类：管理控制流程发布和流程定义
    28.          * RuntimeService: acti流程运行管理类：获取流程执行信息
    29.          * TaskService: acti任务管理类：获取任务信息
    30.          * HistoryService: acti历史管理类：查询历史信息
    31.          * ManagerService: acti引擎管理类：对Acti引擎管理和功能维护
    32.          */
    33.         RepositoryService repositoryService = processEngine.getRepositoryService();
    34.     }

    5.创建Activiti工作流

    1.定义流程，按照BPMN规范，使用流程定义工具，用流程符号把整个流程描述出来
    2.部署流程，把画好的流程定义文件，加载到数据库中，生成表的数据
    3.启动流程，使用代码操作数据库表中的内容
    5.1流程符号

    各网关详解：排他网关（Exclusive Gateway） | AWS BPMN2 Gateway参考指南

    5.2流程设计器使用

    Activiti-Designr使用：16-入门-使用idea流程设计器设计流程_哔哩哔哩_bilibili

    6.流程定义

    使用designer设计器绘制流程，生成.bpmn和.png

    1.将.bpmn文件拷贝桌面保存，并把原bmpn文件改成.xml后缀，点击右键生成图片

    2.导出桌面png文件

    3.将生成的png放回bpmn包下

    4.把xml后缀改回bpmn

    5.activiti模块简介

    1. package com.xuy.test;
    2.  
    3. import org.activiti.engine.*;
    4. import org.activiti.engine.history.HistoricActivityInstance;
    5. import org.activiti.engine.history.HistoricActivityInstanceQuery;
    6. import org.activiti.engine.repository.Deployment;
    7. import org.activiti.engine.repository.ProcessDefinition;
    8. import org.activiti.engine.repository.ProcessDefinitionQuery;
    9. import org.activiti.engine.runtime.ProcessInstance;
    10. import org.activiti.engine.task.Task;
    11. import org.apache.commons.io.IOUtils;
    12. import org.junit.Test;
    13.  
    14. import java.io.File;
    15. import java.io.FileOutputStream;
    16. import java.io.IOException;
    17. import java.io.InputStream;
    18. import java.util.List;
    19. import java.util.zip.ZipInputStream;
    20.  
    21. public class ActivitiDemo {
    22.  
    23.     /**
    24.      * 测试流程部署
    25.      */
    26.     @Test
    27.     public void testDeployment() {
    28.         //1.创建ProcessEngine
    29.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    30.         //2.获取RepoService
    31.         RepositoryService repositoryService = processEngine.getRepositoryService();
    32.         //3.使用service进行流程部署，定义一个流程名字，把bpmn和png部署到数据库中
    33.         Deployment deploy = repositoryService.createDeployment()
    34.                 .name("出差申请流程")
    35.                 .addClasspathResource("bpmn/evection.bpmn")
    36.                 .addClasspathResource("bpmn/evection.png")
    37.                 .deploy();
    38.         //4.输出部署信息
    39.         System.out.println("流程部署id=" + deploy.getId());
    40.         System.out.println("流程部署名字=" + deploy.getName());
    41.     }
    42.  
    43.     /**
    44.      * 启动流程实例
    45.      */
    46.     @Test
    47.     public void testStartProcess() {
    48.         //1.创建ProcessEngine
    49.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    50.         //2.获取Runtimeservice
    51.         RuntimeService runtimeService = processEngine.getRuntimeService();
    52.         //3.根据流程定义的id启动流程‘
    53.         ProcessInstance instance = runtimeService.startProcessInstanceByKey("myEvection");
    54.         //4.输出内容
    55.         System.out.println("流程定义id:" + instance.getProcessDefinitionId());
    56.         System.out.println("流程实例id:" + instance.getId());
    57.         System.out.println("当前活动id:" + instance.getActivityId());
    58.     }
    59.  
    60.  
    61.     /**
    62.      * 查询个人待执行任务
    63.      */
    64.     @Test
    65.     public void testFindPersonalTaskList() {
    66.         //1.获取流程引擎
    67.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    68.         //2.获取taskService
    69.         TaskService taskService = processEngine.getTaskService();
    70.         //3.根据流程key 和 任务的负责人查询任务
    71.         List taskList = taskService.createTaskQuery()
    72.                 .processDefinitionKey("myEvection") //流程key
    73.                 .taskAssignee("创建")  //要查询的负责人
    74.                 .list();
    75.         //4.输出
    76.         for (Task task : taskList) {
    77.             System.out.println("流程实例id=" + task.getProcessDefinitionId());
    78.             System.out.println("任务id=" + task.getId());
    79.             System.out.println("任务负责人=" + task.getAssignee());
    80.             System.out.println("任务名称=" + task.getName());
    81.         }
    82.     }
    83.  
    84.     /**
    85.      * 完成个人任务
    86.      */
    87.     @Test
    88.     public void completTask() {
    89.         //1.获取流程引擎
    90.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    91.         //2.获取taskService
    92.         TaskService taskService = processEngine.getTaskService();
    93.         //3.根据任务id,完成创建人任务
    94.  
    95.         //获取经理 -myEvection对应的任务
    96.         Task task = taskService.createTaskQuery()
    97.                 .processDefinitionKey("myEvection")
    98.                 .taskAssignee("经理")
    99.                 .singleResult();    //只是获取单个任务，要获取所有任务，导出list后完成即可
    100.         taskService.complete(task.getId()); //完成经理的任务
    101.  
    102.         //获取总经理 -myEvection对应的任务
    103.         Task task2 = taskService.createTaskQuery()
    104.                 .processDefinitionKey("myEvection")
    105.                 .taskAssignee("总经理")
    106.                 .singleResult();
    107.         taskService.complete(task2.getId()); //完成总经理的任务
    108.  
    109.         //获取财务 -myEvection对应的任务
    110.         Task task3 = taskService.createTaskQuery()
    111.                 .processDefinitionKey("myEvection")
    112.                 .taskAssignee("财务")
    113.                 .singleResult();
    114.         taskService.complete(task3.getId()); //完成财务的任务
    115.     }
    116.  
    117.     /**
    118.      * 使用zip包进行批量部署
    119.      */
    120.     @Test
    121.     public void deployProcessByZip() {
    122.         //获取流程引擎
    123.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    124.         //获取RepoService
    125.         RepositoryService repositoryService = processEngine.getRepositoryService();
    126.         //流程部署
    127.         //读取资源包文件，构造成inputStream
    128.         InputStream inputStream = this.getClass()
    129.                 .getClassLoader()
    130.                 .getResourceAsStream("bpmn/evection.zip");
    131.         //用inputStream构造ZipInputStream
    132.         ZipInputStream zipInputStream = new ZipInputStream(inputStream);
    133.         //使用压缩包的流进行流程的部署
    134.         Deployment deploy = repositoryService.createDeployment()
    135.                 .addZipInputStream(zipInputStream)
    136.                 .deploy();
    137.         System.out.println("流程部署的id" + deploy.getId());
    138.         System.out.println("流程部署的名称" + deploy.getName());
    139.     }
    140.  
    141.     /**
    142.      * 查询流程定义
    143.      */
    144.     @Test
    145.     public void queryProcessDefinition() {
    146.         //获取流程引擎
    147.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    148.         //获取RepoService
    149.         RepositoryService repositoryService = processEngine.getRepositoryService();
    150.         //获取ProcessDifintionQuery对象
    151.         ProcessDefinitionQuery definitionQuery = repositoryService.createProcessDefinitionQuery();
    152.         //查询当前所有的流程定义,返回流程定义信息的集合
    153.         List definitionList = definitionQuery.processDefinitionKey("myEvection")
    154.                 .orderByProcessDefinitionVersion()
    155.                 .desc()
    156.                 .list();
    157.         //输出信息
    158.         for (ProcessDefinition processDefinition : definitionList) {
    159.             System.out.println("流程定义id=" + processDefinition.getId());
    160.             System.out.println("流程定义名称=" + processDefinition.getName());
    161.             System.out.println("流程定义key=" + processDefinition.getKey());
    162.             System.out.println("流程定义版本=" + processDefinition.getVersion());
    163.             System.out.println("流程定义部署id=" + processDefinition.getDeploymentId());
    164.         }
    165.     }
    166.  
    167.     /**
    168.      * 流程删除部署信息
    169.      * 当前的流程如果并没有完成，想删除需要使用特殊方式，级联删除
    170.      */
    171.     @Test
    172.     public void deleteDeployment() {
    173.         //流程部署id
    174.         String deploymentId = "1";
    175.         //获取流程引擎
    176.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    177.         //获取RepoService
    178.         RepositoryService repositoryService = processEngine.getRepositoryService();
    179.         //删除流程定义，如果该流程定义已有流程实例启动则删除时出错
    180.         //设置true级联删除流程定义，即使该流程有流程实例启动也可以删除，设置为false非级别删除方式，
    181.         repositoryService.deleteDeployment(deploymentId);
    182.         //级联删除
    183.         repositoryService.deleteDeployment(deploymentId, true);
    184.     }
    185.  
    186.     /**
    187.      * 下载资源
    188.      * 方案1：使用activiti提供的api，下载资源文件
    189.      * 方案2：自己写代码从数据库下载文件，使用jdbc对blob类型，clob类型的数据读取出来，保存到文件目录
    190.      * 解决IO操作：导入 commons-io.jar
    191.      */
    192.     @Test
    193.     public void download() throws IOException {
    194.         //1.获取流程引擎
    195.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    196.         //2.获取RepoService
    197.         RepositoryService repositoryService = processEngine.getRepositoryService();
    198.         //3.获取ProcessDefintionQuery对象
    199.         ProcessDefinitionQuery definitionQuery = repositoryService.createProcessDefinitionQuery();
    200.         ProcessDefinition definition = definitionQuery.processDefinitionKey("myEvection").singleResult();
    201.         //4.查询流程定义，获取部署id
    202.         String deploymentId = definition.getDeploymentId();
    203.         //5.通过repoService，传递部署id参数，读取资源信息（png和bpmn）
    204.         //获取png图片流,从流程定义表中，获取png图片的目录和名字，通过部署id和文件名来获取图片的资源
    205.         String pngName = definition.getDiagramResourceName();
    206.         InputStream pngInput = repositoryService.getResourceAsStream(deploymentId, pngName);
    207.         //获取bpmn流
    208.         String bpmnName = definition.getResourceName();
    209.         InputStream bpmnInput = repositoryService.getResourceAsStream(deploymentId, bpmnName);
    210.         //6.构造outputStream流
    211.         File pngFile = new File("dir:/evectionflow.png");
    212.         File bpmnFile = new File("dir:/evectionflow.bpmn");
    213.         FileOutputStream pngOutputStream = new FileOutputStream(pngFile);
    214.         FileOutputStream bpmnOutputStream = new FileOutputStream(bpmnFile);
    215.         //7.输入流，输出流转换
    216.         IOUtils.copy(pngInput, pngOutputStream);
    217.         IOUtils.copy(bpmnInput, bpmnOutputStream);
    218.         //8.关闭流
    219.         pngOutputStream.close();
    220.         bpmnOutputStream.close();
    221.         pngInput.close();
    222.         bpmnInput.close();
    223.     }
    224.  
    225.     /**
    226.      * 查看历史签核信息
    227.      */
    228.     @Test
    229.     public void findHistoryInfo() {
    230.         //获取流程引擎
    231.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    232.         //获取HisService
    233.         HistoryService historyService = processEngine.getHistoryService();
    234.         //获取actinst表的查询对象
    235.         HistoricActivityInstanceQuery instanceQuery = historyService.createHistoricActivityInstanceQuery();
    236.         //构建查询条件
    237.         instanceQuery.processInstanceId("2501").orderByHistoricActivityInstanceStartTime();
    238.         instanceQuery.processDefinitionId("defintionId");
    239.         //查询所有内容
    240.         List activityInstanceList = instanceQuery.list();
    241.         //输出
    242.         for (HistoricActivityInstance hi : activityInstanceList) {
    243.             System.out.println(hi.getActivityId());
    244.             System.out.println(hi.getActivityName());
    245.             System.out.println(hi.getProcessDefinitionId());
    246.             System.out.println(hi.getProcessInstanceId());
    247.         }
    248.     }
    249. }

  • 相关阅读:
    【AI视野·今日NLP 自然语言处理论文速览 四十九期】Fri, 6 Oct 2023
    使用java.util.Timer实现定时任务，详解Thread.sleep() in a loop, probably busy-waiting问题
    使用ffmpeg解码音频sdl（push）播放
    【done】剑指 Offer 53 - II：0～n-1中缺失的数字
    Matlab之当前路径与上一级路径的符号使用
    聚星文社怎么下载聚星文社ai工具安装教程
    Lua速成（1）
    【问题记录】防止mimikatz获取到明文密码
    代码随想录二刷day41
    Vulkan并非“灵药“
  • 原文地址：https://blog.csdn.net/xy294636185/article/details/126197788