//创建ProcessEngineConfiguration
ProcessEngineConfiguration configuration = 
ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml")
//通过ProcessEngineConfiguration创建ProcessEngine，此时会创建数据库
ProcessEngine processEngine = configuration.buildProcessEngine();
System.out.println(processEngine);

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

RuntimeService runtimeService = processEngine.getRuntimeService();
RepositoryService repositoryService = processEngine.getRepositoryService();
TaskService taskService = processEngine.getTaskService();
ManagementService managementService = processEngine.getManagementService();
IdentityService identityService = processEngine.getIdentityService();
HistoryService historyService = processEngine.getHistoryService();
FormService formService = processEngine.getFormService();
DynamicBpmnService dynamicBpmnService = processEngine.getDynamicBpmnService();

ProcessEngineConfiguration configuration = 
ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml")

ProcessEngineConfiguration.createProcessEngineConfigurationFromResource(String resource, String beanName);

//先构建ProcessEngineConfiguration
ProcessEngineConfiguration configuration = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml");
//通过ProcessEngineConfiguration创建ProcessEngine，此时会创建数据库
ProcessEngine processEngine = configuration.buildProcessEngine();

//直接使用工具类 ProcessEngines，使用classpath下的activiti.cfg.xml中的配置创建processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
System.out.println(processEngine);

RuntimeService runtimeService = processEngine.getRuntimeService();
RepositoryService repositoryService = processEngine.getRepositoryService();
TaskService taskService = processEngine.getTaskService();

package com.ydlclass.test;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.repository.Deployment;
import org.junit.Test;

public class ActivitiDemo {
    /**
     * 部署流程定义
     */
    @Test
    public void testDeployment(){
//        1、创建ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        2、得到RepositoryService实例
        RepositoryService repositoryService = processEngine.getRepositoryService();
//        3、使用RepositoryService进行部署
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource("bpmn/holiday.bpmn") // 添加bpmn资源
                .addClasspathResource("bpmn/holiday.png")  // 添加png资源
                .name("出差申请流程")
                .deploy();
//        4、输出部署信息
        System.out.println("流程部署id：" + deployment.getId());
        System.out.println("流程部署名称：" + deployment.getName());
    }
}

@Test
    public void deployProcessByZip() {
        // 定义zip输入流
        InputStream inputStream = this
                .getClass()
                .getClassLoader()
                .getResourceAsStream(
                        "bpmn/holiday.zip");
        ZipInputStream zipInputStream = new ZipInputStream(inputStream);
        // 获取repositoryService
        RepositoryService repositoryService = processEngine
                .getRepositoryService();
        // 流程部署
        Deployment deployment = repositoryService.createDeployment()
                .addZipInputStream(zipInputStream)
                .deploy();
        System.out.println("id：" + deployment.getId());
        System.out.println("Name：" + deployment.getName());
    }

    /**
     * 启动流程实例
     */
    @Test
    public void testStartProcess(){
//        1、创建ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        2、获取RunTimeService
        RuntimeService runtimeService = processEngine.getRuntimeService();
//        3、根据流程定义Id启动流程
        ProcessInstance processInstance = runtimeService
                .startProcessInstanceByKey("holiday");
//        输出内容
        System.out.println("流程定义id：" + processInstance.getProcessDefinitionId());
        System.out.println("流程实例id：" + processInstance.getId());
        System.out.println("当前活动Id：" + processInstance.getActivityId());
    }

/**
     * 查询当前个人待执行的任务
      */
    @Test
    public void testFindPersonalTaskList() {
//        任务负责人
        String assignee = "itlils";
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        创建TaskService
        TaskService taskService = processEngine.getTaskService();
//        根据流程key 和 任务负责人 查询任务
        List<Task> list = taskService.createTaskQuery()
                .processDefinitionKey("holiday") //流程Key
                .taskAssignee(assignee)//只查询该任务负责人的任务
                .list();

        for (Task task : list) {
            System.out.println("流程实例id：" + task.getProcessInstanceId());
            System.out.println("任务id：" + task.getId());
            System.out.println("任务负责人：" + task.getAssignee());
            System.out.println("任务名称：" + task.getName());

        }
    }

// 完成任务
    @Test
    public void completTask(){
//        获取引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        获取taskService
        TaskService taskService = processEngine.getTaskService();

//        根据流程key 和 任务的负责人 查询任务
//        返回一个任务对象
        Task task = taskService.createTaskQuery()
                .processDefinitionKey("holiday") //流程Key
                .taskAssignee("itlils")  //要查询的负责人
                .singleResult();

//        完成任务,参数：任务id
        taskService.complete(task.getId());
    }

    /**
     * 查询流程定义
     */
    @Test
    public void queryProcessDefinition(){
        //        获取引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        repositoryService
        RepositoryService repositoryService = processEngine.getRepositoryService();
//        得到ProcessDefinitionQuery 对象
        ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
//          查询出当前所有的流程定义
//          条件：processDefinitionKey =evection
//          orderByProcessDefinitionVersion 按照版本排序
//        desc倒叙
//        list 返回集合
        List<ProcessDefinition> definitionList = processDefinitionQuery.processDefinitionKey("holiday")
                .orderByProcessDefinitionVersion()
                .desc()
                .list();
//      输出流程定义信息
        for (ProcessDefinition processDefinition : definitionList) {
            System.out.println("id="+processDefinition.getId());
            System.out.println("name="+processDefinition.getName());
            System.out.println("key="+processDefinition.getKey());
            System.out.println("Version="+processDefinition.getVersion());
            System.out.println("DeploymentId ="+processDefinition.getDeploymentId());
        }

    }

public void deleteDeployment() {
        // 流程部署id
        String deploymentId = "1";

    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    // 通过流程引擎获取repositoryService
        RepositoryService repositoryService = processEngine
                .getRepositoryService();
        //删除流程定义，如果该流程定义已有流程实例启动则删除时出错
        repositoryService.deleteDeployment(deploymentId);
        //设置true 级联删除流程定义，即使该流程有流程实例启动也可以删除，设置为false非级别删除方式，如果流程
        //repositoryService.deleteDeployment(deploymentId, true);
    }

@Test
public void downloadFile() throws IOException {
    //创建流程引擎配置文件
    ProcessEngineConfiguration configuration
            = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cgf.xml","processEngineConfiguration");
    //通过配置文件，创建流程
    ProcessEngine processEngine = configuration.buildProcessEngine();

    RepositoryService repositoryService = processEngine.getRepositoryService();
    //1repositoryService 获取相应的数据
    ProcessDefinition definition = repositoryService.createProcessDefinitionQuery().processDefinitionKey("holiday").singleResult();
    String deploymentId = definition.getDeploymentId();

    InputStream xmlFileInputStream = repositoryService.getResourceAsStream(deploymentId,definition.getResourceName());
    InputStream pngInputStream = repositoryService.getResourceAsStream(deploymentId, definition.getDiagramResourceName());

    //2转成输出流，放到本地文件夹下
    FileOutputStream xmlFileOutputStream=new FileOutputStream(new File("e:/holiday.bpmn20.xml"));
    FileOutputStream pngFileOutputStream=new FileOutputStream(new File("e:/holiday.png"));

    //3工具类把输入流转成输出流
    IOUtils.copy(xmlFileInputStream,xmlFileOutputStream);
    IOUtils.copy(pngInputStream,pngFileOutputStream);

    //4关流
    pngFileOutputStream.close();
    xmlFileOutputStream.close();
    pngInputStream.close();
    xmlFileInputStream.close();
}

    /**
     * 查看历史信息
     */
    @Test
    public void findHistoryInfo(){
//      获取引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        获取HistoryService
        HistoryService historyService = processEngine.getHistoryService();
//        获取 actinst表的查询对象
        HistoricActivityInstanceQuery instanceQuery = historyService.createHistoricActivityInstanceQuery();
//        查询 actinst表，条件：根据 InstanceId 查询
//        instanceQuery.processInstanceId("2503");
//        查询 actinst表，条件：根据 DefinitionId 查询
        instanceQuery.processDefinitionId("holiday:1:4");
//        增加排序操作,orderByHistoricActivityInstanceStartTime 根据开始时间排序 asc 升序
        instanceQuery.orderByHistoricActivityInstanceStartTime().asc();
//        查询所有内容
        List<HistoricActivityInstance> activityInstanceList = instanceQuery.list();
//        输出
        for (HistoricActivityInstance hi : activityInstanceList) {
            System.out.println(hi.getActivityId());
            System.out.println(hi.getActivityName());
            System.out.println(hi.getProcessDefinitionId());
            System.out.println(hi.getProcessInstanceId());
            System.out.println("<==========================>");
        }
    }

    /**
     * 启动流程实例，添加businessKey
     */
    @Test
    public void addBusinessKey(){
//        1、得到ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        2、得到RunTimeService
        RuntimeService runtimeService = processEngine.getRuntimeService();
//        3、启动流程实例，同时还要指定业务标识businessKey，也就是出差申请单id，这里是1001
        ProcessInstance processInstance = runtimeService.
                startProcessInstanceByKey("holiday","10001");
//        4、输出processInstance相关属性
        System.out.println("id=="+processInstance.getBusinessKey());

    }

/**
     * 全部流程实例挂起与激活
     */
    @Test
    public void SuspendAllProcessInstance(){
//        获取processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        获取repositoryService
        RepositoryService repositoryService = processEngine.getRepositoryService();
//        查询流程定义的对象
        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().
                processDefinitionKey("holiday").
                singleResult();
//        得到当前流程定义的实例是否都为暂停状态
        boolean suspended = processDefinition.isSuspended();
//        流程定义id
        String processDefinitionId = processDefinition.getId();
//        判断是否为暂停
        if(suspended){
//         如果是暂停，可以执行激活操作 ,参数1 ：流程定义id ，参数2：是否激活，参数3：激活时间
            repositoryService.activateProcessDefinitionById(processDefinitionId,
                    true,
                    null
            );
            System.out.println("processDefinitionId："+processDefinitionId+",activate");
        }else{
//          如果是激活状态，可以暂停，参数1 ：流程定义id ，参数2：是否暂停，参数3：暂停时间
            repositoryService.suspendProcessDefinitionById(processDefinitionId,
                    true,
                    null);
            System.out.println("processDefinitionId："+processDefinitionId+",suspend");
        }

    }

/**
     * 单个流程实例挂起与激活
     */
    @Test
    public void SuspendSingleProcessInstance(){
//        获取processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        RuntimeService
        RuntimeService runtimeService = processEngine.getRuntimeService();
//        查询流程定义的对象
        ProcessInstance processInstance = runtimeService.
                createProcessInstanceQuery().
                processInstanceId("15001").
                singleResult();
//        得到当前流程定义的实例是否都为暂停状态
        boolean suspended = processInstance.isSuspended();
//        流程定义id
        String processDefinitionId = processInstance.getId();
//        判断是否为暂停
        if(suspended){
//         如果是暂停，可以执行激活操作 ,参数：流程定义id
            runtimeService.activateProcessInstanceById(processDefinitionId);
            System.out.println("processDefinitionId："+processDefinitionId+",activate");
        }else{
//          如果是激活状态，可以暂停，参数：流程定义id
            runtimeService.suspendProcessInstanceById( processDefinitionId);
            System.out.println("processDefinitionId："+processDefinitionId+",suspend");
        }

    }

    /**
     * 测试完成个人任务
     */
    @Test
    public void completTask(){
//        获取引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        获取操作任务的服务 TaskService
        TaskService taskService = processEngine.getTaskService();
//        完成任务,参数：流程实例id,完成zhangsan的任务
        Task task = taskService.createTaskQuery()
                .processInstanceId("15001")
                .taskAssignee("itlils")
                .singleResult();


        System.out.println("流程实例id="+task.getProcessInstanceId());
        System.out.println("任务Id="+task.getId());
        System.out.println("任务负责人="+task.getAssignee());
        System.out.println("任务名称="+task.getName());
        taskService.complete(task.getId());
    }

@Test
public void testDeploy(){
    //创建流程引擎配置文件
    ProcessEngineConfiguration configuration
            = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cgf.xml","processEngineConfiguration");
    //通过配置文件，创建流程
    ProcessEngine processEngine = configuration.buildProcessEngine();

    RepositoryService repositoryService = processEngine.getRepositoryService();
    Deployment deployment = repositoryService.createDeployment()
            .addClasspathResource("bpmn/holiday-uel.bpmn20.xml")//增加bpmn.xml
            .name("出差流程-uel") //名字
            .deploy();

    System.out.println("id"+deployment.getId());
    System.out.println("Name"+deployment.getName());
}


@Test
public void testStartProcess(){
    //创建流程引擎配置文件
    ProcessEngineConfiguration configuration
            = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cgf.xml","processEngineConfiguration");
    //通过配置文件，创建流程
    ProcessEngine processEngine = configuration.buildProcessEngine();

    RuntimeService runtimeService = processEngine.getRuntimeService();
    //启动实例
    Map<String,Object> map=new HashMap<>();
    map.put("assignee0","itlils");
    map.put("assignee1","zhuzhu");
    map.put("assignee2","itnanls");
    map.put("assignee3","weiwei");
    ProcessInstance instance = runtimeService.startProcessInstanceByKey("holiday1",map);

    System.out.println("ProcessDefinitionId"+instance.getProcessDefinitionId());
    System.out.println("Id"+instance.getId());
    System.out.println("ActivityId"+instance.getActivityId());
}

public class MyTaskListener implements TaskListener {
    @Override
    public void notify(DelegateTask delegateTask) {
        if(delegateTask.getName().equals("创建出差申请")&&
                delegateTask.getEventName().equals("create")){
            //这里指定任务负责人
            delegateTask.setAssignee("itlils");
        }
    }
} 

// 查询当前个人待执行的任务
@Test
public void findPersonalTaskList() {
    // 流程定义key
    String processDefinitionKey = "myEvection1";
    // 任务负责人
    String assignee = "itlils";
    // 获取TaskService
    TaskService taskService = processEngine.getTaskService();
    List<Task> taskList = taskService.createTaskQuery()
        .processDefinitionKey(processDefinitionKey)
        .includeProcessVariables()
        .taskAssignee(assignee)
        .list();
    for (Task task : taskList) {
        System.out.println("----------------------------");
        System.out.println("流程实例id： " + task.getProcessInstanceId());
        System.out.println("任务id： " + task.getId());
        System.out.println("任务负责人： " + task.getAssignee());
        System.out.println("任务名称： " + task.getName());
    }
}

@Test
    public void findProcessInstance(){
//        获取processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        获取TaskService
        TaskService taskService = processEngine.getTaskService();
//        获取RuntimeService
        RuntimeService runtimeService = processEngine.getRuntimeService();
//        查询流程定义的对象
        Task task = taskService.createTaskQuery()
                .processDefinitionKey("holiday")
                .taskAssignee("itlils")
                .singleResult();
//        使用task对象获取实例id
        String processInstanceId = task.getProcessInstanceId();
//          使用实例id，获取流程实例对象
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
                .processInstanceId(processInstanceId)
                .singleResult();
//        使用processInstance，得到 businessKey
        String businessKey = processInstance.getBusinessKey();

        System.out.println("businessKey=="+businessKey);

    }

/**
     * 完成任务，判断当前用户是否有权限
     */
    @Test
    public void completTask() {
        //任务id
        String taskId = "8888";
//        任务负责人
        String assingee = "itlils";
        //获取processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        // 创建TaskService
        TaskService taskService = processEngine.getTaskService();
//        完成任务前，需要校验该负责人可以完成当前任务
//        校验方法：
//        根据任务id和任务负责人查询当前任务，如果查到该用户有权限，就完成
        Task task = taskService.createTaskQuery()
                .taskId(taskId)
                .taskAssignee(assingee)
                .singleResult();
        if(task != null){
            taskService.complete(taskId);
            System.out.println("完成任务");
        }
    }

public class Holidays implements Serializable {
    /**
     * 主键id
     */
    private Long id;
    /**
     * 出差申请单名称
     */
    private String holidaysName;
    /**
     * 出差天数
     */
    private Double num;
    /**
     * 预计开始时间
     */
    private Date beginDate;
    /**
     * 预计结束时间
     */
    private Date endDate;
    /**
     * 目的地
     */
    private String destination;
    /**
     * 出差事由
     */
    private String reson;

    @Override
    public String toString() {
        return "Holidays{" +
                "id=" + id +
                ", holidaysName='" + holidaysName + '\'' +
                ", num=" + num +
                ", beginDate=" + beginDate +
                ", endDate=" + endDate +
                ", destination='" + destination + '\'' +
                ", reson='" + reson + '\'' +
                '}';
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getHolidaysName() {
        return holidaysName;
    }

    public void setHolidaysName(String holidaysName) {
        this.holidaysName = holidaysName;
    }

    public Double getNum() {
        return num;
    }

    public void setNum(Double num) {
        this.num = num;
    }

    public Date getBeginDate() {
        return beginDate;
    }

    public void setBeginDate(Date beginDate) {
        this.beginDate = beginDate;
    }

    public Date getEndDate() {
        return endDate;
    }

    public void setEndDate(Date endDate) {
        this.endDate = endDate;
    }

    public String getDestination() {
        return destination;
    }

    public void setDestination(String destination) {
        this.destination = destination;
    }

    public String getReson() {
        return reson;
    }

    public void setReson(String reson) {
        this.reson = reson;
    }
}

/**
 * 启动流程实例,设置流程变量的值
 */
@Test
public void startProcess(){
    //创建流程引擎配置文件
    ProcessEngineConfiguration configuration
            = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cgf.xml","processEngineConfiguration");
    //通过配置文件，创建流程
    ProcessEngine processEngine = configuration.buildProcessEngine();

    RuntimeService runtimeService = processEngine.getRuntimeService();
    //启动实例
    Map<String,Object> map=new HashMap<>();
    Holidays holidays = new Holidays();
    holidays.setNum(2d);
    map.put("holidays",holidays);

    map.put("assignee0","itlils");
    map.put("assignee1","zhuzhu");
    map.put("assignee2","itnanls");
    map.put("assignee3","weiwei");
    ProcessInstance instance = runtimeService.startProcessInstanceByKey("holiday-global1",map);

    System.out.println("ProcessDefinitionId"+instance.getProcessDefinitionId());
    System.out.println("Id"+instance.getId());
    System.out.println("ActivityId"+instance.getActivityId());
}

@Test
public void testCompletTask(){
    //创建流程引擎配置文件
    ProcessEngineConfiguration configuration
            = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cgf.xml","processEngineConfiguration");
    //通过配置文件，创建流程
    ProcessEngine processEngine = configuration.buildProcessEngine();
    TaskService taskService = processEngine.getTaskService();

    Task task1 = taskService.createTaskQuery()
            .processDefinitionKey("holiday-global1")
            .taskAssignee("weiwei1")
            .singleResult();

    if(task1!=null){
        taskService.complete(task1.getId());
    }

}

    /**
     * 完成任务，判断当前用户是否有权限
     */
    @Test
    public void completTask() {
        //任务id
        String key = "holiday-global1";
//        任务负责人
        String assingee = "itlils";
//       获取processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//       创建TaskService
        TaskService taskService = processEngine.getTaskService();
//       创建变量集合
        Map<String, Object> map = new HashMap<>();
//        创建出差pojo对象
        Holidays holidays = new Holidays();
        holidays.setNum(2d);
        map.put("holidays",holidays);
//        完成任务前，需要校验该负责人可以完成当前任务
//        校验方法：
//        根据任务id和任务负责人查询当前任务，如果查到该用户有权限，就完成
        Task task = taskService.createTaskQuery()
                .processDefinitionKey(key)
                .taskAssignee(assingee)
                .singleResult();
        if(task != null){
            //完成任务是，设置流程变量的值
            taskService.complete(task.getId(),map);
            System.out.println("任务执行完成");
        }
    }

    @Test
    public void setGlobalVariableByExecutionId(){
//    当前流程实例执行 id，通常设置为当前执行的流程实例
        String executionId="2601";
//     获取processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        获取RuntimeService
        RuntimeService runtimeService = processEngine.getRuntimeService();
//        创建出差pojo对象
        Holidays holidays = new Holidays();
        holidays.setNum(2d);
//      通过流程实例 id设置流程变量
        runtimeService.setVariable(executionId, "holidays", holidays);
//      一次设置多个值
//      runtimeService.setVariables(executionId, variables)
    }

@Test
    public void setGlobalVariableByTaskId(){

        //当前待办任务id
        String taskId="1404";
//     获取processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Holidays holidays = new Holidays();
        holidays.setNum(2d);
        //通过任务设置流程变量
        taskService.setVariable(taskId, "holidays", holidays);
        //一次设置多个值 
        //taskService.setVariables(taskId, variables)
    }

/*
*处理任务时设置local流程变量
*/
@Test
public void completTask() {
   //任务id
   String taskId = "1404";
//  获取processEngine
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    TaskService taskService = processEngine.getTaskService();
//  定义流程变量
   Map<String, Object> variables = new HashMap<String, Object>();
   Holidays holidays = new Holidays();
   holidays.setNum(2d);
// 定义流程变量
   Map<String, Object> variables = new HashMap<String, Object>();
//  变量名是holiday，变量值是holiday对象
    variables.put("holidays", holidays);
//  设置local变量，作用域为该任务
    taskService.setVariablesLocal(taskId, variables);
//  完成任务
   taskService.complete(taskId);
}

@Test
public void setLocalVariableByTaskId(){
//   当前待办任务id
    String taskId="1404";
//  获取processEngine
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    TaskService taskService = processEngine.getTaskService();
    Holidays holidays = new Holidays();
    holidays.setNum(2d);
//  通过任务设置流程变量
    taskService.setVariableLocal(taskId, "holidays", holidays);
//  一次设置多个值 
    //taskService.setVariablesLocal(taskId, variables)
}

// 创建历史任务查询对象
      HistoricTaskInstanceQuery historicTaskInstanceQuery = historyService.createHistoricTaskInstanceQuery();
      // 查询结果包括 local变量
      historicTaskInstanceQuery.includeTaskLocalVariables();
for (HistoricTaskInstance historicTaskInstance : list) {
         System.out.println("==============================");
         System.out.println("任务id：" + historicTaskInstance.getId());
         System.out.println("任务名称：" + historicTaskInstance.getName());
         System.out.println("任务负责人：" + historicTaskInstance.getAssignee());
     System.out.println("任务local变量："+ historicTaskInstance.getTaskLocalVariables());

}

@Test
public void findGroupTaskList() {
   // 流程定义key
   String processDefinitionKey = "holiday-group1";
   // 任务候选人
   String candidateUser = "itwangls";
    //  获取processEngine
   ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
   // 创建TaskService
   TaskService taskService = processEngine.getTaskService();
   //查询组任务
   List<Task> list = taskService.createTaskQuery()
          .processDefinitionKey(processDefinitionKey)
          .taskCandidateUser(candidateUser)//根据候选人查询
          .list();
   for (Task task : list) {
       System.out.println("----------------------------");
       System.out.println("InstanceId：" + task.getProcessInstanceId());
       System.out.println("id：" + task.getId());
       System.out.println("Assignee：" + task.getAssignee());
       System.out.println("Name：" + task.getName());
   }
}