资讯专栏INFORMATION COLUMN

上云采购季！| 2核2G4M爆款云服务器低至59元/年，更有多台、长期优惠，快来选购！

立即前往
首页/文章专栏/activiti个人学习总结

activiti个人学习总结

hufeng / 2314人阅读

摘要：事实也确实如此，可以配置数据库，其中存储了流程运行时的相关信息。在初学之时，了解所有的数据库表的含义对理解工作机制是有很大帮助的，总共涉及的表格总共有个通用数据，用于存放数据。强行回顾了一下前两天的学习历程。

1、关于Activiti

初学activiti我关心的它是什么东西、有什么功能、怎么实现？
先来看一张流程图感受一下：

activiti是一个业务流程管理引擎，它的流程图大概就像是列车的轨道，而所要执行的对象像是一辆自动运行的列车，只要列车启动，它就能沿着轨道一直走到终点，而其中的节点就像是列车到达终点途中所要经过的火车站，它会告诉火车下一站是哪里，然后火车就往指定的下一站驶去，直到终点，流程结束。

如上所描述，最主要的功能就是实现了代码的自动按流程执行

关于怎么实现，既然这是一个框架，自然就是引进jar包，画流程图，然后实现该框架提供的接口来做我们想要做的事情。

2、Activiti数据库的理解

activiti在每个节点都能知道下一个节点是什么，以及当前任务是什么，那势必会有存储流程的各种信息的表。事实也确实如此，activiti可以配置数据库，其中存储了流程运行时的相关信息。在初学Activiti之时，了解activiti所有的数据库表的含义对理解activiti工作机制是有很大帮助的，activiti总共涉及的表格总共有23个：

act_ge_*:general通用数据，用于存放数据。
act_re_*:reposity类似于仓库，存放流程定义文件和流程图片文件，比如一个流程部署之后可以在act_re_deployment表中看到。
act_ru_*:run服务运行时候的数据，当一个流程启动之后当前的活动任务可以在act_ru_task表格中查看 ，以及流程中所有的变量都保存在act_ru_variable表格当中。

本来想写一系列完整的Activiti的学习笔记的，但是学完之后发现工作量着实不小，自身学的也不够深，况且网上大有牛人有类似的学习笔记，所以此文权当是个人学习activiti的过程中填坑记录，仅供参考； 3、运行环境搭建，最简单的运行环境（学习中用到了Junit 4用来测试很好用。），eclipse+jar包+mysql，配置文件，因为我这里没有与Spring整合，所以配置文件就一个activiti.cfg.xml放在class_path下面就好了。 
</>复制代码 
  2.     
  3.     
  4.         
  5.         
  6.         
  7.         
  8.         
  9.         
  10.
4、下载画流程工具activiti-app.war

从官网下载war包（登录用户密码：admin test），找到activiti-app.war放进tomcat，启动之后自己画一个流程图，用于下面的测试
war包下载：https://www.activiti.org/down...
版本6.xx的相关文档都在这里：https://www.activiti.org/docs
版本5.xx的官网好像不再维护了
[画图工具]

5、开始实现Activiti的一些api，并查看表格中的变化 
</>复制代码 
  1. package com.lewin.activiti.taskListener;
  2. import java.io.File;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.util.List;
  6. import org.activiti.engine.ProcessEngine;
  7. import org.activiti.engine.ProcessEngines;
  8. import org.activiti.engine.TaskService;
  9. import org.activiti.engine.repository.Deployment;
  10. import org.activiti.engine.repository.ProcessDefinition;
  11. import org.activiti.engine.runtime.Execution;
  12. import org.activiti.engine.runtime.ProcessInstance;
  13. import org.activiti.engine.task.Task;
  14. import org.activiti.engine.task.TaskQuery;
  15. import org.apache.commons.io.FileUtils;
  16. import org.junit.Test;
  17. public class DepolyTest {
  18.     @Test
  19.     public void run(){
  20.         //获取流程引擎
  21.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  22.         Deployment deployment = processEngine.getRepositoryService()
  23.                 .createDeployment()
  24.                 //.addClasspathResource("taskListener.bpmn20.xml")
  25.                 .addClasspathResource("UserExecuteTask.bpmn20.xml")
  26.                 .deploy();
  27.         String piid = deployment.getId();
  28.         System.out.println("processDefinitionId:"+piid);
  29.         //String processKey = "lewin";
  30.         String processKey = "UserExecuteTask";
  31.         ProcessInstance pi = processEngine.getRuntimeService().startProcessInstanceByKey(processKey);
  32.         System.out.println(pi.getId());
  33.     }
  34.     
  35.     /**
  36.      * 根据流程定义里的id启动流程实例
  37.      */
  38.     public void startInstance(){
  39.         String processInstanceKey = "lewin";
  40.         //“lewin”即对应着流程定义中的id值
  41.         ProcessInstance pi = ProcessEngines.getDefaultProcessEngine()
  42.                 .getRuntimeService()
  43.                 .startProcessInstanceByKey(processInstanceKey);
  44.         System.out.println("started processInstance id is:"+processInstanceKey+"; pi.id is:"+pi.getId());
  45.     }
  46.     
  47.     /*
  48.      * 从class_path中部署流程实例
  49.      */
  50.     @Test
  51.     public void deploymentProcessDefinition_classpath(){
  52.         //获取流程引擎
  53.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  54.         Deployment deployment = processEngine.getRepositoryService()//获取仓库服务
  55.                         .createDeployment()//创建部署实例
  56.                         .name("deploymentName")//设置将要部署的流程实例的名称
  57.                         .addClasspathResource("taskListener.bpmn20.xml")//资源文件：默认路径在class_path下面
  58.                       //.addClasspathResource("diagrams/HelloWorld.png")
  59.                         .deploy();//部署
  60.         System.out.println("id："+deployment.getId());
  61.         System.out.println("name:"+deployment.getName());
  62.         
  63.     }
  64.     
  65.     /*
  66.      * 查询定义了的流程
  67.      * 查询内容来自act_re_deployment
  68.      */
  69.     @Test
  70.     public void findProcessDefinition(){
  71.         //获取流程引擎
  72.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  73.         List list = processEngine.getRepositoryService()
  74.                         .createProcessDefinitionQuery()
  75.                         
  76.                         //.deploymentId(deploymentId)
  77.                         //.processDefinitionId(processDefinitionId)
  78.                         //.processDefinitionKey(processDefinitionKey)
  79.                         //.processDefinitionNameLike(processDefinitionNameLike)
  80.                         
  81.                        
  82.                         .orderByProcessDefinitionVersion().asc()
  83.                         //.orderByProcessDefinitionName().desc()
  84.                         
  85.                         .list();
  86.                         //.singleResult();
  87.                         //.count();
  88.                         //.listPage(firstResult, maxResults)
  89.         
  90.         if(list != null && list.size()>0){
  91.             for(ProcessDefinition processDefinition:list){
  92.                 System.out.println("ID:"+processDefinition.getId());
  93.                 System.out.println("NAME:"+processDefinition.getName());
  94.                 System.out.println("KEY:"+processDefinition.getKey());
  95.                 System.out.println("VERSION:"+processDefinition.getVersion());
  96.                 System.out.println("resourceName:"+processDefinition.getResourceName());
  97.                 System.out.println("图片名字:"+processDefinition.getDiagramResourceName());
  98.                 System.out.println("部署的流程id:"+processDefinition.getDeploymentId());
  99.                 System.out.println("################################");
  100.             }
  101.         }
  102.         
  103.     }
  104.     
  105.     /*
  106.      * 删除流程定义
  107.      */
  108.     @Test
  109.     public void deleteProcessDefinition(){
  110.         //获取流程引擎
  111.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  112.         //流程定义id
  113.         String deploymentId = "2201";
  114.         
  115.         processEngine.getRepositoryService()
  116.                         .deleteDeployment(deploymentId, true);
  117.         
  118.         System.out.println("删除成功！");
  119.     }
  120.     
  121.     /*
  122.      * 查看流程定义图并下载到本地
  123.      */
  124.     @Test
  125.     public void viewPic() throws IOException{
  126.         //获取流程引擎
  127.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  128.         /**流程部署id*/
  129.         String deploymentId = "201";
  130.         //根据id获取存储在act_re_deployment表里面的静态资源，里面就有图片
  131.         List list = processEngine.getRepositoryService()//
  132.                         .getDeploymentResourceNames(deploymentId);
  133.         //获取名字
  134.         String resourceName = "";
  135.         if(list!=null && list.size()>0){
  136.             for(String name:list){
  137.                 if(name.indexOf(".png")>=0){
  138.                     resourceName = name;
  139.                 }
  140.             }
  141.         }
  142.         
  143.         
  144.         //获取图片资源
  145.         InputStream in = processEngine.getRepositoryService()//
  146.                         .getResourceAsStream(deploymentId, resourceName);
  147.         
  148.         //新建文件
  149.         File file = new File("D:/"+resourceName);
  150.         //文件复制
  151.         FileUtils.copyInputStreamToFile(in, file);
  152.     }
  153.     
  154.     /*
  155.      * 删除路程定义根据定义中的名字
  156.      */
  157.     @Test
  158.     public void deleteProcessDefinitionByKey(){
  159.         //获取流程引擎
  160.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  161.         //流程定义文件中的名字，如果相同名字有多个默认使用版本最高的那个
  162.         String processDefinitionKey = "UserExecuteTask";
  163.         List list = processEngine.getRepositoryService()
  164.                         .createProcessDefinitionQuery()
  165.                         .processDefinitionKey(processDefinitionKey)
  166.                         .list();
  167.         //删除所有名字为UserExecuteTask的流程定义
  168.         if(list!=null && list.size()>0){
  169.             for(ProcessDefinition pd:list){
  170.                 //获取ID
  171.                 String deploymentId = pd.getDeploymentId();
  172.                 processEngine.getRepositoryService()
  173.                                 .deleteDeployment(deploymentId);
  174.             }
  175.         }
  176.     }
  177.     
  178.     /**
  179.      * 查询流程状态
  180.      */
  181.     @Test
  182.     public void queryInstanceState(){
  183.         //流程id
  184.         String instanceId = "1309";
  185.         //任务id
  186.         String taskId = "1312";
  187.         //获取流程引擎
  188.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  189.         //通过流程id查询状态
  190.         ProcessInstance pi = processEngine.getRuntimeService()
  191.                 .createProcessInstanceQuery()//创建查询
  192.                 .processInstanceId(instanceId)//根据id
  193.                 .singleResult();//获取状态
  194.         if(pi!=null){
  195.             System.out.println("id为"+instanceId+"的流程正在进行中......");
  196.             //完成当前节点
  197.             processEngine.getTaskService().complete(taskId);
  198.         }else{
  199.             System.out.println("id为"+instanceId+"的流程已经完成！");
  200.         }
  201.     }
  202.     
  203.     /**
  204.      * 查询流程执行对象
  205.      */
  206.     @Test
  207.     public void queryExecution(){
  208.         //查询执行对象
  209.         String exe = "User Task";
  210.         //获取流程实例
  211.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  212.         //查询
  213.         Execution e1 = processEngine.getRuntimeService()
  214.                 .createExecutionQuery()
  215.                 .processInstanceId("1509")
  216.                 .activityId(exe)
  217.                 .singleResult();
  218.         if(e1!=null){
  219.             System.out.println("e1!=null");
  220.         }else{
  221.             System.out.println("e1==null");
  222.         }
  223.     }
  224.     
  225.     /**
  226.      * 根据用户查询任务
  227.      */
  228.     @Test
  229.     public void queryUserTask(){
  230.         
  231.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  232.         // Fetch all tasks for the management group
  233.         TaskService taskService = processEngine.getTaskService();
  234.         List tasks = taskService.createTaskQuery().taskCandidateGroup("management").list();
  235.         for (Task task : tasks) {
  236.           System.out.println("Task available: " + task.getName());
  237.         }
  238.     }
  239.     
  240.     
  241. }
6、例子1：只有用户任务和并行网关的运行

UserExecuteTask.bpmn20.xml文件：

</>复制代码 
  1.   
  2.   
  3.    
  4.       
  5.        
  6.         
  7.         
  8.      
  9.      
  10.       
  11.       
  12.       
  13.          
  14.             
  15.          
  16.       
  17.       
  18.          
  19.             
  20.          
  21.       
  22.       
  23.             
  24.             
  25.          
  26.       
  27.       
  28.       
  29.          
  30.             
  31.          
  32.       
  33.       
  34.       
  35.           
  36.              
  37.           
  38.       
  39.       
  40.       
  41.       
  42.       
  43.       
  44.       
  45.       
  46.       
  47.       
  48.       
  49.       
  50.       
  51.

测试代码：
/**

</>复制代码 
  1.      * 对应UserExecuteTask.bpmn20.xml
  2.      * 这是一个用户任务，所以流程完全执行需要用户的参与
  3.      * 获取所有任务
  4.      * 
  5.      */
  6.     @Test
  7.     public void getAllTasks(){
  8.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  9.         //获取仓库实例
  10.         Deployment deployment = processEngine.getRepositoryService()
  11.                 .createDeployment()
  12.                 .addClasspathResource("UserExecuteTask.bpmn20.xml")
  13.                 .deploy();
  14.         //启动流程实例
  15.         ProcessInstance pi = processEngine.getRuntimeService()
  16.                 .startProcessInstanceByKey("UserExecuteTask");
  17.         System.out.println("pi.id:"+pi.getId());
  18.         
  19.         //第一轮(流程启动之后自动进入下一级节点，
  20.         //下一级节点为并行的三个任务，获取该三个任务依次按定义文件中顺序完成) 
  21.         TaskService taskService = processEngine.getTaskService();
  22.         TaskQuery query = taskService.createTaskQuery().processInstanceId(pi.getId()).orderByTaskName().asc();
  23.         List tasks = query.list();
  24.         //循环打印tasks的信息
  25.         for(Task task : tasks){
  26.             //执行任务  ，完成任务
  27.             taskService.complete(task.getId());  
  28.             System.out.println("name ="+task.getName()); 
  29.             System.out.println(tasks.size());
  30.         }
  31.             
  32.         //第二轮查询任务：上一轮三个任务依次完成之后开始进入下一轮，第二级节点  
  33.         tasks = query.list();
  34.         //循环打印tasks的信息
  35.           for(Task task : tasks){
  36.               //执行任务  ，完成任务
  37.               taskService.complete(task.getId());  
  38.               System.out.println("name ="+task.getName()); 
  39.               System.out.println(tasks.size());
  40.           }
  41.           
  42.         //第三轮查询任务：上一轮一个任务完成之后，开始进入下一级节点，
  43.           //即最后的人事部门审批  
  44.         tasks = query.list();
  45.         //循环打印tasks的信息
  46.           for(Task task : tasks){
  47.               //执行任务  ，完成任务
  48.               taskService.complete(task.getId());  
  49.               System.out.println("name ="+task.getName()); 
  50.               System.out.println(tasks.size());
  51.           }
  52.     }
  53.

运行结果：

7、例子2：只有系统任务和并行网关的运行

AutoUserExecuteTask.bpmn20.xml文件：

</>复制代码 
  1.   
  2.   
  3.   
  4.      
  5.        
  6.         
  7.         
  8.      
  9.     
  10.       
  11.       
  12.       
  13.       
  14.       
  15.       
  16.       
  17.       
  18.       
  19.       
  20.       
  21.       
  22.       
  23.       
  24.       
  25.       
  26.       
  27.       
  28.       
  29.       
  30.       
  31.     
  32.     
  33.     
  34.

测试代码：

</>复制代码 
  1. /**
  2.      * 对应UserExecuteTask.bpmn20.xml
  3.      * 这是一个自动任务（不包含用户任务），所以流程完全执行不需要用户的参与
  4.      * 只需要启动实例，流程会自动按流程走完
  5.      * 获取所有任务
  6.      * 
  7.      */
  8.     @Test
  9.     public void autoRun(){
  10.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  11.         //获取仓库实例
  12.         Deployment deployment = processEngine.getRepositoryService()
  13.                 .createDeployment()
  14.                 .addClasspathResource("AutoUserExecuteTask.bpmn20.xml")
  15.                 .deploy();
  16.         //启动流程实例
  17.         ProcessInstance pi = processEngine.getRuntimeService()
  18.                 .startProcessInstanceByKey("AutoUserExecuteTask");
  19.         System.out.println("pi.id:"+pi.getId());
  20.     }
  21.

运行结果：

![图片上传中...]

8、例子3：只有用户任务和排他网关的运行

ExclusiveGatawayDemo.bpmn20.xml文件：

</>复制代码 
  3.   
  4.     ExclusiveGatawayDemo
  5.     
  6.       
  7.       
  8.     
  9.     
  10.     
  11.       
  12.         
  13.       
  14.     
  15.     
  16.     
  17.     
  18.     
  19.       
  20.         
  21.       
  22.     
  23.     
  24.       
  25.         
  26.       
  27.     
  28.     
  29.     
  30.     
  31.     
  32.       
  33.     
  34.     
  35.       
  36.     
  37.   
  38.   
  39.     
  40.       
  41.         
  42.       
  43.       
  44.         
  45.       
  46.       
  47.         
  48.       
  49.       
  50.         
  51.       
  52.       
  53.         
  54.       
  55.       
  56.         
  57.       
  58.       
  59.         
  60.         
  61.       
  62.       
  63.         
  64.         
  65.       
  66.       
  67.         
  68.         
  69.         
  70.       
  71.       
  72.         
  73.         
  74.       
  75.       
  76.         
  77.         
  78.         
  79.       
  80.       
  81.         
  82.         
  83.       
  84.     
  85.   
  86.

测试代码：

</>复制代码 
  1. /**
  2.      * 对应ExclusiveGatewayDemo.bpmn20.xml
  3.      * 包含排他网关的流程
  4.      * 获取所有任务
  5.      * 
  6.      */
  7.     @Test
  8.     public void exclusiveGatewayTasks(){
  9.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  10.         //获取仓库实例
  11.         Deployment deployment = processEngine.getRepositoryService()
  12.                 .createDeployment()
  13.                 .name("ExclusiveGatawayDemo_Deploymentname")
  14.                 .addClasspathResource("ExclusiveGatawayDemo.bpmn20.xml")
  15.                 .deploy();
  16.         //启动流程实例
  17.         ProcessInstance pi = processEngine.getRuntimeService()
  18.                 .startProcessInstanceByKey("ExclusiveGatawayDemo");
  19.         System.out.println("pi.id:"+pi.getId());
  20.         
  21.         //第一轮(流程启动之后自动进入下一级节点，
  22.         //下一级节点为并行的三个任务，获取该三个任务依次按定义文件中顺序完成) 
  23.         TaskService taskService = processEngine.getTaskService();
  24.         TaskQuery query = taskService.createTaskQuery().processInstanceId(pi.getId()).orderByTaskName().asc();
  25.         List tasks = query.list();
  26.         //循环打印tasks的信息
  27.         for(Task task : tasks){
  28.             //执行任务  ，完成任务
  29.             taskService.complete(task.getId());  
  30.             System.out.println("name ="+task.getName()); 
  31.             System.out.println(tasks.size());
  32.         }
  33.         /**
  34.          * userTask1完成，并且设置变量“myCondition”
  35.          * 这里测试设置的值是"userTask3"
  36.          * 按照定义应该执行userTask3
  37.          * 注释下面代码的情况下，查询act_ru_task可以查看到有userTask3任务
  38.          * 不注释的情况下，流程完成userTask1和userTask3走完整个流程
  39.          */
  40.             
  41.         //第二轮查询任务：上一轮三个任务依次完成之后开始进入下一轮，第二级节点  
  42.         tasks = query.list();
  43.         //循环打印tasks的信息
  44.           for(Task task : tasks){
  45.               //执行任务  ，完成任务
  46.               taskService.complete(task.getId());  
  47.               System.out.println("name ="+task.getName()); 
  48.               System.out.println(tasks.size());
  49.           }
  50.           
  51.         //第三轮查询任务：上一轮一个任务完成之后，开始进入下一级节点，
  52.           //即最后的人事部门审批  
  53.         tasks = query.list();
  54.         //循环打印tasks的信息
  55.           for(Task task : tasks){
  56.               //执行任务  ，完成任务
  57.               taskService.complete(task.getId());  
  58.               System.out.println("name ="+task.getName()); 
  59.               System.out.println(tasks.size());
  60.           }
  61.     }

运行结果：

字数不够，代码来凑，草草结束，细节之处多有遗漏，有一起学习的有问题的可以私信。强行回顾了一下前两天的学习历程。

云服务器 GPU云服务器 个人总结 机器学习学习总结 机器学习总结 javascript学习总结

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/70264.html

相关文章

  • 深度学习调参入门，有哪些技巧？

    摘要：本文将分享一些自己关于深度学习模型调试技巧的总结思考以为主。不过以卷积神经网络为代表的深层神经网络一直被诟病，这对于模型在工业界的应用推广还是带来了一定的阻碍。 作者杨军，从事大规模机器学习系统研发及应用相关工作。本文将分享一些自己关于深度学习模型调试技巧的总结思考（以CNN为主）。最近因为一些需要，参与了一些CNN建模调参的工作，出于个人习性，我并不习惯于通过单纯的trial-and-er...

    Developer 评论0 收藏0

  • android知识大总结 - 收藏集 - 掘金

    摘要：中简单搞定接口访问，以及简析掘金最近总结的一些经验，对于或中使用接口的一些心得。这里，本文将数据结构之学习总结掘金前言前面介绍了的数据结构，今天抽空学习总结一下另一种数据结构。浅析事件传递掘金中的事件传递主要涉及三个方法和。 Android 系统中，那些能大幅提高工作效率的 API 汇总（持续更新中...） - 掘金前言 条条大路通罗马。工作中，实现某个需求的方式往往不是唯一的，这些不...

    luodongseu 评论0 收藏0

发表评论

登陆后可评论

0条评论

hufeng

男|高级讲师
我要私信

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<