`
feohoo
  • 浏览: 112606 次
  • 性别: Icon_minigender_1
  • 来自: 武汉
社区版块
存档分类
最新评论

第 6 章 jPDL

阅读更多

这章将会解释用来描述流程定义的 jPDL文件格式。jDPL是jBPM的突出的流程语言。jPDL的目标 是尽量精简和尽可能的开发者友好,在提供所有你期望 从BPM流程语言中获得功能的同时。

jPDL的schema文件包含了比这个文档中更多的属性和元素。 这个文档解释了jPDL中稳定的被支持的部分。 试验性的、不支持的jPDL特性可以在开发者指南中找到。

下面是一个jPDL流程文件的例子:

<?xml version="1.0" encoding="UTF-8"?>

<process name="Purchase order" xmlns="http://jbpm.org/4.4/jpdl">

  <start>
    <transition to="Verify supplier" />
  </start>

  <state name="Verify supplier">
    <transition name="Supplier ok" to="Check supplier data" />
    <transition name="Supplier not ok" to="Error" />
  </state>

  <decision name="Check supplier data">
    <transition name="nok" to="Error" />
    <transition name="ok" to="Completed" />
  </decision>

  <end name="Completed" />

  <end name="Error" />

</process>

6.1. process流程处理

顶级元素(element)是流程处理定义。

表 6.1. process流程处理的属性

属性 类型 默认值 是否必须 描述
name名称 文本   必须 在与用户交互时, 作为流程名字显示的一个名字或是标签。
key键 字母或数字,下划线 如果省略,key中的非字母和非数字的字符会被替换为 下划线。 可选(optional) 用来辨别不同的流程定义。 拥有同一个key的流程会有多个版本。 对于所有已发布的流程版本,key-name这种组合都必须是 完全一样的。
version版本 整型 比已部署的key相同的流程版本号高1, 如果还没有与之相同的key的流程被部署,那么版本就从1开始。 可选 流程的版本号

表 6.2. process流程的元素

元素 个数 描述
description描述 0个或1个 描述文本
activities活动 至少1个 流程中会有很多活动, 至少要有1个是启动的活动。

 

6.2. 控制流程Activities活动

6.2.1. start启动

说明一个流程的实例从哪里开始。 在一个流程里必须有一个开始节点。 一个流程必须至少拥有一个开始节点。 开始节点必须有一个向外的流向,这个流向会在流程启动的时候执行。

已知的限制:直到现在, 一个流程处理只能有一个启动节点(start)。

表 6.3. start启动的属性

属性 类型 默认值 是否必须 描述
name名称 文本   可选 活动的名字,在启动活动没有内部的转移(transition)时, name名称是可选的。

表 6.4. start启动的元素

元素 个数 描述
transition转移 1 向外的转移

 

6.2.2. State状态节点

一个等待状态节点。 流程处理的流向会在外部触发器调用提供的API之前一直等待。 状态节点和其他的活动不一样, 它没有其他任何属性或元素。

6.2.2.1. 序列状态节点

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

序列状态节点

图 6.1. 序列状态节点


<process name="StateSequence" xmlns="http://jbpm.org/4.4/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);

6.2.2.2. 可选择的状态节点

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

状态节点中的选择

图 6.2. 状态节点中的选择


<process name="StateChoice" xmlns="http://jbpm.org/4.4/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的向外的转移 继续进行。

6.2.3. decision决定节点

在多个选择中选择一条路径。也可以当做是一个决定。 一个决定活动拥有很多个向外的转移。当一个流向到达一个决定活动时, 会自动执行并决定交给哪个向外的转移。

一个决定节点应该配置成下面三个方式之一。

6.2.3.1. decision决定条件

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

表 6.5. exclusive.transition.condition 属性

属性 类型 默认值 是否必须? 描述
expr expression   required必须 将被运行的 指定脚本
lang expression language 脚本引擎配置里得到的默认代表性语言(default-expression-language) 可选 指定expr中执行的 脚本语言的种类

例子:

流程处理的决定条件例子

图 6.3. 流程处理的决定条件例子


<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"));

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

6.2.3.2. decision expression唯一性表达式

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

表 6.6. 决定属性

属性 类型 默认值 是否必须? 描述
expr expression   required必须 将被运行的指定 脚本
lang expression language 脚本引擎配置里得到的默认指定的脚本语言(default-expression-language) 可选 指定expr中执行的脚本语言的 种类。

例子:

流程处理的决定表达式例子

图 6.4. 流程处理的决定表达式例子


<process name="DecisionExpression" xmlns="http://jbpm.org/4.4/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活动。

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

6.2.3.3. Decision handler决定处理器

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

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

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

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

流程处理的exclusive管理例子

图 6.5. 流程处理的exclusive管理例子


<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活动。

6.2.4. concurrency并发

流程的并发路径可以使用 fork 和 join 活动来建模。下面的表格描述了 join 的属性;fork没有特别的属性。

表 6.7. join属性:

属性 类型 默认值 是否必须? 描述
multiplicity 整数或表达式 传入转移的数目 可选 在这个join活动之前需要到达的执行的数目, 然后一个执行 会沿着join的单独的外向转移向外执行。
lockmode {none, read, upgrade, upgrade_nowait, write} upgrade 可选 hibernate的锁定模式,应用在上级执行, 来防止两个还没到达join的同步事务看到对方, 这会导致死锁。

6.2.4.1. 使用 fork实现并行分支

fork 活动允许将一个单独的流程路径分成 两个或多个分支,这些流程分支可以同步执行。

流程处理的并发例子

图 6.6. 流程处理的并发例子


<process name="ConcurrencyGraphBased" xmlns="http://jbpm.org/4.4/jpdl">

   <start>
      <transition to="fork"/>
   </start>

   <fork name="fork">
      <transition to="send invoice" />
      <transition to="load truck"/>
      <transition to="print shipping documents" />
   </fork>

   <state name="send invoice" >
      <transition to="final join" />
   </state>

   <state name="load truck" >
      <transition to="shipping join" />
   </state>

   <state name="print shipping documents">
      <transition to="shipping join" />
   </state>

   <join name="shipping join" >
      <transition to="drive truck to destination" />
   </join>

   <state name="drive truck to destination" >
      <transition to="final join" />
   </state>

   <join name="final join" >
      <transition to="end"/>
   </join>

   <end name="end" />

</process>

6.2.5. end结束

结束流向

6.2.5.1. end process instance结束流程处理实例

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

结束活动

图 6.7. 结束活动


<process name="EndProcessInstance" xmlns="http://jbpm.org/4.4/jpdl">

  <start>
    <transition to="end" />
  </start>

  <end name="end" />

</process>

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

6.2.5.2. end execution结束流向

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

表 6.8. end execution属性

属性 类型 默认值 是否必须 描述
ends {processinstance|execution} processinstance optional可选 流向路径到达end活动 整个流程处理实例就会结束。

 

6.2.5.3. end multiple多个结束

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

多个end events

图 6.8. 多个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结束。

6.2.5.4. end State结束状态

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

表 6.9. end execution 属性

属性 类型 默认值 是否必须 描述
state String   可选 状态分配给流向

参考下面流程的例子。

不同的结束状态

图 6.9. 不同的结束状态


<process name="EndState" xmlns="http://jbpm.org/4.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" state="completed"/>
  <end-cancel name="bad request"/>
  <end-error name="internal server error"/>

</process>
        

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

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

6.2.6. task

在任务组件中,为一个人创建一个任务。

6.2.6.1. 任务分配者

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

表 6.10. 任务属性:

属性 类型 默认值 是否必填 描述
assignee 表达式   可选 用户id引用的用户 负责完成任务。

任务分配者示例流程

图 6.10. 任务分配者示例流程


<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。

6.2.6.2. task候选人

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

表 6.11. 任务属性:

属性 类型 默认值 是否必填 描述
candidate-groups 表达式   可选 一个使用逗号分隔的组id列表。 所有组内的用户将会成为这个任务的 候选人。
candidate-users 表达式   可选 一个使用逗号分隔的用户id列表。 所有的用户将会成为这个任务的候选人。

任务候选人示例流程

图 6.11. 任务候选人示例流程


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

<process name="TaskCandidates">

  <start>
    <transition to="review" />
  </start>

  <task name="review"
        candidate-groups="sales-dept">

     <transition to="wait" />
  </task>

  <state name="wait"/>

</process>
        

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

taskService.findPersonalTasks("johndoe");
taskService.findPersonalTasks("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属性可以和其他分配选项结合使用。

6.2.6.3. 任务分配处理器

一个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 节 “用户代码”

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

任务分配处理器的示例流程

图 6.12. 任务分配处理器的示例流程


<process name="TaskAssignmentHandler" xmlns="http://jbpm.org/4.4/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将在他自己的任务列表中找到这个任务。

6.2.6.4. 任务泳道

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

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

表 6.12. 任务属性:

属性 类型 默认值 是否必填 描述
swimlane 泳道(字符串)   可选 引用一个定义在流程中的泳道

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

表 6.13. 泳道属性:

属性 类型 默认值 是否必填 描述
name 泳道(字符串)   必填 泳道名称。 这个名称将被任务泳道属性中引用。
assignee 表达式   可选 用户id引用的用户 负责完成这个任务。
candidate-groups 表达式   可选 一个使用逗号分隔的组id列表。 所有组中的人将作为这个任务的这个泳道中的 候选人。
candidate-users 表达式   可选 一个使用逗号分隔的用户id列表。 所有的用户将作为这个任务的这个泳道中的 候选人。

任务泳道示例流程

图 6.13. 任务泳道示例流程


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

<process name="TaskSwimlane" xmlns="http://jbpm.org/4.4/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 会释放任务,返回它给其他候选人。

6.2.6.5. 任务变量

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

获得任务变量就像这样:

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);

6.2.6.6. 在任务中支持e-mail

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

表 6.14. task元素

元素 数目 描述
notification 0..1 让一个任务被分配的时候发送一个提醒消息。 如果没有引用模板,也没有提供内部的模板, mail会使用task-notification名字的模板。
reminder 0..1 根据指定的时间间隔发送提醒信息。 如果没有引用模板,也没有提供内部模板, mail会使用task-reminder名字的模板。

表 6.15. notification属性

属性 类型 默认值 是否必填 描述
continue {sync | async | exclusive} sync 可选 指定在发送提醒邮件后, 是不是产生一个异步执行。

表 6.16. reminder属性:

分享到:
评论

相关推荐

    jBPM jPDL 用户开发手册 - 第8章

    **jbPM jPDL 用户开发手册 - 第8章** jbPM(Java Business Process Management)是一个开源的工作流管理系统,用于在Java环境中实现业务流程自动化。它提供了丰富的API、工作流建模语言(jPDL)以及可视化工具,...

    jBPM jPDL 用户指南 (Version 3.2.3) - 第2章

    **jbPM jPDL 用户指南 (Version 3.2.3) - 第2章** jbPM(Java Business Process Management)是一种开源的工作流管理系统,专为Java开发者设计,它提供了业务流程建模、执行和监控的功能。jPDL(jBPM Process ...

    jPDL流程定义语言.doc

    【jPDL流程定义语言详解】 jPDL(Jboss Process Definition Language)是JBoss工作流框架中的流程定义语言,用于描述和定义业务流程。它使用XML格式来编写,允许开发者详细地定义流程中的各个步骤、决策点和事件...

    jbpm-jpdl-suite-3.2.3的安装配置

    6. 启动服务器目录下的JBoss实例,通过Web控制台监控和管理流程实例。 总的来说,jBPM-jPDL-suite-3.2.3提供了一套完整的工具集,使开发者能够轻松地定义、部署和管理业务流程,尤其适合那些希望在Java平台上实现...

    jbpm-jpdl.jar

    jbpm-jpdl.jar jbpm-jpdl.jar

    JBoss jBPM jPDL用户开发手册1.1

    **JBoss jBPM jPDL用户开发手册1.1** **JBoss jBPM** 是一个开源的工作流管理系统,由JBoss组织开发,旨在提供一个灵活且可扩展的平台来设计、执行和管理业务流程。它基于Java,兼容J2EE(Java 2 Platform, ...

    jbpm jpdl 帮助文档pdf版

    ### 6. Configuration #### 6.1 Customizing - **定制化**:如何根据具体需求对jBPM进行配置。 - **配置项**:如日志级别、事务管理等。 以上是基于给定的文件信息整理出的主要知识点,覆盖了jBPM和jpdl的基本概念...

    jBPM-JPDL流程引擎

    **jBPM-JPDL流程引擎详解** jBPM(Java Business Process Management)是一个开源的工作流和业务流程管理系统,主要用于实现企业的业务流程自动化。它基于Java技术,支持BPMN 2.0标准,提供了丰富的功能,包括流程...

    JBPM与BPMN配置及BPMN如何转化到JPDL

    JBPM与BPMN配置及BPMN如何转化到JPDL

    JPDL3.1规范手册[良少]

    6. **任务分配(task-assign)**:任务被分配给某用户时触发。 7. **任务开始(task-start)**:任务开始执行时触发。 8. **任务结束(task-end)**:任务完成时触发。 9. **执行转向前(before-signal)**:在流程...

    JBoss+jBPM+jPDL用户开发手册_3.2.3

    6. **事件处理**:学习如何定义和处理流程中的事件,如定时器事件、信号事件和错误处理。 7. **监控和审计**:掌握如何利用jBPM提供的监控工具跟踪流程实例,查看流程历史记录,以及进行性能分析。 8. **集成与...

    根据jbpm4的.jpdl.xml流程定义文件,绘制出流程图

    3. **创建流程图**:使用流程图工具(如Jbpm本身的Designer或第三方工具如PlantUML),根据JPDL文件中的信息手动或自动生成图形化表示。每个节点需要在图上正确放置,转换线连接它们,确保流程的逻辑清晰可见。 4. ...

    jbpm-jpdl-suite-3.2.GA.zip-6

    jbpm-jpdl-suite-3.2.GA.zip

    jBPM-4.3-jpdl 用户手册(中文)

    ### jBPM-4.3-jpdl 用户手册(中文)知识总结 #### 一、jBPM与jpdl概述 jBPM (Java Business Process Model) 是一款开源的工作流引擎,它支持业务流程管理(BPM)以及业务流程的设计、实现与执行。jBPM的最新版本...

    jbpm-jpdl-suite-3.2.3.zip

    jbpm-jpdl-suite-3.2.3.zipjbpm-jpdl-suite-3.2.3.zipjbpm-jpdl-suite-3.2.3.zipjbpm-jpdl-suite-3.2.3.zipjbpm-jpdl-suite-3.2.3.zipjbpm-jpdl-suite-3.2.3.zipjbpm-jpdl-suite-3.2.3.zipjbpm-jpdl-suite-3.2.3....

    jbpm-jpdl  

    jbpm-jpdl-3.2.3

    jBPM-jPDL学习笔记——流程设计与控制(转载)

    《jBPM-jPDL学习笔记——流程设计与控制》 在IT行业中,流程管理和自动化是企业提升效率的关键。jBPM(Java Business Process Management)是一个开源的工作流和业务流程管理套件,它允许开发者通过定义流程定义...

    jbpm-jpdl-3.2.3.zip

    6. **规则引擎集成**:jbpm可以与Drools等规则引擎结合,使流程决策可以根据预定义的规则动态变化。 7. **监控和管理**:jbpm提供了强大的监控和管理工具,可以查看运行中的流程实例,跟踪流程状态,以及对历史数据...

Global site tag (gtag.js) - Google Analytics