Activiti工作流入门(下)

最新推荐文章于 2023-06-02 22:58:00 发布
最新推荐文章于 2023-06-02 22:58:00 发布
阅读量1.1k 收藏 5
点赞数 2
分类专栏： 工作流入门到实战 文章标签： Activiti
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yangyg_0818/article/details/83962307
版权

1)工作流程变量

1)概念:流程实例中设置的变量使用的变量,它在实例中可以共享数据,作用范围是工作流程中的实例,各个实例的流程变量是互不干扰的;

2)流程变量数据库的取值原理

1)启动流程实例时没有存储任务id,但能通过taskId查询,时因为底层做了兼容,获取不到taskId就获取ExecutionId

3)流程变量的使用

1)工作流程中设置变量值4种方式

1：启动流程的时候设置 

// 启动流程实例

@Test

public void startProcess() throws Exception {

// 拿到核心对象

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

RuntimeService runtimeService = processEngine.getRuntimeService();

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

variables.put("账户余额", 0.06);

variables.put("话费余额", 1);

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

ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("myProcess", variables);

// processInstanceId:2501

System.out.println("processInstanceId:" + processInstance.getId());

System.out.println("processInstanceName:" + processInstance.getName());

}

2：任务完成的时候设置

// taskService 完成complate时设置变量
@Test
public void complateYangTest() throws Exception {
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// taskService设置变量
TaskService taskService = processEngine.getTaskService();
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

   TaskQuery taskQuery = taskService.createTaskQuery();
   Task result = taskQuery.taskAssignee("yang")
                          .processInstanceId("2501")
                          .singleResult();// 在一次流程实例中一个人的任务是唯一的
   String taskId = result.getId();

   // 完成任务的时候设置：
    taskService.complete(taskId, variables);

}

3：runtimeService设置()

// taskService 不在完成complate时设置变量

@Test
public void runtimeServiceYangTest2() throws Exception {
   ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
   RuntimeService runtimeService = processEngine.getRuntimeService();
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
                    //javabean
                    variables.put("技师", new Person("admin", "admin"));
   // 使用RuntimeService存
   ExecutionQuery executionQuery = runtimeService.createExecutionQuery();

   Execution execution = executionQuery
                        .processInstanceId("2501")
                        .activityId("员工请假id")// 活动节点的id
                        .singleResult();
    // 存一个
    runtimeService.setVariable(execution.getId(), "解决", "好好好");
    // 存多个
    runtimeService.setVariables(execution.getId(), variables);
}

4：taskService设置(不完成任务)

// taskService 不在完成complate时设置变量
@Test
public void complateYangTest2() throws Exception {

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

RuntimeService runtimeService = processEngine.getRuntimeService();

// taskService设置变量
TaskService taskService = processEngine.getTaskService();

TaskQuery taskQuery = taskService.createTaskQuery();

Task result = taskQuery

.taskAssignee("yang")

.processInstanceId("2501")

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

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

// javabean
variables.put("技师", new Person("admin", "admin"));

String taskId = result.getId();

// 存一个
taskService.setVariable(taskId, "请假原因", "55");

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

2)工作流程中获取变量的2种方式

1：runtimeService获取变量

// runtimeService获取变量
@Test
public void runTimeServiceTangTest() throws Exception {

// 获取大管家
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

// 拿到任务服务对象实例
RuntimeService runtimeService = processEngine.getRuntimeService();

// 拿到查询对象
ExecutionQuery executionQuery = runtimeService.createExecutionQuery();

// 做事情
Execution execution = executionQuery.processInstanceId("2501")
                                    .activityId("经理审批id")// 活动节点id
                                    .singleResult();

// 取一个变量 要转
String executionId = execution.getId();

String name = (String) runtimeService.getVariable(executionId, "请假原因");

System.out.println("取一个要转:" + name);

// 取一个变量 不转
String executionId2 = execution.getId();

String name2 = runtimeService.getVariable(executionId, "呵呵", String.class);

System.out.println("取一个不转:" + name2);

// 取全部
Map<String, Object> variables = runtimeService.getVariables(executionId);

System.out.println("取全部变量:" + variables);

// 取出部分变量
Map<String, Object> variables2 = runtimeService.getVariables(executionId, Arrays.asList("请假天数", "3"));

System.out.println("取部分:" + variables2);

}

2：taskService获取变量

// tang经理审批完成任务时 TaskService获取变量
@Test
public void taskTangTest() throws Exception {

// 获取大管家
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

// 拿到任务服务对象实例
TaskService taskService = processEngine.getTaskService();

// 设置查询条件
Task task = taskService.createTaskQuery()
                       .taskAssignee("tang")
                       .processInstanceId("2501")
                       .singleResult();
String taskId = task.getId();// 任务id

String variableName = "请假原因";

// 执行任务 取出变量 但要强转 取一个
String varName = (String) taskService.getVariable(taskId, variableName);
System.out.println("取一个要强转:" + varName);

// 取一个但无需强转
String varName2 = taskService.getVariable(taskId, variableName, String.class);
System.out.println("取一个变量不转:" + varName);

// 取全部
Map<String, Object> variables = taskService.getVariables(taskId);
System.out.println("取全部变量:" + variables);

// 取出部分变量
Map<String, Object> variables2 = taskService
                          .getVariables(taskId, Arrays.asList("请假天数", "3"));

System.out.println("取部分" + variables2);

}

3)流程变量数据库的设计原理

1)对于变量的存储在数据库以多个数据类型存储的,满足存储多种数据类型的需求;

        ACT_RU_VARIABLE：运行时流程变量数据表

            1.     ID_：标识 2.     REV_：版本号

            3.     TYPE_：数据类型 4.     NAME_：变量名

            5.     EXECUTION_ID_： 执行实例id 6.     PROC_INST_ID_： 流程实例id

            7.     TASK_ID_： 任务id      8.     BYTEARRAY_ID_：

            9.     DOUBLE_：若数据类型为double ,保存数据在此列

           10.  LONG_： 若数据类型为Long保存数据到此列

            11.  TEXT_： string 保存到此列 12.  TEXT2_：

4)流程定义语言BPMN

1)概念:业务流程建模与标注（Business Process Model and Notation，BPMN),解释了流程是由基本符号和图元组合成的业务流程图;

2)流程(Process):bpmn是一个流程的根元素,一个工作流就是一个工作流;

3)顺序流(SequenceFlow)

概念:顺序流是连接流程节点的线,是一个节点的出口;

顺序流结构:

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

sourceRef：连线的源头节点ID

targetRef：连线的目标节点ID

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

并发流的使用(驳回or同意)

工作流程图驳回还是通过(condition   ${flag==true/false})

代码(在完成任务时设置flag的开关)

package com.yyg.activiti_02.sequenceflow_02;

import static org.junit.Assert.*;

import java.util.HashMap;

import org.activiti.engine.repository.Deployment;

import org.activiti.engine.runtime.ProcessInstance;

import org.activiti.engine.task.Task;

import org.junit.Test;

import com.yyg.activiti_02.base.Basebpmn;

public class SequenceFlowTest extends Basebpmn {

// 部署流程

@Test

public void deployTest() throws Exception {

Deployment deploy = deploy("LeaveProcess", "员工离职流程申请_v01");

System.out.println(deploy);

}
//开启流程
@Test

public void startProcess() throws Exception {

String processDefinitionKey = "leaveProcess";

ProcessInstance processInstance = startProcess(processDefinitionKey);

System.out.println(processInstance);// 2501

}
// 查看yang私有任务
@Test

public void queryYangPersonalTaskTest() throws Exception {

Task queryPrivateTask = queryPrivateTask("yang", "2501");

// Task[id=2504, name=员工申请]

// 第二次 驳回 Task[id=7503, name=员工申请]

// 第三次 null 通过 没有任务

System.out.println(queryPrivateTask);

}
@Test

public void queryYangPersonalTaskTest() throws Exception {

Task queryPrivateTask = queryPrivateTask("yang", "2501");

// Task[id=2504, name=员工申请]

// 第二次 驳回 Task[id=7503, name=员工申请]

// 第三次 null 通过 没有任务

System.out.println(queryPrivateTask);

}
​//查看yang的私有任务
@Test

public void complateYangPersonalTaskTest() throws Exception {

complatePersonalTask("yang", "2501");

}

​// 查看tang的私有任务
@Test

public void queryTangPersonalTaskTest() throws Exception {

Task queryPrivateTask = queryPrivateTask("tang", "2501");

// Task[id=5002, name=经理批准]

//驳回第二次 Task[id=10002, name=经理批准]

System.out.println(queryPrivateTask);

}
// tang经理驳回申请操作测试
@Test

public void tangNoPassTest() throws Exception {

String taskId = queryPrivateTask("tang", "2501").getId();

HashMap<String, Object> variables = new HashMap<>();// 设置变量

variables.put("flag", false);

taskService.complete(taskId, variables);

}
// tang经理通过申请操作测试
@Test

public void tangPassTest() throws Exception {

String taskId = queryPrivateTask("tang", "2501").getId();

HashMap<String, Object> variables = new HashMap<>();// 设置变量

variables.put("flag", true);

taskService.complete(taskId, variables);

}
// 测试状态
@Test

public void testProcessState() throws Exception {

showProcessState("2501");

}}

4)节点

1)节点类型:

  • 开始节点  结束节点
  • 任务节点  网关节点  监听器节点

2)开始事件节点(startEvent):开始事件对应节点

3)结束事件节点(endEvent):结束事件对应节点

4)任务节点 (Task)

  • 接收任务节点 (receiveTask)
  • 接收任务节点概念:不需要人工参与,接收任务会等待信号,任务创建后,节点流程会进入等待状态,引擎收到single信号才继续执行(收到信号触发)
  • 接收任务节点使用
  • 流程图

代码实现

package com.yyg.activiti_02.receiveTask_03;
import static org.junit.Assert.*;
import java.util.HashMap;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.Execution;
import org.activiti.engine.runtime.ProcessInstance;
import org.junit.Test;
import com.yyg.activiti_02.base.Basebpmn;
public class ReceiveTaskTest extends Basebpmn{

//部署流程
@Test
public void deployTest() throws Exception {

Deployment deployment = deploy("ReceiveRequestProcess", "接收任务流程_v1");

//DeploymentEntity[id=1, name=接收任务流程_v1]
System.out.println(deployment);

}
//启动流程
@Test
public void startProcessTest() throws Exception {

ProcessInstance startProcess = startProcess("receiveTaskProcess");

//ProcessInstance[2501]
System.out.println(startProcess);

}
//计算今日销售额 第一个节点
@Test
public void countTotalTest() throws Exception {

//今天的销售额 应该是调用Mapper查询方法计算从数据库
double total=6666.66; 模拟的数据

Execution execution = getExecution("2501", "销售额今日计算id");

String executionId=execution.getId();

//把总额设置到变量 节点要拿到
HashMap<String, Object> variables = new HashMap<>();

   variables.put("total", total);

//向接收任务节点发送信号
runtimeService.signal(executionId, variables);

}
//发送短信  第二个节点
@Test
public void sendMsgTest() throws Exception {

Execution execution = getExecution("2501", "发送短信给老板id");

String executionId=execution.getId();

// 1 从流程变量种获取销售额
Double total = runtimeService.getVariable(executionId, "total", Double.class);

//应该是调用第三方接口发送短信
// 2 把销售额发送给老板
String message="很开心的一天 盈利了"+total+"元";

   System.out.println(message);

// 3 让流程继续往下走 给接收任务节点发送消息
runtimeService.signal(executionId);
}
//4 判断流程结束
@Test
public void isEnd() throws Exception {
showProcessState("2501");//已结束
}
}

用户任务节点 userTask (需要人工参与的节点)

流程图

代码实现

package com.yyg.activiti_02.receiveTask_03;
import java.util.HashMap;
import java.util.Map;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.junit.Test;
import com.yyg.activiti_02.base.Basebpmn;
public class UserTaskTest extends Basebpmn{
@Test
public void test2() {
//部署
deploy("UserTaskProcess", "人工处理任务节点");
//启动时要设置第一个节点的办理者
String processDefinitionKey = "userTaskProcessid";

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

//第一个节点办理者
String assignee = "yang";//当前登录用户名称
       variables.put("apply", assignee);
ProcessInstance pi = startProcess(processDefinitionKey,variables);
 //获取写死办理的任务
 Task task = queryPrivateTask(assignee, pi.getId());

//Task[id=9, name=计算今日销售额]
System.out.println(task);
}

//要把第一个节点走下去
/**
 * 使用流程变量设置
 * @throws Exception
 */

@Test
public void test3Pre() throws Exception {

//启动时要设置第一个节点的办理者

String processDefinitionKey = "userTaskProcessid";

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

//第一个节点办理者
String assignee = "yang";//当前登录用户名称
             variables.put("apply", assignee);
ProcessInstance pi = startProcess(processDefinitionKey,variables);
//获取写死办理的任务
   Task task = queryPrivateTask(assignee,pi.getId());

   //id:2505,name:计算今日销售额,assignee:yang
    System.out.println(task);
    taskService.complete(task.getId());

}

//上一个任务完成设置下一个任务的办理者,没法做,没有办法直接获取下一个任务并设置
//当前任务创建时,再指定办理者
@Test
public void test3() throws Exception {

String assignee ="tang";

String processInstanceId="2501";

Task task = queryPrivateTask(assignee, processInstanceId);

//Task[id=2508, name=发送短信]
System.out.println(task);

//完成第二个任务
taskService.complete(task.getId());

//判断流程是否结束
showProcessState(processInstanceId);//流程已结束

}
}

监听器类设置办理人ManagerSettingListener

/**
 * ①写一个类实现监听器类-TaskListener
 * ②把写好类绑定到对应节点
 * ③实现监听器逻辑
 *  @author 阳彦刚
 */

public class ManagerSettingListener implements TaskListener{
@Override
public void notify(DelegateTask delegateTask) {
System.out.println(delegateTask.getName());

//1 获取申请人
String apply = delegateTask.getVariable("apply", String.class);

//2 通过申请人获取审批人  通过申请人获取部门经理
String manager = apply+"审批人";

//3 设置办理者
delegateTask.setAssignee(manager);

}

}

5)监听器的使用

创建:写一个类实现某个监听器接口，重写方法配置自定义监听器;

1)activiti任务监听器TaskListener

用途：人工任务节点办理者的动态设置,只能监听人工任务节点

流程图(第一个无需监听,根据第一个节点在第二个节点设置办理人)

代码实现

package com.yyg.activiti_02.tasklistener_05;

import static org.junit.Assert.*;

import java.util.HashMap;

import java.util.Map;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.junit.Test;
import com.yyg.activiti_02.base.Basebpmn;
public class MyTaskListenerTest extends Basebpmn{
//部署
@Test
public void deployTest() throws Exception {
Deployment deployment = deploy("TaskProcessTest2","任务监听流程_v02");
//DeploymentEntity[id=1, name=任务监听流程_v02]
System.out.println(deployment);
}

//启动
@Test
public void startProcessTest() throws Exception {
String processDefinitionKey="taskProcessid";
Map<String, Object> variables=new HashMap<>();
variables.put("applyUser", "狗蛋儿");
ProcessInstance processInstance = startProcess(processDefinitionKey, variables);

//ProcessInstance[2501]
System.out.println(processInstance);
}

//第一个节点 查看狗蛋儿的私有任务
@Test
public void queryPersionalTaskTest() throws Exception {
Task task = queryPrivateTask("狗蛋儿", "2501");
//Task[id=2505, name=员工申请]
System.out.println(task);
}

//狗蛋儿完成第一个任务
@Test
public void complateGDTaskTest() throws Exception {
taskService.complete(queryPrivateTask("狗蛋儿", "2501").getId());
}

//查看qian的私有任务
@Test
public void queryQianPersionalTaskTest() throws Exception {
Task task = queryPrivateTask("qian", "2501");
//Task[id=5002, name=部门审批]
System.out.println(task);
}

//第二个节点qian完成第二个任务
@Test
public void complateQianTaskTest() throws Exception {
taskService.complete(queryPrivateTask("qian", "2501").getId());
}

//查看状态
@Test
public void idEnd() throws Exception {
showProcessState("2501");//已结束

}
}

任务监听器MyTaskListener：

package com.yyg.activiti_02.tasklistener_05;
import org.activiti.engine.delegate.DelegateTask;
import org.activiti.engine.delegate.TaskListener;
/**
 * @author Administrator
 * 只能绑定到用户任务节点
 *  可用于用户节点办理者的动态设置,操作日志等,可以从数据库查询出数据为下一节点设置受理人等
 */
public class MyTaskListener implements TaskListener{
@Override
public void notify(DelegateTask task) {

//通过上一个节点查询出当前节点的办理人

//获取到上一个节点的办理人

//流程变量用起来

//查询数据库，得到第一个节点的办理人zhang的部门经理是qian

String name = "qian";//zhang是通过数据库查询出来的办理人
System.out.println("设置了当前任务节点的办理人");

//设置qian为当前任务节点的办理人
task.setAssignee(name);
}
}

2)activiti执行监听器ExecutionListener

用途:可以用来修改开始和结束的状态,可以监听所有节点,可以监听所有节点

执行监听器应用:

流程图

开始执行监听器的方法

结束执行监听器的方法

代码(启动测试即可可以看到执行开始、执行结束、改变状态)

package com.yyg.activiti_02.executionlistener_04;
import static org.junit.Assert.*;
import java.util.HashMap;
import java.util.Map;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.junit.Test;
import com.yyg.activiti_02.base.Basebpmn;
public class MyExecutionListenerTest extends Basebpmn {

// 部署人工节点流程
@Test
public void deployTest() throws Exception {
Deployment deploy = deploy("TaskProcessTest", "人工节点流程监听器_v01");

// DeploymentEntity[id=1, name=人工节点流程监听器_v01]
System.out.println(deploy);
}

// 启动流程
@Test
public void startProcessTest() throws Exception {
String processDefinitionKey = "taskProcessTestIid";
ProcessInstance processInstance = startProcess(processDefinitionKey);

//ProcessInstance[2501]
System.out.println(processInstance);
}

// yang完成私有方法
@Test
public void complateYangTest() throws Exception {
taskService.complete(queryPrivateTask("yang", "2501").getId());
}
}

 6)网关节点

用途:控制流程的流向

排它网关

概念:排他网关流出的顺序流都有个conditionExpression元素，在内部维护返回boolean类型的决策结果决策网关只会返回一条结果如果没有任何一个出口符合条件则抛出异常

流程图

并行网关(parallelGateWay)

概念:多个分支要一起执行完,网关可以表示流程中的并行情况,可以把多条分支 汇聚到一起

流程图

 

不慕y
关注
专栏目录
Spring Boot 整合 Activiti 工作流入门
java专栏
09-04 957
在许多业务场景中，我们需要自动化处理一些业务流程，比如审批流程、订单处理流程等。Activiti 提供了一套完整的解决方案，可以帮助我们轻松地实现这些需求，并且它还支持 BPMN 2.0 标准，这意味着你可以使用图形化工具设计流程图。此外，如果需要更复杂的流程设计，可以考虑使用 Activiti Designer 或者其他 BPMN 设计工具。点击后，流程将被启动，并在任务列表中显示待处理的任务。点击任务，你会看到任务表单，填写完表单后点击提交，任务将被完成。接下来，我们需要创建一个简单的流程定义。
SpringBoot+Activiti7工作流入门实例
最新发布
没刮胡子的程序员专栏
09-27 760
使用SpringBoot+Activiti实现一个最基础的工作流
activiti完成任务源码分析
zpfzly的博客
05-22 1259
activiti发起完成任务后代码的分析
Activiti taskService.complete实现当前用户任务处理
可控的事情要谨慎，不可控的事情要乐观。
09-11 3566
package com.itheima.activiti; import org.activiti.engine.ProcessEngine; import org.activiti.engine.ProcessEngines; import org.activiti.engine.TaskService; import org.activiti.engine.task.Task; /** * 处理当前用户的任务 * 背后操作的表： * act_hi_actinst act_hi_.
activiti的taskService.complete方法
weixin_39102174的博客
04-30 1万+
原文地址：https://blog.csdn.net/u013026207/article/details/53405265 官方提供了三种不同的方法 简单讲一下区别 1.complete(String taskId) 参数：taskId 作用：直接完成此次正在运行的任务，对用ac_ru_task表 2.complete(String taskId, Map<String,O...
activiti完成任务
u013068789的博客
06-02 1187
【代码】activiti完成任务。
Activiti 工作流入门到大神
06-09
什么是流程、工作流作用、Activiti背景简介、Activiti流程设计器安装、Activity环境搭建、通过HelloWorld掌握 Activiti操作流程的步奏、常见API使用、流程部署管理(发布流程、查看流程定义、删除流程、查看流程附件)...
Activiti工作流入门详解教程.doc
10-07
"Activiti工作流入门详解教程" Activiti是一款基于Apache许可的开源BPM（Business Process Management，业务流程管理）框架，由Alfresco软件在2010年5月17日发布。Activiti提供了一个灵活、易扩展的可执行流程语言...
activiti工作流入门教程.docx
03-02
Activiti 是一个开源的工作流引擎，它被设计用于在企业应用程序中实现业务流程自动化。这个工作流引擎基于模型驱动的设计，允许开发人员和业务分析师通过简单的图形化工具定义和执行复杂的业务流程。以下是对...
Activiti系列之任务组件TaskService
捣蛋的博客
07-06 2987
//任务组件TaskService taskService = processEngine.getTaskService(); //流程办理 1、taskService.complete("taskId"); 参数：taskId 作用：直接完成此次正在运行的任务，对用ac_ru_task表Map<String, Object> variables=new HashMap<>();2、taskService.complete("taskId",variables ); ..
Activiti6.0学习实践（8）-核心api：TaskService流程任务服务
csolo的博客
02-05 3643
TaskService也是非常重要的核心api，主要是对用户任务（UserTask）管理和控制，也可以设置UserTask的权限信息，针对用户任务添加任务附件、任务评论和事件记录。虽然TaskService可以对task对象进行创建和删除，但是一般都是在流程定义文件中我们定义task，当流程执行到这个节点时，就触发task执行。下面通过一个demo来说明 1、创建流程定义文件 创建一个关于ta...
Activiti之流程通过、驳回、会签、转办、中止、挂起等核心操作封装(Activiti5.9)
热门推荐
rosten的专栏
07-30 7万+
package com.famousPro.process.service.impl;      import java.util.ArrayList;   import java.util.HashMap;   import java.util.List;   import java.util.Map;      import org.activiti.engine.FormSer
Activiti7工作流引擎：进阶篇(十三) 拒绝(直接结束)
人不风流枉少年
12-21 1万+
驳回或者拒绝就是某个审批人不同意你的申请，此时流程就直接结束了。我们可以增加分支条件或者排它网关来完成驳回功能。此方法适用于节点较少的情况。 如果节点较多，每个节点都增加一个排它网关，感觉整个流程的.bpmn文件内容很多，我们当驳回的时候可以直接操作act_ru删除相关数据和act_hi表中完善end_time等。 ...
activiti7任务服务-流程变量（setVariable与setVariableLocal）
qq_26462567的博客
02-13 4539
activiti7任务服务本地变量和流程变量的区别
Activiti6.0流程引擎学习——(22)activiti的任务管理服务（TaskService）
JJBOOM425的博客
02-16 5814
这里介绍activiti中的任务管理服务，也就是其中的TaskService。 TaskService功能： 1、对用户任务（UserTask）管理和流程的控制； 2、设置用户任务（UserTask）的权限信息（拥有者，候选人，办理人）； 3、针对用户任务添加任务附件、任务评论和事件记录。 TaskService对Task管理与流程控制： 1、Task对象的创建，删除。但是很少使用Ta...
activiti源码解读之心得整编
Angus博客
04-09 1067
TaskService.completeTask()的执行内幕是啥？ activiti采取了command模式，completeTask会被包装成一个CompleteTaskCmd，一个Cmd执行的时候需要一些外围处理，如：log日志。activiti定义了一个拦截器链，链上的每个拦截器都有个next，会一直next执行下去。以CompleteTaskCmd为例，拦截器链为： logger拦截器-->spring事务拦截器-->CommandContext拦截器-->CommandIn
taskService.completeTask("taskId",map);异常
zhouyong0的专栏
12-09 7470
<br />No unnamed transitions were found for the task异常，说没有transitions因为你的transition对应下一个任务缺参数。所有跳不过去。<br />需要改写成下面这样就可以了<br />taskService.setVariables("taskId",map);<br /> taskService.completeTask("taskId");
Activiti工作流入门教程：从零到精通
“Activiti工作流.doc”是一份针对初学者的Activiti工作流入门教程，旨在帮助没有工作流知识或Activiti经验的读者快速上手。教程从工作流的基本概念开始，逐步深入到Activiti的具体使用，包括Activiti的工作流引擎、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值