[关闭]
@ruoli 2016-08-19T14:08:57.000000Z 字数 16024 阅读 2526

Activiti基础操作

Activiti

一、数据库创建与部署

1、数据库创建

以下两种方式可以创建Activiti数据库，初始化必须表结构，示例代码如下：

  1. package activiti.Act_1_数据库创建与部署;
  3. import org.activiti.engine.ProcessEngine;
  4. import org.activiti.engine.ProcessEngineConfiguration;
  5. import org.junit.Test;
  7. public class Act_1_创建表结构 {
  9.     /**
  10.      * 方式一：依赖配置文件
  11.      */
  12.     @Test
  13.     public void createTable() {
  14.         ProcessEngine processEngine = ProcessEngineConfiguration
  15.                 .createProcessEngineConfigurationFromResource(
  16.                         "activiti.cfg.xml")  
  17.                 .buildProcessEngine();
  18.         System.out.println("processEngine:" + processEngine);
  19.     }
  20.     /**
  21.      * 方式二：不依赖配置文件
  22.      */
  23.     @Test  
  24.     public void createTable2(){  
  25.         ProcessEngineConfiguration processEngineConfiguration = ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();  
  26.         //连接数据库的配置  
  27.         processEngineConfiguration.setJdbcDriver("com.mysql.jdbc.Driver");  
  28.         processEngineConfiguration.setJdbcUrl("jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8");  
  29.         processEngineConfiguration.setJdbcUsername("root");  
  30.         processEngineConfiguration.setJdbcPassword("root");  
  32.         /** 
  33.             public static final String DB_SCHEMA_UPDATE_FALSE = "false";//不能自动创建表，需要表存在 
  34.             public static final String DB_SCHEMA_UPDATE_CREATE_DROP = "create-drop";//先删除表再创建表 
  35.             public static final String DB_SCHEMA_UPDATE_TRUE = "true";//如果表不存在，自动创建表 
  36.          */  
  37.         processEngineConfiguration.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);  
  38.         //工作流的核心对象，ProcessEnginee对象  
  39.         ProcessEngine processEngine = processEngineConfiguration.buildProcessEngine();  
  40.         System.out.println("processEngine:"+processEngine);  
  41.     }  
  43. }

依赖配置文件如下：

  1. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemalocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  2. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
  3. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
  4. <bean class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration" id="processEngineConfiguration">
  5.         <!-- 连接数据的配置 -->
  6.     <property name="jdbcDriver" value="com.mysql.jdbc.Driver"></property>
  7.     <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/activiti_wfe?useUnicode=true&characterEncoding=utf8"></property>
  8.     <property name="jdbcUsername" value="root"></property>
  9.     <property name="jdbcPassword" value="root"></property>
  10.     <!-- 没有表创建表 -->
  11.     <property name="databaseSchemaUpdate" value="true"></property>
  12. </bean>
  13. </beans>

2、部署流程图

画好流程图后，可以使用以下两种方式部署流程定义，代码如下：

  1.     package activiti.Act_1_数据库创建与部署;
  3.     import java.io.InputStream;
  4.     import java.util.zip.ZipInputStream;
  6.     import org.activiti.engine.ProcessEngine;
  7.     import org.activiti.engine.ProcessEngines;
  8.     import org.activiti.engine.repository.Deployment;
  9.     import org.junit.Test;
  11.     public class Act_2_部署流程定义 {
  13.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  14.         /**
  15.          * 方式一：
  16.          * 部署流程定义*/
  17.         @Test
  18.         public void deploymentProcessDefinition(){
  19.             Deployment deployment = processEngine.getRepositoryService()//与流程定义和部署对象相关的Service
  20.                             .createDeployment()//创建一个部署对象
  21.                             .name("测试部署名称")//添加部署的名称
  22.                             .addClasspathResource("diagrams/TestAct.bpmn")//从classpath的资源中加载，一次只能加载一个文件
  23.                             .addClasspathResource("diagrams/TestAct.png")//从classpath的资源中加载，一次只能加载一个文件
  24.                             .deploy();//完成部署
  25.             System.out.println("部署ID："+deployment.getId());//1
  26.             System.out.println("部署名称："+deployment.getName());//helloworld入门程序  
  27.         }
  29.         /**
  30.          * 方式二：
  31.          * 部署流程定义（从zip）*/
  32.         @Test
  33.         public void deploymentProcessDefinition_zip(){
  34.             InputStream in = this.getClass().getClassLoader().getResourceAsStream("diagrams/helloworld.zip");
  35.             ZipInputStream zipInputStream = new ZipInputStream(in);
  36.             Deployment deployment = processEngine.getRepositoryService()//与流程定义和部署对象相关的Service
  37.                             .createDeployment()//创建一个部署对象
  38.                             .name("流程定义")//添加部署的名称
  39.                             .addZipInputStream(zipInputStream)//指定zip格式的文件完成部署
  40.                             .deploy();//完成部署
  41.             System.out.println("部署ID："+deployment.getId());//
  42.             System.out.println("部署名称："+deployment.getName());//
  43.         }
  45.     }

二、流程定义操作

1、查询流程定义

  1. package activiti.Act_2_流程定义操作;
  3. import java.util.ArrayList;
  4. import java.util.LinkedHashMap;
  5. import java.util.List;
  6. import java.util.Map;
  8. import org.activiti.engine.ProcessEngine;
  9. import org.activiti.engine.ProcessEngines;
  10. import org.activiti.engine.repository.ProcessDefinition;
  11. import org.junit.Test;
  13. public class Act_1_查询流程定义 {
  14.     ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  15.     /**
  16.      * 查询流程定义
  17.      */
  18.     @Test
  19.     public void findProcessDefinition(){
  20.         List<ProcessDefinition> list = processEngine.getRepositoryService()//与流程定义和部署对象相关的Service
  21.                         .createProcessDefinitionQuery()//创建一个流程定义的查询
  22.                         /**指定查询条件,where条件*/
  23. //                      .deploymentId(deploymentId)//使用部署对象ID查询
  24. //                      .processDefinitionId(processDefinitionId)//使用流程定义ID查询
  25. //                      .processDefinitionKey(processDefinitionKey)//使用流程定义的key查询
  26. //                      .processDefinitionNameLike(processDefinitionNameLike)//使用流程定义的名称模糊查询
  28.                         /**排序*/
  29.                         .orderByProcessDefinitionVersion().asc()//按照版本的升序排列
  30. //                      .orderByProcessDefinitionName().desc()//按照流程定义的名称降序排列
  32.                         /**返回的结果集*/
  33.                         .list();//返回一个集合列表，封装流程定义
  34. //                      .singleResult();//返回惟一结果集
  35. //                      .count();//返回结果集数量
  36. //                      .listPage(firstResult, maxResults);//分页查询
  37.         if(list!=null && list.size()>0){
  38.             for(ProcessDefinition pd:list){
  39.                 System.out.println("流程定义ID:"+pd.getId());//流程定义的key+版本+随机生成数
  40.                 System.out.println("流程定义的名称:"+pd.getName());//对应helloworld.bpmn文件中的name属性值
  41.                 System.out.println("流程定义的key:"+pd.getKey());//对应helloworld.bpmn文件中的id属性值
  42.                 System.out.println("流程定义的版本:"+pd.getVersion());//当流程定义的key值相同的相同下，版本升级，默认1
  43.                 System.out.println("资源名称bpmn文件:"+pd.getResourceName());
  44.                 System.out.println("资源名称png文件:"+pd.getDiagramResourceName());
  45.                 System.out.println("部署对象ID："+pd.getDeploymentId());
  46.                 System.out.println("###################");
  47.             }
  48.         }           
  49.     }
  53.     /**
  54.      * 
  55.      * 查询最新版本的流程定义
  56.      * 
  57.      * */
  58.     @Test
  59.     public void findLastVersionProcessDefinition(){
  60.         List<ProcessDefinition> list = processEngine.getRepositoryService()//
  61.                         .createProcessDefinitionQuery()//
  62.                         .orderByProcessDefinitionVersion().asc()//使用流程定义的版本升序排列
  63.                         .list();
  64.         /**
  65.          * Map<String,ProcessDefinition>
  66.               map集合的key：流程定义的key
  67.               map集合的value：流程定义的对象
  68.               map集合的特点：当map集合key值相同的情况下，后一次的值将替换前一次的值
  69.          */
  70.         Map<String, ProcessDefinition> map = new LinkedHashMap<String, ProcessDefinition>();
  71.         if(list!=null && list.size()>0){
  72.             for(ProcessDefinition pd:list){
  73.                 map.put(pd.getKey(), pd);
  74.             }
  75.         }
  76.         List<ProcessDefinition> pdList = new ArrayList<ProcessDefinition>(map.values());
  77.         if(pdList!=null && pdList.size()>0){
  78.             for(ProcessDefinition pd:pdList){
  79.                 System.out.println("流程定义ID:"+pd.getId());//流程定义的key+版本+随机生成数
  80.                 System.out.println("流程定义的名称:"+pd.getName());//对应helloworld.bpmn文件中的name属性值
  81.                 System.out.println("流程定义的key:"+pd.getKey());//对应helloworld.bpmn文件中的id属性值
  82.                 System.out.println("流程定义的版本:"+pd.getVersion());//当流程定义的key值相同的相同下，版本升级，默认1
  83.                 System.out.println("资源名称bpmn文件:"+pd.getResourceName());
  84.                 System.out.println("资源名称png文件:"+pd.getDiagramResourceName());
  85.                 System.out.println("部署对象ID："+pd.getDeploymentId());
  86.                 System.out.println("#########################################################");
  87.             }
  88.         }   
  89.     }
  91. }

2、删除询流程定义

  1. package activiti.Act_2_流程定义操作;
  3. import java.util.List;
  5. import org.activiti.engine.ProcessEngine;
  6. import org.activiti.engine.ProcessEngines;
  7. import org.activiti.engine.repository.ProcessDefinition;
  8. import org.junit.Test;
  10. public class Act_2_删除流程定义 {
  11.     ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  12.     /**删除流程定义*/
  13.     @Test
  14.     public void deleteProcessDefinition(){
  15.         //使用部署ID，完成删除
  16.         String deploymentId = "1";
  17.         /**
  18.          * 不带级联的删除
  19.          *    只能删除没有启动的流程，如果流程启动，就会抛出异常
  20.          */
  21. //      processEngine.getRepositoryService()//
  22. //                      .deleteDeployment(deploymentId);
  24.         /**
  25.          * 级联删除，删除流程部署信息，流程定义信息，正在执行和历史关联的流程环节
  26.          *    不管流程是否启动，都能可以删除
  27.          */
  28.         processEngine.getRepositoryService()//
  29.                         .deleteDeployment(deploymentId, true);
  30.         System.out.println("删除成功！");
  31.     }
  35.     /**
  36.      * 删除流程定义（删除key相同的所有不同版本的流程定义）
  37.      * */
  38.     @Test
  39.     public void deleteProcessDefinitionByKey(){
  40.         //流程定义的key
  41.         String processDefinitionKey = "testAct";
  42.         //先使用流程定义的key查询流程定义，查询出所有的版本
  43.         List<ProcessDefinition> list = processEngine.getRepositoryService()//
  44.                         .createProcessDefinitionQuery()//
  45.                         .processDefinitionKey(processDefinitionKey)//使用流程定义的key查询
  46.                         .list();
  47.         //遍历，获取每个流程定义的部署ID
  48.         if(list!=null && list.size()>0){
  49.             for(ProcessDefinition pd:list){
  50.                 //获取部署ID
  51.                 String deploymentId = pd.getDeploymentId();
  52.                 processEngine.getRepositoryService()//
  53.                             .deleteDeployment(deploymentId, true);
  54.             }
  55.         }
  56.     }
  57. }

3、查看流程图

  1. package activiti.Act_2_流程定义操作;
  3. import java.io.File;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.util.List;
  8. import org.activiti.engine.ProcessEngine;
  9. import org.activiti.engine.ProcessEngines;
  10. import org.apache.commons.io.FileUtils;
  11. import org.junit.Test;
  13. public class Act_3_查看流程图 {
  14.     ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  15.     /**查看流程图
  16.      * @throws IOException */
  17.     @Test
  18.     public void viewPic() throws IOException{
  19.         /**将生成图片放到文件夹下*/
  20.         String deploymentId = "301";
  21.         //获取图片资源名称
  22.         List<String> list = processEngine.getRepositoryService()//
  23.                         .getDeploymentResourceNames(deploymentId);
  24.         //定义图片资源的名称
  25.         String resourceName = "";
  26.         if(list!=null && list.size()>0){
  27.             for(String name:list){
  28.                 if(name.indexOf(".png")>=0){
  29.                     resourceName = name;
  30.                 }
  31.             }
  32.         }
  35.         //获取图片的输入流
  36.         InputStream in = processEngine.getRepositoryService()//
  37.                         .getResourceAsStream(deploymentId, resourceName);
  39.         //将图片生成到D盘的目录下
  40.         File file = new File("D:/"+resourceName);
  41.         //将输入流的图片写到D盘下
  42.         FileUtils.copyInputStreamToFile(in, file);
  43.     }
  45. }

三、流程扭转操作

1、启动流程实例

  1. package activiti.Act_3_流程扭转操作;
  3. import java.util.ArrayList;
  4. import java.util.HashMap;
  5. import java.util.List;
  6. import java.util.Map;
  8. import org.activiti.engine.ProcessEngine;
  9. import org.activiti.engine.ProcessEngines;
  10. import org.activiti.engine.runtime.ProcessInstance;
  11. import org.junit.Test;
  13. public class Act_1_启动流程实例 {
  14.     /**启动流程实例*/
  15.     @Test
  16.     public void startProcessInstance(){
  17.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  18.         //流程定义的key
  19.         String processDefinitionKey = "processTest";
  20.         List<String> users=new ArrayList<String>();
  21.         users.add("a1");
  22.         users.add("b1");
  23.         Map<String,Object> parameter=new HashMap<String, Object>();
  24.         parameter.put("users", users);
  25.         ProcessInstance pi = processEngine.getRuntimeService()
  26.         //与正在执行的流程实例和执行对象相关的Service
  27.                         .startProcessInstanceByKey(processDefinitionKey,parameter);//使用流程定义的key启动流程实例，key对应helloworld.bpmn文件中id的属性值，使用key值启动，默认是按照最新版本的流程定义启动
  28.         System.out.println("流程实例ID:"+pi.getId());//流程实例ID    101
  29.         System.out.println("流程定义ID:"+pi.getProcessDefinitionId());//流程定义ID   helloworld:1:4
  30.     }
  31. }

2、查询个人任务

  1. package activiti.Act_3_流程扭转操作;
  3. import java.util.List;
  5. import org.activiti.engine.ProcessEngine;
  6. import org.activiti.engine.ProcessEngines;
  7. import org.activiti.engine.task.Task;
  8. import org.junit.Test;
  10. public class Act_2_查询个人任务 {
  12.     /**查询当前人的个人任务*/
  14.     ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  15.     @Test
  16.     public void findMyPersonalTask(){
  17.         String assignee = "admin";
  18.         List<Task> list = processEngine.getTaskService()//与正在执行的任务管理相关的Service
  19.                         .createTaskQuery()//创建任务查询对象
  20.                         .taskAssignee(assignee).active()//指定个人任务查询，指定办理人，此为私有任务
  21.                         .includeTaskLocalVariables()
  22.                         .includeProcessVariables()
  23.                         .list();
  26.         if(list!=null && list.size()>0){
  27.             for(Task task:list){
  28.                 System.out.println("任务ID:"+task.getId());
  29.                 System.out.println("任务名称:"+task.getName());
  30.                 System.out.println("任务的创建时间:"+task.getCreateTime());
  31.                 System.out.println("任务的办理人:"+task.getAssignee());
  32.                 System.out.println("流程实例ID："+task.getProcessInstanceId());
  33.                 System.out.println("执行对象ID:"+task.getExecutionId());
  34.                 System.out.println("流程定义ID:"+task.getProcessDefinitionId());
  35.                 System.out.println("Task中获取参数："+task.getProcessVariables());
  36.                 System.out.println("Task中获取Local参数："+task.getTaskLocalVariables());
  37.                 System.out.println("getTaskService中获取参数："+processEngine.getTaskService().getVariables(task.getId()));
  38.                 System.out.println("流程处理人："+task.getAssignee());
  39.                 System.out.println("########################################################");
  40.             }
  41.         }
  42.     }
  43. }

3、查询流程实例状态

  1. package activiti.Act_3_流程扭转操作;
  3. import org.activiti.engine.ProcessEngine;
  4. import org.activiti.engine.ProcessEngines;
  5. import org.activiti.engine.runtime.ProcessInstance;
  6. import org.junit.Test;
  8. /**
  9.  * 一个流程中，执行对象可以存在多个，但是流程实例只能有一个，一个执行对象可以对应多个任务
  10.  * @author Administrator
  11.  *
  12.  */
  13. public class Act_4_查询流程实例状态 {
  14.     ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  16.     /**
  17.      * 查询流程状态（判断流程正在执行，还是结束）
  18.      * */
  19.     @Test
  20.     public void isProcessEnd(){
  21.         String processInstanceId = "2801";
  22.         ProcessInstance pi = processEngine.getRuntimeService()//表示正在执行的流程实例和执行对象
  23.                         .createProcessInstanceQuery()//创建流程实例查询
  24.                         .processInstanceId(processInstanceId)//使用流程实例ID查询
  25.                         .singleResult();
  26.         if(pi==null){
  27.             System.out.println("流程已经结束");
  28.         }
  29.         else{
  30.             System.out.println("流程正在执行");
  31.         }
  32.     }
  33. }

4、删除所有流程数据

  1. package activiti.Act_3_流程扭转操作;
  3. import java.text.SimpleDateFormat;
  4. import java.util.Date;
  5. import java.util.List;
  7. import org.activiti.engine.ProcessEngine;
  8. import org.activiti.engine.ProcessEngines;
  9. import org.activiti.engine.history.HistoricProcessInstance;
  10. import org.activiti.engine.runtime.ProcessInstance;
  11. import org.junit.Test;
  13. public class Act_7_删除所有流程数据 {
  14.     @Test
  15.     public void  removeIns(){
  16.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine(); 
  17. //      //删除正在运行的流程
  18.         List<ProcessInstance>  instanceList=processEngine.getRuntimeService()
  19.                                                          .createProcessInstanceQuery().list();
  20.         System.out.println("开始删除正在运行的流程数据");
  21.         for (ProcessInstance processInstance : instanceList) {
  22.             processEngine.getRuntimeService().deleteProcessInstance(processInstance.getProcessInstanceId(), "");
  23.             processEngine.getHistoryService().deleteHistoricProcessInstance(processInstance.getProcessInstanceId());
  24.             System.out.println("已删除："+instanceList.indexOf(processInstance)+"/"+instanceList.size());
  25.         }
  26.         System.out.println("正在运行的流程删除完毕");
  28.         //删除历史流程
  29.         try{
  30.         System.out.println("开始删除历史流程数据");
  31.         SimpleDateFormat sdf =   new SimpleDateFormat("yyyy-MM-dd HH:mm:ss" );
  32.         Date date = sdf.parse("2016-07-01 23:20:00");//删除指定日期之前的历史数据
  33.         List<HistoricProcessInstance> list=processEngine.getHistoryService().createHistoricProcessInstanceQuery()
  34.                                                         .startedBefore(date).list();
  35.             for (HistoricProcessInstance processInstance : list){
  36.                 System.out.println(list.indexOf(processInstance));
  37.                 processEngine.getHistoryService().deleteHistoricProcessInstance(processInstance.getId());
  38.                 System.out.println("已删除："+list.indexOf(processInstance)+"/"+list.size());
  39.             }
  40.         System.out.println("历史流程删除完毕"); 
  41.         }catch (Exception e) {
  42.             e.printStackTrace();
  43.         }
  44.     }
  45. }

四、历史数据操作

1、查询历史流程实例

  1. package activiti.Act_4_历史数据操作;
  3. import org.activiti.engine.ProcessEngine;
  4. import org.activiti.engine.ProcessEngines;
  5. import org.activiti.engine.history.HistoricProcessInstance;
  6. import org.junit.Test;
  8. public class Act_1_查询历史流程实例 {
  9.     ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  11.     /**查询历史流程实例（后面讲）*/
  12.     @Test
  13.     public void findHistoryProcessInstance(){
  14.         String processInstanceId = "401";
  15.         HistoricProcessInstance hpi = processEngine.getHistoryService()//与历史数据（历史表）相关的Service
  16.                         .createHistoricProcessInstanceQuery()//创建历史流程实例查询
  17.                         .processInstanceId(processInstanceId)//使用流程实例ID查询
  18.                         .singleResult();
  19.         System.out.println("流程实例ID："+hpi.getId()+"\n流程定义ID："+hpi.getProcessDefinitionId()+"\n流程开始时间："+hpi.getStartTime()+"\n流程结束时间："+hpi.getEndTime()+"\n流程持续毫秒数："+hpi.getDurationInMillis());
  20.     }
  21. }

2、查询个人历史任务

  1. package activiti.Act_4_历史数据操作;
  3. import java.util.List;
  5. import org.activiti.engine.ProcessEngine;
  6. import org.activiti.engine.ProcessEngines;
  7. import org.activiti.engine.history.HistoricTaskInstance;
  8. import org.junit.Test;
  10. public class Act_2_查询个人历史任务 {
  11.     ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  13.     /**查询历史任务（后面讲）*/
  14.     @Test
  15.     public void findHistoryTask(){
  16.         String taskAssignee = "张三";
  17.         List<HistoricTaskInstance> list = processEngine.getHistoryService()//与历史数据（历史表）相关的Service
  18.                         .createHistoricTaskInstanceQuery()//创建历史任务实例查询
  19.                         .taskAssignee(taskAssignee)//指定历史任务的办理人
  20.                         .list();
  21.         if(list!=null && list.size()>0){
  22.             for(HistoricTaskInstance hti:list){
  23.                 System.out.println("TaskID："+hti.getId()+"\nTask名称："+hti.getName()+"\n流程实例ID："+hti.getProcessInstanceId()+"\n任务开始时间："+hti.getStartTime()+"\n任务结束时间："+hti.getEndTime()+"\n持续时间毫秒数："+hti.getDurationInMillis());
  24.                 System.out.println("################################");
  25.             }
  26.         }
  27.     }
  28. }

3、查询历史流程变量

  1. package activiti.Act_4_历史数据操作;
  3. import java.util.List;
  5. import org.activiti.engine.ProcessEngine;
  6. import org.activiti.engine.ProcessEngines;
  7. import org.activiti.engine.history.HistoricVariableInstance;
  8. import org.junit.Test;
  10. public class Act_5_查询历史流程变量 {
  11.     ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  13.     /**查询历史流程变量*/
  14.     @Test
  15.     public void findHistoryProcessVariables(){
  16.         String processInstanceId = "2101";
  17.         List<HistoricVariableInstance> list = processEngine.getHistoryService()
  18.                         .createHistoricVariableInstanceQuery()
  19.                         .processInstanceId(processInstanceId)
  20.                         .list();
  21.         if(list!=null && list.size()>0){
  22.             for(HistoricVariableInstance hvi:list){
  23.                 System.out.println(hvi.getId()+"   "+hvi.getProcessInstanceId()+"   "+hvi.getVariableName()+"   "+hvi.getVariableTypeName()+"    "+hvi.getValue());
  24.                 System.out.println("###############################################");
  25.             }
  26.         }
  27.     }
  28. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注