让我们看一个用序列连接状态 和转移的例子。

<process name="StateSequence" xmlns="http://jbpm.org/4.3/jpdl">  <start>    <transition to="a" />  </start>  <state name="a">    <transition to="b" />  </state>  <state name="b">    <transition to="c" />  </state>  <state name="c" /></process>

下列代码将启动一个流向：

ProcessInstance processInstance =    executionService.startProcessInstanceByKey("StateSequence");

创建的流程处理实例会停留在状态节点a的位置， 使用signalExecution方法就会触发 一个外部触发器。

Execution executionInA = processInstance.findActiveExecutionIn("a");assertNotNull(executionInA);processInstance = executionService.signalExecutionById(executionInA.getId());Execution executionInB = processInstance.findActiveExecutionIn("b");assertNotNull(executionInB);processInstance = executionService.signalExecutionById(executionInB.getId());Execution executionInC = processInstance.findActiveExecutionIn("c");assertNotNull(executionInC);

在第2个状态节点的例子里， 我们将演示如何使用状态节点实现 路径的选择。

<process name="StateChoice" xmlns="http://jbpm.org/4.3/jpdl">  <start>    <transition to="wait for response" />  </start>  <state name="wait for response">    <transition name="accept" to="submit document" />    <transition name="reject" to="try again" />  </state>  <state name="submit document" />  <state name="try again" /></process>

让我们在这个流程处理定义里启动一个新的流程实例。

ProcessInstance processInstance = executionService    .startProcessInstanceByKey("StateChoice");

现在，流向到达wait for response状态节点了。 流向会一直等待到外部触发器的出现。 这里的状态节点拥有多个向外的转移， 外部触发器将为向外的转移提供不同的信号名（signalName）， 下面我们将提供accept信号名（signalName）：

String executionId = processInstance    .findActiveExecutionIn("wait for response")    .getId();processInstance = executionService.signalExecutionById(executionId, "accept");assertTrue(processInstance.isActive("submit document"));

流向会沿着名字是accept的向外的转移继续进行。 同样，当使用reject作为参数触发signalExecutionXxx方法时。流 向会沿着名字是reject的向外的转移 继续进行。

decision中会运行并判断每一个transition里的判断条件。 当遇到一个嵌套条件是true或者没有设置判断条件的转移， 那么转移就会被运行。

例子：

<process name="DecisionConditions" >  <start>    <transition to="evaluate document" />  </start>  <decision name="evaluate document">    <transition to="submit document">      
							<condition expr="#{content=="good"}" />
						    </transition>    <transition to="try again">      
							<condition expr="#{content=="not so good"}" />
						    </transition>    <transition to="give up" />  </decision>  <state name="submit document" />  <state name="try again" />  <state name="give up" /></process>

在使用 good content 启动一个流程之后

Map<String, Object> variables = new HashMap<String, Object>();variables.put("content", "good");ProcessInstance processInstance =    executionService.startProcessInstanceByKey("DecisionConditions", variables);

submit document 活动会变成活动的

assertTrue(processInstance.isActive("submit document"));

参考实例中的单元测试，了解更多的场景。

decision表达式返回类型为字符串的 向外转移的名字。

例子：

<process name="DecisionExpression" xmlns="http://jbpm.org/4.3/jpdl">  <start >    <transition to="evaluate document"/>  </start>  <decision name="evaluate document" 
							expr="#{content}"
						 >    <transition 
							name="good"
						 to="submit document"  />    <transition 
							name="bad"
						  to="try again"  />    <transition 
							name="ugly"
						 to="give up"  />  </decision>  <state name="submit document"  />  <state name="try again"  />  <state name="give up"  /></process>

当你使用good content启动一个新的流程实例，代码如下：

Map<String, Object> variables = new HashMap<String, Object>();variables.put("content", "good");ProcessInstance processInstance =    executionService.startProcessInstanceByKey("DecisionExpression", variables);

然后新流程会到达 submit document 活动。

参考实例中的单元测试，获得其他场景。

唯一性管理是继承了DecisionHandler接口的java类。 决定处理器负责选择 向外转移。

public interface DecisionHandler {   String decide(OpenExecution execution);}

这个handler被列为decision的子元素。 配置属性和decision的 handler 的内容元素 可以在 第 6.7 节 “用户代码” 中找到。

下面是一个决定使用DecisionHandler的流程处理例子：

<process name="DecisionHandler">  <start>    <transition to="evaluate document" />  </start>  <decision name="evaluate document">    <handler class="org.jbpm.examples.decision.handler.ContentEvaluation" />    <transition name="good" to="submit document" />    <transition name="bad" to="try again" />    <transition name="ugly" to="give up" />  </decision>  <state name="submit document" />  <state name="try again" />  <state name="give up" /></process>

下面是ContentEvalation类：

public class ContentEvaluation implements DecisionHandler {  public String decide(OpenExecution execution) {    String content = (String) execution.getVariable("content");    if (content.equals("you're great")) {      return "good";    }    if (content.equals("you gotta improve")) {      return "bad";    }    return "ugly";  }}

当你启动流程处理实例， 并为变量content提供值you're great时， ContentEvalation就会返回字符串good， 流程处理实例便会到达Submit document活动。

默认情况下，结束活动会终结已完成流程处理实例。 因此在流程处理实例中， 仍然在活动的多个并发（concurrent）流向（concurrent） 也会结束。

<process name="EndProcessInstance" xmlns="http://jbpm.org/4.3/jpdl">  <start>    <transition to="end" />  </start>  <end name="end" /></process>

新的流程处理实例一创建便会直接结束。

只有流向到达结束（end）活动时会结束流程处理实例， 并且其他并发流向会放弃活动。 我们可以设置属性ends="execution" 来达到这种状况。

一个流程处理可以有多个end events， 这样就很容易显示出流程处理实例的不同结果。示例：

<process name="EndMultiple" xmlns="http://;jbpm.org/4/jpdl">  <start>    <transition to="get return code" />  <start>  <state name="get return code">    <transition name="200" to="ok"/>    <transition name="400" to="bad request"/>    <transition name="500" to="internal server error"/>  </state>  <end name="ok"/>  <end name="bad request"/>  <end name="internal server error"/></process>        

如果你启动一个流向并使用下面的代码将它执行到get return code等待状态， 流向便会以bad request的end 活动（event）结束

ProcessInstance processInstance = executionService.startProcessInstanceByKey("EndMultiple");String pid = processInstance.getId();processInstance = executionService.signalExecutionById(pid, "400");

同样地，使用值为200或者500就会让流向（execution） 分别以ok或者internal server error的end events结束。

流向（execution）可以以不同的状态结束。可以用其他的方式列出流程处理实例的结果。 可以用end event的状态属性或者end-cancel 和end-error表示。

参考下面流程的例子。

<process name="EndState" xmlns="http://jbpm.org/4.3/jpdl">  <start>     <transition to="get return code"/>  </start>  <state name="get return code">    <transition name="200" to="ok"/>    <transition name="400" to="bad request" />    <transition name="500" to="internal server error"/>  </state>  <end name="ok" state="completed"/>  <end-cancel name="bad request"/>  <end-error name="internal server error"/></process>        

这时，如果我们启动一个流向并使用下面的代码将流向执行到get return code等待状态， 流向会以取消状态（cancel state）结束。

和上面一样，使用值为200或500会让流向 分别以comleted或者error states结束。

一个简单的任务会被分配给一个指定的用户

<process name="TaskAssignee">  <start>    <transition to="review" />  </start>  <task name="review"        
							assignee="#{order.owner}"
						>     <transition to="wait" />  </task>  <state name="wait" /></process>

这个流程演示了任务分配的两个方面。第一， assignee 用来指示用户， 负责完成任务的人。分配人是一个任务中的字符串属性 引用一个用户。

第二，这个属性默认会当做表达式来执行。 在这里任务被分配给 #{order.owner} 。 这意味着首先使用order这个名字查找一个对象。 其中一个查找对象的地方是这个任务对应的流程变量。 然后 getOwner() 方法会用来 获得用户id， 引用的用户负责完成这个任务。

这就是我们例子中使用到得Order类：

public class Order implements Serializable {  String owner;  public Order(String owner) {    this.owner = owner;  }  public String getOwner() {    return owner;  }  public void setOwner(String owner) {    this.owner = owner;  }}

当一个新流程实例会被创建， 把order作为一个流程变量分配给它。

Map<String, Object> variables = new HashMap<String, Object>();variables.put("order", new Order("johndoe"));ProcessInstance processInstance = executionService    .startProcessInstanceByKey("TaskAssignee", variables);

然后 johndoe 的任务列表可以像下面这样获得。

List<Task> taskList = taskService.findPersonalTasks("johndoe");

注意也可以使用纯文本， assignee="johndoe" 。 在这里，任务会被分配给johndoe。

任务可能被分配给一组用户。 其中的一个用户应该接受这个任务并完成它。

这是一个使用任务候选人的示例流程：

<process name="TaskCandidates">  <start>    <transition to="review" />  </start>  <task name="review"        
							candidate-groups="sales-dept"
						>     <transition to="wait" />  </task>  <state name="wait"/></process>        

在启动之后，一个任务会被创建。这个任务不显示在任何人的个人任务列表中。 下面的任务列表会是空的。

taskService.getAssignedTasks("johndoe");taskService.getAssignedTasks("joesmoe");

但是任务会显示在所有 sales-dept 组成员的 分组任务列表中。

在我们的例子中， sales-dept 有两个成员：johndoe和joesmoe

identityService.createGroup("sales-dept");identityService.createUser("johndoe", "johndoe", "John", "Doe");identityService.createMembership("johndoe", "sales-dept");identityService.createUser("joesmoe", "joesmoe", "Joe", "Smoe");identityService.createMembership("joesmoe", "sales-dept"); 

所以在流程创建后， 任务会出现在johndoe和joesmoe用户的分组任务列表中。

taskService.findGroupTasks("johndoe");taskService.findGroupTasks("joesmoe");

候选人必须接受一个任务，在他们处理它之前。 这会表现为两个候选人在同一个任务上开始工作。 分组任务列表中，用户接口必须只接受对这些任务的“接受”操作。

taskService.takeTask(task.getDbid(), "johndoe");

当一个用户接受了一个任务，这个任务的分配人就会变成当前用户。 任务会从所有候选人的分组任务列表中消失， 它会出现在用户的已分配列表中。

用户只允许工作在他们的个人任务列表上。 这应该由用户接口控制。

简单的， candidate-users 属性 可以用来处理用逗号分隔的一系列用户id。 candidate-users 属性可以和其他分配选项结合使用。

一个 AssignmentHandler 可以通过编程方式来计算 一个任务的分配人和候选人。

public interface 
							AssignmentHandler
						 extends Serializable {  /** sets the actorId and candidates for the given assignable. */  void assign(Assignable assignable, OpenExecution execution) throws Exception;}

Assignable 是任务和泳道的通用接口。 所以任务分配处理器可以使用在任务， 也可以用在泳道中（参考后面的内容）。

assignment-handler 是任务元素的一个子元素。 它指定用户代码对象。所以 assignment-handler 的属性和元素 都来自 第 6.7 节 “用户代码”

让我们看一下任务分配的例子流程。

<process name="TaskAssignmentHandler" xmlns="http://jbpm.org/4.3/jpdl">  <start g="20,20,48,48">    <transition to="review" />  </start>  <task name="review" g="96,16,127,52">    
							<assignment-handler class="org.jbpm.examples.task.assignmenthandler.AssignTask">      <field name="assignee">        <string value="johndoe" />      </field>    </assignment-handler>
						    <transition to="wait" />  </task>  <state name="wait" g="255,16,88,52" /></process>

引用的类 AssignTask 看起来像这样：

public class AssignTask implements AssignmentHandler {  String assignee;  public void assign(Assignable assignable, OpenExecution execution) {    assignable.setAssignee(assignee);  }}

请注意，默认AssignmentHandler实现可以使用使用流程变量 任何其他Java API可以访问资源，像你的应用数据库来计算 分配人和候选人用户和组。

启动一个 TaskAssignmentHandler 的新流程实例 会立即让新流程实例运行到任务节点。 一个新 review 任务被创建，在这个时候 AssignTask 的分配处理器被调用。这将设置 johndoe 为分配人。 所以John Doe将在他自己的任务列表中找到这个任务。

一个流程中的多任务应该被分配给同一个用户或换选人。 一个流程中的多任务可以分配给一个单独的泳道。 流程实例将记得换选人和用户，在泳道中执行的第一个任务。 任务序列在同一个泳道中将被分配给 这些用户和候选人。

一个泳道也可以当做一个流程规则。 在一些情况下， 这可能与身份组件中的权限角色相同。 但是实际上它们并不是同一个东西。

泳道可以被声明在流程元素中：

任务泳道示例是下面这个流程文件：

<process name="TaskSwimlane" xmlns="http://jbpm.org/4.3/jpdl">  
							<swimlane name="sales representative"            candidate-groups="sales-dept" />
						  <start>    <transition to="enter order data" />  </start>  <task name="enter order data"        
							swimlane="sales representative"
						>    <transition to="calculate quote"/>  </task>  <task      name="calculate quote"      
							swimlane="sales representative"
						>  </task></process>

在这个例子中，我们在身份组件中 创建了下面的信息：

identityService.createGroup("sales-dept");identityService.createUser("johndoe", "johndoe", "John", "Doe");identityService.createMembership("johndoe", "sales-dept");

在启动一个新流程实例后，用户 johndoe 将成为 enter order data 的一个候选人。还是像上一个流程候选人例子一样， John Doe可以像这样接收任务：

taskService.takeTask(taskDbid, "johndoe");

接收这个任务将让 johndoe 成为任务的分配人。 直到任务与泳道 sales representative 关联， 分配人 johndoe 也会关联到泳道中 作为分配人。

接下来，John Doe可以像下面这样完成任务：

taskService.completeTask(taskDbid);

完成任务会将流程执行到下一个任务， 下一个任务是 calculate quote 。 这个任务也关联着泳道。因此， 任务会分配给 johndoe 。 初始化分配的候选人用户和候选人组也会从泳道复制给任务。 这里所指的用户 johndoe 会释放任务，返回它给其他候选人。

任务可以读取，更新流程变量。 稍后任务可以选择定义任务本地流程变量。 任务变量是任务表单的一个很重要的部分。 任务表单显示来自任务和流程实例的数据。 然后从用户一侧录入的数据会转换成设置的任务变量。

获得任务变量就像这样：

List<Task> taskList = taskService.findPersonalTasks("johndoe");Task task = taskList.get(0);long taskDbid = task.getDbid();Set<String> variableNames = taskService.getVariableNames(taskDbid);Map<String, Object> variables = taskService.getVariables(taskDbid, variableNames);

设置任务变量就像这样：

variables = new HashMap<String, Object>();variables.put("category", "small");variables.put("lires", 923874893);taskService.setVariables(taskDbid, variables);

可以为分配人提供一个提醒， 当一个任务添加到他们的列表时，以及在特定的时间间隔进行提醒。 每个email信息都是根据一个模板生成出来的。模板可以在内部指定， 或者在配置文件中的 process-engine-context 部分指定。

这里有一个基本的例子，可以获得默认的模板。

<task name="review"      assignee="#{order.owner}"     <notification/>     <reminder duedate="2 days" repeat="1 day"/></task>

这个SubProcessVariables示例场景将展示子流程获得基本工作方式， 如何向子流程中反馈信息，当它启动时， 如果从子流程中导出信息，当它结束时。

上级流程调用一个需要重审的文档。

<process name="SubProcessDocument" xmlns="http://jbpm.org/4.3/jpdl">  <start>    <transition to="review" />  </start>  
							<sub-process name="review"               sub-process-key="SubProcessReview">    <variable name="document" init="#{document}" />    <out-variable name="reviewResult" init="#{result}" />    <transition to="wait" />  </sub-process>
						  <state name="wait"/></process>

重审流程是一个可以对所有类型的重审工作重用的流程。

<process name="SubProcessReview" xmlns="http://jbpm.org/4.3/jpdl">  <start>    <transition to="get approval"/>  </start>  <task name="get approval"        assignee="johndoe">    <transition to="end"/>  </task>  <end name="end" /></process>

文档流程被启动，并授予一个文档变量：

Map<String, Object> variables = new HashMap<String, Object>();variables.put("document", "This document describes how we can make more money...");ProcessInstance processInstance = executionService    .startProcessInstanceByKey("SubProcessDocument", variables);

然后上级流程会到达子流程节点。 一个子流程会被创建并关联到上级流程中。 当 SubProcessReview 流程实例启动时， 它到达了 task 。 一个任务会为 johndoe 创建。

List<Task> taskList = taskService.findPersonalTasks("johndoe");Task task = taskList.get(0);

我们可以看到文档已经被通过， 从上级流程实例到子流程实例：

String document = (String) taskService.getVariable(task.getDbid(), "document");assertEquals("This document describes how we can make more money...", document);

然后我们在任务上设置一个变量。这一般都是通过一个表单来完成。 但是这是我们将演示如何使用编程方式完成。

Map<String, Object> variables = new HashMap<String, Object>();variables.put("result", "accept");taskService.setVariables(task.getDbid(), variables);

完成这个任务，会导致子流程实例结束。

taskService.completeTask(task.getDbid());

当子流程结束时，上级流程会被signal标记（不是notify提醒）。 首先 result 变量会从子流程复制到 父流程的 reviewResult 变量中。 然后上级流程会继续， 并离开review活动。

在 SubProcessOutcomeValueTest 示例中， 子流程实例变量的值被用来选择 sub-process 活动 的外出流向。

<process name="SubProcessDocument">  <start>    <transition to="review" />  </start>  <sub-process name="review"               sub-process-key="SubProcessReview"               
							outcome="#{result}"
						>    <transition 
							name="ok"
						 to="next step" />    <transition 
							name="nok"
						 to="update" />    <transition 
							name="reject"
						 to="close" />  </sub-process>  <state name="next step" />  <state name="update" />  <state name="close" /></process>

这个 SubProcessReview 和上面的 子流程变量示例 相同：

<process name="SubProcessReview" xmlns="http://jbpm.org/4.3/jpdl">  <start>    <transition to="get approval"/>  </start>  <task name="get approval"        assignee="johndoe">    <transition to="end"/>  </task>  <end name="end" /></process>

一个新文档实例会像通常一样启动：

ProcessInstance processInstance = executionService    .startProcessInstanceByKey("SubProcessDocument");

任务被获得到 johndoe 的任务列表中

List<Task> taskList = taskService.findPersonalTasks("johndoe");Task task = taskList.get(0);        

然后 result 变量被设置， 任务完成。

Map<String, Object> variables = new HashMap<String, Object>();variables.put("result", "ok");taskService.setVariables(task.getId(), variables);taskService.completeTask(task.getDbid());

在这个场景中， ok 流向被获取在上级流程中 在子流程复审活动外。 这个例子测试用例也展示了其他场景。

一个流程可以有多个结束节点。在 SubProcessOutcomeActivityTest 示例中， 结果的结束节点被用来选择 sub-process 活动的 外出流向。

<process name="SubProcessDocument">  <start>    <transition to="review" />  </start>  <sub-process name="review"               sub-process-key="SubProcessReview">    <transition 
							name="ok"
						 to="next step" />    <transition 
							name="nok"
						 to="update" />    <transition 
							name="reject"
						 to="close" />  </sub-process>  <state name="next step" />  <state name="update" />  <state name="close" /></process>

这个 SubProcessReview 现在拥有多个结束活动：

<process name="SubProcessReview" xmlns="http://jbpm.org/4.3/jpdl">  <start>    <transition to="get approval"/>  </start>  <task name="get approval"        assignee="johndoe">    <transition name="ok" to="ok"/>    <transition name="nok" to="nok"/>    <transition name="reject" to="reject"/>  </task>  
							<end name="ok" />  <end name="nok" />  <end name="reject" />
						</process>

一个新文档流程实例像通常一样被启动：

ProcessInstance processInstance = executionService    .startProcessInstanceByKey("SubProcessDocument");

任务被获取到 johndoe 的任务列表中

List<Task> taskList = taskService.findPersonalTasks("johndoe");Task task = taskList.get(0);        

任务会在 ok 结束。

taskService.completeTask(task.getDbid(), "ok");        

这将导致子流程结束在 ok 结束活动。 上级节点会通过 ok 流向 进入 next step 。

这个示例测试用例也展示了其他场景。

script脚本提供expr属性。 这个短小的符号在属性里比在文本元素里表达更简单。 如果没有指定语言（lang）会使用 默认的表达式语言（default-expression-language）。

在下一个例子中，我们会看到script脚本如何 使用表达式活动和返回结果怎样存储在variable变量里。

<process name="ScriptExpression" xmlns="http://jbpm.org/4.3/jpdl">  <start>    <transition to="invoke script" />  </start>  
							<script name="invoke script"          expr="Send packet to #{person.address}"          var="text">
						    <transition to="wait" />  
							</script>
						  <state name="wait"/></process>

这个例子使用了person类，代码如下：

public class Person implements Serializable {  String address;  public Person(String address) {    this.address = address;  }  public String getAddress() {    return address;  }  public void setAddress(String address) {    this.address = address;  }}

当为这个流程处理启动一个流程处理实例时， 我们提供一个的person的地址属性的变量。

Map<String, Object> variables = new HashMap<String, Object>();variables.put("
							person
						", 
							new Person("Honolulu")
						);executionService.startProcessInstanceByKey("ScriptText", variables);

然后script脚本活动中的整个流向， 变量中将包含'Send packet to Honolulu'

第2种方式是用text元素指定script脚本。 当script text有多行的时候这种方式更方便。

例如：

<process name="ScriptText" xmlns="http://jbpm.org/4.3/jpdl">  <start>    <transition to="invoke script" />  </start>  
							<script name="invoke script"          var="text">    <text>      Send packet to #{person.address}    </text>
						    <transition to="wait" />  
							</script>
						  <state name="wait"/></process>