activity工作流

转载：https://blog.csdn.net/column/details/activiti-xiaowx.html

我有很小的改动

准备

http://activiti.org/download.html

安装流程设计器(eclipse插件)

Name: Activiti BPMN 2.0 designer
Location: http://activiti.org/designer/update/

在activiti-5.13->wars目录下，解压activiti-rest项目，导入activiti-rest目录中WEB-INF\lib下所有包。添加到classpath中。

手动导入mysql-connector-java.jar，添加到classpath下

1.建库建表

执行sql脚本文件activiti-5.13\database\create\activiti.mysql.create.*.sql文件

或者

activiti.cfg.xml的配置方式，直接把此文件放置到Classpath下

ProcessEngine processEngine = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource(“activiti.cfg.xml”) .buildProcessEngine();

2.表的作用

学习Activiti主要是学习自带的23张数据表，那么这篇博客就来分析一下这23张表，下面是分类。

下面来一点一点的来分析一下上图结构。

与部署对象和流程定义相关的表

act_re_deployment：部署数据表，一次部署可以添加多个资源，资源会被保存到资源表（act_ge_bytearray）中；而部署的信息，则保存到部署表中。

act_re_procdef：流程定义表，如果发布部署的文件是流程文件，除了将内容保存到资源表外，还会解析流程文件的内容，形成特定的流程定义数据，保存到此表中。

act_ge_bytearray：资源表，用来保存资源相应的信息

act_ge_property：用来生成下一个主键信息。

与流程实例，执行对象，任务相关的表

act_ru_execution：正在执行的流程实例表，当流程启动后，会产生一个流程实例，同时会产生相应的执行流，那么流程实例和执行流数据均会被保存到act_ru_execution表中。

act_hi_procinst：流程实例的历时表，与act_ru_execution正好对应。

act_ru_task：正在执行的任务列表（只有任务节点（UserTask），该表中才有数据）

act_hi_actinst：所有活动的历史表（包括所有的节点）

与流程变量相关的表

act_ru_variable：正在执行的流程变量表，用来保存在整个流程执行过程中用到的变量信息

act_hi_varinst ：历史的流程变量表，与act_ru_variable正好对应

与组任务表相关的表

act_ru_identitylink ：正在执行的组任务表

act_hi_identitylink：历史的人员表

与组织结构相关的表

act_id_group ：工作流中的角色表

act_id_user ：工作流中的用户表

act_id_membership：中间表，关联关系表

以上就是大致的23张数据表，下面串起来，来把我们的知识连成线。

下面就通过上面这个流程的例子，来把我们上述的表给串起来。

首先是部署和流程相关方面的描述，上图从开始到结束是一个完整的流程，所以就是所谓的一次部署act_re_deployment，然后在整个流程中，我们可能会涉及到多个流程的文件，此时我们会把文件存储到act_ge_bytearray表中，然后把每个文件的详细信息存储到act_re_procdef中。

部署完流程完后，就要开始执行我们的流程了，从开始节点算起，每个节点都是一个流程实例，正在执行的会存储到act_ru_execution，执行完后，此表就会删除，然后把历史记录存储到act_hi_procinst。中间涉及到的用户任务节点，也就是UserTask节点，历史和正在执行的都会分别存储到act_hi_actinst、act_ru_task中。如果在流程中间执行中，设计到变量的传递，比如我们想把流程的执行者，作为变量来传递的话，就会存储到act_ru_variable和act_hi_varinst中。

最后，在整个流程执行过程中，设计到人员的操作信息，存储到act_id_user 中，如果设计到组的概念的话，那么某个用户是属于某个组的，就好比工作里面的部门一样，某些职责只能某些部门来执行，因此在Activi中也涉及到了组的概念，存储到act_id_group ，他们之间的联系用第三张表act_id_membership来关联。

3.activity的api

ProcessEngine

说明：

1) 在Activiti中最核心的类，其他的类都是由他而来。

2）产生方式：ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();

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

3) 可以产生RepositoryService

RepositoryService repositoryService = defaultProcessEngine.getRepositoryService();

4) 可以产生RuntimeService

RuntimeService runtimeService = defaultProcessEngine.getRuntimeService();

5) 可以产生TaskService

TaskService taskService = defaultProcessEngine.getTaskService();

各个Service的作用：

RepositoryService	管理流程定义
RuntimeService	执行管理，包括启动、推进、删除流程实例等操作
TaskService	任务管理
HistoryService	历史管理(执行完的数据的管理)
IdentityService	组织机构管理
FormService	一个可选服务，任务表单管理
ManagerService

RepositoryService

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

1) 产生方式

RepositoryService repositoryService = defaultProcessEngine.getRepositoryService();

2) 可以产生DeploymentBuilder，用来定义流程部署的相关参数

DeploymentBuilder createDeployment = repositoryService.createDeployment();

3) 删除流程定义

repositoryService.deleteDeployment(deploymentId);

RuntimeService

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

TaskService

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

HistoryService

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

ProcessDefinition

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

ProcessInstance

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

Execution

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

从ProcessInstance源代码中可以看出ProcessInstance就是Execution。但在现实意义上有所区别：

在单线流程中，ProcessInstance与Execution是一致的。

而在并发执行时候，总线路代表ProcessInstance，而分线路中每个活动代表Execution。

总结：

* 一个流程中，执行对象可以存在多个，但是流程实例只能有一个。

* 当流程按照规则只执行一次的时候，那么流程实例就是执行对象。

1.使用eclipse的activiti插件画流程图

在resource文件夹下新建一个工作流diagram

右键——new——other…——选择activiti diagram

画一个简单的工作流程图

在Event选出一个开始节点startEvent和一个结束节点endEvent

在中间过程用task里面的userTask

如：

2.部署流程定义（相当于在页面选择bpmn文件上传部署）

    [java] 
view plain
copy
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();  
  
/**部署流程定义*/  
@Test  
public void deploymentProcessDefinition(){  
    Deployment deployment = processEngine.getRepositoryService()//与流程定义和部署对象相关的Service  
                    .createDeployment()//创建一个部署对象  
                    .name(“helloworld入门程序”)//添加部署的名称  
                    .addClasspathResource(“diagrams/helloworld.bpmn”)//从classpath的资源中加载，一次只能加载一个文件  
                    .addClasspathResource(“diagrams/helloworld.png”)//从classpath的资源中加载，一次只能加载一个文件  
                    .deploy();//完成部署  
    System.out.println(“部署ID：”+deployment.getId());//1  
    System.out.println(“部署名称：”+deployment.getName());//helloworld入门程序    
}  

3.启动流程实例（
相当于新建一个流程
）

    [java] 
view plain
copy
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();  
      
    /**启动流程实例*/  
    @Test  
    public void startProcessInstance(){  
        //流程定义的key  
        String processDefinitionKey = “helloworld”;  
        ProcessInstance pi = processEngine.getRuntimeService()//与正在执行的流程实例和执行对象相关的Service  
                        .startProcessInstanceByKey(processDefinitionKey);//使用流程定义的key启动流程实例，key对应helloworld.bpmn文件中id的属性值，使用key值启动，默认是按照最新版本的流程定义启动  
        System.out.println(“流程实例ID:”+pi.getId());//流程实例ID    101  
        System.out.println(“流程定义ID:”+pi.getProcessDefinitionId());//流程定义ID   helloworld:1:4  
    }  

4.查询当前人的个人任务（
相当于查询代办列表
）

    [java] 
view plain
copy
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();  
      
/**查询当前人的个人任务*/  
@Test  
public void findMyPersonalTask(){  
    String assignee = “王五”;  
    List<Task> list = processEngine.getTaskService()//与正在执行的任务管理相关的Service  
                    .createTaskQuery()//创建任务查询对象  
                    .taskAssignee(assignee)//指定个人任务查询，指定办理人  
                    .list();  
    if(list!=null && list.size()>0){  
        for(Task task:list){  
            System.out.println(“任务ID:”+task.getId());  
            System.out.println(“任务名称:”+task.getName());  
            System.out.println(“任务的创建时间:”+task.getCreateTime());  
            System.out.println(“任务的办理人:”+task.getAssignee());  
            System.out.println(“流程实例ID：”+task.getProcessInstanceId());  
            System.out.println(“执行对象ID:”+task.getExecutionId());  
            System.out.println(“流程定义ID:”+task.getProcessDefinitionId());  
            System.out.println(“########################################################”);  
        }  
    }  
}  

5.完成我的任务（
相当于提交流程，流程进入下一环节
）

    [java] 
view plain
copy
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();  
  
  
/**完成我的任务*/  
@Test  
public void completeMyPersonalTask(){  
    //任务ID  
    String taskId = “302”;  
    processEngine.getTaskService()//与正在执行的任务管理相关的Service  
                .complete(taskId);  
    System.out.println(“完成任务：任务ID：”+taskId);  
}

bpmn文件:

BPMN 2.0根节点是definitions节点。这个元素中，可以定义多个流程定义（不过我们建议每个文件只包含一个流程定义，可以简化开发过程中的维护难度）。一个空的流程定义看起来像下面这样。注意，definitions元素最少也要包含xmlns 和 targetNamespace的声明。 targetNamespace可以是任意值，它用来对流程实例进行分类。

说明：流程定义文档有两部分组成：

1) bpmn文件

流程规则文件。在部署后，每次系统启动时都会被解析，把内容封装成流程定义放入项目缓存中。Activiti框架结合这个xml文件自动管理流程，流程的执行就是按照bpmn文件定义的规则执行的，bpmn文件是给计算机执行用的。

2) 展示流程图的图片

在系统里需要展示流程的进展图片，图片是给用户看的。

部署流程定义（zip格式文件）：

    [java] 
view plain
copy
/**部署流程定义（从zip）*/  
@Test  
public void deploymentProcessDefinition_zip(){  
    InputStream in = this.getClass().getClassLoader().getResourceAsStream(“diagrams/helloworld.zip”);  
    ZipInputStream zipInputStream = new ZipInputStream(in);  
    Deployment deployment = processEngine.getRepositoryService()//与流程定义和部署对象相关的Service  
                    .createDeployment()//创建一个部署对象  
                    .name(“流程定义”)//添加部署的名称  
                    .addZipInputStream(zipInputStream)//指定zip格式的文件完成部署  
                    .deploy();//完成部署  
    System.out.println(“部署ID：”+deployment.getId());//  
    System.out.println(“部署名称：”+deployment.getName());//  
}  

查看流程定义：

    [java] 
view plain
copy
    /**查询流程定义*/  
    @Test  
    public void findProcessDefinition(){  
        List<ProcessDefinition> list = processEngine.getRepositoryService()//与流程定义和部署对象相关的Service  
                        .createProcessDefinitionQuery()//创建一个流程定义的查询  
                        /**指定查询条件,where条件*/  
//                      .deploymentId(deploymentId)//使用部署对象ID查询  
//                      .processDefinitionId(processDefinitionId)//使用流程定义ID查询  
//                      .processDefinitionKey(processDefinitionKey)//使用流程定义的key查询  
//                      .processDefinitionNameLike(processDefinitionNameLike)//使用流程定义的名称模糊查询  
                          
                        /**排序*/  
                        .orderByProcessDefinitionVersion().asc()//按照版本的升序排列  
//                      .orderByProcessDefinitionName().desc()//按照流程定义的名称降序排列  
                          
                        /**返回的结果集*/  
                        .list();//返回一个集合列表，封装流程定义  
//                      .singleResult();//返回惟一结果集  
//                      .count();//返回结果集数量  
//                      .listPage(firstResult, maxResults);//分页查询  
        if(list!=null && list.size()>0){  
            for(ProcessDefinition pd:list){  
                System.out.println(“流程定义ID:”+pd.getId());//流程定义的key+版本+随机生成数  
                System.out.println(“流程定义的名称:”+pd.getName());//对应helloworld.bpmn文件中的name属性值  
                System.out.println(“流程定义的key:”+pd.getKey());//对应helloworld.bpmn文件中的id属性值  
                System.out.println(“流程定义的版本:”+pd.getVersion());//当流程定义的key值相同的相同下，版本升级，默认1  
                System.out.println(“资源名称bpmn文件:”+pd.getResourceName());  
                System.out.println(“资源名称png文件:”+pd.getDiagramResourceName());  
                System.out.println(“部署对象ID：”+pd.getDeploymentId());  
                System.out.println(“#########################################################”);  
            }  
        }             
    }  

流程定义的key值相同的情况下，版本是从1开始逐次升级的

流程定义的Id是【key：版本：生成ID】

说明：

1) 流程定义和部署对象相关的Service都是RepositoryService。

2) 创建流程定义查询对象，可以在ProcessDefinitionQuery上设置查询的相关参数

3) 调用ProcessDefinitionQuery对象的list方法，执行查询，获得符合条件的流程定义列表

4) 由运行结果可以看出：

Key和Name的值为：bpmn文件process节点的id和name的属性值

5) key属性被用来区别不同的流程定义。

6) 带有特定key的流程定义第一次部署时，version为1。之后每次部署都会在当前最高版本号上加1

7) Id的值的生成规则为:{processDefinitionKey}:{processDefinitionVersion}:{generated-id},这里的generated-id是一个自动生成的唯一的数字

8) 重复部署一次，deploymentId的值以一定的形式变化

规则act_ge_property表生成

删除流程定义：

    [java] 
view plain
copy
    /**删除流程定义*/  
    @Test  
    public void deleteProcessDefinition(){  
        //使用部署ID，完成删除  
        String deploymentId = “601”;  
        /** 
         * 不带级联的删除 
         *    只能删除没有启动的流程，如果流程启动，就会抛出异常 
         */  
//      processEngine.getRepositoryService()//  
//                      .deleteDeployment(deploymentId);  
          
        /** 
         * 级联删除 
         *    不管流程是否启动，都能可以删除 
         */  
        processEngine.getRepositoryService()//  
                        .deleteDeployment(deploymentId, true);  
        System.out.println(“删除成功！”);  
    }  
      

查看流程图：

    [java] 
view plain
copy
/**查看流程图 
 * @throws IOException */  
@Test  
public void viewPic() throws IOException{  
    /**将生成图片放到文件夹下*/  
    String deploymentId = “801”;  
    //获取图片资源名称  
    List<String> list = processEngine.getRepositoryService()//  
                    .getDeploymentResourceNames(deploymentId);  
    //定义图片资源的名称  
    String resourceName = “”;  
    if(list!=null && list.size()>0){  
        for(String name:list){  
            if(name.indexOf(“.png”)>=0){  
                resourceName = name;  
            }  
        }  
    }  
      
      
    //获取图片的输入流  
    InputStream in = processEngine.getRepositoryService()//  
                    .getResourceAsStream(deploymentId, resourceName);  
      
    //将图片生成到D盘的目录下  
    File file = new File(“D:/”+resourceName);  
    //将输入流的图片写到D盘下  
    FileUtils.copyInputStreamToFile(in, file);  
}  

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

    [java] 
view plain
copy
/***查询最新版本的流程定义*/  
@Test  
public void findLastVersionProcessDefinition(){  
    List<ProcessDefinition> list = processEngine.getRepositoryService()//  
                    .createProcessDefinitionQuery()//  
                    .orderByProcessDefinitionVersion().asc()//使用流程定义的版本升序排列  
                    .list();  
    /** 
     * Map<String,ProcessDefinition> 
 map集合的key：流程定义的key 
 map集合的value：流程定义的对象 
 map集合的特点：当map集合key值相同的情况下，后一次的值将替换前一次的值 
     */  
    Map<String, ProcessDefinition> map = new LinkedHashMap<String, ProcessDefinition>();  
    if(list!=null && list.size()>0){  
        for(ProcessDefinition pd:list){  
            map.put(pd.getKey(), pd);  
        }  
    }  
    List<ProcessDefinition> pdList = new ArrayList<ProcessDefinition>(map.values());  
    if(pdList!=null && pdList.size()>0){  
        for(ProcessDefinition pd:pdList){  
            System.out.println(“流程定义ID:”+pd.getId());//流程定义的key+版本+随机生成数  
            System.out.println(“流程定义的名称:”+pd.getName());//对应helloworld.bpmn文件中的name属性值  
            System.out.println(“流程定义的key:”+pd.getKey());//对应helloworld.bpmn文件中的id属性值  
            System.out.println(“流程定义的版本:”+pd.getVersion());//当流程定义的key值相同的相同下，版本升级，默认1  
            System.out.println(“资源名称bpmn文件:”+pd.getResourceName());  
            System.out.println(“资源名称png文件:”+pd.getDiagramResourceName());  
            System.out.println(“部署对象ID：”+pd.getDeploymentId());  
            System.out.println(“#########################################################”);  
        }  
    }     
}  

删除key相同的所有不同版本的流程定义：

    [java] 
view plain
copy
/**删除流程定义（删除key相同的所有不同版本的流程定义）*/  
@Test  
public void deleteProcessDefinitionByKey(){  
    //流程定义的key  
    String processDefinitionKey = “helloworld”;  
    //先使用流程定义的key查询流程定义，查询出所有的版本  
    List<ProcessDefinition> list = processEngine.getRepositoryService()//  
                    .createProcessDefinitionQuery()//  
                    .processDefinitionKey(processDefinitionKey)//使用流程定义的key查询  
                    .list();  
    //遍历，获取每个流程定义的部署ID  
    if(list!=null && list.size()>0){  
        for(ProcessDefinition pd:list){  
            //获取部署ID  
            String deploymentId = pd.getDeploymentId();  
            processEngine.getRepositoryService()//  
                        .deleteDeployment(deploymentId, true);  
        }  
    }  
}  

总结：

Deployment 部署对象

1、一次部署的多个文件的信息。对于不需要的流程可以删除和修改。

2、对应的表：

act_re_deployment：部署对象表

act_re_procdef：流程定义表

act_ge_bytearray：资源文件表

act_ge_property：主键生成策略表

ProcessDefinition流程定义

1、解析.bpmn后得到的流程定义规则的信息，工作流系统就是按照流程定义的规则执行的。

启动流程实例

    [java] 
view plain
copy
<span style=“font-size:12px;”>    /**启动流程实例*/  
    @Test  
    public void startProcessInstance(){  
        //流程定义的key  
        String processDefinitionKey = “helloworld”;  
        ProcessInstance pi = processEngine.getRuntimeService()//与正在执行的流程实例和执行对象相关的Service  
                        .startProcessInstanceByKey(processDefinitionKey);//使用流程定义的key启动流程实例，key对应helloworld.bpmn文件中id的属性值，使用key值启动，默认是按照最新版本的流程定义启动  
        System.out.println(“流程实例ID:”+pi.getId());//流程实例ID    101  
        System.out.println(“流程定义ID:”+pi.getProcessDefinitionId());//流程定义ID   helloworld:1:4  
    }</span>  

代码说明：

操作数据库的act_ru_execution表,如果是用户任务节点，同时也会在act_ru_task添加一条记录

查询我的个人任务

    [java] 
view plain
copy
    /**查询当前人的个人任务*/  
    @Test  
    public void findMyPersonalTask(){  
        String assignee = “王五”;  
        List<Task> list = processEngine.getTaskService()//与正在执行的任务管理相关的Service  
                        .createTaskQuery()//创建任务查询对象  
                        /**查询条件（where部分）*/  
                        .taskAssignee(assignee)//指定个人任务查询，指定办理人  
//                      .taskCandidateUser(candidateUser)//组任务的办理人查询  
//                      .processDefinitionId(processDefinitionId)//使用流程定义ID查询  
//                      .processInstanceId(processInstanceId)//使用流程实例ID查询  
//                      .executionId(executionId)//使用执行对象ID查询  
                        /**排序*/  
                        .orderByTaskCreateTime().asc()//使用创建时间的升序排列  
                        /**返回结果集*/  
//                      .singleResult()//返回惟一结果集  
//                      .count()//返回结果集的数量  
//                      .listPage(firstResult, maxResults);//分页查询  
                        .list();//返回列表  
        if(list!=null && list.size()>0){  
            for(Task task:list){  
                System.out.println(“任务ID:”+task.getId());  
                System.out.println(“任务名称:”+task.getName());  
                System.out.println(“任务的创建时间:”+task.getCreateTime());  
                System.out.println(“任务的办理人:”+task.getAssignee());  
                System.out.println(“流程实例ID：”+task.getProcessInstanceId());  
                System.out.println(“执行对象ID:”+task.getExecutionId());  
                System.out.println(“流程定义ID:”+task.getProcessDefinitionId());  
                System.out.println(“########################################################”);  
            }  
        }  
    }  

代码说明：

1) 因为是任务查询，所以从processEngine中应该得到TaskService

2) 使用TaskService获取到任务查询对象TaskQuery

3) 为查询对象添加查询过滤条件，使用taskAssignee指定任务的办理者（即查询指定用户的代办任务），同时可以添加分页排序等过滤条件

4) 调用list方法执行查询，返回办理者为指定用户的任务列表

5) 任务ID、名称、办理人、创建时间可以从act_ru_task表中查到。

6) Execution与ProcessInstance见5.6和5.7章节的介绍。在这种情况下，ProcessInstance相当于Execution

7) 如果assignee属性为部门经理，结果为空。因为现在流程只到了”填写请假申请”阶段，后面的任务还没有执行，即在数据库中没有部门经理可以办理的任务，所以查询不到。

8) 一个Task节点和Execution节点是1对1的情况，在task对象中使用Execution_来表示他们之间的关系

9) 任务ID在数据库表act_ru_task中对应“ID_”列

附加：

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

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

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

办理任务

    [java] 
view plain
copy
/**办理我的任务*/  
@Test  
public void completeMyPersonalTask(){  
    //任务ID  
    String taskId = “1202”;  
    processEngine.getTaskService()//与正在执行的任务管理相关的Service  
                .complete(taskId);  
    System.out.println(“完成任务：任务ID：”+taskId);  
}  

说明：

1) 是办理任务，所以从ProcessEngine得到的是TaskService。

2) 当执行完这段代码，再以员工的身份去执行查询的时候，会发现这个时候已经没有数据了，因为正在执行的任务中没有数据。

3) 对于执行完的任务，activiti将从act_ru_task表中删除该任务，下一个任务会被插入进来。

4) 以”部门经理”的身份进行查询，可以查到结果。因为流程执行到部门经理审批这个节点了。

5) 再执行办理任务代码，执行完以后以”部门经理”身份进行查询，没有结果。

重复第3和4步直到流程执行完。

查询流程状态

    [java] 
view plain
copy
/**查询流程状态*/  
@Test  
public void isProcessEnd(){  
    String processInstanceId = “1001”;  
    ProcessInstance pi = processEngine.getRuntimeService()//表示正在执行的流程实例和执行对象  
                    .createProcessInstanceQuery()//创建流程实例查询  
                    .processInstanceId(processInstanceId)//使用流程实例ID查询  
                    .singleResult();  
    if(pi==null){  
        System.out.println(“流程已经结束”);  
    }  
    else{  
        System.out.println(“流程没有结束”);  
    }  
}  

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

说明：

1) 因为是查询流程实例，所以先获取runtimeService

2) 创建流程实例查询对象，设置实例ID过滤参数

3) 由于一个流程实例ID只对应一个实例，使用singleResult执行查询返回一个唯一的结果，如果结果数量大于1，则抛出异常

4) 判断指定ID的实例是否存在，如果结果为空，则代表流程结束，实例在正在执行的执行对象表中已被删除，转换成历史数据。

查询历史任务

    [java] 
view plain
copy
@Test  
public void findHistoryTask(){  
    String taskAssignee = “张三”;  
    List<HistoricTaskInstance> list = processEngine.getHistoryService()//与历史数据（历史表）相关的Service  
                    .createHistoricTaskInstanceQuery()//创建历史任务实例查询  
                    .taskAssignee(taskAssignee)//指定历史任务的办理人  
                    .list();  
    if(list!=null && list.size()>0){  
        for(HistoricTaskInstance hti:list){  
            System.out.println(hti.getId()+”    “+hti.getName()+”    “+hti.getProcessInstanceId()+”   “+hti.getStartTime()+”   “+hti.getEndTime()+”   “+hti.getDurationInMillis());  
            System.out.println(“################################”);  
        }  
    }  
}  

查询历史流程实例

    [java] 
view plain
copy
@Test  
public void findHistoryProcessInstance(){  
    String processInstanceId = “1001”;  
    HistoricProcessInstance hpi = processEngine.getHistoryService()//与历史数据（历史表）相关的Service  
                    .createHistoricProcessInstanceQuery()//创建历史流程实例查询  
                    .processInstanceId(processInstanceId)//使用流程实例ID查询  
                    .singleResult();  
    System.out.println(hpi.getId()+”    “+hpi.getProcessDefinitionId()+”    “+hpi.getStartTime()+”    “+hpi.getEndTime()+”     “+hpi.getDurationInMillis());  
}

今天的文章activity工作流分享到此就结束了，感谢您的阅读。

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至举报，一经查实，本站将立刻删除。
如需转载请保留出处：https://bianchenghao.cn/6906.html