Activiti6 series (5) - core API

Foreword

Originally he wanted to "Crazy workflow handouts -activiti6.0" This book is an example inside to take over, but after reading this book I think the core API code fragment activiti6 written there is not very clear, there are many needs polish where it goes form a blog.
So I put the case before seen dark horse activiti5 take over running into activiti6.0 dependent test, can be used normally, indicating that the core API 5 and 6 is the most commonly used is actually not that much difference, but the dark horse of activiti snippet core API to write more user-friendly, simple comment, glance, picked over.

First, the code creates a table

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);
    }
}

Two, HelloWorld achieve the most basic processes

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);
    }
    
}

Third, the process definition

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);
            }
        }
    }
}

Fourth, process instances, task execution object

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());
    }
}

Fifth, the process variables

Person

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;
    }
    
    
}

ProcessVariablesTest

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("###############################################");
            }
        }
    }
}

Sixth, process history

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("###############################################");
            }
        }
    }
    
}

to sum up

activiti6.0 core is its API, 28 respectively correspond to the table a few tables, typically 1-2 pieces, the API actually CRUD operations on these tables, the operation of the entire process is actually these table data changes, so long as the core of the API activiti6.0 master, process instances can be more skilled and control operations.