activiti5.20简单介绍（八） -- 流程操作续

1.流程定义
流程定义是在部署一个流程之后生成，其中包含流程部署的id、流程定义的id、流程定义的key等内容，其中流程定义的id生成策略为：
（流程定义的key） ： （当前版本号） ： （随机值）
例如：Business:1:4
流程不支持修改操作，其中所有的修改操作使用更新流程来完成，这样可以保证有旧的流程在运行时不会受到影响，下次启动时会默认启动最新的流程。
（1）查询流程定义：
  RepositoryService repositoryService = engine.getRepositoryService();

//查询流程定义，可以排序，查询数量，分页等
List<ProcessDefinition> list = repositoryService.createProcessDefinitionQuery()
.orderByDeploymentId().asc().list();
ProcessDefinition processDefinition = null;
if(list!=null && list.size()>0){
processDefinition = list.get(0);
System.out.println("流程组织机构： "+processDefinition.getCategory());
System.out.println("流程部署ID： "+processDefinition.getDeploymentId());
System.out.println("流程描述： "+processDefinition.getDescription());
System.out.println("流程图片文件： "+processDefinition.getDiagramResourceName());
System.out.println("流程定义ID： "+processDefinition.getId());
System.out.println("流程定义key "+processDefinition.getKey());
System.out.println("流程设计名称： "+processDefinition.getName());
System.out.println("流程定义文件： "+processDefinition.getResourceName());
System.out.println("流程所有人ID： "+processDefinition.getTenantId());
System.out.println("流程版本： "+processDefinition.getVersion());
}
（2）查询最新版本：
a) 之前版本查询最新版本时可以使用
  RepositoryService repositoryService = engine.getRepositoryService();

//将流程按照版本的升序排列得到一个所有流程的集合
List<ProcessDefinition> list = repositoryService.createProcessDefinitionQuery().orderByProcessDefinitionVersion().asc().list();

//使用map集合存储得到的集合，同时将所有低版本的过滤
Map<String, ProcessDefinition> map = new LinkedHashMap<String, ProcessDefinition>();
if(list!=null && list.size()>0){
for (ProcessDefinition pd : list)
{
//新版本数据将会替代就版本数据
map.put(pd.getKey(), pd);
}
}

//循环遍历输出
for (ProcessDefinition processDefinition : map.values())
{
System.out.println("流程组织机构： "+processDefinition.getCategory());
System.out.println("流程部署ID： "+processDefinition.getDeploymentId());
System.out.println("流程描述： "+processDefinition.getDescription());
System.out.println("流程图片文件： "+processDefinition.getDiagramResourceName());
System.out.println("流程定义ID： "+processDefinition.getId());
System.out.println("流程定义key "+processDefinition.getKey());
System.out.println("流程设计名称： "+processDefinition.getName());
System.out.println("流程定义文件： "+processDefinition.getResourceName());
System.out.println("流程所有人ID： "+processDefinition.getTenantId());
System.out.println("流程版本： "+processDefinition.getVersion());
System.out.println("#############################");
}
b) 当前版本提供了一个便捷的API，可以直接查询最新版本
 repositoryService.createProcessDefinitionQuery().latestVersion().singleResult();
 
（3）删除流程定义：
删除流程定义需要使用流程部署id删除部署的流程，流程定义便会相应删除。
  RepositoryService repositoryService = engine.getRepositoryService();
List<ProcessDefinition> list = repositoryService.createProcessDefinitionQuery()
.orderByDeploymentId().asc().list();

ProcessDefinition processDefinition = null;
if(list!=null && list.size()>0){
processDefinition = list.get(0);
String id = processDefinition.getDeploymentId();
// 级联删除流程，不论是否启动，都会删除
repositoryService.deleteDeployment(id, true);
}
（4）挂起和激活流程：
当前API提供了一个挂起流程的操作，如果当前流程不使用的话可以将之挂起，使之不能启动。
  RepositoryService repositoryService = engine.getRepositoryService();
//挂起流程定义，挂起后不能启动
//repositoryService.suspendProcessDefinitionByKey("SF");

//激活流程定义，激活后可以启动
repositoryService.activateProcessDefinitionByKey("SF");
 
 
2.流程实例
在流程启动之后会生成相应的流程实例记录，当前流程实例表示此流程正在运行，如果流程结束，流程实例相应删除，同时历史记录会更新。
（1）启动流程
  //流程运行服务
RuntimeService runtimeService = engine.getRuntimeService();

//1.使用流程定义的id启动流程实例，返回值为流程实例对象
//ProcessInstance processInstance = runtimeService.startProcessInstanceById(id);

//2.使用流程定义的key启动流程实例,推荐使用
//同一个流程key相同，不同的是版本，使用key启动可以默认启动最新版本的流程
ProcessInstance processInstance = runtimeService.startProcessInstanceById(key);

//流程实例中包含的信息
System.out.println("当前活动节点 "+processInstance.getActivityId());
System.out.println("关联业务键： "+processInstance.getBusinessKey());
System.out.println("流程部署id： "+processInstance.getDeploymentId());
System.out.println("流程描述： "+processInstance.getDescription());
System.out.println("流程实例id： "+processInstance.getId());
System.out.println("流程实例名称： "+processInstance.getName());
System.out.println("父流程id： "+processInstance.getParentId());
System.out.println("流程定义id： "+processInstance.getProcessDefinitionId());
System.out.println("流程定义key： "+processInstance.getProcessDefinitionKey());
System.out.println("流程定义名称： "+processInstance.getProcessDefinitionName());
System.out.println("流程实例id： "+processInstance.getProcessInstanceId());
System.out.println("流程所属人id： "+processInstance.getTenantId());
System.out.println("流程定义版本： "+processInstance.getProcessDefinitionVersion());
System.out.println("流程变量： "+processInstance.getProcessVariables());
System.out.println("是否结束： "+processInstance.isEnded());
System.out.println("是否暂停： "+processInstance.isSuspended());
System.out.println("################################");
 
（2）删除流程实例
  RuntimeService runtimeService = engine.getRuntimeService();
//会清空当前执行的流程表和当前任务表中的与当前流程实例对应的数据
//同时更新历史任务表中的数据
runtimeService.deleteProcessInstance("5001", "deleteReason");
（3）业务关联信息更新
  RuntimeService runtimeService = engine.getRuntimeService();

//修改业务关联信息
runtimeService.updateBusinessKey("7501", "BusinessKey");
（4）暂停启动当前流程
  RuntimeService runtimeService = engine.getRuntimeService();
//暂停
//runtimeService.suspendProcessInstanceById("7501");
//启用
runtimeService.activateProcessInstanceById("7501");
（5）查询流程定义
  RuntimeService runtimeService = engine.getRuntimeService();
List<ProcessInstance> list = runtimeService.createProcessInstanceQuery()
.orderByProcessDefinitionId().asc().listPage(0, 10);

if(list!=null && list.size()>0){
for (ProcessInstance processInstance : list)
{
System.out.println("当前活动节点 "+processInstance.getActivityId());
System.out.println("关联业务键： "+processInstance.getBusinessKey());
System.out.println("流程部署id： "+processInstance.getDeploymentId());
System.out.println("流程描述： "+processInstance.getDescription());
System.out.println("流程实例id： "+processInstance.getId());
System.out.println("流程实例名称： "+processInstance.getName());
System.out.println("父流程id： "+processInstance.getParentId());
System.out.println("流程定义id： "+processInstance.getProcessDefinitionId());
System.out.println("流程定义key： "+processInstance.getProcessDefinitionKey());
System.out.println("流程定义名称： "+processInstance.getProcessDefinitionName());
System.out.println("流程实例id： "+processInstance.getProcessInstanceId());
System.out.println("流程所属人id： "+processInstance.getTenantId());
System.out.println("流程定义版本： "+processInstance.getProcessDefinitionVersion());
System.out.println("流程变量： "+processInstance.getProcessVariables());
System.out.println("是否结束： "+processInstance.isEnded());
System.out.println("是否暂停： "+processInstance.isSuspended());
System.out.println("################################");
}
}
（6）流程是否结束
  String processInstanceId = "7501";
ProcessInstance pi = engine.getRuntimeService().createProcessInstanceQuery()
.processInstanceId(processInstanceId).singleResult();
if(pi==null){
System.out.println("流程已经结束");
}
else{
System.out.println("流程没有结束");
}
 
3.流程执行
流程启动之后会有一个执行对象
  ExecutionQuery executionQuery = engine.getRuntimeService().createExecutionQuery();

//查询流程执行信息，可以根据条件查询
List<Execution> list = executionQuery.list();
if(list!=null && list.size()>0){
for (Execution e : list)
{
System.out.println("流程当前活动节点："+e.getActivityId());
System.out.println("流程描述： "+e.getDescription());
System.out.println("流程ID： "+e.getId());
System.out.println("流程名称： "+e.getName());
System.out.println("父流程ID： "+e.getParentId());
System.out.println("流程定义ID： "+e.getProcessInstanceId());
System.out.println("流程所有人ID： "+e.getTenantId());
System.out.println("#######################");
}
}
 
4.任务
任务是在流程执行过程中产生的，对应的任务有个人任务和组任务，组任务最后也需要拾取为个人任务，任务从属于某一个流程实例，流程结束任务同时消失。
（1）任务批注
a) 添加删除批注
  /**
* 添加，删除任务评论 act_hi_comment--历史评论表
*/
@Test
public void testaddComment() {

/**
* 注意：添加批注的时候，由于Activiti底层代码是使用：
* String userId = Authentication.getAuthenticatedUserId();
* CommentEntity comment = new CommentEntity();
* comment.setUserId(userId);
* 所有需要从Session中获取当前登录人，作为该任务的办理人（审核人），对应act_hi_comment表中的
* User_ID的字段，不过不添加审核人，该字段为null
* 所以要求，添加配置执行使用Authentication.setAuthenticatedUserId();添加当前任务的审核人
* */
Authentication.setAuthenticatedUserId("user");
// 添加
// taskService.addComment("7504", "7501", "this is a test");
// 删除
taskService.deleteComments("7504", "7501");
}
b) 查看批注信息
 HistoryService historyService = engine.getHistoryService();
List<HistoricProcessInstance> hplist = historyService.createHistoricProcessInstanceQuery()
.processInstanceId(piid).list();
if (hplist != null && hplist.size() > 0) {
for (HistoricProcessInstance hp : hplist) {
String htaskid = hp.getId();
List<Comment> lc = taskService.getTaskComments(htaskid);
list.addAll(lc);
}
}
以上使用的是流程实例查询，获取当前流程实例相关的批注信息，下面的是使用任务查询
  String taskId = "7504";
List<Comment> list = new ArrayList<Comment>();
Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
String piid = task.getProcessInstanceId();
list = taskService.getProcessInstanceComments(piid);
System.out.println(list);
（2）任务附件
  /**
* 添加，删除附件 act_ge_bytearray--资源表中添加记录 act_hi_attachment--历史附件添加记录
*/
@Test
public void testcreateAttachment() {

// Attachment attachment = taskService.createAttachment("1", "7504",
// "7501", "a", "aaa", new ByteArrayInputStream("haha".getBytes()));

// System.out.println("附件ID： "+attachment.getId());

taskService.deleteAttachment("12501");
}
（3）委派任务
委派任务是将任务的办理人设置为所委派的人
  /**
* 委派任务 将任务的办理人设置为所委派的人
*/
@Test
public void testdelegateTask() {
taskService.delegateTask("7504", "u1");
}
（4）回退任务
回退任务，将任务回退给委派之前的办理人,任务节点不变，需先有委派操作，然后进行回退
  /**
* 回退任务，将任务回退给之前的办理人,任务节点不变
*/
@Test
public void testresolveTask() {
taskService.resolveTask("7504");
}
（5）完成任务
使用任务id完成任务
  /**
* 完成任务
*/
@Test
public void testcomplete() {
taskService.complete("22502");
}
（6）设置办理人
直接为任务设置一个办理人
  /**
* 设置任务办理人
*/
@Test
public void testsetAssignee() {
taskService.setAssignee("22502", "u2");
}
（7）删除任务
  /**
* 删除任务
*/
@Test
public void testdeleteTask() {
taskService.saveTask(new TaskEntity("1234"));

// taskService.deleteTask(taskId);
taskService.deleteTask("1234", true);
// taskService.deleteTask(taskId, deleteReason);
// taskService.deleteTasks(taskIds);
}
（8）认领任务
在组任务中，需要将任务认领为个人任务才可以办理
  /**
* 认领任务,从组任务中认领为个人任务
*/
@Test
public void testCTask() {
taskService.claim("22502", "u1");
}
（9）查询任务
  /**
* 查询个人任务
*/
@Test
public void testTaskAssignee() {
TaskQuery taskQuery = taskService.createTaskQuery();

Task task = taskQuery.taskAssignee("u2").singleResult();

System.out.println("当前任务办理人： " + task.getAssignee());
System.out.println("任务类型： " + task.getCategory());
System.out.println("任务描述： " + task.getDescription());
System.out.println("任务执行ID： " + task.getExecutionId());
System.out.println("表单key： " + task.getFormKey());
System.out.println("任务ID： " + task.getId());
System.out.println("任务名称： " + task.getName());
System.out.println("任务所有者： " + task.getOwner());
System.out.println("任务父ID： " + task.getParentTaskId());
System.out.println("任务优先级： " + task.getPriority());
System.out.println("流程定义的id： " + task.getProcessDefinitionId());
System.out.println("流程实例的id： " + task.getProcessInstanceId());
System.out.println("任务定义的key： " + task.getTaskDefinitionKey());
System.out.println("所有人ID： " + task.getTenantId());
System.out.println("任务创建时间： " + task.getCreateTime());
System.out.println("任务委派状态： " + task.getDelegationState());
System.out.println("持续时间： " + task.getDueDate());
System.out.println("任务流程变量： " + task.getProcessVariables());
System.out.println("##############################");
}
  /**
* 任务查询，可以使用各种条件查询，查讯数量等
*/
@Test
public void testTaskQuery() {
List<Task> list = taskService.createTaskQuery().orderByTaskCreateTime().asc().list();

if (list != null && list.size() > 0) {
for (Task task : list) {
System.out.println("当前任务办理人： " + task.getAssignee());
System.out.println("任务类型： " + task.getCategory());
System.out.println("任务描述： " + task.getDescription());
System.out.println("任务执行ID： " + task.getExecutionId());
System.out.println("表单key： " + task.getFormKey());
System.out.println("任务ID： " + task.getId());
System.out.println("任务名称： " + task.getName());
System.out.println("任务所有者： " + task.getOwner());
System.out.println("任务父ID： " + task.getParentTaskId());
System.out.println("任务优先级： " + task.getPriority());
System.out.println("流程定义的id： " + task.getProcessDefinitionId());
System.out.println("流程实例的id： " + task.getProcessInstanceId());
System.out.println("任务定义的key： " + task.getTaskDefinitionKey());
System.out.println("所有人ID： " + task.getTenantId());
System.out.println("任务创建时间： " + task.getCreateTime());
System.out.println("任务委派状态： " + task.getDelegationState());
System.out.println("持续时间： " + task.getDueDate());
System.out.println("任务流程变量： " + task.getProcessVariables());
System.out.println("##############################");
}
}
}
 
5.流程变量
（1）启动时设置流程变量，同时还可以使用businessKey关联业务数据
  /**
* 设置流程变量
* 1.启动流程时设置,同时还可以使用businessKey关联业务数据
* act_hi_varinst--历史流程变量表
* act_ru_variable--运行时流程变量表
*/
@Test
public void teststartProcessInstanceByKey(){
//engine.getRepositoryService().createDeployment().addClasspathResource("process/Var.bpmn").addClasspathResource("process/Var.png").name("var").deploy();

Map<String, Object> variables = new HashMap<String, Object>();
variables.put("u1", "u1");//启动流程同时设置任务办理人
ProcessInstance processInstance = engine.getRuntimeService()
.startProcessInstanceByKey("Var", "BusinessKey",variables);

//流程实例中包含的信息
System.out.println("当前活动节点 "+processInstance.getActivityId());
System.out.println("关联业务键： "+processInstance.getBusinessKey());
System.out.println("流程部署id： "+processInstance.getDeploymentId());
System.out.println("流程描述： "+processInstance.getDescription());
System.out.println("流程实例id： "+processInstance.getId());
System.out.println("流程实例名称： "+processInstance.getName());
System.out.println("父流程id： "+processInstance.getParentId());
System.out.println("流程定义id： "+processInstance.getProcessDefinitionId());
System.out.println("流程定义key： "+processInstance.getProcessDefinitionKey());
System.out.println("流程定义名称： "+processInstance.getProcessDefinitionName());
System.out.println("流程实例id： "+processInstance.getProcessInstanceId());
System.out.println("流程所属人id： "+processInstance.getTenantId());
System.out.println("流程定义版本： "+processInstance.getProcessDefinitionVersion());
System.out.println("流程变量： "+processInstance.getProcessVariables());
System.out.println("是否结束： "+processInstance.isEnded());
System.out.println("是否暂停： "+processInstance.isSuspended());
System.out.println("################################");

}
（2）为任务设置流程变量
  /**
* 2.为任务设置流程变量
*/
@Test
public void testsetVariable(){
TaskService taskService = engine.getTaskService();
//流程变量的值可以为任意类型
//taskService.setVariable("5005", "hello", new Date());
//taskService.setVariables(taskId, variables);

//与当前任务ID绑定的流程变量，当前任务结束后变量消失
taskService.setVariableLocal("5005", "bd", "aaa");
//任务完成，流程变量失效
//taskService.complete("5005");
}
（3）设置流程变量
  RuntimeService runtimeService = engine.getRuntimeService();
TaskService taskService = engine.getTaskService();

/**设置流程变量*/
// 表示使用执行对象ID，和流程变量的名称，设置流程变量的值（一次只能设置一个值）
// runtimeService.setVariable(executionId, variableName, value)

// 表示使用执行对象ID，和Map集合设置流程变量，map集合的key就是流程变量的名称，map集合的value就是流程变量的值（一次设置多个值）
// runtimeService.setVariables(executionId, variables);

// 表示使用任务ID，和流程变量的名称，设置流程变量的值（一次只能设置一个值）
// taskService.setVariable(taskId, variableName, value)

// 表示使用任务ID，和Map集合设置流程变量，map集合的key就是流程变量的名称，map集合的value就是流程变量的值（一次设置多个值）
// taskService.setVariables(taskId, variables)

// 启动流程实例的同时，可以设置流程变量，用Map集合
// runtimeService.startProcessInstanceByKey(processDefinitionKey, variables);
// 完成任务的同时，设置流程变量，用Map集合
// taskService.complete(taskId, variables)
（4）获取流程变量
  /**获取流程变量*/
//使用执行对象ID和流程变量的名称，获取流程变量的值
// runtimeService.getVariable(executionId, variableName);

//使用执行对象ID，获取所有的流程变量，将流程变量放置到Map集合中，map集合的key就是流程变量的名称，map集合的value就是流程变量的值
// runtimeService.getVariables(executionId);

//使用执行对象ID，获取流程变量的值，通过设置流程变量的名称存放到集合中，获取指定流程变量名称的流程变量的值，值存放到Map集合中
// runtimeService.getVariables(executionId, variableNames);
//
//使用任务ID和流程变量的名称，获取流程变量的值
// taskService.getVariable(taskId, variableName);

//使用任务ID，获取所有的流程变量，将流程变量放置到Map集合中，map集合的key就是流程变量的名称，map集合的value就是流程变量的值
// taskService.getVariables(taskId);

//使用任务ID，获取流程变量的值，通过设置流程变量的名称存放到集合中，获取指定流程变量名称的流程变量的值，值存放到Map集合中
// taskService.getVariables(taskId, variableNames);
 
6.流程连线
（1）流程变量影响流程走向
设计流程时，为流程走向的连线设置条件，使用流程变量将变量的值输入，从而根据条件判断流程走向
  /**
* 启动流程
* 流程为两分支，to_u1走向u1节点，to_u2走向u2节点
*/
@Test
public void teststartProcessInstanceByKey(){
//部署流程
//engine.getRepositoryService().createDeployment().addClasspathResource("process/SequenceFlow.bpmn").addClasspathResource("process/SequenceFlow.png").name("sf").deploy();

Map<String, Object> variables = new HashMap<String, Object>();
variables.put("condition", "to_u1");//启动流程同时设置流程变量，确定流程走向u1
ProcessInstance processInstance = engine.getRuntimeService()
.startProcessInstanceByKey("SF", "BusinessKey",variables);

//流程实例中包含的信息
System.out.println("当前活动节点 "+processInstance.getActivityId());
System.out.println("关联业务键： "+processInstance.getBusinessKey());
System.out.println("流程部署id： "+processInstance.getDeploymentId());
System.out.println("流程描述： "+processInstance.getDescription());
System.out.println("流程实例id： "+processInstance.getId());
System.out.println("流程实例名称： "+processInstance.getName());
System.out.println("父流程id： "+processInstance.getParentId());
System.out.println("流程定义id： "+processInstance.getProcessDefinitionId());
System.out.println("流程定义key： "+processInstance.getProcessDefinitionKey());
System.out.println("流程定义名称： "+processInstance.getProcessDefinitionName());
System.out.println("流程实例id： "+processInstance.getProcessInstanceId());
System.out.println("流程所属人id： "+processInstance.getTenantId());
System.out.println("流程定义版本： "+processInstance.getProcessDefinitionVersion());
System.out.println("流程变量： "+processInstance.getProcessVariables());
System.out.println("是否结束： "+processInstance.isEnded());
System.out.println("是否暂停： "+processInstance.isSuspended());
System.out.println("################################");

}
（2）获得当前任务的出口连线

/**
* 通过任务id
* 查询连线路径信息
*/
@Test
public void testSequenceFlow(){
//存放连线的名称集合
List<String> list = new ArrayList<String>();
//1:使用任务ID，查询任务对象
Task task = engine.getTaskService().createTaskQuery()
.taskId("17505")//使用任务ID查询
.singleResult();
//2：获取流程定义ID
String processDefinitionId = task.getProcessDefinitionId();

//*********************1.使用流程定义id得到流程定义对象**************************
//3：查询ProcessDefinitionEntiy对象
ProcessDefinitionEntity processDefinitionEntity = (ProcessDefinitionEntity) engine.getRepositoryService()
.getProcessDefinition(processDefinitionId);

//使用任务对象Task获取流程实例ID
String processInstanceId = task.getProcessInstanceId();

//*********************2.使用流程实例得到当前活动节点****************************
//使用流程实例ID，查询正在执行的执行对象表，返回流程实例对象
ProcessInstance pi = engine.getRuntimeService().createProcessInstanceQuery()//
.processInstanceId(processInstanceId)//使用流程实例ID查询
.singleResult();
//获取当前活动的id
String activityId = pi.getActivityId();

//*********************3.使用流程定义对象查询活动*******************************
//4：获取当前的活动
ActivityImpl activityImpl = processDefinitionEntity.findActivity(activityId);

//5：获取当前活动完成之后连线的名称
List<PvmTransition> pvmList = activityImpl.getOutgoingTransitions();//出连线
if(pvmList!=null && pvmList.size()>0){
for(PvmTransition pvm:pvmList){
String name = (String) pvm.getProperty("name");
if(StringUtils.isNotBlank(name)){
list.add(name);
}
else{
//list.add("默认");
}
}
}
System.out.println(list);

/***************************************************/
List<String> list2 = new ArrayList<String>();
//获得当前所有活动节点id
List<String> alist = engine.getRuntimeService().getActiveActivityIds(task.getExecutionId());
for (String str : alist)
{
ActivityImpl activity = processDefinitionEntity.findActivity(str);
List<PvmTransition> pvmList2 = activity.getIncomingTransitions();//入连线
for (PvmTransition pvm : pvmList2)
{
String name = (String) pvm.getProperty("name");
if(StringUtils.isNotBlank(name)){
list2.add(name);
}
else{
//list.add("默认");
}
}
}
System.out.println(list2);
}

 
 
7.流程历史
流程历史需要使用historyService服务进行。
（1）历史活动查询
  /**
* 查询流程历史活动实例记录
* act_hi_actinst--活动记录表
*/
@Test
public void testactivityInstanceQuery(){
HistoricActivityInstanceQuery activityInstanceQuery = historyService.createHistoricActivityInstanceQuery();
//根据id查询
//activityInstanceQuery.activityId(activityId).singleResult();

//根据名称查询
//activityInstanceQuery.activityName(activityName).list();

//条件查询
List<HistoricActivityInstance> list = activityInstanceQuery.orderByActivityId().asc()
.orderByProcessDefinitionId().desc().listPage(0, 10);

if(list!=null && list.size()>0){
for (HistoricActivityInstance hai : list)
{
System.out.println("活动id： "+hai.getActivityId());
System.out.println("活动名称： "+hai.getActivityName());
System.out.println("活动类型： "+hai.getActivityType());
System.out.println("任务办理人： "+hai.getAssignee());
System.out.println("调用子流程实例id:"+hai.getCalledProcessInstanceId());
System.out.println("流程执行id： "+hai.getExecutionId());
System.out.println("记录id： "+hai.getId());
System.out.println("流程定义id： "+hai.getProcessDefinitionId());
System.out.println("流程实例id： "+hai.getProcessInstanceId());
System.out.println("任务id： "+hai.getTaskId());
System.out.println("历时时长： "+hai.getDurationInMillis());
System.out.println("流程结束时间： "+hai.getEndTime());//未结束流程该值为空
System.out.println("流程开始时间： "+hai.getStartTime());
System.out.println("创建时间： "+hai.getTime());
System.out.println("###########################");
}
}
}
（2）历史流程定义查询
  /**
* 历史流程定义查询
* act_hi_procinst--历史流程定义表
*/
@Test
public void testhistoricProcessInstanceQuery(){
HistoricProcessInstanceQuery historicProcessInstanceQuery = historyService
.createHistoricProcessInstanceQuery();

//使用条件查询并按ProcessDefinitionId进行升序排列
List<HistoricProcessInstance> list = historicProcessInstanceQuery.processInstanceId("5001").or()
.processDefinitionId("Var:1:2504").endOr().orderByProcessDefinitionId().asc().list();

if(list!=null && list.size()>0){
for (HistoricProcessInstance historicProcessInstance : list)
{
System.out.println("历时流程实例："+historicProcessInstance);
}
}
}
（3）历史任务实例查询
  /**
* 历史任务实例查询
* act_hi_taskinst--历史任务实例表
*/
@Test
public void testhistoricTaskInstanceQuery(){
HistoricTaskInstanceQuery historicTaskInstanceQuery = historyService
.createHistoricTaskInstanceQuery();

List<HistoricTaskInstance> list = historicTaskInstanceQuery.list();

if(list!=null && list.size()>0){

for (HistoricTaskInstance historicTaskInstance : list)
{
System.out.println("历史任务办理人： "+historicTaskInstance.getAssignee());
System.out.println("历史任务描述： "+historicTaskInstance.getDescription());
System.out.println("历史任务实例id： "+historicTaskInstance.getId());
System.out.println("历史执行id： "+historicTaskInstance.getExecutionId());
System.out.println("历史任务优先级： "+historicTaskInstance.getPriority());
System.out.println("历史流程定义id： "+historicTaskInstance.getProcessDefinitionId());
System.out.println("历史流程实例id： "+historicTaskInstance.getProcessInstanceId());
System.out.println("历史任务定义key： "+historicTaskInstance.getTaskDefinitionKey());
System.out.println("创建时间： "+historicTaskInstance.getCreateTime());
System.out.println("历史流程变量： "+historicTaskInstance.getProcessVariables());
System.out.println("###############################");
}
}

}
（4）其他
//历史流程变量查询
historyService.createHistoricVariableInstanceQuery();
//历史详情表
historyService.createHistoricDetailQuery();
//历史流程时日志查询
//historyService.createProcessInstanceHistoryLogQuery(processInstanceId);