Activiti6系列（5）- 核心API

前言

本來想把《瘋狂工作流講義-activiti6.0》這本書里面的實例拿過來，但是這本書我看完后，認為里面編寫的activiti6的核心API代碼片段不是很清晰，有不少需要雕琢的地方才好形成一篇博客。 所以我就把以前看過的黑馬activiti5的案例拿過來放到activiti6.0依賴中運行測試，可以正常使用，說明5和6的核心API也就是最常用的那些其實沒多少區別，而黑馬的activiti核心API的代碼片段寫的更加通俗易懂，注釋簡潔，一目了然，就摘取了過來。

一、代碼創建表

```java package com.guoj.activiti.A_CreateTable;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.junit.Test;

public class TestActiviti {

/**使用代碼創建工作流需要的23張表*/
@Test
public void createTable(){
	ProcessEngineConfiguration processEngineConfiguration = ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();
	//連接數據庫的配置
	processEngineConfiguration.setJdbcDriver("com.mysql.jdbc.Driver");
	processEngineConfiguration.setJdbcUrl("jdbc:mysql://localhost:3306/activiti6_guoj?useUnicode=true&characterEncoding=utf8");
	processEngineConfiguration.setJdbcUsername("root");
	processEngineConfiguration.setJdbcPassword("123456");
	
	/**
	 	public static final String DB_SCHEMA_UPDATE_FALSE = "false";不能自動創建表，需要表存在
		public static final String DB_SCHEMA_UPDATE_CREATE_DROP = "create-drop";先刪除表再創建表
		public static final String DB_SCHEMA_UPDATE_TRUE = "true";如果表不存在，自動創建表
	 */
	processEngineConfiguration.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
	//工作流的核心對象，ProcessEnginee對象
	ProcessEngine processEngine = processEngineConfiguration.buildProcessEngine();
	System.out.println("processEngine:"+processEngine);
}

/**使用配置文件創建工作流需要的23張表*/
@Test
public void createTable_2(){

// ProcessEngineConfiguration processEngineConfiguration = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml");
// //工作流的核心對象，ProcessEnginee對象
// ProcessEngine processEngine = processEngineConfiguration.buildProcessEngine();

	ProcessEngine processEngine = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml")	//
								.buildProcessEngine();
	System.out.println("processEngine:"+processEngine);
}

}

<br>
<br>

###二、HelloWorld實現最基本的流程
<br>
```java
package com.guoj.activiti.B_HelloWorld;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.junit.Test;

import java.util.List;

public class HelloWorld {
	
	ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

	/**部署流程定義*/
	@Test
	public void deploymentProcessDefinition(){
		Deployment deployment = processEngine.getRepositoryService()//與流程定義和部署對象相關的Service
						.createDeployment()//創建一個部署對象
						.name("helloworld入門程序")//添加部署的名稱
						.addClasspathResource("diagram/helloworld.bpmn")//從classpath的資源中加載，一次只能加載一個文件
						.addClasspathResource("diagram/helloworld.png")//從classpath的資源中加載，一次只能加載一個文件
						.deploy();//完成部署
		System.out.println("部署ID："+deployment.getId());//1
		System.out.println("部署名稱："+deployment.getName());//helloworld入門程序  
	}
	
	/**啟動流程實例*/
	@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
	}
	
	
	/**查詢當前人的個人任務*/
	@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("########################################################");
			}
		}
	}
	
	/**完成我的任務*/
	@Test
	public void completeMyPersonalTask(){
		//任務ID
		String taskId = "105002";
		processEngine.getTaskService()//與正在執行的任務管理相關的Service
					.complete(taskId);
		System.out.println("完成任務：任務ID："+taskId);
	}
	
}

三、流程定義

```java package com.guoj.activiti.C_ProcessDefinition;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.repository.ProcessDefinition;
import org.apache.commons.io.FileUtils;
import org.junit.Test;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.zip.ZipInputStream;

public class ProcessDefinitionTest {

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

/**部署流程定義（從classpath）*/
@Test
public void deploymentProcessDefinition_classpath(){
	Deployment deployment = processEngine.getRepositoryService()//與流程定義和部署對象相關的Service
					.createDeployment()//創建一個部署對象
					.name("流程定義")//添加部署的名稱
					.addClasspathResource("diagrams/helloworld.bpmn")//從classpath的資源中加載，一次只能加載一個文件
					.addClasspathResource("diagrams/helloworld.png")//從classpath的資源中加載，一次只能加載一個文件
					.deploy();//完成部署
	System.out.println("部署ID："+deployment.getId());//
	System.out.println("部署名稱："+deployment.getName());//
}

/**部署流程定義（從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());//
}

/**查詢流程定義*/
@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("#########################################################");
}
}
}

/**刪除流程定義*/
@Test
public void deleteProcessDefinition(){
	//使用部署ID，完成刪除
	String deploymentId = "601";
	/**
	 * 不帶級聯的刪除
	 *    只能刪除沒有啟動的流程，如果流程啟動，就會拋出異常
	 */

// processEngine.getRepositoryService()//
// .deleteDeployment(deploymentId);

	/**
	 * 級聯刪除
	 * 	  不管流程是否啟動，都能可以刪除
	 */
	processEngine.getRepositoryService()//
					.deleteDeployment(deploymentId, true);
	System.out.println("刪除成功！");
}

/**查看流程圖
 * @throws IOException */
@Test
public void viewPic() throws IOException{
	/**將生成圖片放到文件夾下*/
	String deploymentId = "801";

	//============== 第一種方式 start ==================//
	//獲取圖片資源名稱
	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);
	//============== 第一種方式 end ==================//

	//=============== 第二種方式 start ==================//

// // 查詢流程定義
// ProcessDefinition processDefinition = processEngine.getRepositoryService().createProcessDefinitionQuery().deploymentId(dep.getId())
// .singleResult();
// // 查詢圖片資源文件
// InputStream is = processEngine.getRepositoryService().getProcessDiagram(processDefinition.getId());
// //將圖片生成到D盤的目錄下
// File file = new File("D:/"+resourceName);
// //將輸入流的圖片寫到D盤下
// FileUtils.copyInputStreamToFile(in, file);
//=============== 第二種方式 end ==================//
}

/***附加功能：查詢最新版本的流程定義*/
@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相同的所有不同版本的流程定義）*/
@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);
		}
	}
}

}

<br>
<br>

###四、流程實例、任務、執行對象
<br>
```java
package com.guoj.activiti.D_ProcessInstance;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.history.HistoricProcessInstance;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.junit.Test;

import java.io.InputStream;
import java.util.List;
import java.util.zip.ZipInputStream;

public class ProcessInstanceTest {

	ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
	
	/**部署流程定義（從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());//
	}
	
	/**啟動流程實例*/
	@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
	}
	
	/**查詢當前人的個人任務*/
	@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("########################################################");
			}
		}
	}
	
	/**完成我的任務*/
	@Test
	public void completeMyPersonalTask(){
		//任務ID
		String taskId = "1202";
		processEngine.getTaskService()//與正在執行的任務管理相關的Service
					.complete(taskId);
		System.out.println("完成任務：任務ID："+taskId);
	}
	
	/**查詢流程狀態（判斷流程正在執行，還是結束）*/
	@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("流程沒有結束");
		}
	}
	
	/**查詢歷史任務（后面講）*/
	@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("################################");
			}
		}
	}
	
	/**查詢歷史流程實例（后面講）*/
	@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());
	}
}

五、流程變量

**Person** ```java package com.guoj.activiti.E_ProcessVariables;

import java.io.Serializable;

public class Person implements Serializable {
/**
*
*/
private static final long serialVersionUID = 6757393795687480331L;

private Integer id;//編號
private String name;//姓名

private String education;

public String getEducation() {
	return education;
}
public void setEducation(String education) {
	this.education = education;
}
public Integer getId() {
	return id;
}
public void setId(Integer id) {
	this.id = id;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}

}

<br>

**ProcessVariablesTest**
```java
package com.guoj.activiti.E_ProcessVariables;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.history.HistoricVariableInstance;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.junit.Test;

import java.io.InputStream;
import java.util.List;

public class ProcessVariablesTest {

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
	
	/**部署流程定義（從InputStream）*/
	@Test
	public void deploymentProcessDefinition_inputStream(){
		InputStream inputStreambpmn = this.getClass().getResourceAsStream("/diagrams/processVariables.bpmn");
		InputStream inputStreampng = this.getClass().getResourceAsStream("/diagrams/processVariables.png");
		Deployment deployment = processEngine.getRepositoryService()//與流程定義和部署對象相關的Service
						.createDeployment()//創建一個部署對象
						.name("流程定義")//添加部署的名稱
						.addInputStream("processVariables.bpmn", inputStreambpmn)//使用資源文件的名稱（要求：與資源文件的名稱要一致），和輸入流完成部署
						.addInputStream("processVariables.png", inputStreampng)//使用資源文件的名稱（要求：與資源文件的名稱要一致），和輸入流完成部署
						.deploy();//完成部署
		System.out.println("部署ID："+deployment.getId());//
		System.out.println("部署名稱："+deployment.getName());//
	}
	
	/**啟動流程實例*/
	@Test
	public void startProcessInstance(){
		//流程定義的key
		String processDefinitionKey = "processVariables";
		ProcessInstance pi = processEngine.getRuntimeService()//與正在執行的流程實例和執行對象相關的Service
						.startProcessInstanceByKey(processDefinitionKey);//使用流程定義的key啟動流程實例，key對應helloworld.bpmn文件中id的屬性值，使用key值啟動，默認是按照最新版本的流程定義啟動
		System.out.println("流程實例ID:"+pi.getId());//流程實例ID    
		System.out.println("流程定義ID:"+pi.getProcessDefinitionId());//流程定義ID  
	}
	
	
	/**設置流程變量*/
	@Test
	public void setVariables(){
		/**與任務（正在執行）*/
		TaskService taskService = processEngine.getTaskService();
		//任務ID
		String taskId = "2104";
		/**一：設置流程變量，使用基本數據類型*/
//		taskService.setVariableLocal(taskId, "請假天數", 5);//與任務ID綁定
//		taskService.setVariable(taskId, "請假日期", new Date());
//		taskService.setVariable(taskId, "請假原因", "回家探親，一起吃個飯");
		/**二：設置流程變量，使用javabean類型*/
		/**
		 * 當一個javabean（實現序列號）放置到流程變量中，要求javabean的屬性不能再發生變化
		 *    * 如果發生變化，再獲取的時候，拋出異常
		 *  
		 * 解決方案：在Person對象中添加：
		 * 		private static final long serialVersionUID = 6757393795687480331L;
		 *      同時實現Serializable 
		 * */
		Person p = new Person();
		p.setId(20);
		p.setName("翠花");
		taskService.setVariable(taskId, "人員信息(添加固定版本)", p);
		
		System.out.println("設置流程變量成功！");
	}
	
	/**獲取流程變量*/
	@Test
	public void getVariables(){
		/**與任務（正在執行）*/
		TaskService taskService = processEngine.getTaskService();
		//任務ID
		String taskId = "2104";
		/**一：獲取流程變量，使用基本數據類型*/
//		Integer days = (Integer) taskService.getVariable(taskId, "請假天數");
//		Date date = (Date) taskService.getVariable(taskId, "請假日期");
//		String resean = (String) taskService.getVariable(taskId, "請假原因");
//		System.out.println("請假天數："+days);
//		System.out.println("請假日期："+date);
//		System.out.println("請假原因："+resean);
		/**二：獲取流程變量，使用javabean類型*/
		Person p = (Person)taskService.getVariable(taskId, "人員信息(添加固定版本)");
		System.out.println(p.getId()+"        "+p.getName());
	}
	
	/**模擬設置和獲取流程變量的場景*/
	public void setAndGetVariables(){
		/**與流程實例，執行對象（正在執行）*/
		RuntimeService runtimeService = processEngine.getRuntimeService();
		/**與任務（正在執行）*/
		TaskService taskService = processEngine.getTaskService();
		
		/**設置流程變量*/
//		runtimeService.setVariable(executionId, variableName, value)//表示使用執行對象ID，和流程變量的名稱，設置流程變量的值（一次只能設置一個值）
//		runtimeService.setVariables(executionId, variables)//表示使用執行對象ID，和Map集合設置流程變量，map集合的key就是流程變量的名稱，map集合的value就是流程變量的值（一次設置多個值）
		
//		taskService.setVariable(taskId, variableName, value)//表示使用任務ID，和流程變量的名稱，設置流程變量的值（一次只能設置一個值）
//		taskService.setVariables(taskId, variables)//表示使用任務ID，和Map集合設置流程變量，map集合的key就是流程變量的名稱，map集合的value就是流程變量的值（一次設置多個值）
		
//		runtimeService.startProcessInstanceByKey(processDefinitionKey, variables);//啟動流程實例的同時，可以設置流程變量，用Map集合
//		taskService.complete(taskId, variables)//完成任務的同時，設置流程變量，用Map集合
		
		/**獲取流程變量*/
//		runtimeService.getVariable(executionId, variableName);//使用執行對象ID和流程變量的名稱，獲取流程變量的值
//		runtimeService.getVariables(executionId);//使用執行對象ID，獲取所有的流程變量，將流程變量放置到Map集合中，map集合的key就是流程變量的名稱，map集合的value就是流程變量的值
//		runtimeService.getVariables(executionId, variableNames);//使用執行對象ID，獲取流程變量的值，通過設置流程變量的名稱存放到集合中，獲取指定流程變量名稱的流程變量的值，值存放到Map集合中
		
//		taskService.getVariable(taskId, variableName);//使用任務ID和流程變量的名稱，獲取流程變量的值
//		taskService.getVariables(taskId);//使用任務ID，獲取所有的流程變量，將流程變量放置到Map集合中，map集合的key就是流程變量的名稱，map集合的value就是流程變量的值
//		taskService.getVariables(taskId, variableNames);//使用任務ID，獲取流程變量的值，通過設置流程變量的名稱存放到集合中，獲取指定流程變量名稱的流程變量的值，值存放到Map集合中
		
	}
	
	/**完成我的任務*/
	@Test
	public void completeMyPersonalTask(){
		//任務ID
		String taskId = "2402";
		processEngine.getTaskService()//與正在執行的任務管理相關的Service
					.complete(taskId);
		System.out.println("完成任務：任務ID："+taskId);
	}
	
	/**查詢流程變量的歷史表*/
	@Test
	public void findHistoryProcessVariables(){
		List<HistoricVariableInstance> list = processEngine.getHistoryService()//
						.createHistoricVariableInstanceQuery()//創建一個歷史的流程變量查詢對象
						.variableName("請假天數")
						.list();
		if(list!=null && list.size()>0){
			for(HistoricVariableInstance hvi:list){
				System.out.println(hvi.getId()+"   "+hvi.getProcessInstanceId()+"   "+hvi.getVariableName()+"   "+hvi.getVariableTypeName()+"    "+hvi.getValue());
				System.out.println("###############################################");
			}
		}
	}
}

六、流程歷史

```java package com.guoj.activiti.F_HistoryQuery;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.history.HistoricActivityInstance;
import org.activiti.engine.history.HistoricProcessInstance;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.history.HistoricVariableInstance;
import org.junit.Test;

import java.util.List;

public class HistoryQueryTest {

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

/**查詢歷史流程實例*/
@Test
public void findHistoryProcessInstance(){
	String processInstanceId = "2101";
	HistoricProcessInstance hpi = processEngine.getHistoryService()//與歷史數據（歷史表）相關的Service
					.createHistoricProcessInstanceQuery()//創建歷史流程實例查詢
					.processInstanceId(processInstanceId)//使用流程實例ID查詢
					.orderByProcessInstanceStartTime().asc()
					.singleResult();
	System.out.println(hpi.getId()+"    "+hpi.getProcessDefinitionId()+"    "+hpi.getStartTime()+"    "+hpi.getEndTime()+"     "+hpi.getDurationInMillis());
}

/**查詢歷史活動*/
@Test
public void findHistoryActiviti(){
	String processInstanceId = "2101";
	List<HistoricActivityInstance> list = processEngine.getHistoryService()//
					.createHistoricActivityInstanceQuery()//創建歷史活動實例的查詢
					.processInstanceId(processInstanceId)//
					.orderByHistoricActivityInstanceStartTime().asc()//
					.list();
	if(list!=null && list.size()>0){
		for(HistoricActivityInstance hai:list){
			System.out.println(hai.getId()+"   "+hai.getProcessInstanceId()+"   "+hai.getActivityType()+"  "+hai.getStartTime()+"   "+hai.getEndTime()+"   "+hai.getDurationInMillis());
			System.out.println("#####################");
		}
	}
}

/**查詢歷史任務*/
@Test
public void findHistoryTask(){
	String processInstanceId = "2101";
	List<HistoricTaskInstance> list = processEngine.getHistoryService()//與歷史數據（歷史表）相關的Service
					.createHistoricTaskInstanceQuery()//創建歷史任務實例查詢
					.processInstanceId(processInstanceId)//
					.orderByHistoricTaskInstanceStartTime().asc()
					.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("################################");
		}
	}
}

/**查詢歷史流程變量*/
@Test
public void findHistoryProcessVariables(){
	String processInstanceId = "2101";
	List<HistoricVariableInstance> list = processEngine.getHistoryService()//
					.createHistoricVariableInstanceQuery()//創建一個歷史的流程變量查詢對象
					.processInstanceId(processInstanceId)//
					.list();
	if(list!=null && list.size()>0){
		for(HistoricVariableInstance hvi:list){
			System.out.println(hvi.getId()+"   "+hvi.getProcessInstanceId()+"   "+hvi.getVariableName()+"   "+hvi.getVariableTypeName()+"    "+hvi.getValue());
			System.out.println("###############################################");
		}
	}
}

}

<br>
<br>

###總結
activiti6.0最核心的就是它的API，分別對應了28張表中的某幾張表，一般是1-2張，API的操作實際上就是對這些表的CRUD，而整個流程的運轉實際上就是這些表數據的變化，因此，只要掌握了activiti6.0的核心API，就能對流程實例進行更熟練的控制和操作。

<br>
<br>