码迷,mamicode.com
首页 > Windows程序 > 详细

Activiti6系列(5)- 核心API

时间:2019-08-09 01:52:48      阅读:133      评论:0      收藏:0      [点我收藏+]

标签:efi   puts   row   let   type   数据类型   inpu   init   ini   

前言



本来想把《疯狂工作流讲义-activiti6.0》这本书里面的实例拿过来,但是这本书我看完后,认为里面编写的activiti6的核心API代码片段不是很清晰,有不少需要雕琢的地方才好形成一篇博客。
所以我就把以前看过的黑马activiti5的案例拿过来放到activiti6.0依赖中运行测试,可以正常使用,说明5和6的核心API也就是最常用的那些其实没多少区别,而黑马的activiti核心API的代码片段写的更加通俗易懂,注释简洁,一目了然,就摘取了过来。




一、代码创建表


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




二、HelloWorld实现最基本的流程


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




三、流程定义


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




四、流程实例、任务、执行对象


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

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




六、流程历史


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




总结

activiti6.0最核心的就是它的API,分别对应了28张表中的某几张表,一般是1-2张,API的操作实际上就是对这些表的CRUD,而整个流程的运转实际上就是这些表数据的变化,因此,只要掌握了activiti6.0的核心API,就能对流程实例进行更熟练的控制和操作。




Activiti6系列(5)- 核心API

标签:efi   puts   row   let   type   数据类型   inpu   init   ini   

原文地址:https://www.cnblogs.com/fulongyuanjushi/p/11324589.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!