Activiti 工作流引擎详解

seo靠我 2023-09-24 12:45:03

Activiti 工作流引擎详解

1、Activiti工作流概述1.1、工作流概述1.2、工作流系统1.3、Activiti概述1.4、BPM 2、Activiti工作流环境搭建3、Activiti SEO靠我类、配置文件之间的关系3.1、activiti.cfg.xml3.2、流程引擎配置类3.2.1、StandaloneProcessEngineConfiguration3.2.2、SpringProcSEO靠我essEngineConfiguration 3.3、Servcie服务接口 4、流程的创建与操作4.1、流程图的绘制4.2、流程的部署4.2.1、单个文件部署方式4.2.2、使用压缩包的方式 4.3SEO靠我、开始流程4.4、任务查询4.5、任务推动4.6、流程定义信息查询4.7、流程删除4.8、下载资源文件4.9、流程历史信息的查看4.10、给流程实例添加Businesskey（业务标识）4.11、流程SEO靠我的挂起与激活4.11.1、全部流程实例挂起4.11.2、单个流程实例挂起4.11.3、流程实例推动 5、个人任务5.1、分配任务负责人5.1.1、固定负责人5.1.2、表达式分配5.1.3、监听器分配SEO靠我 5.2、查询任务5.3、任务推动 6、流程变量与组任务6.1、流程变量概述6.2.1、流程变量是什么 6.2、使用Global变量控制流程6.2.1、启动流程时设置变量6.2.2、任务办理时设置变量SEO靠我6.2.3、通过当前流程实例设置6.2.4、通过当前任务设置 6.3、组任务办理流程6.3.1、查询组任务6.3.2、拾取组任务6.3.3、归还组任务 7、网关7.1、排他网关7.2、并行网关7.3、SEO靠我包含网关7.4、事件网关 8、SpringBoot 整合 Activiti

1、Activiti工作流概述

1.1、工作流概述

工作流(Workflow)，就是通过计算机对业务流程自动化执行管理。它主要解决SEO靠我的是“使在多个参与者之间按照某种预定义的规则自动进行传递文档、信息或任务的过程，从而实现某个预期的业务目标，或者促使此目标的实现”。

1.2、工作流系统

一个软件系统中具有工作流的功能，我们把它称为工作流SEO靠我系统，一个系统中工作流的功能是什么？就是对系统的业务流程进行自动化管理，所以工作流是建立在业务流程的基础上，所以一个软件的系统核心根本上还是系统的业务流程，工作流只是协助进行业务流程管理。即使没有工作SEO靠我流业务系统也可以开发运行，只不过有了工作流可以更好的管理业务流程，提高系统的可扩展性。

1.3、Activiti概述

Activiti是一个工作流引擎， activiti可以将业务系统中复杂的业务流程抽取SEO靠我出来，使用专门的建模语言BPMN2.0进行定义，业务流程按照预先定义的流程进行执行，实现了系统的流程由activiti进行管理，减少业务系统由于流程变更进行系统升级改造的工作量，从而提高系统的健壮性，SEO靠我同时也减少了系统开发维护成本。

1.4、BPM

BPM即业务流程管理，是一种规范化的构造端到端的业务流程，以持续的提高组织业务效率。

idea插件安装：https://plugins.jetbrains.cSEO靠我om/plugin/7429-actibpm/versions

将下载的jar包插件直接整到idea当中，在settings当中的插件当中，导入本地插件，导入插件之后重启idea即可。

2、ActivitSEO靠我i工作流环境搭建

首先还是构建一个maven项目，之后导入依赖，这里就包括了activiti所需要的依赖包，以及junti测试包、mysql驱动包、连接池包。在进行使用的时候只需要对数据库驱动包的版本进SEO靠我行调整即可。

<properties><slf4j.version>1.6.6</slf4j.version><log4j.version>1.2.12</log4j.version><activitiSEO靠我.version>7.0.0.Beta1</activiti.version> </properties> <dependencies><dependency><groSEO靠我upId>org.activiti</groupId><artifactId>activiti-engine</artifactId><version>${activiti.version}</verSEO靠我sion></dependency><dependency><groupId>org.activiti</groupId><artifactId>activiti-spring</artifactIdSEO靠我><version>${activiti.version}</version></dependency><dependency><groupId>org.activSEO靠我iti</groupId><artifactId>activiti-bpmn-model</artifactId><version>${activiti.version}</version></depSEO靠我endency><dependency><groupId>org.activiti</groupId><artifactId>activiti-bpmn-convertSEO靠我er</artifactId><version>${activiti.version}</version></dependency><dependency>SEO靠我<groupId>org.activiti</groupId><artifactId>activiti-json-converter</artifactId><version>${activiti.vSEO靠我ersion}</version></dependency><dependency><groupId>org.activiti</groupId><artifactIdSEO靠我>activiti-bpmn-layout</artifactId><version>${activiti.version}</version></dependency><dependency><groupId>org.activiti.cloud</groupId><artifactId>activiti-cloud-services-api</artiSEO靠我factId><version>${activiti.version}</version></dependency><dependency><groupId>mysqlSEO靠我</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.40</version></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.4.5</vSEO靠我ersion></dependency><dependency><groupId>commons-dbcp</groupId><artifactId>commons-dbcp<SEO靠我/artifactId><version>1.4</version></dependency><dependency><groupId>junit</groupId><artifactId>junitSEO靠我</artifactId><version>4.12</version></dependency><dependency><groupId>log4j</groupSEO靠我Id><artifactId>log4j</artifactId><version>${log4j.version}</version></dependency><dependency><groupISEO靠我d>org.slf4j</groupId><artifactId>slf4j-api</artifactId><version>${slf4j.version}</version></dependenSEO靠我cy><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId><version>${slf4j.veSEO靠我rsion}</version></dependency> </dependencies>

在这里使用log4j日志包，可以对日志进行配置，直接在resources下创建log4j.prSEO靠我operties

# Set root category priority to INFO and its only appender to CONSOLE. #log4j.rootCaSEO靠我tegory=INFO, CONSOLE debug info warn error fatal log4j.rootCategory=debug, CONSOLE, LOGFILE SEO靠我 # Set the enterprise logger category to FATAL and its only appender to CONSOLE. log4SEO靠我j.logger.org.apache.axis.enterprise=FATAL, CONSOLE # CONSOLE is set to be a ConsoleAppender SEO靠我using a PatternLayout. log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender log4jSEO靠我.appender.CONSOLE.layout=org.apache.log4j.PatternLayout log4j.appender.CONSOLE.layout.ConverSEO靠我sionPattern=%d{ISO8601} %-6r[%15.15t] %-5p %30.30c %x - %m\n # LOGFILE is set to be a File aSEO靠我ppender using a PatternLayout. log4j.appender.LOGFILE=org.apache.log4j.FileAppender SEO靠我log4j.appender.LOGFILE.File=f:\act\activiti.log log4j.appender.LOGFILE.Append=true lSEO靠我og4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout log4j.appender.LOGFILE.layout.CoSEO靠我nversionPattern=%d{ISO8601} %-6r[%15.15t] %-5p %30.30c %x - %m\n

添加activiti配置文件，使用activiti提供的默认方式来创建mSEO靠我ysql的表。默认方式是在 resources 下创建 activiti.cfg.xml 文件，注意：默认方式目录和文件名不能修改，因为activiti的源码中已经设置，到固定的目录读取固定文件名的文SEO靠我件。默认要在在activiti.cfg.xml中bean的名字叫processEngineConfiguration，名字不可修改，在这里直接连接到本地数据库activiti这个库。

<?xml verSEO靠我sion="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"xmlnSEO靠我s:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schemSEO靠我a/context"xmlns:tx="http://www.springframework.org/schema/tx"xsi:schemaLocation="http://www.springfrSEO靠我amework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd http://SEO靠我www.springframework.org/schema/contex http://www.springframework.org/schema/context/spring-cSEO靠我ontext.xsd http://www.springframework.org/schema/tx http://www.springframework.org/sSEO靠我chema/tx/spring-tx.xsd"><bean id="processEngineConfiguration"class="org.activiti.engine.impl.cfg.StandaloneProcessEnginSEO靠我eConfiguration"><property name="jdbcDriver" value="com.mysql.jdbc.Driver"/><property name="jdbcUrl" SEO靠我value="jdbc:mysql:///activiti"/><property name="jdbcUsername" value="root"/><property name="jdbcPassSEO靠我word" value="root"/><property name="databaseSchemaUpdate" value="true"/></bSEO靠我ean> </beans>

当然了除了直接配置这个数据库的信息之外，还可以通过数据源的方式来进行配置。

<bean id="dataSourcSEO靠我e" class="org.apache.commons.dbcp.BasicDataSource"><property name="driverClassName" value="com.mysqlSEO靠我.jdbc.Driver" /><property name="url" value="jdbc:mysql:///activiti" /><property name="username" valuSEO靠我e="root" /><property name="password" value="root" /><property name="maxActive" value="3" /><propertySEO靠我 name="maxIdle" value="1" /></bean><bean id="processEngineConfiguration"class="org.activiti.engine.iSEO靠我mpl.cfg.StandaloneProcessEngineConfiguration"><property name="dataSource" ref=SEO靠我"dataSource" /><property name="databaseSchemaUpdate" value="true"/></bean>

创SEO靠我建一个测试类，调用activiti的工具类，生成acitivti需要的数据库表。直接使用activiti提供的工具类ProcessEngines，会默认读取classpath下的activiti.cfSEO靠我g.xml文件，读取其中的数据库配置，创建 ProcessEngine，在创建ProcessEngine 时会自动创建表。代码执行完成之后在数据库当中进行查看对应的表是否都创建出来了。

@TestpubSEO靠我lic void testCreateDbTable() {//使用classpath下的activiti.cfg.xml中的配置创建processEngineProcessEngine procesSEO靠我sEngine = ProcessEngines.getDefaultProcessEngine();System.out.println(processEngine);// 而除了使用默认配置进行创SEO靠我建工作流引擎对象，还可以通过自定义的方式进行创建。// 自定义配置文件名ProcessEngineConfiguration processEngineConfigurationFromResourcSEO靠我e = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml");// 自SEO靠我定义配置文件名 bean对象idProcessEngineConfiguration processEngineConfigurationFromResource1 = ProcessEngineCoSEO靠我nfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml", "processEngineConfiguraSEO靠我tion");}

生成的表说明：

表分类表名解释一般数据[ACT_GE_BYTEARRAY]通用的流程定义和流程资源[ACT_GE_PROPERTY]系统相关属性流程历史记录[ACT_HI_ACTINSTSEO靠我]历史的流程实例[ACT_HI_ATTACHMENT]历史的流程附件[ACT_HI_COMMENT]历史的说明性信息[ACT_HI_DETAIL]历史的流程运行中的细节信息[ACT_HI_IDENTISEO靠我TYLINK]历史的流程运行过程中用户关系[ACT_HI_PROCINST]历史的流程实例[ACT_HI_TASKINST]历史的任务实例[ACT_HI_VARINST]历史的流程运行中的变量信息流程SEO靠我定义表[ACT_RE_DEPLOYMENT]部署单元信息[ACT_RE_MODEL]模型信息[ACT_RE_PROCDEF]已部署的流程定义运行实例表[ACT_RU_EVENT_SUBSCR]运行时事SEO靠我件[ACT_RU_EXECUTION]运行时流程执行实例[ACT_RU_IDENTITYLINK]运行时用户关系信息，存储任务节点与参与者的相关信息[ACT_RU_JOB]运行时作业[ACT_RU_TSEO靠我ASK]运行时任务[ACT_RU_VARIABLE]运行时变量表

3、Activiti 类、配置文件之间的关系

3.1、activiti.cfg.xml

activiti的引擎配置文件，包括：ProcessSEO靠我EngineConfiguration的定义、数据源定义、事务管理器等，此文件其实就是一个spring配置文件。

3.2、流程引擎配置类

流程引擎的配置类（ProcessEngineConfiguratiSEO靠我on），通过ProcessEngineConfiguration可以创建工作流引擎ProceccEngine，常用的两种方法如下：

3.2.1、StandaloneProcessEngineConfigSEO靠我uration

使用StandaloneProcessEngineConfigurationActiviti可以单独运行，来创建ProcessEngine，Activiti会自己处理事务。配置文件方式：SEO靠我通常在activiti.cfg.xml配置文件中定义一个id为 processEngineConfiguration 的bean，见环境搭建模块，就是使用这种方式进行配置的。

3.2.2、SpringPSEO靠我rocessEngineConfiguration

通过org.activiti.spring.SpringProcessEngineConfiguration 与Spring整合。

3.3、ServciSEO靠我e服务接口

Service是工作流引擎提供用于进行工作流部署、执行、管理的服务接口，我们使用这些接口可以就是操作服务对应的数据表，并且在这里通过processEngine对象get对应的service就SEO靠我可以获取到service对象了。

service名称service作用功能描述RepositoryServiceactiviti的资源管理类activiti的资源管理类，提供了管理和控制流程发布包和流程SEO靠我定义的操作。使用工作流建模工具设计的业务流程图需要使用此service将流程定义文件的内容部署到计算机RuntimeServiceactiviti的流程运行管理类Activiti的流程运行管理类。可以SEO靠我从这个服务类中获取很多关于流程执行相关的信息TaskServiceactiviti的任务管理类Activiti的任务管理类。可以从这个类中获取任务的信息。HistoryServiceactiviti的SEO靠我历史管理类Activiti的历史管理类，可以查询历史信息，执行流程时，引擎会保存很多数据（根据配置），比如流程实例启动时间，任务的参与者，完成任务的时间，每个流程实例的执行路径，等等。这个服务主要SEO靠我通过查询功能来获得这些数据。ManagerServiceactiviti的引擎管理类Activiti的引擎管理类，提供了对 Activiti 流程引擎的管理和维护功能，这些功能不在工作流驱动的应用程序SEO靠我中使用，主要用于 Activiti 系统的日常维护。

4、流程的创建与操作

4.1、流程图的绘制

在之前就已经安装好了bpmn的插件，到这里就可以直接新建一个bpmn文件用来绘制流程图了，简单的绘制一个请假SEO靠我审批的一个流程，对每个流程设置一下id和name。

这里还可以将这个流程到处一张png图片文件，当然了，直接截图也是可以的，这里只是做一个简单的记录，首先将bpmn文件后缀改成xml，之后选中该文件，使SEO靠我用ctrl+shift+alt+u快捷键（或者右键文件选择Diagrams->show bpmn 2.0 designer）就可以通过流程图的形式打开文件了，之后将该流程图进行到处即可

4.2、流程的部SEO靠我署

将上面在设计器中定义的流程部署到activiti数据库中，就是流程定义部署。

4.2.1、单个文件部署方式

@Testpublic void devo() {// 创建流程对象ProcessEngineSEO靠我 processEngine = ProcessEngines.getDefaultProcessEngine();// 获取service对象RepositoryService repositorySEO靠我Service = processEngine.getRepositoryService();// 流程部署设置名字将bpmn和png部署进去Deployment deploy = repositSEO靠我oryService.createDeployment().addClasspathResource("bpmn/leave.bpmn").addClasspathResource("bpmn/leaSEO靠我ve.png").name("请假流程").deploy();System.out.println("id = " + deploy.getId());System.out.println("nameSEO靠我 = " + deploy.getName());}

之后直接启动这个测试方法进行流程部署，可以观察日志，整个部署的过程当中总共操作了三张表

act_re_deployment 流程定义部署表，每部署一次SEO靠我增加一条记录act_re_procdef 流程定义表，部署每个新的流程定义都会在这张表中增加一条记录act_ge_bytearray 流程资源表

act_re_deployment 和 act_re_pSEO靠我rocdef一对多关系，一次部署在流程部署表生成一条记录，但一次部署可以部署多个流程定义，每个流程定义在流程定义表生成一条记录。每一个流程定义在act_ge_bytearray会存在两个资源记录，bpSEO靠我mn和png。

4.2.2、使用压缩包的方式

@Testpublic void devoZip(){ProcessEngine processEngine = ProcessEngines.getDefaSEO靠我ultProcessEngine();RepositoryService repositoryService = processEngine.getRepositoryService();InputSSEO靠我tream inputStream = this.getClass().getClassLoader().getResourceAsStream("bpmn/leave.zip");ZipInputSSEO靠我tream zipInputStream = new ZipInputStream(inputStream);Deployment deploy = repositoryService.createDSEO靠我eployment().addZipInputStream(zipInputStream).deploy();System.out.println("id = " + deploy.getId());SEO靠我System.out.println("name = " + deploy.getName());}

4.3、开始流程

启动一个流程表示发起一个新的请假申请，这就相当于java类与java对象的关系，类定SEO靠我义好后需要new创建一个对象使用，当然可以new多个对象。对于请出差申请流程，发起一个请假申请单需要启动一个流程实例，请假申请单发起请假也需要启动一个流程实例。

@Testpublic void staSEO靠我rt(){ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();RuntimeService runtimeSeSEO靠我rvice = processEngine.getRuntimeService();// 根据流程id启动流程ProcessInstance instance = runtimeService.staSEO靠我rtProcessInstanceByKey("myLeave");System.out.println("流程id = " + instance.getProcessDefinitionId());SEO靠我System.out.println("实例id = " + instance.getId());System.out.println("活动id = " + instance.getActivitySEO靠我Id());}

4.4、任务查询

流程启动后，任务的负责人就可以查询自己当前需要处理的任务，查询出来的任务都是该用户的待办任务。

@Testpublic void findTask(){ProcessEngSEO靠我ine processEngine = ProcessEngines.getDefaultProcessEngine();TaskService taskService = processEngineSEO靠我.getTaskService();List<Task> list = taskService.createTaskQuery().processDefinitionKey("myLeave").taSEO靠我skAssignee("yueyue").list();for (Task task : list){System.out.println("流程id = " + task.getProcessInsSEO靠我tanceId());System.out.println("任务id = " + task.getId());System.out.println("任务负责人 = " + task.getAssiSEO靠我gnee());System.out.println("任务名称 = " + task.getName());}}

而对应的查询语句也是：根据流程的Key以及负责人去task当中查询任务。

SELECT SEO靠我DISTINCT RES.* FROM ACT_RU_TASK RES INNER JOIN ACT_RE_PROCDEF D ON RES.PROC_DEF_ID_ = D.ID_ SEO靠我WHERE RES.ASSIGNEE_ = yueyue AND D.KEY_ = myLeave ORDER BY RES.ID_ ASC LIMIT 2147483647 OFFSET 0

4.5、SEO靠我任务推动

在前面我们可以获取到负责人所有的任务，并且可以获取到相对应的任务id，这里只需要获取id进行推动流程即可。

@Testpublic void next(){ProcessEngine proceSEO靠我ssEngine = ProcessEngines.getDefaultProcessEngine();TaskService taskService = processEngine.getTaskSSEO靠我ervice();taskService.complete("2505");// 获取单个流程数据进行操作，替换掉上面的2505// Task task = taskService.createTasSEO靠我kQuery().processDefinitionKey("myLeave").taskAssignee("zhangsan").singleResult();// taskService.compSEO靠我lete(task.getId());System.out.println("任务完成");}

任务推动之后还是和查询任务一致的查询语句获取当前负责人的数据，也可以直接查看 act_ru_task这张表SEO靠我的流程数据推动了没，而之前的流程会保存在 act_hi_taskinst 这张表当中。而这里对后续的几个流程的推动也是相同的道理，就不继续进行流程推动了，当最后一步的流程走完之后，整个流程已经结束，在SEO靠我act_ru_task这张表就不会存在当前这个流程的数据了。

4.6、流程定义信息查询

查询流程相关信息，包含流程定义，流程部署，流程定义版本

@Testpublic void processInfo() SEO靠我{ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();RepositoryService repositorySEO靠我Service = processEngine.getRepositoryService();ProcessDefinitionQuery processDefinitionQuery = reposSEO靠我itoryService.createProcessDefinitionQuery();List<ProcessDefinition> list = processDefinitionQuery.prSEO靠我ocessDefinitionKey("myLeave").orderByProcessDefinitionVersion().desc().list();for (ProcessDefinitionSEO靠我 definition : list) {System.out.println("id = " + definition.getId());System.out.println("name = " +SEO靠我 definition.getName());System.out.println("key = " + definition.getKey());System.out.println("versioSEO靠我n = " + definition.getVersion());}}

4.7、流程删除

@Testpublic void deleteProcess() {ProcessEngine processEnSEO靠我gine = ProcessEngines.getDefaultProcessEngine();RepositoryService repositoryService = processEngine.SEO靠我getRepositoryService();repositoryService.deleteDeployment("1");// 如果该流程定义下存在已经运行的流程，使用普通删除报错，可用级联删除方SEO靠我法将流程及相关记录全部删除。// 先删除没有完成流程节点，最后就可以完全删除流程定义信息// repositoryService.deleteDeployment("1", true);}

4.8、下载SEO靠我资源文件

首先可以知道资源文件存在 act_ge_bytearray 这张表当中，而对于流程的数据bpmn和png文件的DEPLOYMENT_ID这个字段是相同的，因此只需要获取到这个id就能得到相对应SEO靠我的数据，这个id如何获取呢？在前面4.6获取流程信息当中就可以获取到这个id，因此把之前获取全部改为获取单个，就能拿到这个id了。而后续根据repositoryService来进行获取需要两个参数，一SEO靠我个就是这个id，另外一个就是文件的路径，文件的路径可以在 act_re_procdef 当中进行获取。

@Testpublic void getBolb() throws IOException {PrSEO靠我ocessEngine processEngine = ProcessEngines.getDefaultProcessEngine();RepositoryService repositorySerSEO靠我vice = processEngine.getRepositoryService();ProcessDefinitionQuery processDefinitionQuery = repositoSEO靠我ryService.createProcessDefinitionQuery();ProcessDefinition definition = processDefinitionQuery.proceSEO靠我ssDefinitionKey("myLeave").orderByProcessDefinitionVersion().desc().singleResult();// 获取流程id 文件名StriSEO靠我ng deploymentId = definition.getDeploymentId();String diagramResourceName = definition.getDiagramResSEO靠我ourceName();String resourceName = definition.getResourceName();// 得到input流InputStream pngInput = repSEO靠我ositoryService.getResourceAsStream(deploymentId, diagramResourceName);InputStream bpmnInput = reposiSEO靠我toryService.getResourceAsStream(deploymentId, resourceName);File pngFile = new File("d:/leave.png");SEO靠我File bpmnFile = new File("d:/leave.bpmn");FileOutputStream pngOutputStream = new FileOutputStream(pnSEO靠我gFile);FileOutputStream bpmnOutputStream = new FileOutputStream(bpmnFile);// 输入输出转换IOUtils.copy(pngISEO靠我nput, pngOutputStream);IOUtils.copy(bpmnInput, bpmnOutputStream);pngInput.close();pngOutputStream.clSEO靠我ose();bpmnInput.close();bpmnOutputStream.close();}

并且这里使用到的IOUtils工具类是apache提供的，需要引入新的依赖

<dependency><SEO靠我groupId>commons-io</groupId><artifactId>commons-io</artifactId><version>2.6</version></dependency>

4.SEO靠我9、流程历史信息的查看

即使流程定义已经删除了，流程执行的历史信息通过前面的分析，依然保存在activiti的act_hi_*相关的表中。所以我们还是可以查询流程执行的历史信息，可以通过HistorySSEO靠我ervice来查看相关的历史记录。

@Testpublic void findHistroy() {ProcessEngine processEngine = ProcessEngines.getDefSEO靠我aultProcessEngine();HistoryService historyService = processEngine.getHistoryService();// 设置查询条件进行查询LSEO靠我ist<HistoricActivityInstance> list = historyService.createHistoricActivityInstanceQuery().orderByHisSEO靠我toricActivityInstanceStartTime().asc().processInstanceId("2501").list();for (HistoricActivityInstancSEO靠我e historiy : list) {System.out.println("activiti id = " + historiy.getActivityId());System.out.printSEO靠我ln("activiti name = " + historiy.getActivityName());System.out.println("process definition id = " + SEO靠我historiy.getProcessDefinitionId());System.out.println("process instance id = " + historiy.getProcessSEO靠我InstanceId());System.out.println("start time = " + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").formaSEO靠我t(historiy.getStartTime()));System.out.println("===============================================");}}SEO靠我

4.10、给流程实例添加Businesskey（业务标识）

启动流程实例时，指定的businesskey，就会在act_ru_execution #流程实例的执行表中存储businesskey。

BusiSEO靠我nesskey：业务标识，通常为业务表的主键，业务标识和流程实例一一对应。业务标识来源于业务系统。存储业务标识就是根据业务标识来关联查询业务系统的数据。@Testpublic void addLeavSEO靠我eKey() {ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();RuntimeService runtimSEO靠我eService = processEngine.getRuntimeService();ProcessInstance myLevel = runtimeService.startProcessInSEO靠我stanceByKey("myLevel", "1001");System.out.println(myLevel.getBusinessKey());}

4.11、流程的挂起与激活

4.11.1、全部流SEO靠我程实例挂起

操作流程定义为挂起状态，该流程定义下边所有的流程实例全部暂停：流程定义为挂起状态该流程定义将不允许启动新的流程实例，同时该流程定义下所有的流程实例将全部挂起暂停执行。

@Testpublic SEO靠我void suspendAll() {ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();RepositorySEO靠我Service repositoryService = processEngine.getRepositoryService();ProcessDefinition definition = repoSEO靠我sitoryService.createProcessDefinitionQuery().processDefinitionKey("myLevel").singleResult();// 是否暂停bSEO靠我oolean suspended = definition.isSuspended();String id = definition.getId();if (suspended) {repositorSEO靠我yService.activateProcessDefinitionById(id, true, null);System.out.println("id = " + id + " 激活");} elSEO靠我se {repositoryService.suspendProcessDefinitionById(id, true, null);System.out.println("id = " + id +SEO靠我 " 挂起");}}

4.11.2、单个流程实例挂起

操作流程实例对象，针对单个流程执行挂起操作，某个流程实例挂起则此流程不再继续执行，完成该流程实例的当前任务将报异常。

@Testpublic void SEO靠我suspendOne() {ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();RuntimeService SEO靠我runtimeService = processEngine.getRuntimeService();ProcessInstance processInstance = runtimeService.SEO靠我createProcessInstanceQuery().processInstanceId("12501").singleResult();boolean suspended = processInSEO靠我stance.isSuspended();String id = processInstance.getId();if (suspended) {runtimeService.activateProcSEO靠我essInstanceById(id);System.out.println("id = " + id + " 激活");} else {runtimeService.suspendProcessInSEO靠我stanceById(id);System.out.println("id = " + id + " 挂起");}}

4.11.3、流程实例推动

在前面我们对一个整个的流程以及单个流程进行了激活和挂起操作SEO靠我，之后可以编写一段代码来进行推动流程操作，主要是用来当流程被挂起后流程还能否被继续推动。很显然，当挂起的流程去进行流程推动是不允许推动流程的，必须是流程是激活状态下才能够被推动。

@TestpublicSEO靠我 void complate() {ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();TaskServiceSEO靠我 taskService = processEngine.getTaskService();Task task = taskService.createTaskQuery().processInstaSEO靠我nceId("12501").taskAssignee("yueyue").singleResult();System.out.println("id = " + task.getId());SystSEO靠我em.out.println("name = " + task.getName());System.out.println("assignee = " + task.getAssignee());taSEO靠我skService.complete(task.getId());}

5、个人任务

5.1、分配任务负责人

5.1.1、固定负责人

在进行业务流程建模时指定固定的任务负责人，直接在bpmn当中指定assignSEO靠我ee

5.1.2、表达式分配

由于固定分配方式，任务只管一步一步执行任务，执行到每一个任务将按照 bpmn 的配置去分配任务负责人。和前面一样进行指定，使用${变量名}的方式进行指定。而指定之后的这些变SEO靠我量在流程启动的时候可以通过一个map对象来进行赋值。

@Testpublic void start() {ProcessEngine processEngine = ProcessEngines.getSEO靠我DefaultProcessEngine();RuntimeService runtimeService = processEngine.getRuntimeService();// 根据流程id启动SEO靠我流程Map<String, Object> map = new HashMap();map.put("assignee", "huangyueyue");map.put("director", "yuSEO靠我eyueniao");map.put("manager", "zhangsan");ProcessInstance instance = runtimeService.startProcessInstSEO靠我anceByKey("myLeaveUel", map);}

在这里就存在一个问题，我这的idea的版本是2018版的，发现修改后的bpmn文件保存不了数据，在xml文件和bpmn文件直接切来切去，还是SEO靠我无法解决，索性就直接修改xml文件了，对应的xml文件如下：

5.1SEO靠我.3、监听器分配

任务监听器的Event的选项包含：

Create：任务创建后触发Assignment：任务分配后触发Delete：任务完成后触发All：所有事件发生都触发

定义任务监听类，且类必须实现 oSEO靠我rg.activiti.engine.delegate.TaskListener 接口

public class MyTaskListener implements TaskListener {@OveSEO靠我rridepublic void notify(DelegateTask delegateTask) {if (delegateTask.getName().equals("请假申请") &&deleSEO靠我gateTask.getEventName().equals("create")) {//这里指定任务负责人delegateTask.setAssignee("黄阅阅");}} }

这个SEO靠我流程是直接对请假申请流程添加了一个监听器，在这里对监听器指定对应的class，并且在监听器执行的时候进行设置负责人。而监听器对应的xml文件如下：

5.2、查询任务

在前面就已经可以通过流程key和负责人就可以查询出这个人负责的流程单，而实SEO靠我际应用时，查询待办任务可能要显示出业务系统的一些相关信息。这里可以通过 businessKey（业务标识）关联查询业务系统的数据。

@Testpublic void findProcessInstanSEO靠我ce() {ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();TaskService taskServiceSEO靠我 = processEngine.getTaskService();RuntimeService runtimeService = processEngine.getRuntimeService();SEO靠我Task task = taskService.createTaskQuery().processDefinitionKey("myLeave").taskAssignee("yueyue").sinSEO靠我gleResult();String processInstanceId = task.getProcessInstanceId();ProcessInstance processInstance =SEO靠我 runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();StrSEO靠我ing businessKey = processInstance.getBusinessKey();System.out.println("businessKey==" + businessKey)SEO靠我;}

5.3、任务推动

在之前可以通过TaskService这个类的complate方法推动任务的流动，而在这里我们还需要对当前用户是否拥有推动该流程的权限，只需要先通过查询当前负责人的所有流程进行判断即SEO靠我可。有该流程即可推动，反之无法推动流程。

@Testpublic void completTask() {ProcessEngine processEngine = ProcessEngines.getSEO靠我DefaultProcessEngine();TaskService taskService = processEngine.getTaskService();Task task = taskServSEO靠我ice.createTaskQuery().taskId("15005").taskAssignee("yueyue").singleResult();if (task != null) {taskSSEO靠我ervice.complete("15005");System.out.println("完成任务");}}

6、流程变量与组任务

6.1、流程变量概述

6.2.1、流程变量是什么

流程变量在 activitSEO靠我i 中是一个非常重要的角色，流程运转有时需要靠流程变量，业务系统和 activiti 结合时少不了流程变量，流程变量就是 activiti 在管理工作流时根据管理需要而设置的变量。

虽然流程变量中可以存SEO靠我储业务数据可以通过activiti的api查询流程变量从而实现查询业务数据，但是不建议这样使用，因为业务数据查询由业务系统负责，activiti设置流程变量是为了流程执行需要而创建

**6.1.2、流SEO靠我程变量作用域

流程变量的作用域可以是一个流程实例，或一个任务，或一个执行实例

global变量

流程变量的默认作用域是流程实例。当一个流程变量的作用域为流程实例时，可以称为 global 变量global SEO靠我变量中变量名不允许重复，设置相同名称的变量，后设置的值会覆盖前设置的变量值。

local变量

任务和执行实例仅仅是针对一个任务和一个执行实例范围，范围没有流程实例大，称为 local 变量。Local SEO靠我变量由于在不同的任务或不同的执行实例中，作用域互不影响，变量名可以相同没有影响。Local 变量名也可以和 global 变量名相同，没有影响。

6.2、使用Global变量控制流程

还是和前面的整个流程SEO靠我一样，现在对流程的分支进行控制，通过流程变量来进行控制，当天数大于或等于三天还需要通过经理审批，反之直接通过主管审批就结束了整个流程。

这里的话使用的UEL表达式使用的是uel-method来进行赋值，SEO靠我所以在这里需要一个实体类来进行值的给予，先定义一个类。该类当中必须包含这个day变量，也就是在bpmn文件当中指定的变量，以及该类必须实例化。并且加上getset方法。public class LeaSEO靠我ve implements Serializable {private Double day; }

6.2.1、启动流程时设置变量

在启动流程时设置流程变量，变量的作用域是整个流程实例。通SEO靠我过Map<key,value>设置流程变量，map中可以设置多个变量，这个key就是流程变量的名字。后续通过TaskService的compele方法来进行推动流程实例的代码就不给出了，直接获取tasSEO靠我kid进行推动，查看流程的走向。

@Testpublic void startSet() {ProcessEngine processEngine = ProcessEngines.getDefaultSEO靠我ProcessEngine();RuntimeService runtimeService = processEngine.getRuntimeService();Leave leave = new SEO靠我Leave();leave.setDay(4d);Map map = new HashMap();map.put("leave", leave);map.put("assignee", "yueyueSEO靠我niao");map.put("director", "张三");map.put("manager", "黄阅阅");ProcessInstance processInstance = runtimeSEO靠我Service.startProcessInstanceByKey("myLeaveGlabal", map);}

6.2.2、任务办理时设置变量

在完成任务时设置流程变量，该流程变量只有在该任务完成后其SEO靠我它结点才可使用该变量，它的作用域是整个流程实例，如果设置的流程变量的key在流程实例中已存在相同的名字则后设置的变量替换前边设置的变量。这样对前面6.2.1的代码当中往map对象当中添加leave的代SEO靠我码注掉。

@Testpublic void complete() {ProcessEngine processEngine = ProcessEngines.getDefaultProcessEnginSEO靠我e();TaskService taskService = processEngine.getTaskService();Leave leave = new Leave();leave.setDay(SEO靠我4d);Map map = new HashMap();map.put("leave", leave);Task task = taskService.createTaskQuery().procesSEO靠我sDefinitionKeyLike("myLeaveGlabal").taskAssignee("张三").singleResult();if (task != null) {taskServiceSEO靠我.complete(task.getId(), map);}}

6.2.3、通过当前流程实例设置

通过流程实例id设置全局变量，该流程实例必须未执行完成。

@Testpublic void setGlobaSEO靠我lVariableByExecutionId() {ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();RunSEO靠我timeService runtimeService = processEngine.getRuntimeService();Leave leave = new Leave();leave.setDaSEO靠我y(4d);runtimeService.setVariable("75001", "leave", leave);}

6.2.4、通过当前任务设置

@Testpublic void setGlobalVSEO靠我ariableByTaskId() {ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();TaskServicSEO靠我e taskService = processEngine.getTaskService();Leave leave = new Leave();leave.setDay(4d);taskServicSEO靠我e.setVariable("75001", "leave", leave);}

6.3、组任务办理流程

查询组任务

指定候选人，查询该候选人当前的待办任务。候选人不能立即办理任务。

拾取任务

该组任务的所有候SEO靠我选人都能拾取。将候选人的组任务，变成个人任务。原来候选人就变成了该任务的负责人。如果拾取后不想办理该任务，需要将已经拾取的个人任务归还到组里边，将个人任务变成了组任务。

、查询个人任务

查询方式同个人任务SEO靠我部分，根据assignee查询用户负责的个人任务。

办理个人任务

首先创建一个bpmn文件，在user当中可以对candidateUsers进行设置多个人员，之间用都好进行隔开，而对应的xml如下：

<usSEO靠我erTask activiti:candidateUsers="zhangsan,lisi" activiti:exclusive="true" id="_3" name="申请-group"/><uSEO靠我serTask activiti:candidateUsers="wangwu,zhaoliu" activiti:exclusive="true" id="_4" name="审核-group"/>SEO靠我

之后将该bpmn进行部署，并且启动任务。

6.3.1、查询组任务

根据候选人查询组任务，可以看到这个task在act_ru_task这张表当中的assignee却是一个null，也就是该用户虽然可以查询出SEO靠我该任务，却无法对该任务进行处理。

@Testpublic void findGroup() {ProcessEngine processEngine = ProcessEngines.getDefaulSEO靠我tProcessEngine();TaskService taskService = processEngine.getTaskService();List<Task> list = taskServSEO靠我ice.createTaskQuery().processDefinitionKey("myLeaveGroup").taskCandidateUser("zhangsan").list();for SEO靠我(Task task : list) {System.out.println("instance id = " + task.getProcessInstanceId());System.out.prSEO靠我intln("id = " + task.getId());System.out.println("assignee = " + task.getAssignee());System.out.prinSEO靠我tln("name = " + task.getName());}}

6.3.2、拾取组任务

候选人员拾取组任务后该任务变为自己的个人任务。用户拾取任务之后，对应的act_ru_task表对应的行数据的aSEO靠我ssignee就会变成相对应的人员。

@Testpublic void getTask() {ProcessEngine processEngine = ProcessEngines.getDefaulSEO靠我tProcessEngine();TaskService taskService = processEngine.getTaskService();Task task = taskService.crSEO靠我eateTaskQuery().taskId("87505").taskCandidateUser("zhangsan").singleResult();if (task != null) {taskSEO靠我Service.claim("87505", "zhangsan");System.out.println("用户拾取");}}

6.3.3、归还组任务

直接通过assignee进行查询，查询到数据再将aSEO靠我ssignee置空也就表示归还了任务。同理任务的交接就不用设置为空了，直接设置给另一个用户即可。

@Testpublic void returnTask() {ProcessEngine processSEO靠我Engine = ProcessEngines.getDefaultProcessEngine();TaskService taskService = processEngine.getTaskSerSEO靠我vice();Task task = taskService.createTaskQuery().taskId("87505").taskAssignee("zhangsan").singleResuSEO靠我lt();if (task != null) {taskService.setAssignee("87505", null);System.out.println("用户归还");}}

7、网关

7.1、SEO靠我排他网关

排他网关，用来在流程中实现决策。当流程执行到这个网关，所有分支都会判断条件是否为true，如果为true则执行该分支，注意：排他网关只会选择一个为true的分支执行。如果有两个分支条件都为tSEO靠我rue，排他网关会选择id值较小的一条分支去执行。

在这里对A流程后设置一个排他网关进行流程分支，这两条分支线也就对应两个uel表达式进行判断，而后就可以直接把这个流程进行部署，部署之后在启动流程的时候SEO靠我就给这个day进行设置值，直接进行推动流程，查看流程的流转。@Testpublic void startSet() {ProcessEngine processEngine = ProcessEngiSEO靠我nes.getDefaultProcessEngine();RuntimeService runtimeService = processEngine.getRuntimeService();LeavSEO靠我e leave = new Leave();leave.setDay(-4d);Map map = new HashMap();map.put("leave", leave);ProcessInstaSEO靠我nce processInstance = runtimeService.startProcessInstanceByKey("gateway-pt", map);}@Testpublic void SEO靠我compete() {ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();TaskService taskSeSEO靠我rvice = processEngine.getTaskService();Task task = taskService.createTaskQuery().processDefinitionKeSEO靠我y("gateway-pt").taskAssignee("张三").singleResult();if (task != null) {taskService.complete(task.getIdSEO靠我());}}

7.2、并行网关

并行网关允许将流程分成多条分支，也可以把多条分支汇聚到一起，并行网关的功能是基于进入和外出顺序流的：

fork分支：并行后的所有外出顺序流，为每个顺序流都创建一个并发分支。

jSEO靠我oin汇聚：所有到达并行网关，在此等待的进入分支，直到所有进入顺序流的分支都到达以后，流程就会通过汇聚网关。

并行网关的测试代码和前面排他网关的代码基本一致，在首先进行部署之后启动流程，给流程设置一SEO靠我个天数，而之后推动任务之后，首先进入到并行网关，这里并不会进行判断，这里的意思是表示B和C都可以进行对该任务流程进行操作，并且只有到B和C都做了相关的操作流程才会继续往后流转，后面接的排他网关直接通过SEO靠我最开始设置的值再进行判断做流程的流转。

7.3、包含网关

包含网关可以看做是排他网关和并行网关的结合体。和排他网关一样，可以在外出顺序流上定义条件，包含网关会解析它们。但是主要的区别是包含网关可以选择多SEO靠我于一条顺序流，这和并行网关一样。

分支：所有外出顺序流的条件都会被解析，结果为true的顺序流会以并行方式继续执行，会为每个顺序流创建一个分支。汇聚：所有并行分支到达包含网关，会进入等待状态，直到每SEO靠我个包含流程token的进入顺序流的分支都到达。这是与并行网关的最大不同。换句话说，包含网关只会等待被选中执行了的进入顺序流。在汇聚之后，流程会穿过包含网关继续执行。

和之前的网关一样进行部署推动流程SEO靠我，可以发现在进入到包含网关的时候，网关会对条件进行判断再进行流转。二里面的包含又相当于并行网关，当并行的流程都执行完成之后再由包含网关进行汇聚。之后走排他网关进行判断流转。

7.4、事件网关

事件网关允许SEO靠我根据事件判断流向。网关的每个外出顺序流都要连接到一个中间捕获事件。当流程到达一个基于事件网关，网关会进入等待状态：会暂停执行。与此同时，会为每个外出顺序流创建相对的事件订阅。

事件网关的外出顺序流和普SEO靠我通顺序流不同，这些顺序流不会真的"执行"，相反它们让流程引擎去决定执行到事件网关的流程需要订阅哪些事件。要考虑以下条件：

事件网关必须有两条或以上外出顺序流；事件网关后，只能使用intermediaSEO靠我teCatchEvent类型（activiti不支持基于事件网关后连接ReceiveTask）连接到事件网关的中间捕获事件必须只有一个入口顺序流。

8、SpringBoot 整合 Activiti

直接快SEO靠我速初始化一个springboot项目，再直接导入所需要的以来即可

<dependency><groupId>org.activiti</groupId><artifactId>activiti-spriSEO靠我ng-boot-starter</artifactId><version>7.0.0.Beta2</version></dependency><dependency><groupId>mysql</gSEO靠我roupId><artifactId>mysql-connector-java</artifactId><version>8.0.18</version></dependency><dependencSEO靠我y><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency>

修改配置文件，这里还是使用propeSEO靠我rties，用yml的话修改对应的格式即可。

spring.datasource.url=jdbc:mysql:///activiti?useUnicode=true&characterEncodinSEO靠我g=utf8&serverTimezone=GMT spring.datasource.driver-class-name=com.mysql.jdbc.Driver SEO靠我spring.datasource.username=root spring.datasource.password=root #1.flase：默认值。activitSEO靠我i在启动时，对比数据库表中保存的版本，如果没有表或者版本不匹配，将抛出异常 #2.true： activiti会对数据库中所有表进行更新操作。如果表不存在，则自动创建 SEO靠我#3.create_drop：在activiti启动时创建表，在关闭时删除表（必须手动关闭引擎，才能删除表） #4.drop-create：在activiti启动时删除原来的旧表，SEO靠我然后在创建新表（不需要手动关闭引擎） spring.activiti.database-schema-update=true #检测历史表是否存在 activiti7默SEO靠我认没有开启数据库历史记录启动数据库历史记录 spring.activiti.db-history-used=true #记录历史等级可配置的历史级别有none, aSEO靠我ctivity, audit, full #none：不保存任何的历史数据，因此，在流程执行过程中，这是最高效的。 #activity：级别高于none，保存流程实例与SEO靠我流程行为，其他数据不保存。 #audit：除activity级别会保存的数据外，还会保存全部的流程任务及其属性。audit为history的默认值。 #full：保存历SEO靠我史数据的最高级别，除了会保存audit级别的数据外，还会保存其他全部流程相关的细节数据，包括一些流程参数等。 spring.activiti.history-level=full SEO靠我 #校验流程文件，默认校验resources下的processes文件夹里的流程文件 spring.activiti.check-process-definitions=faSEO靠我lse

在Activiti7与SpringBoot整合后，默认情况下，集成了SpringSecurity安全框架，这样我们就要去准备SpringSecurity整合进来的相关用户权限配置信息，添加一个SSEO靠我ecurityUtil类，用来获取当前用户。

package com.lzq.utils;import org.slf4j.Logger; import org.slf4j.LoggerSEO靠我Factory; import org.springframework.beans.factory.annotation.Autowired; import org.sSEO靠我pringframework.beans.factory.annotation.Qualifier; import org.springframework.security.core.SEO靠我Authentication; import org.springframework.security.core.GrantedAuthority; import orSEO靠我g.springframework.security.core.context.SecurityContextHolder; import org.springframework.seSEO靠我curity.core.context.SecurityContextImpl; import org.springframework.security.core.userdetailSEO靠我s.UserDetails; import org.springframework.security.core.userdetails.UserDetailsService; SEO靠我 import org.springframework.stereotype.Component;import java.util.Collection;/*** @author huangyuSEO靠我eyueniao* @version 1.0* @date 2022-01-06 20:39*/ @Component public class SecurityUtiSEO靠我l {private Logger logger = LoggerFactory.getLogger(SecurityUtil.class);@Autowired@Qualifier("myUserDSEO靠我etailsService")private UserDetailsService userDetailsService;public void logInAs(String username) {USEO靠我serDetails user = userDetailsService.loadUserByUsername(username);if (user == null) {throw new IllegSEO靠我alStateException("User " + username + " doesnt exist, please provide a valid user");}logger.info("> SEO靠我Logged in as: " + username);SecurityContextHolder.setContext(new SecurityContextImpl(new AuthenticatSEO靠我ion() {@Overridepublic Collection<? extends GrantedAuthority> getAuthorities() {return user.getAuthoSEO靠我rities();}@Overridepublic Object getCredentials() {return user.getPassword();}@Overridepublic ObjectSEO靠我 getDetails() {return user;}@Overridepublic Object getPrincipal() {return user;}@Overridepublic boolSEO靠我ean isAuthenticated() {return true;}@Overridepublic void setAuthenticated(boolean isAuthenticated) tSEO靠我hrows IllegalArgumentException {}@Overridepublic String getName() {return user.getUsername();}}));orSEO靠我g.activiti.engine.impl.identity.Authentication.setAuthenticatedUserId(username);} }

在ActivitiSEO靠我7官方下载的Example中找到DemoApplicationConfig类，它的作用是为了实现SpringSecurity框架的用户权限的配置，这样我们就可以在系统中使用用户权限信息。

packageSEO靠我 com.lzq.config;import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.SEO靠我springframework.context.annotation.Bean; import org.springframework.context.annotation.ConfiSEO靠我guration; import org.springframework.security.core.authority.SimpleGrantedAuthority; SEO靠我 import org.springframework.security.core.userdetails.User; import org.springframework.securSEO靠我ity.core.userdetails.UserDetailsService; import org.springframework.security.crypto.bcrypt.BSEO靠我CryptPasswordEncoder; import org.springframework.security.crypto.password.PasswordEncoder; SEO靠我 import org.springframework.security.provisioning.InMemoryUserDetailsManager;import java.util.SEO靠我Arrays; import java.util.List; import java.util.stream.Collectors;/*** @author huangSEO靠我yueyue* @version 1.0* @date 2022-01-06 20:44*/ @Configuration public class DemoAppliSEO靠我cationConfiguration {private Logger logger = LoggerFactory.getLogger(DemoApplicationConfiguration.clSEO靠我ass);@Beanpublic UserDetailsService myUserDetailsService() {InMemoryUserDetailsManager inMemoryUserDSEO靠我etailsManager = new InMemoryUserDetailsManager();//这里添加用户，后面处理流程时用到的任务负责人，需要添加在这里String[][] usersGroSEO靠我upsAndRoles = {{"jack", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},{"rose", "password",SEO靠我 "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},{"tom", "password", "ROLE_ACTIVITI_USER", "GROUP_activiSEO靠我tiTeam"},{"other", "password", "ROLE_ACTIVITI_USER", "GROUP_otherTeam"},{"system", "password", "ROLESEO靠我_ACTIVITI_USER"},{"admin", "password", "ROLE_ACTIVITI_ADMIN"},};for (String[] user : usersGroupsAndRSEO靠我oles) {List<String> authoritiesStrings = Arrays.asList(Arrays.copyOfRange(user, 2, user.length));logSEO靠我ger.info("> Registering new user: " + user[0] + " with the following Authorities[" + authoritiesStriSEO靠我ngs + "]");inMemoryUserDetailsManager.createUser(new User(user[0], passwordEncoder().encode(user[1])SEO靠我,authoritiesStrings.stream().map(s -> new SimpleGrantedAuthority(s)).collect(Collectors.toList())));SEO靠我}return inMemoryUserDetailsManager;}@Beanpublic PasswordEncoder passwordEncoder() {return new BCryptSEO靠我PasswordEncoder();} }

在Activiti7当中可以自动部署流程，前提是在resources目录下，创建一个新的目录processes，用来放置bpmn文件，在配置文件当中可以对是否SEO靠我需要进行自动部署（spring.activiti.check-process-definitions=true）进行配置。这里就使用自动部署，在resources下创建对应的一个bpmn文件，并且这里SEO靠我就在给userTask设置人员的地方给定用户组，而在DemoApplicationConfiguration这个类当中也对用户做了组的设置。

最后就是添加一个测试类进行流程的测试，

import com.lzq.utils.SSEO靠我ecurityUtil; import lombok.extern.slf4j.Slf4j; import org.activiti.api.process.model.ProcessDefinitiSEO靠我on; import org.activiti.api.process.model.ProcessInstance; import org.activiti.api.process.model.buiSEO靠我lders.ProcessPayloadBuilder; import org.activiti.api.process.runtime.ProcessRuntime; import org.actiSEO靠我viti.api.runtime.shared.query.Page; import org.activiti.api.runtime.shared.query.Pageable; import orSEO靠我g.activiti.api.task.model.Task; import org.activiti.api.task.model.builders.TaskPayloadBuilder; impoSEO靠我rt org.activiti.api.task.runtime.TaskRuntime; import org.junit.jupiter.api.Test; import org.junit.ruSEO靠我nner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframewSEO靠我ork.boot.test.context.SpringBootTest; import org.springframework.test.context.junit4.SpringRunner;@SSEO靠我pringBootTest @Slf4j @RunWith(SpringRunner.class) public class SpringbootactivitiApplicationTests {@SEO靠我Autowiredprivate ProcessRuntime processRuntime;@Autowiredprivate TaskRuntime taskRuntime;@AutowiredpSEO靠我rivate SecurityUtil securityUtil;// 获取所有部署了的流程@Testpublic void find() {securityUtil.logInAs("jack");SEO靠我Page<ProcessDefinition> processDefinitionPage = processRuntime.processDefinitions(Pageable.of(0, 10)SEO靠我);log.info("总条数{}", processDefinitionPage.getTotalItems());for (ProcessDefinition processDefinition SEO靠我: processDefinitionPage.getContent()) {System.out.println("流程定义：" + processDefinition);}}// 对用户组进行任务SEO靠我的拾取以及任务完成@Testpublic void start() {securityUtil.logInAs("jack");ProcessInstance start = processRuntiSEO靠我me.start(ProcessPayloadBuilder.start().withProcessDefinitionKey("springboot-leave").build());log.infSEO靠我o("流程实例内容：{}", start);}@Testpublic void doTask() {securityUtil.logInAs("tom");Page<Task> tasks = tasSEO靠我kRuntime.tasks(Pageable.of(0, 10));if (tasks != null && tasks.getTotalItems() > 0) {for (Task task :SEO靠我 tasks.getContent()) {taskRuntime.claim(TaskPayloadBuilder.claim().withTaskId(task.getId()).build())SEO靠我;log.info("任务拾取 {}", task);taskRuntime.complete(TaskPayloadBuilder.complete().withTaskId(task.getId(SEO靠我)).build());log.info("任务完成 {}", task);}}} }

又是卷的一天！

“SEO靠我”的新闻页面文章、图片、音频、视频等稿件均为自媒体人、第三方机构发布或转载。如稿件涉及版权等问题，请与我们联系删除或处理，客服邮箱：html5sh@163.com，稿件内容仅为传递更多信息之目的，不代表本网观点，亦不代表本网站赞同其观点或证实其内容的真实性。

上一篇：史上最全测试开发工具推荐（含自动化、性能、稳定性、抓包）
下一篇：域名的URL转发功能

Activiti 工作流引擎 详解