Activiti02流程基本功能使用

主要分为一下几个步骤：

　　1.画图

　　2.部署流程-把图的信息转入到数据表格中

　　3.创建流程实例-开始一个流程-实际发起了一个流程

　　4.执行任务：获取任务+完成任务

1.画图

　　画了一个简单的流程图，图形文件名称是：qj01.bpmn   id:myProcess_1

　　   流程： 请假(qingjia)--->审批(shenpi)--->结束

　　

指定了这一步骤的名称和执行人   Assignee:dcc  执行人时dcc

指定了第二步的名称和执行人  Assignee:jcc  执行人时jcc

 2.部署流程

2.1方法1

　　(本地测试可以用下，实际项目不使用)

  private ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

    //流程定义
    @Test
    public void deploy(){
        RepositoryService repositoryService = processEngine.getRepositoryService();
        Deployment de = repositoryService.createDeployment().addClasspathResource("bpmn/qj01.bpmn").name("qj").deploy();  //这里name里面传入中文，到act_re_deployment表可能出现乱码
        System.out.println("部署id"+de.getId());

        /*
        流程定义：
        流程部署表 re_deployment
        流程定义表 re_procdef
        资源信息表 ge_bytearray
        */
    }

addClasspathResource("bpmn/qj01.bpmn")，这里文件是bpmn图形文件的路径

执行，在数据库中查看，影响到3张数据表格：流程部署表 re_deployment  流程定义表 re_procdef  资源信息表 ge_bytearray

2.2方法2：上传压缩文件的方式

2.2.1第一步：把bpmnt图形文件压缩成zip文件

　　

2.2.2编码

　　这里我省略了上传zip文件的过程，直接从本地读取的

@Test
public void deploy2() throws FileNotFoundException {
    RepositoryService repositoryService = processEngine.getRepositoryService();
    InputStream in = new FileInputStream("C:\\Users\\Administrator\\IdeaProjects\\jsnhcopy\\src\\main\\resources\\bpmn\\qj01.zip"); //zip文件路径
    ZipInputStream zipInputStream = new ZipInputStream(in);
    Deployment deploy = repositoryService.createDeployment().addZipInputStream(zipInputStream).name("qjlc").deploy();

    System.out.println("部署id"+deploy.getId());

    /*
    流程定义：
    流程部署表 re_deployment
    流程定义表 re_procdef
    资源信息表 ge_bytearray
    */
}

2.3中文乱码问题
　　存在中文的时候，出现乱码，尝试了各种方法，都没有生效
　　　　1）idea安装目录下两个文件加入配置：-Dfile.encoding=UTF-8，没有用
　　　　
　　

　　　　2）配置idea，无效

　　　　　　file-setting-editor-fileencoding

　　

　　　　3)pom文件加入配置，无效

　　<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.version>4.1.4.RELEASE</spring.version>
    </properties>

　　　　　　<plugin>
              <groupId>org.apache.maven.plugins</groupId>
              <artifactId>maven-compiler-plugin</artifactId>
              <version>3.1</version>
              <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                        <encoding>UTF-8</encoding>
            </configuration>
          </plugin>

　　最后没有办法，只能不用中文

3.创建流程实例-启动流程

  //启动流程实例
    @Test
    public void run(){
        RuntimeService runtimeService = processEngine.getRuntimeService();
        ProcessInstance myProcess_1 = runtimeService.startProcessInstanceByKey("myProcess_1");//表re_procdef里面的key字段

        System.out.println("实例id"+myProcess_1.getId());
        System.out.println("流程定义id"+myProcess_1.getProcessDefinitionId());

        /*
        启动流程实例
            运行时任务表：ru_task
            运行时流程执行表：ru_execution
            运行时执行主体信息表：ru_identitylink
        */
    }

其中 myProcess_1的值是有图形的id决定的。会成为表act_re_procdef里面的KEY_的值，这个属性用来标识流程。相同的KEY_的流程表示同一流程的不同版本。默认启动的是同一流程的最新版本

执行，影响到三张表 运行时任务表：ru_task   运行时流程执行表：ru_execution   运行时执行主体信息表：ru_identitylink，此时一个流程被发起，有了任务act_ru_task

除了使用KEY_来创建流程实例，还可以通过流程的id等其它属性来创建流程实例 runtimeService.startProcessInstanceById(1)

4.执行任务

4.1获取任务

    @Test
    public void findtask(){
        //获取任务
        TaskService taskService = processEngine.getTaskService();
        List<Task> task_list = taskService.createTaskQuery().taskAssignee("dcc").list();//查询dcc的任务
        task_list.stream().forEach((x)->{
            System.out.println("任务id"+x.getId());
            System.out.println("任务名称"+x.getName());
        });

这里是通过任务执行人来获取的任务，获取的是dcc的任务。这里获取到id为25005的任务

4.2完成任务

   @Test
    public void complete() {

        TaskService taskService = processEngine.getTaskService();
        taskService.complete("25005");
        System.out.println("完成任务");

           /*
                任务id2505
                完成任务id2505
                */
               /*
               完成任务：
                    ru的几张表的数据清楚了
                    历史相关表：
　　　　　　　　　　　　　　历史任务表：hi_taskinst

   　　　　　　　　　　　　 历史流程实例表：hi_procinst

   　　　　　　　　　　　　 历史流程参与者表：hi_identitylink

    　　　　　　　　　　　　历史活动节点表：hi_actinst
               */
    }

　　这里通过任务id来完成任务

　　在完成了这个任务后，流程就走到了审批流程，表中ru_task表中id为25005任务没有了，出现了一个新的任务-审批

　　上面执行，完成了第一个步骤-请假，再依照上面，获取任务-完成任务，完成第二个步骤-审批，整个流程就走完了。

　　 流程走完后，此时act_ru_的几张表的数据会清空，历史信息进入历史表，涉及到一下四张表

　　　　　　　　历史任务表：hi_taskinst

   　　　　　　　历史流程实例表：hi_procinst

   　　　　　　　 历史流程参与者表：hi_identitylink

    　　　　　　　历史活动节点表：hi_actinst

　　

 5.流程的CRUD

5.1新增

　　新增一个流程也就是流程部署，也就是上面标题2的内容

5.2修改

　　流程本身是不能修改的。只能通过发布新的版本的流程来实现。

　　

　　这个属性，也就是表act_re_procdef的KEY_属性值，相同表示同一流程，版本号增加。

　　如下图，我共画了3张图，重复发布，总共发布了7次，但是没修改id，流程的KEY_是相同的，都是"myProcess_1",所以KEY_值相同，版本号增加。如果此时通过KEY_来创建流程实例，默认是创建的最新版本的流程实例。

5.3删除

　　不建议删除

5.4查询

　　可以通过多个条件去查询KEy_ 、id等

   @Test
    public void query(){
　　　　 ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        ProcessDefinitionQuery processDefinitionQuery = processEngine.getRepositoryService().createProcessDefinitionQuery();
        List<ProcessDefinition> myProcess_1 = processDefinitionQuery.processDefinitionKey("myProcess_1").list();
        if(!myProcess_1.isEmpty()){
            myProcess_1.stream().forEach(x->{
                System.out.println(x.getKey());
                System.out.println(x.getId());
            });
        }
    }

6.历史的查询

6.1查询历史任务

　　可以通过多种条件查询 id、时间等

  @Test
    public void queryHi(){
        HistoricTaskInstanceQuery historicTaskInstanceQuery = processEngine.getHistoryService().createHistoricTaskInstanceQuery();
        List<HistoricTaskInstance> myProcess_11 = historicTaskInstanceQuery.processDefinitionKey("myProcess_1").list();

        if(!myProcess_11.isEmpty()){
            myProcess_11.stream().forEach(x->{
                System.out.println(x.getName());
                System.out.println(x.getId());
            });
        }
    }

7.查询流程实例

　　可以通过多个条件查询，KEY_、id、name等

@Test
    public void queryDeployVo(){
        ProcessInstanceQuery processInstanceQuery = processEngine.getRuntimeService().createProcessInstanceQuery();
        List<ProcessInstance> myProcess_1 = processInstanceQuery.processDefinitionKey("myProcess_1").list();

        if(!myProcess_1.isEmpty()){
            myProcess_1.stream().forEach(x->{
                System.out.println(x.getName());
                System.out.println(x.getId());
            });
        }
    }

8.流程中的参数传递

8.1基本说明

　　这里的参数是指创建流程实例-执行任务中的参数传递。支持的数据类型包括基本数据类型、序列化对象

　　 参数分为两类：任务节点本地变量和全局流程实例变量，前者在流程的指定节点有效，后者整个流程实例过程有效，一般使用后面的

8.2实例

8.2.1流程图

 8.2.2部署流程

  @Test
    public void deploy(){
        RepositoryService repositoryService = processEngine.getRepositoryService();
        Deployment de = repositoryService.createDeployment().addClasspathResource("bpmn/qj01.bpmn").name("qj").deploy();

    }

8.2.3启动一个流程实例并传递参数

    @Test
    public void run(){
        RuntimeService runtimeService = processEngine.getRuntimeService();
        Map<String,Object> pa = new HashMap<>();
        pa.put("start","qidong");
        ProcessInstance myProcess_1 = runtimeService.startProcessInstanceByKey("myid2",pa);//表re_procdef里面的key字段

    }

这里传递了一个名为start的参数

8.2.4执行任务

先创建一个对象PoTe，序列化，这样子就可以作为参数传递

public class PoTe implements Serializable {  //需要序列化

    private String username;

    private String password;

    public PoTe() {
    }

    public PoTe(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "PoTe{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

　　执行请假任务

@Test
    public void complete() {

        TaskService taskService = processEngine.getTaskService();

        Object start = taskService.getVariable("40006", "start");
        System.out.println("启动变量"+start);  //启动变量qidong

        taskService.setVariable("40006","username","hahaha");
        taskService.setVariable("40006","password","123");
        taskService.setVariable("40006","po",new PoTe("hahaha","123"));
        /*
        Map<String,Object> pa = new HashMap<>();
        pa.put("username","hahaha");
        pa.put("password","123");
        pa.put("po",new PoTe("hahaha","123"));
        taskService.setVariables("25005",pa);
        */

        taskService.complete("40006");
        System.out.println("完成任务");

    }

　　获取到了前面添加的名称为start的变量。并且又添加了三个变量

　　执行审批任务

    @Test
    public void complete2() {

        TaskService taskService = processEngine.getTaskService();

        String username = taskService.getVariable("42507", "username", String.class);
        String password = taskService.getVariable("42507", "password", String.class);
        String start = taskService.getVariable("42507", "start", String.class);
        PoTe po = taskService.getVariable("42507", "po", PoTe.class);
        System.out.println(username);  //hahaha
        System.out.println(password);  //123
        System.out.println(start);  //qidong
        System.out.println(po);  //PoTe{username='hahaha', password='123'}
        Map<String, VariableInstance> variableInstances = taskService.getVariableInstances("42507");
        variableInstances.keySet().stream().forEach(x->{
            VariableInstance variableInstance = variableInstances.get(x);
            System.out.println(variableInstance.toString());
            //VariableInstanceEntity[id=42502, name=password, type=string, textValue=123]
            //VariableInstanceEntity[id=40002, name=start, type=string, textValue=qidong]
            //VariableInstanceEntity[id=42501, name=username, type=string, textValue=hahaha]
            //VariableInstanceEntity[id=42504, name=po, type=serializable, byteArrayValueId=42503]
        });
        taskService.complete("42507");
        System.out.println("完成任务 42507");

    }

　　这里获取到了start等4个参数。流程结束。

9.流程不同的分支走向-连线中的表达式

9.1画图

图的文件名:qj02.bpmn    图的id：myid3　　

这里的流程是：

　　　　请假(qjia)--->部门审批(shenpi)--->天数小于等于5->流程结束

　　　　　　　　　　                           --->天数大于5->领导审批(shenpi2)->流程结束

　　

在这条连线设置了条件表达式：days>5

这里连线添加了条件：day<=5

9.2部署流程

   //流程定义
    @Test
    public void deploy(){
        RepositoryService repositoryService = processEngine.getRepositoryService();
        Deployment de = repositoryService.createDeployment().addClasspathResource("bpmn/qj02.bpmn").name("qj").deploy();
        System.out.println("部署id"+de.getId());

    }

9.3创建流程实例

 @Test
    public void run(){
        RuntimeService runtimeService = processEngine.getRuntimeService();
        Map<String,Object> pa = new HashMap<>();
        pa.put("start","qidong");

        ProcessInstance myProcess_1 = runtimeService.startProcessInstanceByKey("myid3",pa);//表re_procdef里面的key字段

        System.out.println("实例id"+myProcess_1.getId());
        System.out.println("流程定义id"+myProcess_1.getProcessDefinitionId());

    }

9.4.执行任务

9.4.1第一个任务-请假

此时任务表，有一个任务，id为67507，执行人时dcc，也就是请假这一步

执行任务

    @Test
    public void complete() {

          TaskService taskService = processEngine.getTaskService();

　　　　　　taskService.setVariable("67507","days",3);

　　　　　　taskService.complete("67507"); System.out.println("完成任务");
 }

注意，这里传递了一个参数days为3

9.4.2第二个任务-部门审批

上面任务执行完成后，再看任务表。有一个任务，id为70002，执行人为jcc，也就是走到了第一个审批

 @Test
    public void complete2() {
        TaskService taskService = processEngine.getTaskService();
        taskService.complete("70002");
    }

执行任务，执行完成后，发现任务表为空，整个流程完成了，因为day为3，所以没有走第二个审批

下面我们把days换做6

9.5创建流程实例

    @Test
    public void run(){
        RuntimeService runtimeService = processEngine.getRuntimeService();
        Map<String,Object> pa = new HashMap<>();
        pa.put("start","qidong");
        ProcessInstance myProcess_1 = runtimeService.startProcessInstanceByKey("myid3",pa);//表re_procdef里面的key字段
    }

9.6执行任务

9.6.1第一个任务-请假

　　任务表有一个任务，id为75007，执行人为dcc，也就是第一步-请假

   @Test
    public void complete() {
        TaskService taskService = processEngine.getTaskService();
        taskService.setVariable("85006","days",6);
        taskService.complete("85006");
        System.out.println("完成任务");
    }

注意，这里传递的days的参数是6

9.6.2第二个任务-部门审批

 @Test
    public void complete2() {
        TaskService taskService = processEngine.getTaskService();
        taskService.complete("87503");
        System.out.println("完成任务");
    }

9.6.3第三个任务-领导审批

    @Test
    public void complete2() {
        TaskService taskService = processEngine.getTaskService();
        taskService.complete("90002");
        System.out.println("完成任务");
    }

执行后，任务表没有任务了，流程走完了

10条件表达式

activiti支持两个UEL表达式：UEL-value和UEL-method

11.网关

11.1排他网关

　　几条不同的线，只走其中一条线

11.1.1画图

　　图形名称：qj03.bpmn  图形id：myid4

　　流程： 请假(qjia)--->请假天数<=5天--->部门审批(shenpi)--->结束

　　　　　　　　　 --->请假天数>5天--->领导审批(shenpi2)--->结束

 11.1.2代码测试

　　和上面的代码差不多，我这里就不贴出来了。先测试3天，再测试6天。发现3天时，是部门审批，6天时，是领导审批

11.2并行网关

　　并行网关是指，几条线都需要执行通过，才能往下走

11.2.1画图

图名:qj04.bpmn  id:myid6

流程:  请假(qjia)--->部门审批(shenpi1)+领导审批(shenpi2)--->老板审批(shenpi3)--->结束

这里部门审批和领导审批都需要审批，这里就没有设计条件表达式了，因为都要去审批

11.2.1部署流程

   @Test
    public void deploy(){
        RepositoryService repositoryService = processEngine.getRepositoryService();
        Deployment de = repositoryService.createDeployment().addClasspathResource("bpmn/qj04.bpmn").name("qj").deploy();
        System.out.println("部署id"+de.getId());
    }

11.2.2创建流程实例

    @Test
    public void run(){
        RuntimeService runtimeService = processEngine.getRuntimeService();
        Map<String,Object> pa = new HashMap<>();
        ProcessInstance myProcess_1 = runtimeService.startProcessInstanceByKey("myid6",pa);//表re_procdef里面的key字段
    }

11.2.3执行任务

11.2.3.1第一步任务-请假

有一个任务 请假(qjia)

执行任务

    @Test
    public void complete2() {
        TaskService taskService = processEngine.getTaskService();
        taskService.complete("107505");
        System.out.println("完成任务");
    }

11.2.3.2第二步-部门审批(shenpi)+领导审批(shenpi2)

　　上面完成后，任务里面有两个，分别是部门审批(shenpi)和领导审批(shenpi2)

先执行一个审批，随便先执行哪一个都可以

    @Test
    public void complete2() {
        TaskService taskService = processEngine.getTaskService();
        taskService.complete("110004");
        System.out.println("完成任务");
    }

一个审批完成后，发现第三步审批任务还没有，任务里面还剩下一个领导审批

继续执行领导审批

   @Test
    public void complete2() {
        TaskService taskService = processEngine.getTaskService();
        taskService.complete("110007");
        System.out.println("完成任务");
}

11.2.3.3第三步-老板审批(shenpi3)

上面2个审批都执行完后，任务里面出现了老板审批(shenpi3)的任务

执行

   @Test
    public void complete2() {
        TaskService taskService = processEngine.getTaskService();
        taskService.complete("115003");
        System.out.println("完成任务");
    }

执行完成后，没有任务了，流程执行完

12.任务分配

　　前面我们画图的时候，每一步任务由谁执行，都是固定写死的，现在我们使用表达式

　　　写死的：

　　　　

　　表达式：

　　　　

12.1画图

　　图形bpmn文件名称：qj05.bpmn  id：myid11

　　流程：员工(employee)请假--->部门领导审批(leader)--->结束

 12.2部署流程

  //流程定义
    @Test
    public void deploy(){
        RepositoryService repositoryService = processEngine.getRepositoryService();
        Deployment de = repositoryService.createDeployment().addClasspathResource("bpmn/qj05.bpmn").name("qj").deploy();
        System.out.println("部署id"+de.getId());
}

12.3启动流程实例

    //启动流程实例
    @Test
    public void run(){
        RuntimeService runtimeService = processEngine.getRuntimeService();
        Map<String,Object> pa = new HashMap<>();
        pa.put("employee","ddd");
        ProcessInstance myProcess_1 = runtimeService.startProcessInstanceByKey("myid10",pa);//表re_procdef里面的key字段
    }

启动流程的时候，设置哪些人可以请假，这里设置ddd可以请假

此时有任务，执行人就是ddd

12.4执行任务

12.4.1第一步-请假

ddd可以获取到任务，并执行

获取

   @Test
    public void findtask(){
        //获取任务
        TaskService taskService = processEngine.getTaskService();
        List<Task> task_list = taskService.createTaskQuery().taskAssignee("ddd").list();//查询dcc的任务
    }
    

执行，执行时指定由谁来审批，这里指定的是jjj

  @Test
    public void complete() {
        TaskService taskService = processEngine.getTaskService();
        taskService.setVariable("150006","leader","jjj");
        taskService.complete("150006");
        System.out.println("完成任务");
    }

12.4.2第二步-审批

　　jjj获取任务并执行

 @Test
    public void findtask(){
        //获取任务
        TaskService taskService = processEngine.getTaskService();
        List<Task> task_list = taskService.createTaskQuery().taskAssignee("jjj").list();//查询dcc的任务
    }

执行

 @Test
    public void complete() {
        TaskService taskService = processEngine.getTaskService();
        taskService.setVariable("152503","leader","jjj");
        taskService.complete("152503");
        System.out.println("完成任务");
    }

流程走完了，任务没有了