flowable工作流中的任务监听器,表达式用法

合集下载

flowable 节点结束条件

flowable 节点结束条件Flowable节点结束条件1. 什么是Flowable节点结束条件？Flowable是一个开源的工作流引擎，可以帮助开发者实现复杂的流程管理。

在Flowable中，节点是工作流中的基本单位，每个节点都有自己的执行逻辑和结束条件。

节点结束条件是指节点在何种情况下可以结束执行，可以进入下一个节点或结束整个流程。

节点结束条件可以是简单的条件判断，也可以是复杂的表达式计算。

2. 节点结束条件的设置方式在Flowable中，可以通过如下几种方式来设置节点的结束条件：•简单条件判断：可以设置一个布尔类型的变量作为节点的结束条件，当条件为真时，节点结束执行。

•表达式计算：可以利用Flowable提供的表达式引擎，在节点上设置一个表达式，根据表达式的计算结果来决定节点的结束条件。

•监听器设置：可以在节点上设置一个监听器，当监听器中的逻辑判断为真时，节点结束执行。

•定时器设置：可以设置一个定时器，当定时器时间到达时，节点结束执行。

3. 节点结束条件的应用场景节点结束条件的设置可以根据具体的需求进行灵活的应用，以下是一些常见的应用场景：•审批流程：在一个多级审批流程中，可以根据不同的审批结果来判断节点的结束条件，当所有审批节点都通过时，流程结束。

•条件分支：在某些情况下，根据不同的条件需要分支到不同的节点，可以利用节点结束条件来实现分支条件的判断。

•超时自动处理：可以设置一个定时器来监控节点的执行时间，当超过一定时间后自动结束节点的执行，防止流程长时间卡在某个节点上。

4. 节点结束条件的注意事项在设置节点结束条件时，需要注意以下几点：•准确性：节点结束条件的设置需要准确地反映业务需求，避免出现逻辑错误或不完整的判断。

•性能影响：复杂的表达式计算可能会对系统性能产生一定的影响，需要评估计算的复杂度和频率，避免影响整体的流程执行效率。

•可读性：节点结束条件的逻辑需要简洁、清晰，便于其他开发人员理解和维护。

flowable 表达式

flowable 实现流程表达式校验场景：工作流在配置分支的时候，需要配置流条件，而流条件有时候会比较复杂，容易写错。

本章主要描述如何从 flowable 源码中拿到表达式处理代码。

环境：springboot：2.2.0.RELEASEflowable：6.4.2测试流程图如上图，表达式的写法可以很多用，flowable会基于spring EL 表达式的基础上，再进行扩展：到节点A：（自定义函数）流条件：${variables:substr(a1,index1,end1)}=='哈哈'}到节点B：（数字比较）流条件：${b==2}到节点C：（字符串对象方法）流条件：${c.contains("BCD")}所以如果要进行flowable 表达式校验，就需要模拟拿到核心。

从源码中可以找到类：org.flowable.engine.impl.util.condition.ConditionUtilExpression expression = CommandContextUtil.getProcessEngine Configuration().getExpressionManager().createExpression(conditionExpres sion);Condition condition =new UelExpressionCondition(expressio n);return condition.evaluate(sequenceFlow.getId(), execution);通过Debug，可以找到实现类：org.flowable.spring.SpringExpressionManagerorg.flowable.engine.impl.el.JuelExpressionorg.flowable.engine.impl.el.UelExpressionConditionorg.flowable.engine.impl.el.UelExpressionConditionpublic class UelExpressionCondition implements Condition { protected Expression expression;public UelExpressionCondition(Expression expression) {this.expression = expression;}@Overridepublic boolean evaluate(String sequenceFlowId, DelegateExecution ex ecution) {Object result = expression.getValue(execution);if (result ==null) {throw new FlowableException("condition expression returns n ull (sequenceFlowId: "+ sequenceFlowId +")" );}if (!(result instanceof Boolean)) {throw new FlowableException("condition expression returns n on-Boolean (sequenceFlowId: "+ sequenceFlowId +"): "+ result +" (" + result.getClass().getName() +")");}return (Boolean) result;}}由上面就可以基本定位到主要代码只有Expression expression = CommandContextUtil.getProcessEngineConfiguratio n().getExpressionManager().createExpression(conditionExpression);Object result = expression.getValue(execution);PS: 前置条件：CommandContextUtil 这一类Utils在flowable中，会在Command获取缓存，直接调回导致空指针最终代码为：package com.example.oldguy.modules.app.plugins;import mon.engine.api.delegate.Expression;import org.fl mon.engine.impl.el.ExpressionManager;import m mand;import mon.engine.im mandContext;import org.flowable.engine.delegate.Deleg ateExecution;import org.flowable.engine.impl.persistence.entity.Executi onEntityImpl;import mandContextUtil;import java.util.Map;/*** @ClassName: ExpressTestCmd* @Author: hrh* @Description:* @Version：**/public class ExpressTestCmd implements Command<Object> {private String conditionExpression;private Map<String, Object>data;public ExpressTestCmd(String conditionExpression, Map<String, Objec t>data) {this.conditionExpression = conditionExpression;this.data =data;}@Overridepublic Object execute(CommandContext commandContext) {ExpressionManager expressionManager = CommandContextUtil.getPro cessEngineConfiguration().getExpressionManager();Expression expression = expressionManager.createExpression(cond itionExpression);DelegateExecution delegateExecution = new ExecutionEntityImpl ();delegateExecution.setTransientVariables(data);return expression.getValue(delegateExecution);}}测试调用：@SpringBootTestpublic class ExpressTests0924 {@Autowiredprivate ManagementService managementService;@Testpublic void test() {// String expression = "${a==1}";String expression ="${variables:substr(a1,index1,end1)}${varia bles:substr(a2,index2)}";// String expression = "${substr(a1,ind ex1,end1)}";Map<String, Object>data= new HashMap<>();data.put("a1", "东方");data.put("a", "1");data.put("index1", 0);data.put("end1", 2);data.put("a2", "方不败");data.put("index2", 1);Object result = managementService.executeCommand(new ExpressTes tCmd(expression, data));System.out.println(result);}}返回结果：image.png最后在调用异常的时候，需要对异常进行处理（下面只示例参数传输不完整）mon.engine.impl.javax.el.PropertyNotFoundException传值不完整时候。

Activiti工作流框架中的任务调度！工作流框架中的任务流程元素详解，使用监听器监听任务执行

Activiti⼯作流框架中的任务调度！⼯作流框架中的任务流程元素详解，使⽤监听器监听任务执⾏任务⽤户任务描述⽤户任务⽤来设置必须由⼈员完成的⼯作当流程执⾏到⽤户任务,会创建⼀个新任务,并把这个新任务加⼊到分配⼈或群组的任务列表中图形标记⽤户任务显⽰成⼀个普通任务(圆⾓矩形),左上⾓有⼀个⼩⽤户图标XML内容XML中的⽤户任务定义:id属性是必须的,name属性是可选的:<userTask id="theTask" name="Important task" />⽤户任务可以设置描述,添加documentation元素可以定义描述:<userTask id="theTask" name="Schedule meeting" ><documentation>Schedule an engineering meeting for next week with the new hire.</documentation>描述⽂本可以通过标准的java⽅法来获取:task.getDescription()持续时间任务可以⽤⼀个字段来描述任务的持续时间可以使⽤查询API来对持续时间进⾏搜索,根据在时间之前或之后进⾏搜索Activiti提供了⼀个节点扩展,在任务定义中设置⼀个表达式,这样在任务创建时就可以设置初始持续时间表达式应该是:java.util.Datejava.util.String(ISO8601格式),ISO8601持续时间(⽐如PT50M)null在流程中使⽤上述格式输⼊⽇期,或在前⼀个服务任务中计算⼀个时间.这⾥使⽤了持续时间,持续时间会基于当前时间进⾏计算,再通过给定的时间段累加: 使⽤"PT30M"作为持续时间,任务就会从现在开始持续30分钟<userTask id="theTask" name="Important task" activiti:dueDate="${dateVariable}"/>任务的持续时间也可以通过TaskService修改,或在TaskListener中通过传⼊的DelegateTask参数修改⽤户分配⽤户任务可以直接分配给⼀个⽤户,通过humanPerformer元素定义humanPerformer定义需要⼀个resourceAssignmentExpression来实际定义⽤户.⽬前只⽀持formalExpressions<process ... >...<userTask id='theTask' name='important task' ><humanPerformer><resourceAssignmentExpression><formalExpression>kermit</formalExpression></resourceAssignmentExpression></humanPerformer></userTask>只有⼀个⽤户可以作为任务的执⾏者分配⽤户在activiti中,⽤户叫做执⾏者拥有执⾏者的⽤户不会出现在其他⼈的任务列表中,只能出现执⾏者的个⼈任务列表中直接分配给⽤户的任务可以通过TaskService获取:List<Task> tasks = taskService.createTaskQuery().taskAssignee("kermit").list();任务也可以加⼊到⼈员的候选任务列表中.需要使⽤potentialOwner元素⽤法和humanPerformer元素类似,需要指定表达式中的每个项⽬是⼈员还是群组<process ... >...<userTask id='theTask' name='important task' ><potentialOwner><resourceAssignmentExpression><formalExpression>user(kermit), group(management)</formalExpression></resourceAssignmentExpression></potentialOwner></userTask>使⽤potentialOwner元素定义的任务可以通过TaskService获取:List<Task> tasks = taskService.createTaskQuery().taskCandidateUser("kermit");这会获取所有kermit为候选⼈的任务,表达式中包含user(kermit).这也会获得所有分配包含kermit这个成员的群组(⽐如,group(management),前提是kermit是这个组的成员,并且使⽤了activiti的账号组件).⽤户所在的群组是在运⾏阶段获取的, 它们可以通过IdentityService进⾏管理如果没有显式指定设置的是⽤户还是群组,引擎会默认当做群组处理下⾯的设置与使⽤group(accountancy)⼀样:<formalExpression>accountancy</formalExpression>Activiti对任务分配的扩展当分配不复杂时,⽤户和组的设置⾮常⿇烦.为避免复杂性,可以使⽤⽤户任务的⾃定义扩展assignee属性: 直接把⽤户任务分配给指定⽤户(和使⽤humanPerformer 效果完全⼀样)<userTask id="theTask" name="my task" activiti:assignee="kermit" />candidateUsers属性: 为任务设置候选⼈(和使⽤potentialOwner效果完全⼀样,不需要像使⽤potentialOwner通过user(kermit)声明,这个属性只能⽤于⼈员)<userTask id="theTask" name="my task" activiti:candidateUsers="kermit, gonzo" />candidateGroups属性: 为任务设置候选组(和使⽤potentialOwner效果完全⼀样,不需要像使⽤potentialOwner通过group(management)声明,这个属性只能⽤于群组)<userTask id="theTask" name="my task" activiti:candidateGroups="management, accountancy" />candidateUsers和candidateGroups可以同时设置在同⼀个⽤户任务中Activiti中虽然有账号管理组件和IdentityService ,账号组件不会检测设置的⽤户是否存在. Activiti允许与其他已存的账户管理⽅案集成使⽤创建事件的任务监听器来实现⾃定义的分配逻辑:<userTask id="task1" name="My task" ><extensionElements><activiti:taskListener event="create" class="org.activiti.MyAssignmentHandler" /></extensionElements></userTask>DelegateTask会传递给TaskListener的实现,通过它可以设置执⾏⼈,候选⼈和候选组public class MyAssignmentHandler implements TaskListener {public void notify(DelegateTask delegateTask) {// Execute custom identity lookups here// and then for example call following methods:delegateTask.setAssignee("kermit");delegateTask.addCandidateUser("fozzie");delegateTask.addCandidateGroup("management");...}}使⽤spring时,使⽤表达式把任务监听器设置为spring代理的bean,让这个监听器监听任务的创建事件⽰例:执⾏者会通过调⽤ldapService这个spring bean的findManagerOfEmployee⽅法获得.流程变量emp会作为参数传递给bean<userTask id="task" name="My Task" activiti:assignee="${ldapService.findManagerForEmployee(emp)}"/>可以⽤来设置候选⼈和候选组:<userTask id="task" name="My Task" activiti:candidateUsers="${ldapService.findAllSales()}"/>⽅法返回类型只能为String(候选⼈) 或Collection < String >(候选组):public class FakeLdapService {public String findManagerForEmployee(String employee) {return "Kermit The Frog";}public List<String> findAllSales() {return Arrays.asList("kermit", "gonzo", "fozzie");}}脚本任务描述脚本任务是⼀个⾃动节点当流程到达脚本任务,会执⾏对应的脚本图形标记脚本任务显⽰为标准BPMN 2.0任务(圆⾓矩形),左上⾓有⼀个脚本⼩图标XML内容脚本任务定义需要指定script和scriptFormat<scriptTask id="theScriptTask" name="Execute script" scriptFormat="groovy"><script>sum = 0for ( i in inputArray ) {sum += i}</script></scriptTask>scriptFormat的值必须兼容JSR-223(java平台的脚本语⾔).默认Javascript会包含在JDK中,不需要额外的依赖.如果要使⽤其他的脚本引擎,必须要是JSR-223引擎兼容的.还需要把对应的jar添加到classpath下, 并使⽤合适的名称:activiti单元测试经常使⽤groovygroovy脚本引擎放在groovy-all.jar中,在2.0版本之前,脚本引擎是groovy jar的⼀部分.使⽤需要添加依赖:<dependency><groupId>org.codehaus.groovy</groupId><artifactId>groovy-all</artifactId><version>2.x.x<version></dependency>脚本变量到达脚本任务的流程可以访问的所有流程变量,都可以在脚本中使⽤<script>sum = 0for ( i in inputArray ) {sum += i}</script>也可以在脚本中设置流程变量,直接调⽤execution.setVariable("variableName", variableValue) 默认,不会⾃动保存变量(activiti 5.12之前) 可以在脚本中⾃动保存任何变量,只要把scriptTask的autoStoreVariables属性设置为true 最佳实践是不要使⽤,⽽是显式调⽤execution.setVariable()<scriptTask id="script" scriptFormat="JavaScript" activiti:autoStoreVariables="false">参数默认为false: 如果没有为脚本任务定义设置参数,所有声明的变量将只存在于脚本执⾏的阶段在脚本中设置变量: 这些命名已经被占⽤,不能⽤作变量名- out, out:print, lang:import, context, elcontext.<script>def scriptVar = "test123"execution.setVariable("myVar", scriptVar)</script>脚本结果脚本任务的返回值可以通过制定流程变量的名称,分配给已存在或者⼀个新流程变量,需要使⽤脚本任务定义的'activiti:resultVariable'属性任何已存在的流程变量都会被脚本执⾏的结果覆盖如果没有指定返回的变量名,脚本的返回值会被忽略<scriptTask id="theScriptTask" name="Execute script" scriptFormat="juel" activiti:resultVariable="myVar"><script>#{echo}</script></scriptTask>脚本的结果-表达式 #{echo} 的值会在脚本完成后,设置到myVar变量中Java服务任务描述Java服务任务⽤来调⽤外部Java类图形标记Java服务任务显⽰为圆⾓矩形,左上⾓有⼀个齿轮⼩图标XML内容声明Java调⽤逻辑有四种⽅式:实现JavaDelegate或者ActivityBehavior执⾏解析代理对象的表达式调⽤⼀个⽅法表达式调⽤⼀个值表达式执⾏⼀个在流程执⾏中调⽤的类,需要在activiti:class属性中设置全类名:<serviceTask id="javaService"name="My Java Service Task"activiti:class="org.activiti.MyJavaDelegate" />使⽤表达式调⽤⼀个对象,对象必须遵循⼀些规则,并使⽤activiti:delegateExpression属性进⾏创建:<serviceTask id="serviceTask" activiti:delegateExpression="${delegateExpressionBean}" />delegateExpressionBean是⼀个实现了JavaDelegate接⼝的bean,定义在实例的spring容器中要执⾏指定的UEL⽅法表达式, 需要使⽤activiti:expression:<serviceTask id="javaService"name="My Java Service Task"activiti:expression="#{printer.printMessage()}" />⽅法printMessage()会调⽤名为printer对象的⽅法为表达式中的⽅法传递参数:<serviceTask id="javaService"name="My Java Service Task"activiti:expression="#{printer.printMessage(execution, myVar)}" />调⽤名为printer对象上的⽅法printMessage.第⼀个参数是DelegateExecution, 在表达式环境中默认名称为execution. 第⼆个参数传递的是当前流程的名为myVar的变量要执⾏指定的UEL⽅法表达式, 需要使⽤activiti:expression:<serviceTask id="javaService"name="My Java Service Task"activiti:expression="#{split.ready}" />ready属性的getter⽅法:getReady() 会作⽤于名为split的bean上.这个对象会被解析为流程对象和spring环境中的对象实现要在流程执⾏中实现⼀个调⽤的类,这个类需要实现org.activiti.engine.delegate.JavaDelegate接⼝,并在execute⽅法中提供对应的业务逻辑.当流程执⾏到特定阶段,会指定⽅法中定义好的业务逻辑,并按照默认BPMN 2.0中的⽅式离开节点⽰例: 创建⼀个java类的例⼦,对流程变量中字符串转换为⼤写这个类需要实现org.activiti.engine.delegate.JavaDelegate接⼝,要求实现execute(DelegateExecution) ⽅法,包含的业务逻辑会被引擎调⽤流程实例信息:流程变量和其他信息,可以通过DelegateExecution接⼝访问和操作public class ToUppercase implements JavaDelegate {public void execute(DelegateExecution execution) throws Exception {String var = (String) execution.getVariable("input");var = var.toUpperCase();execution.setVariable("input", var);}}serviceTask定义的class只会创建⼀个java类的实例所有流程实例都会共享相同的类实例,并调⽤execute(DelegateExecution) 类不能使⽤任何成员变量,必须是线程安全的,必须能模拟在不同线程中执⾏.影响着属性注⼊的处理⽅式流程定义中引⽤的类(activiti:class)不会在部署时实例化只有当流程第⼀次执⾏到使⽤类的时候,类的实例才会被创建如果找不到类,会抛出⼀个ActivitiException这个原因是部署环境(更确切是的classpath)和真实环境往往是不同的:当使⽤ant或业务归档上传到Activiti Explorer来发布流程,classpath没有包含引⽤的类内部实现类也可以提供实现org.activiti.engine.impl.pvm.delegate.ActivityBehavior接⼝的类实现可以访问更强⼤的ActivityExecution,它可以影响流程的流向注意: 这应该尽量避免.只有在⾼级情况下并且确切知道要做什么的情况下,再使⽤ActivityBehavior接⼝属性注⼊为代理类的属性注⼊数据. ⽀持如下类型的注⼊: 固定的字符串表达式如果有效的话,数值会通过代理类的setter⽅法注⼊,遵循java bean的命名规范(⽐如fistName属性对应setFirstName(Xxx)⽅法)如果属性没有对应的setter⽅法,数值会直接注⼊到私有属性中⼀些环境的SecurityManager不允许修改私有属性,要把想注⼊的属性暴露出对应的setter⽅法来⽆论流程定义中的数据是什么类型,注⼊⽬标的属性类型都应该是 org.activiti.engine.delegate.Expression⽰例: 把⼀个常量注⼊到属性中属性注⼊可以使⽤class属性在声明实际的属性注⼊之前,需要定义⼀个extensionElements的XML元素<serviceTask id="javaService"name="Java service invocation"activiti:class="org.activiti.examples.bpmn.servicetask.ToUpperCaseFieldInjected"><extensionElements><activiti:field name="text" stringValue="Hello World" /></extensionElements></serviceTask>ToUpperCaseFieldInjected类有⼀个text属性,类型是org.activiti.engine.delegate.Expression. 调⽤text.getValue(execution) 时,会返回定义的字符串Hello World可以使⽤长⽂字(⽐如,内嵌的email),使⽤activiti:string⼦元素:<serviceTask id="javaService"name="Java service invocation"activiti:class="org.activiti.examples.bpmn.servicetask.ToUpperCaseFieldInjected"><extensionElements><activiti:field name="text"><activiti:string>Hello World</activiti:string></activiti:field></extensionElements></serviceTask>可以使⽤表达式,实现在运⾏期动态解析注⼊的值这些表达式可以使⽤流程变量或spring定义的bean.服务任务中的java类实例会在所有流程实例中共享:为了动态注⼊属性的值,可以在org.activiti.engine.delegate.Expression中使⽤值和⽅法表达式会使⽤传递给execute⽅法的DelegateExecution参数进⾏解析<serviceTask id="javaService" name="Java service invocation"activiti:class="org.activiti.examples.bpmn.servicetask.ReverseStringsFieldInjected"><extensionElements><activiti:field name="text1"><activiti:expression>${genderBean.getGenderString(gender)}</activiti:expression></activiti:field><activiti:field name="text2"><activiti:expression>Hello ${gender == 'male' ? 'Mr.' : 'Mrs.'} ${name}</activiti:expression></activiti:field></ extensionElements></ serviceTask>⽰例: 注⼊表达式,并使⽤在当前传⼊的DelegateExecution解析:public class ReverseStringsFieldInjected implements JavaDelegate {private Expression text1;private Expression text2;public void execute(DelegateExecution execution) {String value1 = (String) text1.getValue(execution);execution.setVariable("var1", new StringBuffer(value1).reverse().toString());String value2 = (String) text2.getValue(execution);execution.setVariable("var2", new StringBuffer(value2).reverse().toString());}}可以把表达式设置成⼀个属性,⽽不是⼦元素:因为java类实例会被重⽤,注⼊只会发⽣⼀次,当服务任务调⽤第⼀次的时候发⽣注⼊当代码中的属性改变了,值也不会重新注⼊,把它们看作是不变的,不⽤修改它们服务任务结果服务流程返回的结果(使⽤表达式的服务任务)可以分配给已经存在的或新的流程变量通过指定服务任务定义的activiti:resultVariable属性来实现指定的流程变量会被服务流程的返回结果覆盖如果没有指定返回变量名,就会忽略返回结果<serviceTask id="aMethodExpressionServiceTask"activiti:expression="#{myService.doSomething()}"activiti:resultVariable="myVar" />服务流程的返回值(在myService上调⽤doSomething() ⽅法的返回值,myService可能是流程变量,也可能是spring的bean),在服务执⾏完成之后,会设置到名为myVar的流程变量⾥处理异常执⾏⾃定义逻辑时,常常需要捕获对应的业务异常,在流程内部进⾏处理抛出BPMN Errors: 在服务任务或脚本任务的代码⾥抛出BPMN error: 要从JavaDelegate,脚本,表达式和代理表达式中抛出名为BpmnError的特殊ActivitiExeption 引擎会捕获这个异常,把它转发到对应的错误处理中:边界错误事件或错误事件⼦流程public class ThrowBpmnErrorDelegate implements JavaDelegate {public void execute(DelegateExecution execution) throws Exception {try {executeBusinessLogic();} catch (BusinessException e) {throw new BpmnError("BusinessExceptionOccured");}}}构造参数是错误代码,会被⽤来决定哪个错误处理器会来响应这个错误这个机制只⽤于业务失败,应该被流程定义中设置的边界错误事件或错误事件⼦流程处理. 技术上的错误应该使⽤其他异常类型,通常不会在流程⾥处理异常顺序流: 内部实现类在⼀些异常发⽣时,让流程进⼊其他路径<serviceTask id="javaService"name="Java service invocation"activiti:class="org.activiti.ThrowsExceptionBehavior"></serviceTask><sequenceFlow id="no-exception" sourceRef="javaService" targetRef="theEnd" /><sequenceFlow id="exception" sourceRef="javaService" targetRef="fixException" />这⾥的服务任务有两个外出顺序流:分别叫exception和no-exception. 异常出现时会使⽤顺序流的ID来决定流向public class ThrowsExceptionBehavior implements ActivityBehavior {public void execute(ActivityExecution execution) throws Exception {String var = (String) execution.getVariable("var");PvmTransition transition = null;try {executeLogic(var);transition = execution.getActivity().findOutgoingTransition("no-exception");} catch (Exception e) {transition = execution.getActivity().findOutgoingTransition("exception");}execution.take(transition);}}JavaDelegate使⽤Activiti服务需要在Java服务任务中使⽤Activiti服务的场景: ⽐如,通过RuntimeService启动流程实例,⽽callActivity不满⾜需求org.activiti.engine.delegate.DelegateExecution允许通过 org.activiti.engine.EngineServices接⼝直接获得这些服务:public class StartProcessInstanceTestDelegate implements JavaDelegate {public void execute(DelegateExecution execution) throws Exception {RuntimeService runtimeService = execution.getEngineServices().getRuntimeService();runtimeService.startProcessInstanceByKey("myProcess");}}所有activiti服务的API都可以通过这个接⼝获得使⽤这些API调⽤出现的所有数据改变,都是在当前事务中在例如spring和CDI这样的依赖注⼊环境也会起作⽤,⽆论是否启⽤了JTA数据源⽰例: 下⾯的代码功能与上⾯的代码⼀致,这是RuntimeService是通过依赖注⼊获得,⽽不是通过org.activiti.engine.EngineServices接⼝@Component("startProcessInstanceDelegate")public class StartProcessInstanceTestDelegateWithInjection {@Autowiredprivate RuntimeService runtimeService;public void startProcess() {runtimeService.startProcessInstanceByKey("oneTaskProcess");}}因为服务调⽤是在当前事务⾥,数据的产⽣或改变,在服务任务执⾏完之前,还没有提交到数据库.所以API对于数据库数据的操作,意味着未提交的操作在服务任务的API调⽤中都是不可见的WebService任务描述WebService任务可以⽤来同步调⽤⼀个外部的WebService图形标记WebService任务与Java服务任务显⽰效果⼀样(圆⾓矩形,左上⾓有⼀个齿轮⼩图标)XML内容要使⽤WebService需要导⼊操作和类型,可以使⽤import标签来指定WebService的WSDL<import importType="/wsdl/"location="http://localhost:63081/counter?wsdl"namespace="/" />声明告诉activiti导⼊WSDL定义,但没有创建itemDefinition和message假设想调⽤⼀个名为prettyPrint的⽅法,必须创建为请求和响应信息对应的message和itemDefinition <message id="prettyPrintCountRequestMessage" itemRef="tns:prettyPrintCountRequestItem" /><message id="prettyPrintCountResponseMessage" itemRef="tns:prettyPrintCountResponseItem" /><itemDefinition id="prettyPrintCountRequestItem" structureRef="counter:prettyPrintCount" /><itemDefinition id="prettyPrintCountResponseItem" structureRef="counter:prettyPrintCountResponse" />在申请服务任务之前,必须定义实际引⽤WebService的BPMN接⼝和操作基本上,定义接⼝和必要的操作.对每个操作都会重⽤上⾯定义的信息作为输⼊和输出⽰例: 定义了counter接⼝和prettyPrintCountOperation操作:<interface name="Counter Interface" implementationRef="counter:Counter"><operation id="prettyPrintCountOperation" name="prettyPrintCount Operation"implementationRef="counter:prettyPrintCount"><inMessageRef>tns:prettyPrintCountRequestMessage</inMessageRef><outMessageRef>tns:prettyPrintCountResponseMessage</outMessageRef></operation></interface>然后定义WebService任务,使⽤WebService实现,并引⽤WebService操作<serviceTask id="webService"name="Web service invocation"implementation="##WebService"operationRef="tns:prettyPrintCountOperation">WebService任务IO规范每个WebService任务可以定义任务的输⼊输出IO规范<ioSpecification><dataInput itemSubjectRef="tns:prettyPrintCountRequestItem" id="dataInputOfServiceTask" /><dataOutput itemSubjectRef="tns:prettyPrintCountResponseItem" id="dataOutputOfServiceTask" /><inputSet><dataInputRefs>dataInputOfServiceTask</dataInputRefs></inputSet><outputSet><dataOutputRefs>dataOutputOfServiceTask</dataOutputRefs></outputSet></ioSpecification>WebService任务数据输⼊关联指定数据输⼊关联有两种⽅式:使⽤表达式使⽤简化⽅式使⽤表达式指定数据输⼊关联: 需要定义来源和⽬的item,并指定每个item属性之间的对应关系:<dataInputAssociation><sourceRef>dataInputOfProcess</sourceRef><targetRef>dataInputOfServiceTask</targetRef><assignment><from>${dataInputOfProcess.prefix}</from><to>${dataInputOfServiceTask.prefix}</to></assignment><assignment><from>${dataInputOfProcess.suffix}</from><to>${dataInputOfServiceTask.suffix}</to></assignment></dataInputAssociation>分配item的前缀和后缀使⽤简化⽅式指定数据输⼊关联: sourceRef元素是activiti的变量名,targetRef元素是item定义的⼀个属性:<dataInputAssociation><sourceRef>PrefixVariable</sourceRef><targetRef>prefix</targetRef></dataInputAssociation><dataInputAssociation><sourceRef>SuffixVariable</sourceRef><targetRef>suffix</targetRef></dataInputAssociation>PrefixVariable变量的值分配给prefix属性,把SuffixVariable变量的值分配给suffix属性WebService任务数据输出关联指定数据输出关联有两种⽅式:使⽤表达式使⽤简化⽅式使⽤表达式指定数据输出关联: 需要定义⽬的变量和来源表达式<dataOutputAssociation><targetRef>dataOutputOfProcess</targetRef><transformation>${dataOutputOfServiceTask.prettyPrint}</transformation></dataOutputAssociation>⽅法和数据输⼊关联完全⼀样使⽤简化⽅式指定数据输出关联: sourceRef元素是item定义的⼀个属性,targetRef元素是activiti的变量名<dataOutputAssociation><sourceRef>prettyPrint</sourceRef><targetRef>OutputVariable</targetRef></dataOutputAssociation>⽅法和数据输⼊关联完全⼀样业务规则任务描述业务规则任务⽤来同步执⾏⼀个或多个规则Activiti使⽤drools规则引擎执⾏业务规则: 包含业务规则的.drl⽂件必须和流程定义⼀起发布流程定义⾥包含了执⾏这些规则的业务规则任务流程使⽤的所有.drl⽂件都必须打包在流程BAR⽂件⾥如果想要⾃定义规则任务的实现: 想⽤不同⽅式使⽤drools,或者使⽤完全不同的规则引擎.你可以使⽤BusinessRuleTask上的class或表达式属性图形标记业务规则任务是⼀个圆⾓矩形,左上⾓使⽤⼀个表格⼩图标进⾏显⽰XML内容要执⾏部署流程定义的BAR⽂件中的⼀个或多个业务规则,需要定义输⼊和输出变量:对于输⼊变量定义,可以使⽤逗号分隔的⼀些流程变量输出变量定义只包含⼀个变量名,会把执⾏业务规则后返回的对象保存到对应的流程变量中注意: 结果变量会包含⼀个对象列表,如果没有指定输出变量名称,默认会使⽤ org.activiti.engine.rules.OUTPUT<process id="simpleBusinessRuleProcess"><startEvent id="theStart" /><sequenceFlow sourceRef="theStart" targetRef="businessRuleTask" /><businessRuleTask id="businessRuleTask" activiti:ruleVariablesInput="${order}"activiti:resultVariable="rulesOutput" /><sequenceFlow sourceRef="businessRuleTask" targetRef="theEnd" /><endEvent id="theEnd" /></process>业务规则任务也可以配置成只执⾏部署的.drl⽂件中的⼀些规则.这时要设置逗号分隔的规则名,只会执⾏rule1和rule2:<businessRuleTask id="businessRuleTask" activiti:ruleVariablesInput="${order}"activiti:rules="rule1, rule2" />定义哪些规则不⽤执⾏:除了rule1和rule2以外,所有部署到流程定义同⼀个BAR⽂件中的规则都会执⾏:<businessRuleTask id="businessRuleTask" activiti:ruleVariablesInput="${order}"activiti:rules="rule1, rule2" exclude="true" />可以⽤⼀个选项修改BusinessRuleTask的实现:<businessRuleTask id="businessRuleTask" activiti:class="${MyRuleServiceDelegate}" />BusinessRuleTask的功能和ServiceTask⼀样,但是使⽤BusinessRuleTask的图标来表⽰在这⾥要执⾏业务规则邮件任务Activiti强化了业务流程,⽀持⾃动邮件任务: 可以发送邮件给⼀个或多个参与者,包括⽀持cc,bcc,HTML内容等等邮件任务不是BPMN 2.0规范定义的官⽅任务,Activiti中邮件任务是⽤专门的服务任务实现的邮件服务器配置Activiti引擎要通过⽀持SMTP功能的外部邮件服务器发送邮件为了实际发送邮件,引擎穾知道如何访问邮件服务器.下⾯的配置可以设置到activiti.cfg.xml配置⽂件中:属性是否必须描述mailServerHost否邮件服务器的主机名(⽐如:).默认为localhostmailServerPort 是如果没有使⽤默认端⼝邮件服务器上的SMTP传输端⼝.默认为25mailServerDefaultFrom否如果⽤户没有指定发送邮件的邮件地址,默认设置的发送者的邮件地址。

flowable 边界事件 cron表达式

Flowable 是一个用于开发业务流程管理系统的开源 BPM(Business Process Management)框架，它能够帮助开发者轻松地创建、管理和执行复杂的业务流程。

在 Flowable 中，边界事件和 cron 表达式是两个非常重要的概念，它们可以帮助开发者更好地控制流程的行为和执行时间。

一、边界事件在 Flowable 中，边界事件是指与流程中的特定节点关联的事件，这些事件可以在节点执行过程中被触发，从而改变节点执行的行为。

边界事件可以是定时事件、消息事件、错误事件等。

1. 定时边界事件定时边界事件是流程中与特定节点关联的定时触发的事件。

开发者可以在流程图中为节点添加定时边界事件，并设置定时触发的时间。

当节点执行到定时边界事件时，如果触发时间到达，相关的事件将被触发，从而改变节点的执行行为。

2. 消息边界事件消息边界事件是流程中与特定节点关联的消息触发的事件。

开发者可以在流程图中为节点添加消息边界事件，并指定需要触发的消息类型。

当节点执行到消息边界事件时，如果匹配的消息到达，相关的事件将被触发，从而改变节点的执行行为。

3. 错误边界事件错误边界事件是流程中与特定节点关联的错误触发的事件。

开发者可以在流程图中为节点添加错误边界事件，并指定需要触发的错误类型。

当节点执行到错误边界事件时，如果触发的错误类型匹配，相关的事件将被触发，从而改变节点的执行行为。

二、cron 表达式在使用 Flowable 进行流程开发时，经常会遇到需要定时触发的场景。

这时，cron 表达式就非常有用了。

cron 表达式是一种时间表达式，可以精确地指定时间点或时间段来触发事件。

1. cron 表达式的格式cron 表达式由 6 个字段组成，分别表示秒、分、时、日、月、周几，其中周几可以使用英文缩写或数字表示。

cron 表达式的格式如下：```秒分时日月周几* * * * * *```其中，* 表示任意值，可以使用数字或者通配符 - / ，例如：- */3 表示每隔 3 单位- 3,6 表示 3 或 6- 3-6 表示 3 到 6 的范围- MON-FRI 表示周一到周五2. cron 表达式的使用在 Flowable 中，开发者可以通过配置定时任务的方式来指定流程的执行时间。

flowableeventlistener 判断驳回 -回复

flowableeventlistener 判断驳回-回复什么是FlowableEventListener？Flowable是一个基于Java的开源工作流引擎，提供了一系列的API和工具来帮助开发人员设计、执行和管理工作流程。

FlowableEventListener 是Flowable引擎中的一个事件监听器。

它可以监听Flowable引擎中的各种事件，如任务创建、任务完成、流程开始、流程结束等。

通过使用FlowableEventListener，开发人员可以在工作流引擎的执行过程中进行扩展和定制。

在本文中，我们将重点讨论如何使用FlowableEventListener 来判断驳回事件。

什么是驳回事件？在工作流引擎中，驳回事件指的是当一个任务或流程实例被驳回时触发的事件。

驳回事件通常发生在任务被审批人或流程参与者拒绝执行或处理时。

在驳回事件发生时，我们可以根据特定的需求和条件来做出相应的处理，如发送通知、记录事件日志等。

如何判断驳回事件？使用FlowableEventListener可以轻松地监听到驳回事件的发生。

以下是一步一步的方法来判断驳回事件：步骤一：创建自定义的FlowableEventListener类首先，我们需要创建一个自定义的FlowableEventListener类来监听流程事件。

这个类需要实现FlowableEventListener接口，并且重写相应的方法来处理驳回事件。

我们可以在事件发生时执行自定义的逻辑。

步骤二：注册FlowableEventListener接下来，我们需要将自定义的FlowableEventListener类注册到Flowable 引擎中。

在Flowable引擎启动时，我们可以通过配置文件或编程方式来注册事件监听器。

注册后，Flowable引擎会在事件发生时调用对应的监听器方法。

步骤三：处理驳回事件在FlowableEventListener类中，我们可以在驳回事件发生时执行自定义的逻辑。

flowable tasklistener 调用service层的方法-概述说明以及解释

flowable tasklistener 调用service层的方法-概述说明以及解释1.引言概述部分的内容可以如下编写：1.1 概述Flowable是一个开源的工作流引擎，它提供了一种轻量级、可扩展的方式来管理和执行各种类型的流程。

Flowable TaskListener是Flowable 中的一个组件，用于监听和处理流程中的任务事件。

在开发实际应用中，我们通常需要根据不同的任务状态来触发一些自定义的业务逻辑。

而Flowable TaskListener则提供了这样的机制，允许我们在任务创建、分配、完成等各个阶段，通过编写监听器逻辑来执行特定的操作。

然而，对于一些复杂的业务需求，往往需要调用更复杂的逻辑，可能需要与Service层交互来处理特定的业务逻辑。

这就引发了一个问题：如何在Flowable TaskListener中调用Service层的方法？本文将会深入探讨如何在Flowable TaskListener中调用Service层的方法，并提供一些实际应用的示例。

首先，我们会详细介绍Flowable TaskListener的基本概念和使用方法。

然后，我们将探讨如何与Service 层进行交互，并给出一些最佳实践和注意事项。

通过本文的学习，读者将能够了解如何利用Flowable TaskListener来处理各种任务事件，并使用Service层来实现复杂的业务逻辑。

本文所提供的实例代码将帮助读者更好地理解和应用这些概念。

最后，我们将总结本文的内容，并展望未来在Flowable TaskListener与Service层交互方面的发展前景。

在下一节中，我们将详细介绍本文的组织结构和主要内容。

1.2文章结构文章结构部分主要用于介绍本文的结构和内容安排，让读者能够清楚地了解文章的组织和流程。

在撰写文章结构时，可以包括以下内容：1. 文章的主要章节和子章节的标题：可以简单列出章节的标题，以及每个章节下面的子章节标题。

flowable流程流转表达式类

flowable流程流转表达式类英文回答：Flowable process expression class is an important component in the Flowable framework, which allows users to define and control the flow of a process instance. It provides a way to specify the conditions under which a process can move from one task to another, based on certain expressions or rules.The process expression class in Flowable is used to define the conditions for transitioning from one activityto another within a process. It allows users to specify the conditions using various expressions, such as EL expressions, Groovy scripts, or even Java code. These expressions can be used to evaluate variables, make decisions, and control the flow of the process.For example, let's say we have a process with two tasks: "Task A" and "Task B". We want to transition from "Task A"to "Task B" only if a certain condition is met. In this case, we can use the process expression class to define the condition. We can write an expression like "#{variableName == 'value'}" to check if a variable has a specific value, and based on the result, the process will either move to "Task B" or stay at "Task A".The process expression class also allows for more complex conditions and expressions. It supports logical operators, comparison operators, functions, and variables. This gives users a lot of flexibility in defining the flow of their processes. For example, we can use expressionslike "#{variableName1 > variableName2 && variableName3 != 'value'}" to define more intricate conditions for transitioning between tasks.In addition to expressions, the process expression class also supports the use of business rules, such as decision tables or decision trees, to control the flow of the process. This allows for more dynamic and configurable process flows, where the decision logic can be easily changed without modifying the process definition.Overall, the process expression class in Flowable is a powerful tool for defining and controlling the flow of a process instance. It provides a flexible and configurable way to specify conditions for transitioning between tasks, based on expressions, rules, or even custom code.中文回答：Flowable流程流转表达式类是Flowable框架中的一个重要组件，允许用户定义和控制流程实例的流转。

flowable cmmn引擎使用

flowable cmmn引擎使用Flowable CMMN引擎使用CMMN（Case Management Model and Notation）是一种用于建模、执行和监控案例管理的标准化表示法。

Flowable CMMN引擎是一个基于CMMN规范实现的工作流引擎，可以帮助开发人员更方便地构建和管理复杂的案例管理应用。

本文将分为以下几个部分来介绍Flowable CMMN引擎的使用：1. 引擎的安装和配置2. 创建案例模型3. 部署和启动案例4. 监控和管理案例5. 扩展和定制引擎功能一. 引擎的安装和配置首先，我们需要下载Flowable CMMN引擎的发行版。

你可以从Flowable 的官方网站或GitHub仓库上找到最新版本。

下载并解压缩后，我们可以开始配置引擎。

在config目录下，找到flowable.cfg.xml文件。

这个文件中包含了引擎的基本配置选项，如数据库连接信息和流程引擎参数。

我们可以根据自己的需求进行相应的设置。

二. 创建案例模型使用Flowable CMMN引擎，我们可以使用CMMN Builder来创建和编辑案例模型。

在你的开发环境中，你可以在Flowable的web应用中找到CMMN Builder。

打开CMMN Builder后，你可以在画布上拖拽和放置各种元素，如案例任务、案例计划、条件事件等。

通过连接这些元素，你可以定义案例的各个阶段和流程。

同时，你还可以为每个元素设置各种属性，如名称、描述和响应规则。

三. 部署和启动案例完成案例模型的设计后，我们需要将其部署到Flowable引擎中，以便开始执行。

要部署案例模型，你可以使用Flowable的可视化设计器或者通过API接口进行部署。

在部署后，你可以使用Flowable的管理应用来查看已部署的模型，并进行必要的配置。

一旦模型被部署，你就可以通过API接口启动案例。

四. 监控和管理案例Flowable CMMN引擎提供了丰富的监控和管理工具，用于跟踪案例的执行。

flowable操作手册

flowable操作手册Flowable 操作手册1. 简介Flowable 是一个功能强大的开源工作流和业务流程管理引擎，它提供了开发人员友好的 API 和丰富的功能，能够高效地处理各种流程场景。

本操作手册将引导您使用 Flowable，实现业务流程的建模、部署和执行。

2. 安装和配置2.1 下载和安装首先，在 Flowable 官方网站上下载适用于您的操作系统的 Flowable 发布包。

解压缩下载的包，并设置必要的环境变量。

2.2 数据库配置Flowable 使用关系型数据库存储流程实例和相关数据。

您需要创建一个数据库，并在 Flowable 的配置文件中指定数据库连接。

3. Flowable 的基本概念在开始使用 Flowable 之前，我们需要了解一些基本概念。

- 流程引擎：Flowable 的核心组件，通过流程引擎实现流程的定义、部署、执行和监控。

- 流程定义：定义业务流程的一种方式，以 BPMN 2.0 或其他支持的规范进行描述。

- 流程实例：根据流程定义创建的实例，可以理解为执行中的流程。

- 任务：在流程中的工作单元，需要由流程参与人完成。

- 执行流：流程定义中的一个节点。

- 历史数据：已经完成的流程实例的数据，包括流程实例、任务和变量等。

- 监听器：在流程执行过程中，通过监听器可以根据事件完成一些自定义操作。

4. 建立和部署流程4.1 使用 BPMN 进行流程建模Flowable 支持 BPMN 2.0 规范，您可以使用 Flowable 提供的图形建模工具或其他 BPMN 工具创建流程图。

在流程建模过程中，您需要定义流程中的任务和顺序流等元素。

4.2 部署流程使用 Flowable 的 API，您可以将流程定义部署到流程引擎中。

部署后的流程定义可以被实例化和执行。

5. 执行和管理流程5.1 启动流程实例在完成流程的建模和部署后，您可以通过调用 Flowable 的 API 来启动流程实例。

flowable工作流笔记

flowable⼯作流笔记专业词汇处理分发的事件的另⼀个⽅法，是抛出BPMN事件，实体，entityType可⽤的值有：attachment（附件）, comment（备注）, execution（执⾏）, identity-link（⾝份关联）, job（作业）, process-instance（流程实例）, process-definition（流程定义）, task（任务）。

throwEvent="globalSignal"流程定义的xml⽂档位置：2.3.2. 部署流程定义<?xml version="1.0" encoding="UTF-8"?><definitions xmlns="/spec/BPMN/20100524/MODEL"xmlns:xsi="/2001/XMLSchema-instance"xmlns:xsd="/2001/XMLSchema"xmlns:bpmndi="/spec/BPMN/20100524/DI"xmlns:omgdc="/spec/DD/20100524/DC"xmlns:omgdi="/spec/DD/20100524/DI"xmlns:flowable="/bpmn"typeLanguage="/2001/XMLSchema"expressionLanguage="/1999/XPath"targetNamespace="/processdef"><process id="holidayRequest" name="Holiday Request" isExecutable="true"><startEvent id="startEvent"/><sequenceFlow sourceRef="startEvent" targetRef="approveTask"/><userTask id="approveTask" name="Approve or reject request"/><sequenceFlow sourceRef="approveTask" targetRef="decision"/><exclusiveGateway id="decision"/><sequenceFlow sourceRef="decision" targetRef="externalSystemCall"><conditionExpression xsi:type="tFormalExpression"><![CDATA[${approved}]]></conditionExpression></sequenceFlow><sequenceFlow sourceRef="decision" targetRef="sendRejectionMail"><conditionExpression xsi:type="tFormalExpression"><![CDATA[${!approved}]]></conditionExpression></sequenceFlow><serviceTask id="externalSystemCall" name="Enter holidays in external system"flowable:class="org.flowable.CallExternalSystemDelegate"/><sequenceFlow sourceRef="externalSystemCall" targetRef="holidayApprovedTask"/><userTask id="holidayApprovedTask" name="Holiday approved"/><sequenceFlow sourceRef="holidayApprovedTask" targetRef="approveEnd"/><serviceTask id="sendRejectionMail" name="Send out rejection email"flowable:class="org.flowable.SendRejectionMail"/><sequenceFlow sourceRef="sendRejectionMail" targetRef="rejectEnd"/><endEvent id="approveEnd"/><endEvent id="rejectEnd"/></process></definitions>1.选⽤mysql数据库的时候选择5.6.4及其以上，如果要较低版本的flowalbe⽀持⽐较⾼的mysql，需要加⼊如下配置：要进⾏升级，⾸先需要将下列配置参数放⼊你的flowable.cfg.xml配置⽂件：<beans ><bean id="processEngineConfiguration"class="org.flowable.engine.impl.cfg.StandaloneProcessEngineConfiguration"> <property name="databaseSchemaUpdate" value="true" /> </bean></beans>同时需要改驱动2.选择flowable版本6.0.1版本及其以上较好性能。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

flowable工作流中的任务监听器,表达式用法
Flowable工作流中的任务监听器表达式用法
监听器简介
在Flowable工作流中，可以通过任务监听器对任务的执行进行监听和控制，以实现一些额外的逻辑处理。

其中，表达式是任务监听器中常用的一种方式，它可以通过表达式语言来对任务的执行进行控制和定制。

表达式语言
Flowable工作流中的任务监听器表达式可以使用以下几种语言：- JUEL (Java Unified Expression Language): 这是一种基于Java 的表达式语言，它支持在Flowable工作流中使用的大部分功能。

- Groovy: 这是一种动态编程语言，它可以直接在Flowable工作流中使用，并提供了更丰富的语法特性和函数库。

- JavaScript: 这是一种脚本语言，它可以使用Flowable提供的JavaScript引擎直接在Flowable工作流中执行。

表达式用法示例
1. 设置任务办理人
在任务创建时，可以使用任务监听器的表达式来设置任务的办理人。

以下是一个使用JUEL表达式设置任务办理人的示例：
<userTask id="task1" name="Task 1" activiti:assigne e="${}" />
这个表达式${}表示获取到当前用户的ID作为任务的办理人。

2. 获取流程变量
在任务执行过程中，可以使用监听器表达式获取流程变量的值，从而根据流程变量的值来进行一些操作。

以下是一个使用Groovy表达式获取流程变量值的示例：
def value = ('variableName')
这个表达式('variableName')表示获取名为variableName的流程变量的值。

3. 执行自定义业务逻辑
任务监听器的表达式还可以执行一些自定义的业务逻辑，以满足特定需求。

以下是一个使用JavaScript表达式执行自定义业务逻辑的示例：
function customLogic(task) {
// 执行自定义的业务逻辑
}
customLogic(task);
这个表达式中定义了一个名为customLogic的函数，然后在最后一行调用了这个函数来执行自定义的业务逻辑。

总结
任务监听器表达式是Flowable工作流中非常有用的一种功能，它可以通过使用不同的表达式语言来实现对任务执行过程的灵活控制和定制。

本文介绍了一些常见的任务监听器表达式用法，包括设置任务办理人、获取流程变量和执行自定义业务逻辑等。

读者可以根据具体需求选择合适的表达式语言和使用方式来应用在自己的工作流中。