一、IDEA安装activiti插件

在插件库中查找actiBPM，安装该插件，如果找不到该插件，请到插件库中下载该包手动安装，插件地址

http://plugins.jetbrains.com/plugin/7429-actibpm 安装后重启IDEA

二、activiti基础环境搭建

2.1 actiBPM插件使用示例

将需要用到的activiti包引入到工程中

  1. <dependency>
  2.     <groupId>org.activiti</groupId>
  3.     <artifactId>activiti-engine</artifactId>
  4.     <version>5.17.0</version>
  5. </dependency>

resources目录下创建diagrams文件夹

右键new，点击BpmnFeil,然后取个名

鼠标左键拖拽StartEvent到界面上，同样再弄几个其他图标

鼠标放到图标中心会变成黑白扇形，拖拽连线到另一个图标进行画图

 

生成png文件

右键点击hello.bpmn，选择Diagrams

点击箭头指的图标，选择生成位置即可

2.2 初始化activiti表结构

2.2.1 通过代码创建工作流使用的表

  1. public class TestActiviti {
  2.     /**
  3.      * 使用代码创建工作流使用的23张表
  4.      */
  5.     @Test
  6.     public void createTable(){
  7.         //创建引擎配置类
  8.         ProcessEngineConfiguration configuration = ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();
  9.         configuration.setJdbcDriver("com.mysql.jdbc.Driver");
  10.         configuration.setJdbcUrl("jdbc:mysql://192.168.27.14:3306/activiti");
  11.         configuration.setJdbcUsername("root");
  12.         configuration.setJdbcPassword("root");
  13.  
  14.         //不自动创建表，需要表存在 DB_SCHEMA_UPDATE_FALSE = "false";
  15.         //先删除表，再创建表 DB_SCHEMA_UPDATE_CREATE_DROP = "create-drop";
  16.         //如果表不存在，先创建表 DB_SCHEMA_UPDATE_TRUE = "true";
  17.         configuration.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
  18.         //创建工作流核心对象
  19.         ProcessEngine processEngine = configuration.buildProcessEngine();
  20.         System.out.println(processEngine);
  21.     }
  22. }

2.2.2 通过配置文件方式配置数据库等，resourses目录下添加activiti.cfg.xml配置文件，再通过代码初始化工作流使用的表

  1. <beans xmlns="http://www.springframework.org/schema/beans"
  2.        xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  5. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
  6. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
  7.  
  8.     <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
  9.         <!-- 连接数据的配置 -->
  10.         <property name="jdbcDriver" value="com.mysql.jdbc.Driver"/>
  11.         <property name="jdbcUrl" value="jdbc:mysql://192.168.27.14:3306/activiti?characterEncoding=utf8"/>
  12.         <property name="jdbcUsername" value="root"/>
  13.         <property name="jdbcPassword" value="root"/>
  14.         <!--  不自动创建表，需要表存在 "false";
  15.               先删除表，再创建表  "create-drop";
  16.               如果表不存在，先创建表"true";
  17.         -->
  18.         <property name="databaseSchemaUpdate" value="true"/>
  19.     </bean>
  20. </beans>
  1. @Test
  2. public void createTable2(){
  3.     ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml")
  4.             .buildProcessEngine();
  5. }

2.2.3 那么，能不能再给力一点？前面看到了两种创建ProcessEngine（流程引擎）的方式，而这里要简化很多，调用ProcessEngines的getDefaultProceeEngine方法时会自动加载classpath下名为activiti.cfg.xml文件。

  1. @Test
  2. public void createTable3(){
  3.     ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  4. }

三、activiti核心api讲解

3.1ProcessEngine

在Activiti中最核心的类，其他的类都是由他而来，由工作流引擎可以创建各个Service，这些Service是调用工作流23张表的服务

  1. @Test
  2. public void getService(){
  3.     ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  4.  
  5.     //管理流程定义
  6.     RepositoryService repositoryService = processEngine.getRepositoryService();
  7.     //执行管理，包括启动、推进、删除流程实例等
  8.     RuntimeService runtimeService = processEngine.getRuntimeService();
  9.     //任务管理
  10.     TaskService taskService = processEngine.getTaskService();
  11.     //历史管理（执行完的数据的管理
  12.     HistoryService historyService = processEngine.getHistoryService();
  13.     //组织机构管理
  14.     IdentityService identityService = processEngine.getIdentityService();
  15.     //可选服务，任务表单管理
  16.     FormService formService = processEngine.getFormService();
  17.  
  18.     ManagementService managementService = processEngine.getManagementService();
  19. }

3.2 RepositoryService

是Activiti的仓库服务类。所谓的仓库指流程定义文档的两个文件：bpmn文件和流程图片。

  1. @Test
  2. public void testRespositoryService(){
  3.     ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  4.     RepositoryService repositoryService = processEngine.getRepositoryService();
  5.     //可产生DeploymentBuilder用来定义流程部署的相关参数
  6.     DeploymentBuilder deployment = repositoryService.createDeployment();
  7.     //删除流程定义
  8.     repositoryService.deleteDeployment("deploymentId");
  9. }

3.3 RuntimeService

是activiti的流程执行服务类。可以从这个服务类中获取很多关于流程执行相关的信息。

3.4 TaskService

是activiti的任务服务类。可以从这个类中获取任务的信息。

3.5 HistoryService

是activiti的查询历史信息的类。在一个流程执行完成后，这个对象为我们提供查询历史信息。

3.6 ProcessDefinition

流程定义类。可以从这里获得资源文件等。

3.7 ProcessInstance

代表流程定义的执行实例。如小明请了一天的假，就必须发出一个流程实例的申请。一个流程实例包括了所有的运行节点。我们可以利用这个对象来了解当前流程实例的进度等信息。流程实例就表示一个流程从开始到结束的最大的流程分支，即一个流程中流程实例只有一个。

3.8 Execution

Activiti用这个对象去描述流程执行的每一个节点。在没有并发的情况下，Execution就是同ProcessInstance。流程按照流程定义的规则执行一次的过程，就可以表示执行对象Execution。

四、一个简单的HelloWorld程序示例

4.1 利用插件创建流程图

4.2 部署流程定义

  1. /**
  2.  * 部署流程定义
  3.  */
  4. @Test
  5. public void deploymentProcessDefinition(){
  6.  
  7.     //获取流程定义与部署相关Service
  8.     Deployment deployment = processEngine.getRepositoryService()
  9.             .createDeployment()     //创建一个部署对象
  10.             .name("helloworld入门程序")
  11.             .addClasspathResource("diagrams/helloworld.bpmn")//加载资源文件
  12.             .deploy();//完成部署
  13.     System.out.println(deployment.getId());
  14.     System.out.println(deployment.getName());
  15. }

4.3 启动流程实例

  1. /**
  2.  * 启动流程实例
  3.  */
  4. @Test
  5. public void startProcessInstance(){
  6.     //获取与正在执行的流程示例和执行对象相关的Service
  7.     ProcessInstance processInstance = processEngine.getRuntimeService()
  8.             //使用流程定义的key启动实例，key对应bpmn文件中id的属性值，默认按照最新版本流程启动
  9.             .startProcessInstanceByKey("helloworld");
  10.     System.out.println(processInstance.getId());
  11.     System.out.println(processInstance.getProcessDefinitionId());
  12. }

4.4 查看我的个人任务

  1. /**
  2.  * 查询当前的个人任务
  3.  */
  4. @Test
  5. public void findPersonalTask(){
  6.     //与正在执行的任务相关的Service
  7.     List<Task> list = processEngine.getTaskService()
  8.             .createTaskQuery()  //创建查询任务对象
  9.             .taskAssignee("王五")     //指定个人任务查询，指定办理人
  10.             .list();
  11.     if(list != null && list.size() > 0){
  12.         for(Task task : list){
  13.             System.out.println(task.getId());
  14.             System.out.println(task.getName());
  15.             System.out.println(task.getCreateTime());
  16.             System.out.println(task.getAssignee());
  17.             System.out.println(task.getProcessInstanceId());
  18.             System.out.println(task.getExecutionId());
  19.             System.out.println(task.getProcessDefinitionId());
  20.         }
  21.     }
  22. }

4.5 完成我的个人任务

  1. /**
  2.  * 完成我的任务
  3.  */
  4. @Test
  5. public void completePersonalTask(){
  6.     processEngine.getTaskService()
  7.             .complete("7502");
  8. }

五、管理流程定义

5.1 部署流程定义

通过classpath部署流程定义

  1. /**部署流程定义（从classpath）*/
  2. @Test
  3. public void deploymentProcessDefinition_classpath(){
  4.     Deployment deployment = processEngine.getRepositoryService()//与流程定义和部署对象相关的Service
  5.             .createDeployment()//创建一个部署对象
  6.             .name("流程定义")//添加部署的名称
  7.             .addClasspathResource("diagrams/helloworld.bpmn")//从classpath的资源中加载，一次只能加载一个文件
  8.             .addClasspathResource("diagrams/helloworld.png")//从classpath的资源中加载，一次只能加载一个文件
  9.             .deploy();//完成部署
  10.     System.out.println("部署ID："+deployment.getId());//
  11.     System.out.println("部署名称："+deployment.getName());//
  12. }

通过zip文件部署流程定义

  1. /**部署流程定义（从zip）*/
  2. @Test
  3. public void deploymentProcessDefinition_zip(){
  4.     InputStream in = this.getClass().getClassLoader().getResourceAsStream("diagrams/helloworld.zip");
  5.     ZipInputStream zipInputStream = new ZipInputStream(in);
  6.     Deployment deployment = processEngine.getRepositoryService()//与流程定义和部署对象相关的Service
  7.             .createDeployment()//创建一个部署对象
  8.             .name("流程定义")//添加部署的名称
  9.             .addZipInputStream(zipInputStream)//指定zip格式的文件完成部署
  10.             .deploy();//完成部署
  11.     System.out.println("部署ID："+deployment.getId());//
  12.     System.out.println("部署名称："+deployment.getName());//
  13. }

这一步在数据库中将操作三张表：

a) act_re_deployment（部署对象表）

　　存放流程定义的显示名和部署时间，每部署一次增加一条记录

b) act_re_procdef（流程定义表）

　　存放流程定义的属性信息，部署每个新的流程定义都会在这张表中增加一条记录。

注意：当流程定义的key相同的情况下，使用的是版本升级

c) act_ge_bytearray（资源文件表）

　　存储流程定义相关的部署信息。即流程定义文档的存放地。每部署一次就会增加两条记录，一条是关于bpmn规则文件的，一条是图片的（如果部署时只指定了bpmn一个文件，activiti会在部署时解析bpmn文件内容自动生成流程图）。两个文件不是很大，都是以二进制形式存储在数据库中。

5.2 查看流程定义

  1. /**查询流程定义*/
  2. @Test
  3. public void findProcessDefinition(){
  4.     List<ProcessDefinition> list = processEngine.getRepositoryService()//与流程定义和部署对象相关的Service
  5.             .createProcessDefinitionQuery()//创建一个流程定义的查询
  6.             /**指定查询条件,where条件*/
  7. //                        .deploymentId(deploymentId)//使用部署对象ID查询
  8. //                        .processDefinitionId(processDefinitionId)//使用流程定义ID查询
  9. //                        .processDefinitionKey(processDefinitionKey)//使用流程定义的key查询
  10. //                        .processDefinitionNameLike(processDefinitionNameLike)//使用流程定义的名称模糊查询
  11.  
  12.             /**排序*/
  13.             .orderByProcessDefinitionVersion().asc()//按照版本的升序排列
  14. //                        .orderByProcessDefinitionName().desc()//按照流程定义的名称降序排列
  15.  
  16.             /**返回的结果集*/
  17.             .list();//返回一个集合列表，封装流程定义
  18. //                        .singleResult();//返回惟一结果集
  19. //                        .count();//返回结果集数量
  20. //                        .listPage(firstResult, maxResults);//分页查询
  21.     if(list!=null && list.size()>0){
  22.         for(ProcessDefinition pd:list){
  23.             System.out.println("流程定义ID:"+pd.getId());//流程定义的key+版本+随机生成数
  24.             System.out.println("流程定义的名称:"+pd.getName());//对应helloworld.bpmn文件中的name属性值
  25.             System.out.println("流程定义的key:"+pd.getKey());//对应helloworld.bpmn文件中的id属性值
  26.             System.out.println("流程定义的版本:"+pd.getVersion());//当流程定义的key值相同的相同下，版本升级，默认1
  27.             System.out.println("资源名称bpmn文件:"+pd.getResourceName());
  28.             System.out.println("资源名称png文件:"+pd.getDiagramResourceName());
  29.             System.out.println("部署对象ID："+pd.getDeploymentId());
  30.             System.out.println("#########################################################");
  31.         }
  32.     }
  33. }

结果：

再部署一次运行结果为：

　　可以看到流程定义的key值相同的情况下，版本是从1开始逐次升级的，流程定义的Id是【key：版本：生成ID】。由运行结果可以看出：Key和Name的值为：bpmn文件process节点的id和name的属性值。key属性被用来区别不同的流程定义，带有特定key的流程定义第一次部署时，version为1。之后每次部署都会在当前最高版本号上加1，Id的值的生成规则为:{processDefinitionKey}:{processDefinitionVersion}:{generated-id}, 这里的generated-id是一个自动生成的唯一的数字，重复部署一次，deploymentId的值以一定的形式变化，规则act_ge_property表生成。

5.3 删除流程定义

  1. /**删除流程定义*/
  2. @Test
  3. public void deleteProcessDefinition(){
  4.     //使用部署ID，完成删除
  5.     String deploymentId = "601";
  6.     /**
  7.      * 不带级联的删除
  8.      *    只能删除没有启动的流程，如果流程启动，就会抛出异常
  9.      */
  10. //        processEngine.getRepositoryService()//
  11. //                        .deleteDeployment(deploymentId);
  12.  
  13.     /**
  14.      * 级联删除
  15.      *       不管流程是否启动，都能可以删除
  16.      */
  17.     processEngine.getRepositoryService()//
  18.             .deleteDeployment(deploymentId, true);
  19.     System.out.println("删除成功！");
  20. }

　　如果该流程定义下没有正在运行的流程，则可以用普通删除。如果是有关联的信息，用级联删除。项目开发中使用级联删除的情况比较多，删除操作一般只开放给超级管理员使用。

5.4 获取流程定义文档的资源

查询出流程定义文档。主要查的是图片，用于显示流程用。

  1. /**查看流程图
  2.  * @throws IOException */
  3. @Test
  4. public void viewPic() throws IOException {
  5.     /**将生成图片放到文件夹下*/
  6.     String deploymentId = "801";
  7.     //获取图片资源名称
  8.     List<String> list = processEngine.getRepositoryService()//
  9.             .getDeploymentResourceNames(deploymentId);
  10.     //定义图片资源的名称
  11.     String resourceName = "";
  12.     if(list!=null && list.size()>0){
  13.         for(String name:list){
  14.             if(name.indexOf(".png")>=0){
  15.                 resourceName = name;
  16.             }
  17.         }
  18.     }
  19.     //获取图片的输入流
  20.     InputStream in = processEngine.getRepositoryService()//
  21.             .getResourceAsStream(deploymentId, resourceName);
  22.     //将图片生成到D盘的目录下
  23.     File file = new File("D:/"+resourceName);
  24.     //将输入流的图片写到D盘下
  25.     FileUtils.copyInputStreamToFile(in, file);
  26. }

　　deploymentId为流程部署ID，resourceName为act_ge_bytearray表中NAME_列的值，使用repositoryService的getDeploymentResourceNames方法可以获取指定部署下得所有文件的名称，使用repositoryService的getResourceAsStream方法传入部署ID和资源图片名称可以获取部署下指定名称文件的输入流，最后的有关IO流的操作，使用FileUtils工具的copyInputStreamToFile方法完成流程流程到文件的拷贝，将资源文件以流的形式输出到指定文件夹下。

5.5 查询最新版本的流程定义

  1. /***附加功能：查询最新版本的流程定义*/
  2. @Test
  3. public void findLastVersionProcessDefinition(){
  4.     List<ProcessDefinition> list = processEngine.getRepositoryService()//
  5.             .createProcessDefinitionQuery()//
  6.             .orderByProcessDefinitionVersion().asc()//使用流程定义的版本升序排列
  7.             .list();
  8.     /**
  9.      * Map<String,ProcessDefinition>
  10.      map集合的key：流程定义的key
  11.      map集合的value：流程定义的对象
  12.      map集合的特点：当map集合key值相同的情况下，后一次的值将替换前一次的值
  13.      */
  14.     Map<String, ProcessDefinition> map = new LinkedHashMap<String, ProcessDefinition>();
  15.     if(list!=null && list.size()>0){
  16.         for(ProcessDefinition pd:list){
  17.             map.put(pd.getKey(), pd);
  18.         }
  19.     }
  20.     List<ProcessDefinition> pdList = new ArrayList<ProcessDefinition>(map.values());
  21.     if(pdList!=null && pdList.size()>0){
  22.         for(ProcessDefinition pd:pdList){
  23.             System.out.println("流程定义ID:"+pd.getId());//流程定义的key+版本+随机生成数
  24.             System.out.println("流程定义的名称:"+pd.getName());//对应helloworld.bpmn文件中的name属性值
  25.             System.out.println("流程定义的key:"+pd.getKey());//对应helloworld.bpmn文件中的id属性值
  26.             System.out.println("流程定义的版本:"+pd.getVersion());//当流程定义的key值相同的相同下，版本升级，默认1
  27.             System.out.println("资源名称bpmn文件:"+pd.getResourceName());
  28.             System.out.println("资源名称png文件:"+pd.getDiagramResourceName());
  29.             System.out.println("部署对象ID："+pd.getDeploymentId());
  30.             System.out.println("#########################################################");
  31.         }
  32.     }
  33. }

5.6 删除流程定义

  1. /**附加功能：删除流程定义（删除key相同的所有不同版本的流程定义）*/
  2. @Test
  3. public void deleteProcessDefinitionByKey(){
  4.     //流程定义的key
  5.     String processDefinitionKey = "helloworld";
  6.     //先使用流程定义的key查询流程定义，查询出所有的版本
  7.     List<ProcessDefinition> list = processEngine.getRepositoryService()//
  8.             .createProcessDefinitionQuery()//
  9.             .processDefinitionKey(processDefinitionKey)//使用流程定义的key查询
  10.             .list();
  11.     //遍历，获取每个流程定义的部署ID
  12.     if(list!=null && list.size()>0){
  13.         for(ProcessDefinition pd:list){
  14.             //获取部署ID
  15.             String deploymentId = pd.getDeploymentId();
  16.             processEngine.getRepositoryService()//
  17.                     .deleteDeployment(deploymentId, true);
  18.         }
  19.     }
  20. }

 六、流程实例、任务的执行

涉及到的表

6.1 启动流程实例

  1.     /**
  2.      * 启动流程实例
  3.      */
  4.     @Test
  5.     public void startProcessInstance(){
  6.         //获取与正在执行的流程示例和执行对象相关的Service
  7.         ProcessInstance processInstance = processEngine.getRuntimeService()
  8.                 //使用流程定义的key启动实例，key对应bpmn文件中id的属性值，默认按照最新版本流程启动
  9.                 .startProcessInstanceByKey("helloworld");
  10.         System.out.println(processInstance.getId());
  11.         System.out.println(processInstance.getProcessDefinitionId());
  12.     }

　　通过流程定义的key启动流程实例，这时打开数据库act_ru_execution表，ID_表示执行对象ID，PROC_INST_ID_表示流程实例ID，如果是单例流程（没有分支和聚合），那么流程实例ID和执行对象ID是相同的。

一个流程流程实例只有一个，执行对象可以存在多个。

 6.2 查询我的个人任务

  1. /**查询当前人的个人任务*/
  2.     @Test
  3.     public void findMyPersonalTask(){
  4.         String assignee = "张三";
  5.         List<Task> list = processEngine.getTaskService()//与正在执行的任务管理相关的Service
  6.                 .createTaskQuery()//创建任务查询对象
  7.                 /**查询条件（where部分）*/
  8.                 .taskAssignee(assignee)//指定个人任务查询，指定办理人
  9. //                        .taskCandidateUser(candidateUser)//组任务的办理人查询
  10. //                        .processDefinitionId(processDefinitionId)//使用流程定义ID查询
  11. //                        .processInstanceId(processInstanceId)//使用流程实例ID查询
  12. //                        .executionId(executionId)//使用执行对象ID查询
  13.                 /**排序*/
  14.                 .orderByTaskCreateTime().asc()//使用创建时间的升序排列
  15.                 /**返回结果集*/
  16. //                        .singleResult()//返回惟一结果集
  17. //                        .count()//返回结果集的数量
  18. //                        .listPage(firstResult, maxResults);//分页查询
  19.                 .list();//返回列表
  20.         if(list!=null && list.size()>0){
  21.             for(Task task:list){
  22.                 System.out.println("任务ID:"+task.getId());
  23.                 System.out.println("任务名称:"+task.getName());
  24.                 System.out.println("任务的创建时间:"+task.getCreateTime());
  25.                 System.out.println("任务的办理人:"+task.getAssignee());
  26.                 System.out.println("流程实例ID："+task.getProcessInstanceId());
  27.                 System.out.println("执行对象ID:"+task.getExecutionId());
  28.                 System.out.println("流程定义ID:"+task.getProcessDefinitionId());
  29.                 System.out.println("########################################################");
  30.             }
  31.         }
  32.     }

　　因为是任务查询，所以从processEngine中应该得到TaskService，使用TaskService获取到任务查询对象TaskQuery，为查询对象添加查询过滤条件，使用taskAssignee指定任务的办理者（即查询指定用户的代办任务），同时可以添加分页排序等过滤条件，调用list方法执行查询，返回办理者为指定用户的任务列表，任务ID、名称、办理人、创建时间可以从act_ru_task表中查到。在这种情况下，ProcessInstance相当于Execution， 如果assignee属性为部门经理，结果为空。因为现在流程只到了”填写请假申请”阶段，后面的任务还没有执行，即在数据库中没有部门经理可以办理的任务，所以查询不到。 一个Task节点和Execution节点是1对1的情况，在task对象中使用Execution_来表示他们之间的关系任务ID在数据库表act_ru_task中对应“ID_”列。

　　在activiti任务中，主要分为两大类查询任务（个人任务和组任务）：

1.确切指定了办理者的任务，这个任务将成为指定者的私有任务，即个人任务。

2.无法指定具体的某一个人来办理的任务，可以把任务分配给几个人或者一到 多个小组，让这个范围内的用户可以选择性（如有空余时间时）来办理这类任务，即组任务。

 6.3 办理任务

  1.     /**完成我的任务*/
  2.     @Test
  3.     public void completeMyPersonalTask(){
  4.         //任务ID
  5.         String taskId = "1202";
  6.         processEngine.getTaskService()//与正在执行的任务管理相关的Service
  7.                 .complete(taskId);
  8.         System.out.println("完成任务：任务ID："+taskId);
  9.     }

　　是办理任务，所以从ProcessEngine得到的是TaskService。当执行完这段代码，再以员工的身份去执行查询的时候，会发现这个时候已经没有数据了，因为正在执行的任务中没有数据。对于执行完的任务，activiti将从act_ru_task表中删除该任务，下一个任务会被插入进来。以”部门经理”的身份进行查询，可以查到结果。因为流程执行到部门经理审批这个节点了。再执行办理任务代码，执行完以后以”部门经理”身份进行查询，没有结果。重复这个步骤直到流程执行完。

6.4 查询流程状态（判断流程是正在执行还是结束）

  1.     /**查询流程状态（判断流程正在执行，还是结束）*/
  2.     @Test
  3.     public void isProcessEnd(){
  4.         String processInstanceId = "1001";
  5.         ProcessInstance pi = processEngine.getRuntimeService()//表示正在执行的流程实例和执行对象
  6.                 .createProcessInstanceQuery()//创建流程实例查询
  7.                 .processInstanceId(processInstanceId)//使用流程实例ID查询
  8.                 .singleResult();
  9.         if(pi==null){
  10.             System.out.println("流程已经结束");
  11.         }
  12.         else{
  13.             System.out.println("流程没有结束");
  14.         }
  15.     }

在流程执行的过程中，创建的流程实例ID在整个过程中都不会变，当流程结束后，流程实例将会在正在执行的执行对象表中（act_ru_execution）被删除。

　　因为是查询流程实例，所以先获取runtimeService，创建流程实例查询对象，设置实例ID过滤参数，由于一个流程实例ID只对应一个实例，使用singleResult执行查询返回一个唯一的结果，如果结果数量大于1，则抛出异常，判断指定ID的实例是否存在，如果结果为空，则代表流程结束，实例在正在执行的执行对象表中已被删除，转换成历史数据。

6.5 查询历史任务

  1. /**查询历史任务*/
  2. @Test
  3. public void findHistoryTask(){
  4.     String taskAssignee = "张三";
  5.     List<HistoricTaskInstance> list = processEngine.getHistoryService()//与历史数据（历史表）相关的Service
  6.             .createHistoricTaskInstanceQuery()//创建历史任务实例查询
  7.             .taskAssignee(taskAssignee)//指定历史任务的办理人
  8.             .list();
  9.     if(list!=null && list.size()>0){
  10.         for(HistoricTaskInstance hti:list){
  11.             System.out.println(hti.getId()+"    "+hti.getName()+"    "+hti.getProcessInstanceId()+"   "+hti.getStartTime()+"   "+hti.getEndTime()+"   "+hti.getDurationInMillis());
  12.             System.out.println("################################");
  13.         }
  14.     }
  15. }

6.6 查询历史流程实例

  1. /**查询历史流程实例*/
  2. @Test
  3. public void findHistoryProcessInstance(){
  4.     String processInstanceId = "1001";
  5.     HistoricProcessInstance hpi = processEngine.getHistoryService()//与历史数据（历史表）相关的Service
  6.             .createHistoricProcessInstanceQuery()//创建历史流程实例查询
  7.             .processInstanceId(processInstanceId)//使用流程实例ID查询
  8.             .singleResult();
  9.     System.out.println(hpi.getId()+"    "+hpi.getProcessDefinitionId()+"    "+hpi.getStartTime()+"    "+hpi.getEndTime()+"     "+hpi.getDurationInMillis());
  10. }

七、流程变量

流程变量涉及到的表

7.1模拟获取流程变量的场景

  1. /**模拟设置和获取流程变量的场景 */
  2. @Test
  3. public void setAndGetVariables(){
  4.     RuntimeService runtimeService = processEngine.getRuntimeService();
  5.     TaskService taskService = processEngine.getTaskService();
  6.  
  7.     //使用执行对象ID设置
  8.     runtimeService.setVariable(executionId, variableName, value);（设置一个）
  9.     runtimeService.setVariables(executionId, variables);
  10.  
  11.     //使用任务ID设置
  12.     taskService.setVariable(taskId, variableName, value);（设置一个）
  13.     taskService.setVariables(taskId, variables);
  14.  
  15.     //启动流程实例的同时设置
  16.     runtimeService.startProcessInstanceByKey(processDefinitionKey, variables);
  17.  
  18.     //完成任务的同时设置
  19.     taskService.complete(taskId, variables);
  20.  
  21.     /**获取流程变量*/
  22.     //使用执行对象ID和流程变量的名称，获取流程变量的值
  23.     runtimeService.getVariable(executionId, variableName);
  24.     //使用执行对象ID，获取所有的流程变量，将流程变量放置到Map集合中，map集合的key就是流程变量的名称，map集合的value就是流程变量的值
  25.     runtimeService.getVariables(executionId);
  26.     //使用执行对象ID，获取流程变量的值，通过设置流程变量的名称存放到集合中，获取指定流程变量名称的流程变量的值，值存放到Map集合中
  27.     runtimeService.getVariables(executionId, variableNames);
  28.  
  29.     //使用任务ID和流程变量的名称，获取流程变量的值
  30.     taskService.getVariable(taskId, variableName);
  31.     //使用任务ID，获取所有的流程变量，将流程变量放置到Map集合中，map集合的key就是流程变量的名称，map集合的value就是流程变量的值
  32.     taskService.getVariables(taskId);
  33.     //使用任务ID，获取流程变量的值，通过设置流程变量的名称存放到集合中，获取指定流程变量名称的流程变量的值，值存放到Map集合中
  34.     taskService.getVariables(taskId, variableNames);
  35. }

7.2 设置流程变量

  1. /**设置流程变量 */
  2. @Test
  3. public void setVariables(){
  4.     TaskService taskService = processEngine.getTaskService();
  5.     //任务ID
  6.     String taskId = "50004";
  7.     //一、设置流程变量，使用基本数据类型
  8.     taskService.setVariableLocal(taskId,"请假天数",3);//local与当前task绑定，下一个task不可见
  9.     taskService.setVariable(taskId,"请假日期",new Date());
  10.     taskService.setVariable(taskId,"请假原因","回家探亲");
  11.     //二：设置流程变量，使用javabean类型
  12.     /**
  13.      * 当一个javabean（实现序列号）放置到流程变量中，要求javabean的属性不能再发生变化
  14.      *    * 如果发生变化，再获取的时候，抛出异常
  15.      *
  16.      * 解决方案：在Person对象中添加：
  17.      *         private static final long serialVersionUID = 6757393795687480331L;
  18.      *      同时实现Serializable
  19.      * */
  20.     Person p = new Person();
  21.     p.setId(20);
  22.     p.setName("翠花");
  23.     taskService.setVariable(taskId, "人员信息(添加固定版本)", p);
  24.  
  25.     System.out.println("流程变量设置成功");
  26. }

流程变量支持的类型：

　　从图中可以看出包括了大部分封装类型和Date、String和实现了Serializable接口的类的类型。流程变量的获取针对流程实例（即1个流程），每个流程实例获取的流程变量时不同的，使用基本类型获取流程变量，在taskService中使用任务ID，流程变量的名称，获取流程变量的值。Javabean类型设置获取流程变量，除了需要这个javabean实现了Serializable接口外，还要求流程变量对象的属性不能发生变化，否则抛出异常。解决方案，固定序列化ID。

setVariable和setVariableLocal的区别：

setVariable：设置流程变量的时候，流程变量名称相同的时候，后一次的值替换前一次的值，而且可以看到TASK_ID的字段不会存放任务ID的值

setVariableLocal：

1. 设置流程变量的时候，针对当前活动的节点设置流程变量，如果一个流程中存在2个活动节点，对每个活动节点都设置流程变量，即使流程变量的名称相同，后一次的版本的值也不会替换前一次版本的值，它会使用不同的任务ID作为标识，存放2个流程变量值，而且可以看到TASK_ID的字段会存放任务ID的值

例如act_hi_varinst 表的数据：不同的任务节点，即使流程变量名称相同，存放的值也是不同的。

如图：

2. 使用setVariableLocal说明流程变量绑定了当前的任务，当流程继续执行时，下个任务获取不到这个流程变量（因为正在执行的流程变量中没有这个数据），所有查询正在执行的任务时不能查询到我们需要的数据，此时需要查询历史的流程变量。

7.3 获取流程变量

  1. /**获取流程变量 */
  2. @Test
  3. public void getVariables(){
  4.     TaskService taskService = processEngine.getTaskService();
  5.     //任务ID
  6.     String taskId = "55002";
  7.     /**一：获取流程变量，使用基本数据类型*/
  8.     Integer days = (Integer) taskService.getVariable(taskId, "请假天数");
  9.     Date date = (Date) taskService.getVariable(taskId, "请假日期");
  10.     String resean = (String) taskService.getVariable(taskId, "请假原因");
  11.     System.out.println("请假天数："+days);
  12.     System.out.println("请假日期："+date);
  13.     System.out.println("请假原因："+resean);
  14.     /**二：获取流程变量，使用javabean类型*/
  15.     Person p = (Person)taskService.getVariable(taskId, "人员信息(添加固定版本)");
  16.     System.out.println(p.getId()+"        "+p.getName());
  17. }

7.4 查询历史流程变量

  1. /**查询流程变量的历史表*/
  2. @Test
  3. public void findHistoryProcessVariables(){
  4.     List<HistoricVariableInstance> list = processEngine.getHistoryService()//
  5.             .createHistoricVariableInstanceQuery()//创建一个历史的流程变量查询对象
  6.             .variableName("请假天数")
  7.             .list();
  8.     if(list!=null && list.size()>0){
  9.         for(HistoricVariableInstance hvi:list){
  10.             System.out.println(hvi.getId()+"   "+hvi.getProcessInstanceId()+"   "+hvi.getVariableName()+"   "+hvi.getVariableTypeName()+"    "+hvi.getValue());
  11.             System.out.println("###############################################");
  12.         }
  13.     }
  14. }

　　历史的流程变量查询，指定流程变量的名称，查询act_hi_varinst表（也可以针对，流程实例ID，执行对象ID，任务ID查询）

Activiti工作流引擎使用详解（一）的更多相关文章

  1. activiti工作流引擎

    参考文章 Activiti-5.18.0与springMvc项目集成和activiti-explorer单独部署Web项目并与业务数据库关联方法(AutoEE_V2实现方式) https://blog ...

  2. Activiti工作流引擎开发系列

    Activiti工作流引擎开发系列-01 作者:Jesai 没有伞的孩子,只能光脚奔跑! 前言: 初次接触工作流这个概念是自从2014年11月份开始,当时是由于我的毕业设计需要,还记得当时我毕业设计的 ...

  3. Activiti工作流引擎参考资料

    Activiti工作流引擎使用 工作流-Activiti核心API介绍 传智播客Activiti工作流视频教程(企业开发实例讲解) 工作流引擎Activiti演示项目 http://www.kafei ...

  4. VC 与Matlab混合编程之引擎操作详解

    Visual C++ 是当前主流的应用程序开发环境之一,开发环境强大,开发的程序执行速度快.但在科学计算方面函数库显得不够丰富.读取.显示数据图形不方便. Matlab 是一款将数值分析.矩阵计算.信 ...

  5. Activiti工作流引擎简介

    Activiti工作流引擎简介 一.概述 Activiti是由Alfresco软件在2010年5月17日发布的业务流程管理(BPM)框架,它是覆盖了业务流程管理,工作流,服务协作等领域的一个开源,灵活 ...

  6. Activiti工作流引擎数据库表结构

    Activiti工作流引擎数据库表结构 一.数据库表的命名 Acitiviti数据库中表的命名都是以ACT_开头的.第二部分是一个两个字符用例表的标识.此用例大体与服务API是匹配的. ACT_RE_ ...

  7. Activiti工作流引擎核心介绍

    引言 Activiti 作为一个遵从 Apache 许可的工作流和业务流程管理开源平台,其核心是基于 Java 的超快速.超稳定的 BPMN 2.0 流程引擎,强调流程服务的可嵌入性和可扩展性,同时更 ...

  8. Activiti工作流引擎使用

    http://www.kafeitu.me/activiti/2012/03/22/workflow-activiti-action.html 1.简单介工作流引擎与Activiti 对于工作流引擎的 ...

  9. 基于Activiti工作流引擎实现的请假审核流程

    概要 本文档介绍的是某商用中集成的Activiti工作流的部署及使用,该框架用的Activiti版本为5.19.0.本文档中主要以一个请假流程为例子进行说明,该例子的流程图如下: 这是一个可以正常运作 ...

随机推荐

  1. docker安装pxc集群

      前言 现在mysql自建集群方案有多种,keepalived.MHA.PXC.MYSQL主备等,但是目前根据自身情况和条件,选择使用pxc的放来进行搭建,最大的好处就是,多主多备,即主从一体,没有 ...

  2. redis sentinel搭建

    /usr/local/bin /usr/local/etc https://www.centos.bz/2017/08/redis-3-x-sentinel-ha-service/ https://w ...

  3. Java学习（二十一）

    今天学的访问控制权限修饰符: 和c++比多了一个缺省,基本和c++功能一样,private多了一个同包的限制. 缺省的话是同包就可访问. 基本都学过,所以理解的也很快. 然后又把最近学得总结了一下: ...

  4. 微信小程序（六）

    MINA 框架: 启动: 冷启动,热启动 加载: 生命周期 路由: 事件: 事件时视图层到逻辑层的通信方式 事件可以将用户的行为反馈到逻辑层进行处理 事件可以绑定在组件上,触发事件后就会执行逻辑层对应 ...

  5. 菜鸡的Java笔记 第二十五 wrapperClass 包装类

    wrapperClass 包装类         1.包装类的特点        2.装箱与拆箱操作        3.数据转型处理            内容        Object 类可以接收 ...

  6. Python 深拷贝和浅拷贝的区别

    python的复制,深拷贝和浅拷贝的区别    在python中,对象赋值实际上是对象的引用.当创建一个对象,然后把它赋给另一个变量的时候,python并没有拷贝这个对象,而只是拷贝了这个对象的引用  ...

  7. Java设计模式之（四）——原型模式

    1.什么是原型模式 Specify the kinds of objects to create using a prototypical instance,and create new object ...

  8. [atARC101F]Robots and Exits

    每一个点一定匹配其左边/右边的第一个出口(在最左/右边的出口左/右边的点直接删除即可),否则记到左右出口的距离分别为$x_{i}$和$y_{i}$ 令$p_{i}$表示$i$匹配的出口(左0右1),结 ...

  9. 一文详解 OpenGL ES 3.x 渲染管线

    OpenGL ES 构建的三维空间,其中的三维实体由许多的三角形拼接构成.如下图左侧所示的三维实体圆锥,其由许多三角形按照一定规律拼接构成.而组成圆锥的每一个三角形,其任意一个顶点由三维空间中 x.y ...

  10. 多线程07.thread-join

    package com.wangwenjun.concurrency.chapter5; public class ThreadJoin3 { public static void main(Stri ...