阅读数:547 评论数:0

一、自定义扩展

标准通常是不同公司（不同观点）大量讨论与妥协的结果。作为阅读BPMN 2.0 XML流程定义的开发者，有时会觉得某些结构或方法十分笨重。Flowable将开发者的感受放在最高优先，因此引入了一些'Flowable BPMN扩展（extensions）'。这些“扩展”并不在BPMN 2.0规格中，有些是新结构，有些是对特定结构的简化。

使用自定义扩展时，总是通过flowable:命名空间前缀，明确标识出XML元素、属性等。请注意Flowable引擎也支持activiti:命名空间前缀。

二、事件

事件（event）通常用于为流程生命周期中发生的事情建模。事件总是图形化为圆圈。在BPMN 2.0中，有两种主要的事件分类：捕获（catching）与抛出（throwing）事件。

事件分为五大类：开始事件、结束事件、中间事件、边界事件、边界补偿事件。

如何区分中间事件和边界事件

中间事件会以节点的形式出现在流程图中，但不会产生实际的节点。

边界事件与节点共存，中间事件可以理解为一个任务的发起前置监听，而边界事件可以理解为对整个节点的监听。

重点说一下补偿事件，主要用于对已完成的流程做回退处理。

1、捕获

当流程执行到达这个事件时，会等待直到触发器动作。触发器的类型由其中的图标，或者说XML中的类型声明而定义。捕获事件与抛出事件显示上的区别，是其内部的图标没有填充（即是白色的）。

2、抛出

当流程执行到达这个事件时，会触发一个触发器。触发器的类型，由其中的图标，或者说XML中的类型声明而定义。抛出事件与捕获事件显示上的区别，是其内部的图标填充为黑色。

3、事件定义

事件定义（event definition），用于定义事件的语义。没有事件定义的话，事件就“不做什么特别的事情”。例如，一个没有事件定义的开始事件，并不限定具体是什么启动了流程。如果为这个开始事件添加事件定义（例如定时器事件定义），就声明了启动流程的“类型”（例如对于定时器事件定义，就是到达了特定的时间点）。

（1）定时器事件定义

定时器事件（timer event definition），是由定时器所触发的事件。可以用开始事件、中间事件或边界事件。定时器事件的行为取决于所使用的业务日历（business calendar）。定时器事件有默认的业务日历，但也可以为每个定时器事件定义，单独定义业务日历。

<timerEventDefinition flowable:businessCalendarName="custom">
    ...
</timerEventDefinition>

<timerEventDefinition>
    <timeDate>2011-03-11T12:13:14</timeDate>
</timerEventDefinition>

<timerEventDefinition>
    <timeDuration>P10D</timeDuration>
</timerEventDefinition>

<timerEventDefinition>
    <timeCycle flowable:endDate="2015-02-25T16:42:11+00:00">R3/PT10H</timeCycle>
</timerEventDefinition>

<timerEventDefinition>
    <timeCycle>R3/PT10H/${EndDate}</timeCycle>
</timerEventDefinition>

0 0/5 * * * ?

<endEvent id="myErrorEndEvent">
  <errorEventDefinition errorRef="myError" />
</endEvent>

<definitions... >
    <!-- 声明信号 -->
    <signal id="alertSignal" name="alert" />

    <process id="catchSignal">
        <intermediateThrowEvent id="throwSignalEvent" name="Alert">
            <!-- 信号事件定义 -->
            <signalEventDefinition signalRef="alertSignal" />
        </intermediateThrowEvent>
        ...
        <intermediateCatchEvent id="catchSignalEvent" name="On Alert">
            <!-- 信号事件定义 -->
            <signalEventDefinition signalRef="alertSignal" />
        </intermediateCatchEvent>
        ...
    </process>
</definitions>

RuntimeService.signalEventReceived(String signalName);
RuntimeService.signalEventReceived(String signalName, String executionId);

 List<Execution> executions = runtimeService.createExecutionQuery()
      .signalEventSubscriptionName("alert")
      .list();

<signal id="alertSignal" name="alert" flowable:scope="processInstance"/>

<definitions id="definitions"
  xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
  xmlns:flowable="http://flowable.org/bpmn"
  targetNamespace="Examples"
  xmlns:tns="Examples">

  <message id="newInvoice" name="newInvoiceMessage" />
  <message id="payment" name="paymentMessage" />

  <process id="invoiceProcess">

    <startEvent id="messageStart" >
    	<messageEventDefinition messageRef="newInvoice" />
    </startEvent>
    ...
    <intermediateCatchEvent id="paymentEvt" >
    	<messageEventDefinition messageRef="payment" />
    </intermediateCatchEvent>
    ...
  </process>

</definitions>

ProcessInstance startProcessInstanceByMessage(String messageName);
ProcessInstance startProcessInstanceByMessage(String messageName, Map<String, Object> processVariables);
ProcessInstance startProcessInstanceByMessage(String messageName, String businessKey,
    Map<String, Object> processVariables);

void messageEventReceived(String messageName, String executionId);
void messageEventReceived(String messageName, String executionId, HashMap<String, Object> processVariables);

ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
      .messageEventSubscription("newCallCenterBooking")
      .singleResult();

Execution execution = runtimeService.createExecutionQuery()
      .messageEventSubscriptionName("paymentReceived")
      .variableValueEquals("orderId", message.getOrderId())
      .singleResult();

<startEvent id="request" flowable:initiator="initiator" />

ProcessInstance processInstance = runtimeService.startProcessInstanceByXXX();

<startEvent id="start" name="my start event" />

<startEvent id="theStart">
  <timerEventDefinition>
    <timeCycle>R4/2011-03-11T12:13/PT5M</timeCycle>
  </timerEventDefinition>
</startEvent>

ProcessInstance startProcessInstanceByMessage(String messageName);
ProcessInstance startProcessInstanceByMessage(String messageName, Map<String, Object> processVariables);
ProcessInstance startProcessInstanceByMessage(String messageName, String businessKey,
    Map<String, Object< processVariables);

消息启动事件用其中有一个消息事件标志的圆圈表示。这个标志并未填充，用以表示捕获（接收）行为。

消息启动事件的XML表示格式，为普通启动事件声明加上messageEventDefinition子元素：

<definitions id="definitions"
  xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
  xmlns:flowable="http://flowable.org/bpmn"
  targetNamespace="Examples"
  xmlns:tns="Examples">

  <message id="newInvoice" name="newInvoiceMessage" />

  <process id="invoiceProcess">

    <startEvent id="messageStart" >
    	<messageEventDefinition messageRef="tns:newInvoice" />
    </startEvent>
    ...
  </process>

</definitions>

信号启动事件

这个信号可以由流程实例中的信号抛出中间事件（intermediary signal throw event），或者API（runtimeService.signalEventReceivedXXX方法）触发。两种方式都会启动所有拥有相同名字信号启动事件的流程定义。

<signal id="theSignal" name="The Signal" />

<process id="processWithSignalStart1">
  <startEvent id="theStart">
    <signalEventDefinition id="theSignalEventDefinition" signalRef="theSignal"  />
  </startEvent>
  <sequenceFlow id="flow1" sourceRef="theStart" targetRef="theTask" />
  <userTask id="theTask" name="Task in process A" />
  <sequenceFlow id="flow2" sourceRef="theTask" targetRef="theEnd" />
  <endEvent id="theEnd" />
</process>

<startEvent id="messageStart" >
	<errorEventDefinition errorRef="someError" />
</startEvent>

结束事件（end event）标志着流程或子流程中一个分支的结束。结束事件总是抛出（型）事件。这意味着当流程执行到达结束事件时，会抛出一个结果。结果的类型由事件内部的黑色图标表示。在XML表示中，类型由子元素声明给出。

空结束事件

“空”结束事件(none end event)，意味着当到达这个事件时，没有特别指定抛出的结果。因此，引擎除了结束当前执行分支之外，不会多做任何事情。

<endEvent id="end" name="my end event" />

<endEvent id="myErrorEndEvent">
  <errorEventDefinition errorRef="myError" />
</endEvent>

<error id="myError" errorCode="123" />
...
<process id="myProcess">
...

<endEvent id="myEndEvent >
  <terminateEventDefinition flowable:terminateAll="true"></terminateEventDefinition>
</endEvent>

<endEvent id="myCancelEndEvent">
  <cancelEventDefinition />
</endEvent>

<boundaryEvent id="myBoundaryEvent" attachedToRef="theActivity">
      <XXXEventDefinition/>
</boundaryEvent>

<boundaryEvent id="escalationTimer" cancelActivity="true" attachedToRef="firstLineSupport">
  <timerEventDefinition>
    <timeDuration>PT4H</timeDuration>
  </timerEventDefinition>
</boundaryEvent>

<boundaryEvent id="catchError" attachedToRef="mySubProcess">
  <errorEventDefinition errorRef="myError"/>
</boundaryEvent>

<boundaryEvent id="boundary" attachedToRef="task" cancelActivity="true">
    <signalEventDefinition signalRef="alertSignal"/>
</boundaryEvent>

<boundaryEvent id="boundary" attachedToRef="task" cancelActivity="true">
    <messageEventDefinition messageRef="newCustomerMessage"/>
</boundaryEvent>

<boundaryEvent id="boundary" attachedToRef="transaction" >
    <cancelEventDefinition />
</boundaryEvent>

<boundaryEvent id="compensateBookHotelEvt" attachedToRef="bookHotel" >
    <compensateEventDefinition />
</boundaryEvent>

<association associationDirection="One" id="a1"
    sourceRef="compensateBookHotelEvt" targetRef="undoBookHotel" />

<serviceTask id="undoBookHotel" isForCompensation="true" flowable:class="..." />

所有的捕获中间事件（intermediate catching events）都使用相同方式定义：

<intermediateCatchEvent id="myIntermediateCatchEvent" >
    <XXXEventDefinition/>
</intermediateCatchEvent>

定时器捕获中间事件

当执行到达捕获事件时，启动定时器，当定时器触发时，沿定时器中间事件的出口顺序继续执行。

<intermediateCatchEvent id="timer">
  <timerEventDefinition>
    <timeDuration>PT5M</timeDuration>
  </timerEventDefinition>
</intermediateCatchEvent>

信号捕获中间事件

<intermediateCatchEvent id="signal">
  <signalEventDefinition signalRef="newCustomerSignal" />
</intermediateCatchEvent>

消息捕获中间事件

<intermediateCatchEvent id="message">
  <messageEventDefinition signalRef="newCustomerMessage" />
</intermediateCatchEvent>

（9）抛出中间事件

<intermediateThrowEvent id="myIntermediateThrowEvent" >
      <XXXEventDefinition/>
</intermediateThrowEvent>

空抛出中间事件

<intermediateThrowEvent id="noneEvent">
  <extensionElements>
    <flowable:executionListener class="org.flowable.engine.test.bpmn.event.IntermediateNoneEventTest$MyExecutionListener" event="start" />
  </extensionElements>
</intermediateThrowEvent>

信号抛出中间事件

<intermediateThrowEvent id="signal">
  <signalEventDefinition signalRef="newCustomerSignal" />
</intermediateThrowEvent>

异步信号事件

<intermediateThrowEvent id="signal">
  <signalEventDefinition signalRef="newCustomerSignal" flowable:async="true" />
</intermediateThrowEvent>

补偿抛出中间事件

<intermediateThrowEvent id="throwCompensation">
    <compensateEventDefinition />
</intermediateThrowEvent>

另外，activityRef可选项用于为指定的范围或活动触发补偿：

<intermediateThrowEvent id="throwCompensation">
    <compensateEventDefinition activityRef="bookHotel" />
</intermediateThrowEvent>

三、顺序流

顺序流（sequence flow）是流程中两个元素间的连接器。在流程执行过程中，一个元素被访问后，会沿着其所有出口顺序流继续执行。这意味着BPMN 2.0默认是并行执行的：两个出口顺序流就会创建两个独立的、并行的执行路径。

<sequenceFlow id="flow1" sourceRef="theStart" targetRef="theTask" />

1、条件顺序流

<sequenceFlow id="flow" sourceRef="theStart" targetRef="theTask">
  <conditionExpression xsi:type="tFormalExpression">
    <![CDATA[${order.price > 100 && order.price < 250}]]>
  </conditionExpression>
</sequenceFlow>

可以省略xsi:type定义。

目前conditionExpressions只能使用UEL。

2、默认顺序流

只有当没有其他顺序流可以选择时，才会选择默认顺序流作为活动的出口顺序流，流程会忽略默认顺序流上的条件。

活动的默认顺序流由该活动的default属性定义。

<exclusiveGateway id="exclusiveGw" name="Exclusive Gateway" default="flow2" />

<sequenceFlow id="flow1" sourceRef="exclusiveGw" targetRef="task1">
    <conditionExpression xsi:type="tFormalExpression">${conditionA}</conditionExpression>
</sequenceFlow>

<sequenceFlow id="flow2" sourceRef="exclusiveGw" targetRef="task2"/>

<sequenceFlow id="flow3" sourceRef="exclusiveGw" targetRef="task3">
    <conditionExpression xsi:type="tFormalExpression">${conditionB}</conditionExpression>
</sequenceFlow>

四、网关

网关用于控制执行的流向。

1、排他网关

当执行到这个网关时，会按照所有出口顺序流定义的顺序对它们进行计算，选择第一个条件计算为true的顺序流。

排他网关用内部带有“X”的标准网关（菱形）表示。

<exclusiveGateway id="exclusiveGw" name="Exclusive Gateway" />

<sequenceFlow id="flow2" sourceRef="exclusiveGw" targetRef="theTask1">
  <conditionExpression xsi:type="tFormalExpression">${input == 1}</conditionExpression>
</sequenceFlow>

<sequenceFlow id="flow3" sourceRef="exclusiveGw" targetRef="theTask2">
  <conditionExpression xsi:type="tFormalExpression">${input == 2}</conditionExpression>
</sequenceFlow>

<sequenceFlow id="flow4" sourceRef="exclusiveGw" targetRef="theTask3">
  <conditionExpression xsi:type="tFormalExpression">${input == 3}</conditionExpression>
</sequenceFlow>

2、并行网关

这可以外将执行分支为多条路径 ，也可以合并多条入口路径的执行。

（1）所有的出口顺序流都并行执行，为每一条顺序流创建一个并行执行。

（2）所有到达并行网关的并行执行都会在网关处等待，直到每一条入口顺序流都到达有个执行。然后流程经过该合并网关继续。

并行网关，用内部带加事情图标的网关（菱形）表示。

<parallelGateway id="myParallelGateway" />

3、包容网关

可以把包容网关看作排他网关与并行网关的组合，与排他网关一样，可以在包容网关的出口顺序流上定义条件，包容网关会计算条件。然而主要的区别是，包容网关与并行网关一样，可以同时选择多于一条出口顺序深沟高垒 。

包容网关，用内部带有圆圈的图标的网关（菱形）表示。

<inclusiveGateway id="myInclusiveGateway" />

4、基于事件的网关

当流程执行到达基于事件的网关时，与等待状态类似，网关会暂停执行，燕且为每个出口顺序流创建一个事件订阅。

基于事件的网磁，用内部有五边形加两圆的网关（菱形）表示。

XML元素为eventBasedGateway。

五、任务

1、用户任务

用于对需要人工执行的任务进行建模，当流程执行到达用户任务时，会为指派至该任务的用户或组的任务列表创建一个新任务。

用户任务用左上角有一个小用户图标的标准任务（圆角矩形）表示。

<userTask id="theTask" name="Important task" />

任务BPMN 2.0元素都可以有描述，描述由documentation元素定义。

<userTask id="theTask" name="Schedule meeting" >
  <documentation>
      Schedule an engineering meeting for next week with the new hire.
  </documentation>

可以使用标准java方式获取描述文本

task.getDescription()

（1）到期日期

可以在任务定义中使用表达式设定到期日期，该表达式必须解析为java.util.Date、java.util.String(ISO8601格式)、ISO8601时间长度（例如PT50M）或者null。

<userTask id="theTask" name="Important task" flowable:dueDate="${dateVariable}"/>

任务的到期日期也可以使用TaskService或者TaskListener中使用传递的DelegateTask修改。

（2）用户指派

可以定义humanPerformer子元素来实现，humanPerformer需要resourceAssignmentExpression来实际定义用户。目前，只支持formalExpressions。

<process >

  ...

  <userTask id='theTask' name='important task' >
    <humanPerformer>
      <resourceAssignmentExpression>
        <formalExpression>kermit</formalExpression>
      </resourceAssignmentExpression>
    </humanPerformer>
  </userTask>

只能指定一个用户作为任务的humanPerformer，在Flowable术语中，这个用户被称为办理人（assignee）。可以通过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结构的任务。

 List<Task> tasks = taskService.createTaskQuery().taskCandidateUser("kermit");

如果未指定给定字符串是用户还是组，引擎默认其为组。

当指派关系不复杂时，为避免这种复杂性，可以在用户任务上使用自定义扩展。

<userTask id="theTask" name="my task" flowable:assignee="kermit" />
<userTask id="theTask" name="my task" flowable:candidateUsers="kermit, gonzo" />
<userTask id="theTask" name="my task" flowable:candidateGroups="management, accountancy" />

Flowable支持的身份关联类型有

public class IdentityLinkType {
  /* Flowable内置角色 */
  public static final String ASSIGNEE = "assignee";
  public static final String CANDIDATE = "candidate";
  public static final String OWNER = "owner";
  public static final String STARTER = "starter";
  public static final String PARTICIPANT = "participant";
}

2、脚本任务

当流程执行到达脚本任务时，会执行相应的脚本 。

脚本任务用左上角有一个小“脚本”的图标表示。

<scriptTask id="theScriptTask" name="Execute script" scriptFormat="groovy">
  <script>
    sum = 0
    for ( i in inputArray ) {
      sum += i
    }
  </script>
</scriptTask>

scriptFormat属性的值，必须是兼容JSR-223的名字，默认情况下，JavaScript包含在每一个JDK中，因此不需要添加任何jar。而使用groovy，需要添加如下依赖

<dependency>
    <groupId>org.codehaus.groovy</groupId>
    <artifactId>groovy-all</artifactId>
    <version>2.x.x<version>
</dependency>

（1）脚本中的变量

到达脚本引擎的执行中，所有的流程变量都可以在脚本中使用。也可以简单地调用 execution.serVariable("variableName",variableValue)。

（2）脚本任务的结果

脚本任务的返回值 ，可以通过脚本任务定义的flowable:resultVariable属性设置为流程变量。

<scriptTask id="theScriptTask" name="Execute script" scriptFormat="juel" flowable:resultVariable="myVar">
  <script>#{echo}</script>
</scriptTask>

3、Java服务任务

用于调用Java类。

左上角有一个小齿轮图标的圆角矩形表示。

有四种方法声明如何调用 Java逻辑：

（1）指定实现了JavaDelegate或ActivityBehavior的类

（2）调用解析为委托对象（delegation object）的表达式

（3）调用方法表达式（method expression）

（4）对值表达式（value expression）求值

<serviceTask id="javaService"
             name="My Java Service Task"
             flowable:class="org.flowable.MyJavaDelegate" />
<serviceTask id="serviceTask" flowable:delegateExpression="${delegateExpressionBean}" />
<serviceTask id="javaService"
             name="My Java Service Task"
             flowable:expression="#{printer.printMessage()}" />

4、Web服务任务

用于同步地调用外部的Web服务。

与Java服务任务图标一样。

使用Web服务之前，需要导入其操作及复杂的类型，可以使用导入标签指向Web服务的WSDL。

<import importType="http://schemas.xmlsoap.org/wsdl/"
	location="http://localhost:63081/counter?wsdl"
	namespace="http://webservice.flowable.org/" />

5、业务规则任务

用于同步地执行一条或多条规则，Flowable使用名为Drools Expert的Drools规则引擎执行业务规则。

图标显示为带有表格图标的圆角矩形。

6、邮件任务

可以向一个或多个收信人发送邮件。

7、Http任务

用于发出HTT请求，注意Http任务不是BPMN 2.0规范任务。

8、Mule任务

可以向Mule发送消息，不是BPMN 2.0规范任务。

9、Camel任务，可以向Camel发送消息，不是BPMN 2.0规范任务。