含蓄的显示器 · mac更新yarn版本 - CSDN文库· 2 周前 · |
玩命的小虾米 · 红帽公布CoreOS与红帽 ...· 1 月前 · |
深沉的钥匙扣 · 云画的月光漫画/最新章节/笔趣阁· 6 月前 · |
正直的椰子 · 甲状腺乳头状癌术后第1天甲状旁腺激素水平对永 ...· 7 月前 · |
沉稳的消防车 · Accessing my repl's ...· 11 月前 · |
业务流程管理 流程管理 bpmn activiti |
https://www.rewind.show/2023/02/25/java/java%E6%89%A9%E5%B1%95/Activity7%E5%B7%A5%E4%BD%9C%E6%B5%81/ |
文质彬彬的充电器
1 月前 |
1、关键业务流程:订单、报价处理、合同审核、客户电话处理、供应链管理等
2、行政管理类:出差申请、加班申请、请假申请、用车申请、各种办公用品申请、购买申请、日报周报等凡是原来手工流转处理的行政表单。
3、人事管理类:员工培训安排、绩效考评、职位变动处理、员工档案信息管理等。
4、财务相关类:付款请求、应收款处理、日常报销处理、出差报销、预算和计划申请等。
5、客户服务类:客户信息管理、客户投诉、请求处理、售后服务管理等。
6、特殊服务类:ISO系列对应流程、质量管理对应流程、产品数据信息管理、贸易公司报关处理、物流公司货物跟踪处理等各种通过表单逐步手工流转完成的任务均可应用工作流软件自动规范地实施。
在没有专门的工作流引擎之前,我们之前为了实现流程控制,通常的做法就是采用状态字段的值来跟踪流程的变化情况。这样不用角色的用户,通过状态字段的取值来决定记录是否显示。
针对有权限可以查看的记录,当前用户根据自己的角色来决定审批是否合格的操作。如果合格将状态字段设置一个值,来代表合格;当然如果不合格也需要设置一个值来代表不合格的情况。
这是一种最为原始的方式。通过状态字段虽然做到了流程控制,但是当我们的流程发生变更的时候,这种方式所编写的代码也要进行调整。
那么有没有专业的方式来实现工作流的管理呢?并且可以做到业务流程变化之后,我们的程序可以不用改变,如果可以实现这样的效果,那么我们的业务系统的适应能力就得到了极大提升。
Activiti是一个工作流引擎, activiti可以将业务系统中复杂的业务流程抽取出来,使用专门的建模语言BPMN2.0进行定义,业务流程按照预先定义的流程进行执行,实现了系统的流程由activiti进行管理,减少业务系统由于流程变更进行系统升级改造的工作量,从而提高系统的健壮性,同时也减少了系统开发维护成本。
官方网站: https://www.activiti.org/
BPM(Business Process Management),即业务流程管理,是一种规范化的构造端到端的业务流程,以持续的提高组织业务效率。常见商业管理教育如EMBA、MBA等均将BPM包含在内。
BPM软件就是根据企业中业务环境的变化,推进人与人之间、人与系统之间以及系统与系统之间的整合及调整的经营方法与解决方案的IT工具。
通过BPM软件对企业内部及外部的业务流程的整个生命周期进行建模、自动化、管理监控和优化,使企业成本降低,利润得以大幅提升。
BPM软件在企业中应用领域广泛,凡是有业务流程的地方都可以BPM软件进行管理,比如企业人事办公管理、采购流程管理、公文审批流程管理、财务管理等。
2004年5月发布了BPMN1.0规范.BPMI于2005年9月并入OMG(The Object Management Group对象管理组织)组织。OMG于2011年1月发布BPMN2.0的最终版本。
BPMN 是目前被各 BPM 厂商广泛接受的 BPM 标准。Activiti 就是使用 BPMN 2.0 进行流程建模、流程执行管理,它包括很多的建模符号,比如:
Event 用一个圆圈表示,它是流程中运行过程中发生的事情。
活动用圆角矩形表示,一个流程由一个活动或多个活动组成
Bpmn图形其实是通过xml表示业务流程,.bpmn文件使用文本编辑器打开:
<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:activiti="http://activiti.org/bpmn" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC" xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI" typeLanguage="http://www.w3.org/2001/XMLSchema" expressionLanguage="http://www.w3.org/1999/XPath" targetNamespace="http://www.activiti.org/test">
<process id="myProcess" name="My process" isExecutable="true">
<startEvent id="startevent1" name="Start"></startEvent>
<userTask id="usertask1" name="创建请假单"></userTask>
<sequenceFlow id="flow1" sourceRef="startevent1" targetRef="usertask1"></sequenceFlow>
<userTask id="usertask2" name="部门经理审核"></userTask>
<sequenceFlow id="flow2" sourceRef="usertask1" targetRef="usertask2"></sequenceFlow>
<userTask id="usertask3" name="人事复核"></userTask>
<sequenceFlow id="flow3" sourceRef="usertask2" targetRef="usertask3"></sequenceFlow>
<endEvent id="endevent1" name="End"></endEvent>
<sequenceFlow id="flow4" sourceRef="usertask3" targetRef="endevent1"></sequenceFlow>
</process>
<bpmndi:BPMNDiagram id="BPMNDiagram_myProcess">
<bpmndi:BPMNPlane bpmnElement="myProcess" id="BPMNPlane_myProcess">
<bpmndi:BPMNShape bpmnElement="startevent1" id="BPMNShape_startevent1">
<omgdc:Bounds height="35.0" width="35.0" x="130.0" y="160.0"></omgdc:Bounds>
</bpmndi:BPMNShape>
<bpmndi:BPMNShape bpmnElement="usertask1" id="BPMNShape_usertask1">
<omgdc:Bounds height="55.0" width="105.0" x="210.0" y="150.0"></omgdc:Bounds>
</bpmndi:BPMNShape>
<bpmndi:BPMNShape bpmnElement="usertask2" id="BPMNShape_usertask2">
<omgdc:Bounds height="55.0" width="105.0" x="360.0" y="150.0"></omgdc:Bounds>
</bpmndi:BPMNShape>
<bpmndi:BPMNShape bpmnElement="usertask3" id="BPMNShape_usertask3">
<omgdc:Bounds height="55.0" width="105.0" x="510.0" y="150.0"></omgdc:Bounds>
</bpmndi:BPMNShape>
<bpmndi:BPMNShape bpmnElement="endevent1" id="BPMNShape_endevent1">
<omgdc:Bounds height="35.0" width="35.0" x="660.0" y="160.0"></omgdc:Bounds>
</bpmndi:BPMNShape>
<bpmndi:BPMNEdge bpmnElement="flow1" id="BPMNEdge_flow1">
<omgdi:waypoint x="165.0" y="177.0"></omgdi:waypoint>
<omgdi:waypoint x="210.0" y="177.0"></omgdi:waypoint>
</bpmndi:BPMNEdge>
<bpmndi:BPMNEdge bpmnElement="flow2" id="BPMNEdge_flow2">
<omgdi:waypoint x="315.0" y="177.0"></omgdi:waypoint>
<omgdi:waypoint x="360.0" y="177.0"></omgdi:waypoint>
</bpmndi:BPMNEdge>
<bpmndi:BPMNEdge bpmnElement="flow3" id="BPMNEdge_flow3">
<omgdi:waypoint x="465.0" y="177.0"></omgdi:waypoint>
<omgdi:waypoint x="510.0" y="177.0"></omgdi:waypoint>
</bpmndi:BPMNEdge>
<bpmndi:BPMNEdge bpmnElement="flow4" id="BPMNEdge_flow4">
<omgdi:waypoint x="615.0" y="177.0"></omgdi:waypoint>
<omgdi:waypoint x="660.0" y="177.0"></omgdi:waypoint>
</bpmndi:BPMNEdge>
</bpmndi:BPMNPlane>
</bpmndi:BPMNDiagram>
</definitions>
Activiti是一个工作流引擎(其实就是一堆jar包API),业务系统访问(操作)activiti的接口,就可以方便的操作流程相关数据,这样就可以把工作流环境与业务系统的环境集成在一起。
使用activiti流程建模工具(activity-designer)定义业务流程(.bpmn文件) 。
.bpmn文件就是业务流程定义文件,通过xml定义业务流程。
使用activiti提供的api把流程定义内容存储起来,在Activiti执行过程中可以查询定义的内容
Activiti执行把流程定义内容存储在数据库中
启动一个流程实例表示开始一次业务流程的运行。
在员工请假流程定义部署完成后,如果张三要请假就可以启动一个流程实例,如果李四要请假也启动一个流程实例,两个流程的执行互相不影响。
用户查询待办任务后,就可以办理某个任务,如果这个任务办理完成还需要其它用户办理,比如采购单创建后由部门经理审核,这个过程也是由activiti帮我们完成了。
activiti运行需要有数据库的支持,支持的数据库有:h2, mysql, oracle, postgres, mssql, db2。
activiti 支持的数据库和版本如下:
数据库类型 JDBC连接示例 1.3.168 jdbc:h2:tcp://localhost/activiti 默认配置的数据库 mysql 5.1.21 jdbc:mysql://localhost:3306/activiti?autoReconnect=true 使用 mysql-connector-java 驱动测试 oracle 11.2.0.1.0 jdbc:oracle:thin:@localhost:1521:xe postgres jdbc:postgresql://localhost:5432/activiti DB2 10.1 using db2jcc4 jdbc:db2://localhost:50000/activiti mssql 2008 using sqljdbc4 jdbc:sqlserver://localhost:1433/activiti
act_hi_*
:history,此前缀的表包含
历史数据
,如历史(结束)流程实例,变量,任务等等。
act_ge_*
:general,此前缀的表为
通用数据
,用于不同场景中。
act_evt_*
:event,此前缀的表为
事件日志
。
act_procdef_*
:processdefine,此前缀的表为记录
流程定义变更
信息。
act_re_*
:repository,此前缀的表包含了
流程定义和流程静态资源
(图片,规则等等)。
act_ru_*
:runtime,此前缀的表是
记录运行时的数据
,包含流程实例,任务,变量,异步任务等运行中的数据。Activiti只在流程实例执行过程中保存这些数据,在流程结束时就会删除这些
act_hi_actinst | 历史节点表 | act_hi_attachment | 历史附件表 | act_hi_comment | 历史意见表 | act_hi_detail | 历史详情表,提供历史变量的查询 | act_hi_identitylink | 历史流程用户信息表 | act_hi_procinst | 历史流程实例表 | act_hi_taskinst | 历史任务实例表 | act_hi_varinst | 历史变量表 |
act_ge_bytearray | 二进制数据表,存储通用的流程定义和流程资源。 | act_ge_property | 系统相关属性,属性数据表存储整个流程引擎级别的数据,初始化表结构时,会默认插入三条记录。 |
act_evt_log | 流程引擎的通用事件日志记录表 |
act_procdef_info | 流程定义的动态变更信息 |
act_re_deployment | 部署信息表 | act_re_model | 流程设计模型部署表 | act_re_procdef | 流程定义数据表 |
Activiti7发布正式版之后,它与SpringBoot2.x已经完全支持整合开发。
Activiti下载地址: http://activiti.org/download.html ,Maven的依赖如下:
<dependency>
<groupId>org.activiti</groupId>
<artifactId>activiti-spring-boot-starter</artifactId>
<version>7.0.0.Beta2</version>
<exclusions>
<!-- 排除activiti的mybatis,避免和外面的mybatis-plus冲突 -->
<exclusion>
<artifactId>mybatis</artifactId>
<groupId>org.mybatis</groupId>
</exclusion>
</exclusions>
</dependency>
注意:activiti7默认没有开启数据库历史记录,需要手动配置开启
spring:
datasource:
url: jdbc:mysql:///activiti?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT
username: root
password: 123456
driver-class-name: com.mysql.jdbc.Driver
activiti:
#1.flase:默认值。activiti在启动时,对比数据库表中保存的版本,如果没有表或者版本不匹配,将抛出异常
#2.true: activiti会对数据库中所有表进行更新操作。如果表不存在,则自动创建
#3.create_drop: 在activiti启动时创建表,在关闭时删除表(必须手动关闭引擎,才能删除表)
#4.drop-create: 在activiti启动时删除原来的旧表,然后在创建新表(不需要手动关闭引擎)
database-schema-update: true
#检测历史表是否存在 activiti7默认没有开启数据库历史记录 启动数据库历史记录
db-history-used: true
#记录历史等级 可配置的历史级别有none, activity, audit, full
#none:不保存任何的历史数据,因此,在流程执行过程中,这是最高效的。
#activity:级别高于none,保存流程实例与流程行为,其他数据不保存。
#audit:除activity级别会保存的数据外,还会保存全部的流程任务及其属性。audit为history的默认值。
#full:保存历史数据的最高级别,除了会保存audit级别的数据外,还会保存其他全部流程相关的细节数据,包括一些流程参数等。
history-level: full
#校验流程文件,默认校验resources下的processes文件夹里的流程文件
check-process-definitions: false
因为Activiti7与SpringBoot整合后,默认情况下,集成了SpringSecurity安全框架,这样我们就要去准备SpringSecurity整合进来的相关用户权限配置信息。
SpringBoot的依赖包已经将SpringSecurity的依赖包也添加进项目中。
默认情况下,springsecurity会自动配置,从而,在访问项目接口的时候,需要输入用户名和密码。
为了能够快速实现SpringSecurity安全框架的配置,所添加的一个组件。
这个类可以从我们下载的Activiti7官方提供的Example中找到。
import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.security.core.Authentication; import org.springframework.security.core.GrantedAuthority; import org.springframework.security.core.context.SecurityContextHolder; import org.springframework.security.core.context.SecurityContextImpl; import org.springframework.security.core.userdetails.UserDetails; import org.springframework.security.core.userdetails.UserDetailsService; import org.springframework.stereotype.Component; import java.util.Collection; @Component public class SecurityUtil { private Logger logger = LoggerFactory.getLogger(SecurityUtil.class); @Autowired @Qualifier("myUserDetailsService") private UserDetailsService userDetailsService; public void logInAs(String username) { UserDetails user = userDetailsService.loadUserByUsername(username); if (user == null) { throw new IllegalStateException("User " + username + " doesn't exist, please provide a valid user"); logger.info("> Logged in as: " + username); SecurityContextHolder.setContext( new SecurityContextImpl( new Authentication() { @Override public Collection<? extends GrantedAuthority> getAuthorities() { return user.getAuthorities(); @Override public Object getCredentials() { return user.getPassword(); @Override public Object getDetails() { return user; @Override public Object getPrincipal() { return user; @Override public boolean isAuthenticated() { return true; @Override public void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException { } @Override public String getName() { return user.getUsername(); })); org.activiti.engine.impl.identity.Authentication.setAuthenticatedUserId(username);
(2)用户权限配置类
本次项目中基本是在文件中定义出来的用户信息,当然也可以是数据库中查询的用户权限信息。
import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.security.core.authority.SimpleGrantedAuthority; import org.springframework.security.core.userdetails.User; import org.springframework.security.core.userdetails.UserDetailsService; import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; import org.springframework.security.crypto.password.PasswordEncoder; import org.springframework.security.provisioning.InMemoryUserDetailsManager; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; @Configuration public class DemoApplicationConfiguration { private Logger logger = LoggerFactory.getLogger(DemoApplicationConfiguration.class); @Bean public UserDetailsService myUserDetailsService() { InMemoryUserDetailsManager inMemoryUserDetailsManager = new InMemoryUserDetailsManager(); //这里添加用户,后面处理流程时用到的任务负责人,需要添加在这里 String[][] usersGroupsAndRoles = { {"jack", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"}, {"rose", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"}, {"tom", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"}, {"other", "password", "ROLE_ACTIVITI_USER", "GROUP_otherTeam"}, {"system", "password", "ROLE_ACTIVITI_USER"}, {"admin", "password", "ROLE_ACTIVITI_ADMIN"}, for (String[] user : usersGroupsAndRoles) { List<String> authoritiesStrings = Arrays.asList(Arrays.copyOfRange(user, 2, user.length)); logger.info("> Registering new user: " + user[0] + " with the following Authorities[" + authoritiesStrings + "]"); inMemoryUserDetailsManager.createUser(new User(user[0], passwordEncoder().encode(user[1]), authoritiesStrings.stream().map(s -> new SimpleGrantedAuthority(s)).collect(Collectors.toList()))); return inMemoryUserDetailsManager; @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder();
(3)自定义配置
(4)不使用SpringSecurity
如果项目中不使用 SpringSecurity ,则可以通过以下方法去除
@SpringBootApplication( exclude = { org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration.class, org.springframework.boot.actuate.autoconfigure.security.servlet.ManagementWebSecurityAutoConfiguration.class public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); * 该配置类仅仅为了跳过spring-security的验证 @Configuration public class SpringSecurityConfig extends WebSecurityConfigurerAdapter {
这样,访问接口的时候,就不要求用户认证了。即springSecurity的认证就不起作用了。
4、创建Bpmn文件
Activiti7可以自动部署流程,前提是在resources目录下,创建一个新的目录processes,用来放置bpmn文件。
创建一个简单的Bpmn流程文件,并设置任务的用户组Candidate Groups。
Candidate Groups中的内容与上面DemoApplicationConfiguration类中出现的用户组名称要保持一致,可以填写:activitiTeam 或者 otherTeam。
这样填写的好处:当不确定到底由谁来负责当前任务的时候,只要是Groups内的用户都可以拾取这个任务
5、测试
@RunWith(SpringRunner.class) @SpringBootTest public class Actviti7DemoApplicationTests { @Autowired private ProcessRuntime processRuntime; @Autowired private TaskRuntime taskRuntime; @Autowired private SecurityUtil securityUtil; @Test public void testActBoot(){ System.out.println(taskRuntime); * 查看流程定义 @Test public void contextLoads() { securityUtil.logInAs("system"); Page<org.activiti.api.process.model.ProcessDefinition> processDefinitionPage = processRuntime.processDefinitions(Pageable.of(0, 10)); System.out.println("可用的流程定义数量:" + processDefinitionPage.getTotalItems()); for (org.activiti.api.process.model.ProcessDefinition pd : processDefinitionPage.getContent()) { System.out.println("流程定义:" + pd); * 启动流程实例 @Test public void testStartProcess() { securityUtil.logInAs("system"); ProcessInstance pi = processRuntime.start(ProcessPayloadBuilder. start(). withProcessDefinitionKey("myProcess"). build()); System.out.println("流程实例ID:" + pi.getId()); **查询任务,并完成自己的任务 @Test public void testTask() { securityUtil.logInAs("jack"); Page<Task> taskPage=taskRuntime.tasks(Pageable.of(0,10)); if (taskPage.getTotalItems()>0){ for (Task task:taskPage.getContent()){ taskRuntime.claim(TaskPayloadBuilder. claim(). withTaskId(task.getId()).build()); System.out.println("任务:"+task); taskRuntime.complete(TaskPayloadBuilder. complete(). withTaskId(task.getId()).build()); Page<Task> taskPage2=taskRuntime.tasks(Pageable.of*(0,10)); if (taskPage2.getTotalItems()>0){ System.out.println("任务:"+taskPage2.getContent());
五、API
1、Activiti 的架构
引擎API是与Activiti交互的最常见方式。中心起点是
ProcessEngine
,可以按照配置部分中所述的多种方式创建 。从ProcessEngine,您可以获得包含工作流/ BPM方法的各种服务。ProcessEngine和服务对象是线程安全的。因此,您可以为整个服务器保留对其中之一的引用。Activiti的工作流程是通过读取一个配置文件,然后得到一个工作流引擎实例,通过这个引擎可以获取多个不同模块的Service,然后就可以使用这些Service去完成相应的接口,比如部署会使用到
RepositoryService
,实例会用到RuntimeService
等。(注意:FormService
和IdentityService
已经在新版本中删除了)2、流程引擎配置类
StandaloneProcessEngineConfiguration
:未集成 Spring 使用的配置类SpringProcessEngineConfiguration
:集成 Spring 的配置类@Autowired private SpringProcessEngineConfiguration springProcessEngineConfiguration; public void test13(){ ProcessEngine processEngine = springProcessEngineConfiguration.buildProcessEngine();
因为在 starter 中已经自动注入了
@Configuration @AutoConfigureAfter(DataSourceAutoConfiguration.class) @EnableConfigurationProperties(ActivitiProperties.class) public class ProcessEngineAutoConfiguration extends AbstractProcessEngineAutoConfiguration { @Bean @ConditionalOnMissingBean public SpringProcessEngineConfiguration springProcessEngineConfiguration(){ ...
3、工作流引擎的创建
(1)默认创建方式-Spring下
//直接使用工具类 ProcessEngines,使用classpath下的activiti.cfg.xml中的配置创建processEngine ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine(); System.out.println(processEngine);
(2)一般创建方式-Spring下
//先构建ProcessEngineConfiguration ProcessEngineConfiguration configuration = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml"); //通过ProcessEngineConfiguration创建ProcessEngine,此时会创建数据库 ProcessEngine processEngine = configuration.buildProcessEngine();
(3)SpringBoot创建
@Autowired private ProcessEngine processEngine;
在 starter 下,是通过 FactoryBean 注入的
public abstract class AbstractProcessEngineAutoConfiguration extends AbstractProcessEngineConfiguration { @Bean public ProcessEngineFactoryBean processEngine(SpringProcessEngineConfiguration configuration) { return super.springProcessEngineBean(configuration);
4、Servcie服务接口
(1)总览
是activiti的资源管理类,提供了管理和控制流程发布包和流程定义的操作。使用工作流建模工具设计的业务流程图需要使用此service将流程定义文件的内容部署到计算机。
暂停或激活发布包,对应全部和特定流程定义。 暂停意味着它们不能再执行任何操作了,激活是对应的反向操作。获得多种资源,像是包含在发布包里的文件, 或引擎自动生成的流程图。
获得流程定义的pojo版本, 可以用来通过java解析流程,而不必通过xml。
Activiti的流程运行管理类。可以从这个服务类中获取很多关于流程执行相关的信息
Activiti的任务管理类。可以从这个类中获取任务的信息。
Activiti的引擎管理类,提供了对 Activiti 流程引擎的管理和维护功能,这些功能不在工作流驱动的应用程序中使用,主要用于 Activiti 系统的日常维护。
(2)创建方式
RuntimeService runtimeService = processEngine.getRuntimeService();
RepositoryService repositoryService = processEngine.getRepositoryService();
TaskService taskService = processEngine.getTaskService();
@Autowired
private RuntimeService runtimeService;
public abstract class AbstractProcessEngineAutoConfiguration
extends AbstractProcessEngineConfiguration {
@Bean
@ConditionalOnMissingBean
@Override
public RuntimeService runtimeServiceBean(ProcessEngine processEngine) {
return super.runtimeServiceBean(processEngine);
@Bean
@ConditionalOnMissingBean
@Override
public RepositoryService repositoryServiceBean(ProcessEngine processEngine) {
return super.repositoryServiceBean(processEngine);
@Bean
@ConditionalOnMissingBean
@Override
public TaskService taskServiceBean(ProcessEngine processEngine) {
return super.taskServiceBean(processEngine);
@Bean
@ConditionalOnMissingBean
@Override
public HistoryService historyServiceBean(ProcessEngine processEngine) {
return super.historyServiceBean(processEngine);
@Bean
@ConditionalOnMissingBean
@Override
public ManagementService managementServiceBeanBean(ProcessEngine processEngine) {
return super.managementServiceBeanBean(processEngine);
六、流程图创建
1、定义流程,按照BPMN的规范,使用流程定义工具,用流程符号把整个流程描述出来
2、部署流程,把画好的流程定义文件,加载到数据库中,生成表的数据
1、流程符号
(1)事件 Event
(2)活动 Activity
活动是工作或任务的一个通用术语。一个活动可以是一个任务,还可以是一个当前流程的子处理流程; 其次,你还可以为活动指定不同的类型。常见活动如下:
(3)网关 GateWay
排他网关 (x)
只有一条路径会被选择。流程执行到该网关时,按照输出流的顺序逐个计算,当条件的计算结果为true时,继续执行当前网关的输出流;
如果多条线路计算结果都是 true,则会执行第一个值为 true 的线路。如果所有网关计算结果没有true,则引擎会抛出异常。
排他网关需要和条件顺序流结合使用,default 属性指定默认顺序流,当所有的条件不满足时会执行默认顺序流。
并行网关 (+)
拆分 —— 并行执行所有输出顺序流,为每一条顺序流创建一个并行执行线路。
合并 —— 所有从并行网关拆分并执行完成的线路均在此等候,直到所有的线路都执行完成才继续向下执行。
包容网关 (+)
拆分 —— 计算每条线路上的表达式,当表达式计算结果为true时,创建一个并行线路并继续执行
合并 —— 所有从并行网关拆分并执行完成的线路均在此等候,直到所有的线路都执行完成才继续向下执行。
事件网关 (+)
专门为中间捕获事件设置的,允许设置多个输出流指向多个不同的中间捕获事件。当流程执行到事件网关后,流程处于等待状态,需要等待抛出事件才能将等待状态转换为活动状态。
(4)流向 Flow
2、创建流程图
因高版本的 IDEA 不支持 actiBPM 插件,故采用 Camunda Modeler
软件来绘制流程图
官网下载:https://camunda.com/download/modeler/
百度云:https://pan.baidu.com/s/1KdQrCBo4k5j6UNF4m1Ki4g
提取码:8i44
双击 Camunda Modeler.exe
打开
1、点击右上角 file - new file - 创建BPMN文件
在properties视图指定每个任务结点的负责人,如:
填写出差申请的负责人为 zhangsan
经理审批负责人为 jerry
总经理审批负责人为 jack
财务审批负责人为 rose
3、导出 BPMN 文件和 PNG 文件
3、注意
如果使用 Camunda Modeler
软件进行绘图,生成的 xml 文件,如果有手动指定任务处理人,需要将其中的 camunda:assignee
替换为 activiti:assignee
<bpmn:userTask id="Task_17tkcmk" name="创建出差申请单" camunda:assignee="zhangsan">
<bpmn:userTask id="Task_17tkcmk" name="创建出差申请单" activiti:assignee="zhangsan">
七、流程定义
1、流程定义部署
将上面在设计器中定义的流程(.bpmn和png文件)部署到activiti数据库中,就是流程定义部署。
通过调用 activiti 的 api 将流程定义的 bpmn 和 png 两个文件一个一个添加部署到 activiti 中,也可以将两个文件打成zip包进行部署。
先将两个文件放置到 /resources/bpmn/
目录下
(1)单文件部署
@Autowired
private RepositoryService repositoryService;
@Test
public void test14(){
// 使用RepositoryService进行部署
Deployment deployment = repositoryService.createDeployment()
.addClasspathResource("bpmn/evection.bpmn") // 添加bpmn资源
.addClasspathResource("bpmn/evection.png") // 添加png资源
.name("出差申请流程")
.key("myEvection") // 指定流程定义的 KEY,流程唯一键,后续启动流程需要这个
.deploy();
// 输出部署信息
System.out.println("流程部署id:" + deployment.getId());
System.out.println("流程部署名称:" + deployment.getName());
执行此操作后activiti会将上边代码中指定的bpm文件和图片文件保存在activiti数据库。
如果报错文件 NOT FOUND 重新编译下项目就可以了
(2)压缩包部署
@Autowired
private RepositoryService repositoryService;
@Test
public void test14(){
// 定义zip输入流
InputStream inputStream = this
.getClass()
.getClassLoader()
.getResourceAsStream(
"bpmn/evection.zip");
ZipInputStream zipInputStream = new ZipInputStream(inputStream);
// 流程部署
Deployment deployment = repositoryService.createDeployment()
.addZipInputStream(zipInputStream)
.deploy();
System.out.println("流程部署id:" + deployment.getId());
System.out.println("流程部署名称:" + deployment.getName());
(3)相关数据表
act_ru_deadletter_job | 作业死亡信息表,作业失败超过重试次数 | act_ru_event_subscr | 运行时事件表 | act_ru_execution | 运行时流程执行实例表 | act_ru_identitylink | 运行时用户信息表 | act_ru_integration | 运行时积分表 | act_ru_job | 运行时作业信息表 | act_ru_suspended_job | 运行时作业暂停表 | act_ru_task | 运行时任务信息表 | act_ru_timer_job | 运行时定时器作业表 | act_ru_variable | 运行时变量信息表 | service名称 | service作用 | RepositoryService | activiti的资源管理类 | RuntimeService | activiti的流程运行管理类 | TaskService | activiti的任务管理类 | HistoryService | activiti的历史管理类 | ManagerService | activiti的引擎管理类 | act_re_deployment | 流程定义部署表,每部署一次增加一条记录 | act_re_procdef | 流程定义表,部署每个新的流程定义都会在这张表中增加一条记录 | act_ge_bytearray | 流程资源表 |
---|
3、待办任务查询
流程启动后,任务的负责人就可以查询自己当前需要处理的任务,查询出来的任务都是该用户的待办任务。
// 任务负责人
String assignee = "zhangsan";
// 根据流程key 和 任务负责人 查询任务
List<Task> list = taskService.createTaskQuery()
.processDefinitionKey("myEvection") //流程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());
4、流程任务处理
// 根据流程key 和 任务的负责人 查询任务
// 返回一个任务对象
Task task = taskService.createTaskQuery()
.processDefinitionKey("myEvection") //流程Key
.taskAssignee("zhangsan") //要查询的负责人
.singleResult();
// 完成任务,参数:任务id
taskService.complete(task.getId());
5、流程定义信息查询
// 得到ProcessDefinitionQuery 对象
ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
// 查询出当前所有的流程定义
// 条件:processDefinitionKey =evection
// orderByProcessDefinitionVersion 按照版本排序
// desc倒叙
// list 返回集合
List<ProcessDefinition> definitionList = processDefinitionQuery.processDefinitionKey("myEvection")
.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("流程部署ID ="+processDefinition.getDeploymentId());
6、流程删除
// 流程部署id
String deploymentId = "1";
//删除流程定义,如果该流程定义已有流程实例启动则删除时出错
repositoryService.deleteDeployment(deploymentId);
//设置true 级联删除流程定义,即使该流程有流程实例启动也可以删除,设置为false非级别删除方式,如果流程
//repositoryService.deleteDeployment(deploymentId, true);
如果该流程定义下存在已经运行的流程,使用普通删除报错,可用级联删除方法将流程及相关记录全部删除。
7、流程资源下载
现在我们的流程资源文件已经上传到数据库了,如果其他用户想要查看这些资源文件,可以从数据库中把资源文件下载到本地。
1、jdbc对blob类型,clob类型数据读取出来,保存到文件目录
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.6</version>
</dependency>
// 得到查询器:ProcessDefinitionQuery,设置查询条件,得到想要的流程定义
ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
.processDefinitionKey("myEvection")
.singleResult();
// 通过流程定义信息,得到部署ID
String deploymentId = processDefinition.getDeploymentId();
// 通过repositoryService的方法,实现读取图片信息和bpmn信息
// png图片的流
InputStream pngInput = repositoryService.getResourceAsStream(deploymentId, processDefinition.getDiagramResourceName());
// bpmn文件的流
InputStream bpmnInput = repositoryService.getResourceAsStream(deploymentId, processDefinition.getResourceName());
// 构造OutputStream流
File file_png = new File("d:/evectionflow01.png");
File file_bpmn = new File("d:/evectionflow01.bpmn");
FileOutputStream bpmnOut = new FileOutputStream(file_bpmn);
FileOutputStream pngOut = new FileOutputStream(file_png);
// 输入流,输出流的转换
IOUtils.copy(pngInput,pngOut);
IOUtils.copy(bpmnInput,bpmnOut);
// 关闭流
pngOut.close();
bpmnOut.close();
pngInput.close();
bpmnInput.close();
使用repositoryService的getDeploymentResourceNames方法可以获取指定部署下得所有文件的名称
使用repositoryService的getResourceAsStream方法传入部署ID和资源图片名称可以获取部署下指定名称文件的输入流
8、流程历史信息的查看
// 获取 actinst表的查询对象
HistoricActivityInstanceQuery instanceQuery = historyService.createHistoricActivityInstanceQuery();
// 查询 actinst表,条件:根据 InstanceId 查询
// instanceQuery.processInstanceId("2501");
// 查询 actinst表,条件:根据 DefinitionId 查询
instanceQuery.processDefinitionId("myEvection: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());
八、流程实例
1、什么是流程实例
流程实例(ProcessInstance)代表流程定义的执行实例。
一个流程实例包括了所有的运行节点。我们可以利用这个对象来了解当前流程实例的进度等信息。
例如:用户或程序按照流程定义内容发起一个流程,这就是一个流程实例。
其实就可以类比为 类和对象 的关系,流程定义就是类,用户发起流程就是创建对象,发起的流程就是流程实例。
2、启动流程实例
流程定义部署在activiti后,就可以在系统中通过activiti去管理该流程的执行,执行流程表示流程的一次执行。
比如部署系统出差流程后,如果某用户要申请出差这时就需要执行这个流程,如果另外一个用户也要申请出差则也需要执行该流程,每个执行互不影响,每个执行是单独的流程实例。
启动流程实例时,指定的 businesskey
,就会在act_ru_execution
#流程实例的执行表中存储businesskey
。
Businesskey
:业务标识,通常为业务表的主键,业务标识和流程实例一一对应。业务标识来源于业务系统。存储业务标识就是根据业务标识来关联查询业务系统的数据。
比如:出差流程启动一个流程实例,就可以将出差单的id作为业务标识存储到activiti中,将来查询activiti的流程实例信息就可以获取出差单的id从而关联查询业务系统数据库得到出差单信息。
// 启动流程实例,同时还要指定业务标识businessKey,也就是出差申请单id,这里是1001
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("myEvection","1001");
// 输出processInstance相关属性
System.out.println("业务id=="+processInstance.getBusinessKey());
3、相关数据表
act_ru_execution:程实例执行表,记录当前流程实例的执行情况
启动流程实例,流程当前执行到第一个任务结点,此表会插入一条记录表示当前任务的执行情况,如果任务完成则记录删除。
act_ru_identitylink:任务参与者,记录当前参与任务的用户或组
流程实例启动,会在此表插入一条记录,流程实例运行完成记录也不会删除。
开始一个任务,不仅在act_ru_task表插入记录,也会在历史任务表插入一条记录,任务历史表的主键就是任务id,任务完成此表记录不删除。
活动包括任务,所以此表中不仅记录了任务,还记录了流程执行过程的其它活动,比如开始事件、结束事件。
4、查询流程实例
流程在运行过程中可以查询流程实例的状态,当前运行结点等信息。
// 流程定义key
String processDefinitionKey = "evection";
// 查询流程实例
List<ProcessInstance> list = runtimeService
.createProcessInstanceQuery()
.processDefinitionKey(processDefinitionKey)//
.list();
for (ProcessInstance processInstance : list) {
System.out.println("----------------------------");
System.out.println("流程实例id:"
+ processInstance.getProcessInstanceId());
System.out.println("所属流程定义id:"
+ processInstance.getProcessDefinitionId());
System.out.println("是否执行完成:" + processInstance.isEnded());
System.out.println("是否暂停:" + processInstance.isSuspended());
System.out.println("当前活动标识:" + processInstance.getActivityId());
5、关联业务数据
在查询流程实例时,通过businessKey(业务标识 )关联查询业务系统的出差单表,查询出出差天数等信息。
6、挂起/激活流程实例
某些情况可能由于流程变更需要将当前运行的流程暂停而不是直接删除,流程暂停后将不会继续执行。
(1)操作流程定义-全部
操作流程定义为挂起状态,该流程定义下边所有的流程实例全部暂停:
流程定义为挂起状态该流程定义将不允许启动新的流程实例,同时该流程定义下所有的流程实例将全部挂起暂停执行。
// 查询流程定义的对象
ProcessDefinition processDefinition = repositoryService
.createProcessDefinitionQuery().
processDefinitionKey("myEvection").
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+",已激活");
}else{
// 如果是激活状态,可以暂停,参数1 :流程定义id ,参数2:是否暂停,参数3:暂停时间
repositoryService.suspendProcessDefinitionById(processDefinitionId,true,null);
System.out.println("流程定义:"+processDefinitionId+",已挂起");
(2)操作流程实例-单条
操作流程实例对象,针对单个流程执行挂起操作,某个流程实例挂起则此流程不再继续执行,完成该流程实例的当前任务将报异常。
// 查询流程定义的对象
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+",已激活");
}else{
// 如果是激活状态,可以暂停,参数:流程定义id
runtimeService.suspendProcessInstanceById( processDefinitionId);
System.out.println("流程定义:"+processDefinitionId+",已挂起");
九、个人任务
1、分配任务责任人-固定
并在 properties 视图中,填写 Assignee 项为任务负责人。
2、分配任务责任人-表达式
由于固定分配方式,任务只管一步一步执行任务,执行到每一个任务将按照 bpmn 的配置去分配任
务负责人。
(1)UEL 表达式
可在绘制的流程图中的用户任务中的 Assignee
的值设置为${assignee}
,从而可以进行动态配置,即启动流程实例时通过代码进行赋值
${user.assignee}
表示通过调用 user 的 getter 方法获取值。
${UserBean.getUserId()}
:userBean 是 spring 容器中的一个 bean,表示调用该 bean 的 getUserId()方法。
表达式支持解析基础类型、 bean、 list、 array 和 map,也可作为条件判断。
如下:
${order.price > 100 && order.price < 250}
(2)代码设置变量
// 设置assignee的取值,用户可以在界面上设置流程的执行
Map<String,Object> assigneeMap = new HashMap<>();
assigneeMap.put("assignee0","张三");
assigneeMap.put("assignee1","李经理");
assigneeMap.put("assignee2","王总经理");
assigneeMap.put("assignee3","赵财务");
// 启动流程实例,同时还要设置流程定义的assignee的值
runtimeService.startProcessInstanceByKey("myEvection1",assigneeMap);
// 输出
System.out.println(processEngine.getName());
3、分配任务责任人-监听器
我们使用监听器的方式来指定负责人,那么在流程设计时就不需要指定assignee。
任务监听器是发生对应的任务相关事件时执行自定义 java 逻辑 或表达式。
take:执行监听,只能加在序列流上面
create:任务创建后触发
assigment:任务分配后触发
complete:任务完成后触发
delete:任务完成后自动删除时触发
start:流程实例/任务启动监听,不能加在序列流(流程图上的箭头)上面
end:流程实例/任务结束监听,不能加在序列流上面
(1)监听器
/**
* Activity 监听器
public class MyStartListener implements TaskListener,ExecutionListener {
* Execution Listeners 相关事件监听
@Override
public void notify(DelegateExecution delegateExecution) {
System.out.println("ExecutionListener...");
System.out.println(delegateExecution);
System.out.println(delegateExecution.getEventName());
* Task Linsteners 相关事件监听
@Override
public void notify(DelegateTask delegateTask) {
System.out.println("TaskListener...");
System.out.println(delegateTask);
System.out.println(delegateTask.getEventName());
if(delegateTask.getName().equals("创建出差申请单") &&
delegateTask.getEventName().equals("create")){
System.out.println("创建出差申请单");
//这里指定任务负责人
delegateTask.setAssignee("zhangsan");
System.out.println(delegateTask.getAssignee());
(2)流程代码
@Test
public void test14(){
// 流程定义 KEY
String processDefinitionKey = "myEvection";
repositoryService.deleteDeployment("ec1bb8ec-bcb7-11ed-87b9-744ca153de09", true);
// 使用RepositoryService进行部署
Deployment deployment = repositoryService.createDeployment()
.addClasspathResource("bpmn/evection.bpmn") // 添加bpmn资源
.addClasspathResource("bpmn/evection.png") // 添加png资源
.name("出差申请流程")
.key(processDefinitionKey)
.deploy();
// 输出部署信息
System.out.println("流程部署id:" + deployment.getId());
System.out.println("流程部署名称:" + deployment.getName());
// 启动流程实例,同时还要指定业务标识businessKey,也就是出差申请单id,这里是1001
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(processDefinitionKey,deployment.getId());
System.out.println("流程启动:" + processInstance);
finishTask(processDefinitionKey, "zhangsan");
finishTask(processDefinitionKey, "jerry");
finishTask(processDefinitionKey, "jack");
finishTask(processDefinitionKey, "rose");
// 查询流程实例
List<ProcessInstance> list = runtimeService
.createProcessInstanceQuery()
.processDefinitionKey(processDefinitionKey)
.list();
for (ProcessInstance instance : list) {
System.out.println("流程实例:" + instance.getName());
System.out.println("是否执行完成:" + instance.isEnded());
public void finishTask(String processDefinitionKey, String assignee){
List<Task> taskList = taskService.createTaskQuery()
.processDefinitionKey(processDefinitionKey)
.includeProcessVariables()
.taskAssignee(assignee)
.list();
System.out.println(assignee + "流程实例查询:" + taskList);
for (Task task : taskList) {
System.out.println("----------------------------");
System.out.println("任务负责人: " + task.getAssignee());
System.out.println("任务名称: " + task.getName());
taskService.complete(task.getId());
System.out.println("----------------------------");
(3)输出
流程部署id:6644fd6b-c3ce-11ed-b225-744ca153de09
流程部署名称:出差申请流程
ExecutionListener...
Execution[ id '66d90010-c3ce-11ed-b225-744ca153de09' ] - activity 'Task_17tkcmk - parent '66d8b1ef-c3ce-11ed-b225-744ca153de09'
start
TaskListener...
Task[id=66dca993-c3ce-11ed-b225-744ca153de09, name=创建出差申请单]
assignment
zhangsan
TaskListener...
Task[id=66dca993-c3ce-11ed-b225-744ca153de09, name=创建出差申请单]
create
创建出差申请单
zhangsan
流程启动:ProcessInstance[66d8b1ef-c3ce-11ed-b225-744ca153de09]
zhangsan流程实例查询:[Task[id=66dca993-c3ce-11ed-b225-744ca153de09, name=创建出差申请单]]
----------------------------
任务负责人: zhangsan
任务名称: 创建出差申请单
TaskListener...
Task[id=66dca993-c3ce-11ed-b225-744ca153de09, name=创建出差申请单]
complete
zhangsan
TaskListener...
Task[id=66dca993-c3ce-11ed-b225-744ca153de09, name=创建出差申请单]
delete
zhangsan
ExecutionListener...
Execution[ id '66d90010-c3ce-11ed-b225-744ca153de09' ] - activity 'Task_17tkcmk - parent '66d8b1ef-c3ce-11ed-b225-744ca153de09'
----------------------------
jerry流程实例查询:[Task[id=67f67e06-c3ce-11ed-b225-744ca153de09, name=部门经理审批]]
----------------------------
任务负责人: jerry
任务名称: 部门经理审批
----------------------------
jack流程实例查询:[Task[id=6900c219-c3ce-11ed-b225-744ca153de09, name=总经理审批]]
----------------------------
任务负责人: jack
任务名称: 总经理审批
----------------------------
rose流程实例查询:[Task[id=6a5814bc-c3ce-11ed-b225-744ca153de09, name=财务审批]]
----------------------------
任务负责人: rose
任务名称: 财务审批
----------------------------
4、查询个人任务
// 流程定义key
String processDefinitionKey = "myEvection1";
// 任务负责人
String assignee = "张三";
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());
5、获取业务单号
// 查询流程定义的对象
Task task = taskService.createTaskQuery()
.processDefinitionKey("myEvection1")
.taskAssignee("张三")
.singleResult();
// 使用task对象获取实例id
String processInstanceId = task.getProcessInstanceId();
// 使用实例id,获取流程实例对象
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
.processInstanceId(processInstanceId)
.singleResult();
// 使用processInstance,得到 businessKey
String businessKey = processInstance.getBusinessKey();
6、办理任务
注意:在实际应用中,完成任务前需要校验任务的负责人是否具有该任务的办理权限 。
// 完成任务前,需要校验该负责人可以完成当前任务
// 校验方法:
// 根据任务id和任务负责人查询当前任务,如果查到该用户有权限,就完成
Task task = taskService.createTaskQuery()
.taskId(taskId)
.taskAssignee(assingee)
.singleResult();
if(task != null){
taskService.complete(taskId);
System.out.println("完成任务");
十、流程变量
1、介绍
2、变量类型
如果将 pojo 存储到流程变量中,必须实现序列化接口 serializable,为了防止由于新增字段无
法反序列化,需要生成 serialVersionUID。
3、作用域
流程变量的作用域可以是一个流程实例(processInstance),或一个任务(task),或一个执行实例(execution)
(1)globa变量
流程变量的默认作用域是流程实例。当一个流程变量的作用域为流程实例时,可以称为 global 变量
如: Global变量:userId(变量名)、zhangsan(变量值)
global 变量中变量名不允许重复,设置相同名称的变量,后设置的值会覆盖前设置的变量值。
(2)local变量
任务和执行实例仅仅是针对一个任务和一个执行实例范围,范围没有流程实例大, 称为 local 变量。
Local 变量由于在不同的任务或不同的执行实例中,作用域互不影响,变量名可以相同没有影响。Local 变量名也可以和 global 变量名相同,没有影响。
4、流程变量使用方法
(1)在属性上使用UEL表达式
可以在 assignee 处设置 UEL 表达式,表达式的值为任务的负责人,比如: ${assignee}, assignee 就是一个流程变量名称。
Activiti获取UEL表达式的值,即流程变量assignee的值 ,将assignee的值作为任务的负责人进行任务分配
(2)在连线上使用UEL表达式
比如:${price<10000} 。price就是一个流程变量名称,uel表达式结果类型为布尔类型。
5、Global变量控制流程案例
(1)需求
员工创建出差申请单,由部门经理审核,部门经理审核通过后出差3天及以下由人财务直接审批,3天以上先由总经理审核,总经理审核通过再由财务审批。
(3)设置global变量
在部门经理审核前设置流程变量,变量值为出差单信息(包括出差天数),部门经理审核后可以根据流程变量的值决定流程走向。
在设置流程变量时,可以在启动流程时设置,也可以在任务办理时设置
(4)创建POJO类
/**
* 出差申请 pojo
public class Evection implements Serializable {
* 主键id
private Long id;
* 出差申请单名称
private String evectionName;
* 出差天数
private Double num;
* 预计开始时间
private Date beginDate;
* 预计结束时间
private Date endDate;
* 目的地
private String destination;
* 出差事由
private String reson;
(5)启动流程时设置变量
通过 Map<key,value>
设置流程变量,map中可以设置多个变量,这个key就是流程变量的名字。
* 启动流程实例,设置流程变量的值
@Test
public void startProcess(){
// 流程定义key
String key = "myEvection2";
// 创建变量集合
Map<String, Object> map = new HashMap<>();
// 创建出差pojo对象
Evection evection = new Evection();
// 设置出差天数
evection.setNum(2d);
// 定义流程变量,把出差pojo对象放入map
map.put("evection",evection);
// 设置assignee的取值,用户可以在界面上设置流程的执行
map.put("assignee0","张三");
map.put("assignee1","李经理");
map.put("assignee2","王总经理");
map.put("assignee3","赵财务");
// 启动流程实例,并设置流程变量的值(把map传入)
ProcessInstance processInstance = runtimeService
.startProcessInstanceByKey(key, map);
// 输出
System.out.println("流程实例名称="+processInstance.getName());
System.out.println("流程定义id=="+processInstance.getProcessDefinitionId());
startProcessInstanceByKey(processDefinitionKey, variables)
流程变量作用域是一个流程实例,流程变量使用Map存储,同一个流程实例设置变量map中key相同,后者覆盖前者。
(6)任务办理时设置变量
在完成任务时设置流程变量,该流程变量只有在该任务完成后其它结点才可使用该变量,它的作用域是整个流程实例,如果设置的流程变量的key在流程实例中已存在相同的名字则后设置的变量替换前边设置的变量。
* 完成任务,判断当前用户是否有权限
@Test
public void completTask() {
//任务id
String key = "myEvection2";
// 任务负责人
String assingee = "张三";
// 创建变量集合
Map<String, Object> map = new HashMap<>();
// 创建出差pojo对象
Evection evection = new Evection();
// 设置出差天数
evection.setNum(2d);
// 定义流程变量
map.put("evection",evection);
// 完成任务前,需要校验该负责人可以完成当前任务
// 校验方法:
// 根据任务id和任务负责人查询当前任务,如果查到该用户有权限,就完成
Task task = taskService.createTaskQuery()
.processDefinitionKey(key)
.taskAssignee(assingee)
.singleResult();
if(task != null){
//完成任务是,设置流程变量的值
taskService.complete(task.getId(), map);
System.out.println("任务执行完成");
通过当前任务设置流程变量,需要指定当前任务id,如果当前执行的任务id不存在则抛出异常。
任务办理时也是通过 map<key,value>
设置流程变量,一次可以设置多个变量。
(7)通过当前流程实例设置
@Test
public void setGlobalVariableByExecutionId(){
// 当前流程实例执行 id,通常设置为当前执行的流程实例
String executionId="2601";
// 创建出差pojo对象
Evection evection = new Evection();
// 设置天数
evection.setNum(3d);
// 通过流程实例 id设置流程变量
runtimeService.setVariable(executionId, "evection", evection);
// 一次设置多个值
// runtimeService.setVariables(executionId, variables)
executionId必须当前未结束 流程实例的执行id,通常此id设置流程实例 的id。也可以通runtimeService.getVariable()
获取流程变量。
(8)通过当前任务设置
@Test
public void setGlobalVariableByTaskId(){
//当前待办任务id
String taskId="1404";
Evection evection = new Evection();
evection.setNum(3);
//通过任务设置流程变量
taskService.setVariable(taskId, "evection", evection);
//一次设置多个值
//taskService.setVariables(taskId, variables)
任务id必须是当前待办任务id,act_ru_task中存在。如果该任务已结束,会报错
也可以通过 taskService.getVariable()
获取流程变量。
(9)注意事项
2、 如果UEL表达式中流程变量值为空NULL,流程不按UEL表达式去执行,而流程结束 。
(10)操作数据库表
设置流程变量会在当前执行流程变量表插入记录,同时也会在历史流程变量表也插入记录。
#当前流程变量表
SELECT * FROM act_ru_variable
记录当前运行流程实例可使用的流程变量,包括 global和local变量
Execution_id_:所属流程实例执行id,global和local变量都存储
Proc_inst_id_:所属流程实例id,global和local变量都存储
Bytearray_:serializable类型变量存储对应act_ge_bytearray表的id
#历史流程变量表
SELECT * FROM act_hi_varinst
记录所有已创建的流程变量,包括 global和local变量
6、设置local流程变量案例
(1)任务办理时设置
任务办理时设置local流程变量,当前运行的流程实例只能在该任务结束前使用,任务结束该变量无法在当前流程实例使用,可以通过查询历史任务查询。
*处理任务时设置local流程变量
@Test
public void completTask() {
//任务id
String taskId = "1404";
// 定义流程变量
Map<String, Object> variables = new HashMap<String, Object>();
Evection evection = new Evection ();
evection.setNum(3d);
// 定义流程变量
Map<String, Object> variables = new HashMap<String, Object>();
// 变量名是holiday,变量值是holiday对象
variables.put("evection", evection);
// 设置local变量,作用域为该任务
taskService.setVariablesLocal(taskId, variables);
// 完成任务
taskService.complete(taskId);
说明:设置作用域为任务的local变量,每个任务可以设置同名的变量,互不影响。
(2)通过当前任务设置
@Test
public void setLocalVariableByTaskId(){
// 当前待办任务id
String taskId="1404";
Evection evection = new Evection ();
evection.setNum(3d);
// 通过任务设置流程变量
taskService.setVariableLocal(taskId, "evection", evection);
// 一次设置多个值
//taskService.setVariablesLocal(taskId, variables)
注意:任务id必须是当前待办任务id,act_ru_task
中存在。
(3)查询变量
// 创建历史任务查询对象
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());
注意:查询历史流程变量,特别是查询pojo变量需要经过反序列化,不推荐使用。
十一、组任务
act_hi_actinst | 流程实例执行历史 | act_hi_identitylink | 流程的参与用户历史信息 | act_hi_procinst | 流程实例历史信息 | act_hi_taskinst | 流程任务历史信息 | act_ru_execution | 流程执行信息 | act_ru_identitylink | 流程的参与用户信息 | act_ru_task | ${var} | 获取 var 的值 | ${var.name} | 获取 var 的 name 属性的值 | ${serviceBean.confirm()} | 执行变量名为 serviceBean 的 confirm 方法 | ${serviceBean.confirm(‘str1’)} |
执行变量名为 serviceBean 的 confirm 方法,参数为
str1
。参数也可以为变量。
|
${serviceBean.confirm(‘str1’,execution)} | 执行变量名为 serviceBean 的 confirm 方法,参数为变量 name。第二个变量是引擎内置变量。 | ${order.price > 100 && order.price < 250} |
${name=="zhangsan"}
|
${name=="zhangsan" and pwd=="123"}
|
${name=="zhangsan" or name=="lisi"}
|
${1+1}
|
${1-1}
|
${1*1}
|
/或div |
${1/1}
或
${1 div 1}
|
%或mod |
${1+1}
或
${1 mod 1}
|