activiti基础流量变量

1.流量变量

流程变量在整个工作流中扮演很重要的作用。例如：请假流程中有请假天数、请假原因等一些参数都为流程变量的范围。流程变量的作用域范围是流程实例。也就是说各个流程实例的流程变量是不相互影响的。流程实例结束完成以后流程变量还保存在数据库中（存放到流程变量的历史表中）。

   ①：启动流程的时候设置
              ②：任务完成的时候设置
              ③：runtimeService设置
              ④：taskService设置
        获取流程变量：2种
              ①：runtimeService获取变量
              ②：taskService获取变量
       注意：
       1.流程变量应该可以被所有的执行对象获取(只要流程实例不结束，流程变量可以在任何地方获取)
       2.流程变量是可以覆盖的
       3.如果存放domain实体类的话就需要这个实体类实现序列化接口 Serializable

2.部署流程定义

         @Test

         public void deployTest() {

                   //获取核心对象

                   ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

                   //获取服务

                   RepositoryService repositoryService = processEngine.getRepositoryService();

                   //操作

                   DeploymentBuilder deploymentBuilder = repositoryService.createDeployment();

                   deploymentBuilder

                                     .name("请假流程")//设置部署名称

                                     .addClasspathResource("ProcessVarTest.bpmn")

                                     .addClasspathResource("ProcessVarTest.png");

                   deploymentBuilder.deploy();

         }

3.启动流程实例

        @Test

         public void startProcessTest() throws Exception {

                   //创建核心对象

                   ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

                   //获取服务

                   RuntimeService runtimeService = processEngine.getRuntimeService();

                   String processDefinitionKey="ProcessVarTestId";

                   Map<String,Object> variables=new HashMap<>();

                   variables.put("剩余年假天数", 3);

                   variables.put("剩余病假天数", 10);

                   //操作:启动的时候设置流程变量

                   ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(processDefinitionKey, variables);

                   System.out.println("pId="+processInstance.getId());//2501

         }

4.设置流程变量

        @Test

         public void setVarTest() throws Exception {

                   ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

                   TaskService taskService = processEngine.getTaskService();

                   String processInstanceId="2501";

                   String assignee="小莉";



                   //通过任务服务获取这个流程实例中小莉的唯一的一个任务

                   Task task = taskService.createTaskQuery()

                   .processInstanceId(processInstanceId)//在一次流程实例中一个人的任务是唯一的

                   .taskAssignee(assignee)

                   .singleResult();

                   System.out.println(task);

                   //设置一个流程变量

                   String taskId = task.getId();

                   taskService.setVariable(taskId, "请假人", assignee);

                   Map<String,Object> variables=new HashMap<>();

                   variables.put("请假原因","想男朋友了");//设置String

                   variables.put("请假天数", 3);//设置Integer

                   variables.put("是否扣工资",true);//设置boolean：存long型：1true；0false

                   variables.put("请假开始时间", new Date());//设置Date类型

                   variables.put("扣多少钱", 666.666d);//设置Double

                   //设置多个流程变量：

                   taskService.setVariables(taskId, variables);

                   //完成任务的时候设置：

                   Map<String,Object> variables1=new HashMap<>();

                   variables1.put("叫老板", "亲爱的老板，我真的要回去找男朋友，很急的。。。。。");

                   taskService.complete(taskId, variables1);

         }

5.获取流程变量

      // 获取流程变量的方式：

         @Test

         public void getVarTest() throws Exception {

                   ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

                   TaskService taskService = processEngine.getTaskService();

                   String processInstanceId="2501";

                   String assignee="美丽";

                   //一个流程实例中，一个办理人只有一个任务

                   Task task = taskService.createTaskQuery().

                                     processInstanceId(processInstanceId).

                                     taskAssignee(assignee)

                                     .singleResult();

                   String taskId=task.getId();



                   Map<String, Object> variables = taskService.getVariables(taskId);

                   System.out.println("所有的流程变量："+variables);

                  Map<String, Object> variables2 = taskService.getVariables(taskId, Arrays.asList("请假天数","叫老板"));

                   System.out.println("批量获取流程变量："+variables2);

                   Double money = (Double) taskService.getVariable(taskId, "扣多少钱");

                   System.out.println("获取一个变量："+money);

                   Date beginDate = taskService.getVariable(taskId, "请假开始时间",Date.class);

                   System.out.println("获取一个变量："+beginDate);

         }

6.模拟流程变量的设置和获取的场景

           /**

         * 模拟查看设置变量和获取变量的api，目的是整理属性api

         * //设置流程变量：4种

                            //①：启动流程的时候设置

                            //②：任务完成的时候设置

                            //③：runtimeService设置

                            //④：taskService设置

                   //获取流程变量：2种

                            //①：runtimeService获取变量

                            //②：taskService获取变量

         */

         @Test

         public void setVarAndGetVarTest() throws Exception {

                   ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

                   RuntimeService runtimeService = processEngine.getRuntimeService();

                   TaskService taskService = processEngine.getTaskService();

                   //设置流程变量：4种

                            //①：启动流程的时候设置

                                     //runtimeService.startProcessInstanceByKey(processDefinitionKey, variables);

                            //②：任务完成的时候设置

                                     //taskService.complete(taskId, variables);

                            //③：runtimeService设置

                                     //runtimeService.setVariable(executionId, variableName, value);//存一个

                                     //runtimeService.setVariables(executionId, variables);//存多个

                            //④：taskService设置

                                     //taskService.setVariable(taskId, variableName, value);//存一个

                                     //taskService.setVariables(taskId, variables);//存多个

                   //获取流程变量：2种

                            //①：runtimeService获取变量

                                     //runtimeService.getVariables(executionId)//获取所有

                                     //runtimeService.getVariables(executionId, variableNames)//批量获取

                                     //runtimeService.getVariable(executionId, variableName);//获取一个，但是要强转

                                     //runtimeService.getVariable(executionId, variableName, variableClass)//获取一个,带泛型，不强转

                            //②：taskService获取变量

                                     //taskService.getVariables(taskId)//获取所有

                                     //taskService.getVariables(taskId, variableNames)//批量获取

                                     //taskService.getVariable(taskId, variableName);//获取一个，但是要强转

                                     //taskService.getVariable(taskId, variableName, variableClass)//获取一个,带泛型，不强转

         }

7.流程定义语言（BPMN）

7.1什么是BPMN

业务流程建模与标注（Business Process Model and Notation，BPMN) ，描述流程的基本符号，包括这些图元如何组合成一个业务流程图（Business Process Diagram）

Eclispse画出流程,有两个文件bpmn文件和png文件,其中bpmn文件又可以叫做流程定义文件,它需要遵循BPMN语言规范.png:就是一个单纯的图片,没有任何作用.

7.2流程(process)

bpmn文件一个流程的根元素。一个流程就代表一个工作流。

7.3顺序流

顺序流是连接两个流程节点的连线，代表一个节点的出口。流程执行完一个节点后，会沿着节点的所有外出顺序流继续执行。就是说，BPMN 2.0默认的行为就是并发的：两个外出顺序流会创造两个单独的，并发流程分支。

顺序流主要由4个属性组成：

Id: 唯一标示，用来区分不同的顺序流

sourceRef：连线的源头节点ID

targetRef：连线的目标节点ID

name（可选）：连线的名称，不涉及业务，主要用于显示。多出口原则要设置。

说明：

结束节点没有出口

其他节点有一个或多个出口。如果有一个出口，则代表是一个单线流程；如果有多个出口，则代表是开启并发流程。

7.4分支流程-流程图

8.公共代码抽取

package cn.itsource.activiti.day02;

import org.activiti.engine.ProcessEngine;

import org.activiti.engine.ProcessEngines;

import org.activiti.engine.RepositoryService;

import org.activiti.engine.RuntimeService;

import org.activiti.engine.TaskService;

import org.activiti.engine.repository.Deployment;

import org.activiti.engine.repository.DeploymentBuilder;

import org.activiti.engine.runtime.ProcessInstance;

import org.activiti.engine.task.Task;

public class BaseBpmn {

         private ProcessEngine processEngine=ProcessEngines.getDefaultProcessEngine();

         //自己类和子类都可能使用：使用protected修饰

         protected RepositoryService repositoryService = processEngine.getRepositoryService();

         protected RuntimeService runtimeService = processEngine.getRuntimeService();

         protected TaskService taskService = processEngine.getTaskService();



         /**

         *

         * @param name 部署流程的名字

         * @param resourceName 加载资源的名字前缀

         * @return

         */

         protected Deployment deploy(String name, String resourceName) {

                   //创建核心

                   //获取服务

                   //做事情

                   // this.getClass().getClassLoader().getResourceAsStream("LeaveFlow.bpmn");从classpath下面加载

                   // this.getClass().getResourceAsStream("/LeaveFlow.bpmn");//从classpath下面加载

                   // this.getClass().getResourceAsStream("LeaveFlow.bpmn");//从当前类当前包加载(采纳)

                   // this.getClass().getResourceAsStream("./LeaveFlow.bpmn");//从当前类当前包加载(采纳)

                   String resourceNameBpmn=resourceName+".bpmn";

                   String resourceNamePng=resourceName+".png";

                   DeploymentBuilder deploymentBuilder = repositoryService.createDeployment();

                   deploymentBuilder.name(name)

                                                        .addInputStream(resourceNameBpmn, this.getClass().getResourceAsStream(resourceNameBpmn))

                                                        .addInputStream(resourceNamePng, this.getClass().getResourceAsStream(resourceNamePng));

                   Deployment deployment = deploymentBuilder.deploy();

                   return deployment;

   }

          // 启动流程的定义的key

         protected ProcessInstance startProcess(String processDefinitionKey) {

                   return runtimeService.startProcessInstanceByKey(processDefinitionKey);

         }

         /**

         * 在一个流程实例中，一个办理人只有一个唯一的任务

         * @param processInstanceId 流程实例id

         * @param assignee 办理人

         * @return

         */

         protected Task queryPersonalTask(String processInstanceId, String assignee) {

         return       taskService.createTaskQuery()

                   .processInstanceId(processInstanceId)

                   .taskAssignee(assignee)

                   .singleResult();

         }

}

9.分支流程-测试代码

        @Test

         public void deployTest() throws Exception {

                   Deployment deployment = deploy("报销申请","SequesceFlowTest");

                   System.out.println("deploymentId:"+deployment.getId());

         }

         @Test

         public void startProcessTest() throws Exception {

                            String processDefinitionKey="SequesceFlowTest";

                            ProcessInstance processInstance = startProcess(processDefinitionKey);

                            System.out.println("ProcessInstanceId:"+processInstance.getId());//2501

         }



//测试驳回

         /**

         * ①：先完成报销申请,

         * ②：走到审批的时候，设置一个flag的流程变量为flase，驳回

         * ③：回到①，在完成报销申请

         * ④：审批人又得到审批审批任务

         * @throws Exception

         */

         @Test

         public void notPassTest() throws Exception {

                   //①：先完成报销申请,

                   String processInstanceId="2501";

                   String assignee="小明";

                   Task applyTask = queryPersonalTask(processInstanceId,assignee);

                   System.out.println("获取申请任务："+applyTask);

                   //先完成报销申请

                   taskService.complete(applyTask.getId());



                   assignee="小刚";

                   Task approveTask = queryPersonalTask(processInstanceId,assignee);

                   System.out.println("获取审批任务："+applyTask);

                   // ②：走到审批的时候，设置一个flag的流程变量为flase

                   taskService.setVariable(approveTask.getId(),"flag", "false");

                   //驳回

                  taskService.complete(approveTask.getId());

                   //④：审批人又得到审批审批任务

                   assignee="小明";

                   applyTask = queryPersonalTask(processInstanceId,assignee);

                   System.out.println("再次获取申请任务："+applyTask);

         }

          /**

         * 通过

         */

         @Test

         public void passTest() throws Exception {

                   String processInstanceId="2501";

                   String assignee="小刚";

                   Task approveTask = queryPersonalTask(processInstanceId,assignee);

                   System.out.println("获取审批任务："+approveTask);

                   // ②：走到审批的时候，设置一个flag的流程变量为flase

                   taskService.setVariable(approveTask.getId(),"flag", "true");

                   //通过

                   taskService.complete(approveTask.getId());

以上就这些希望对大家有作用，谢谢

activiti基础流量变量

猜你喜欢