JBPM5的一些概念

 

人工任务分三部分：
1.运行一项 任务服务器，不仅启动了TaskServer,同时还加载了如群组，用户等数据。
2.启动一个 流程实例，这个类的功能是启动一个流程实例。
3. 人工处理某一个流程，获得某个User的任务列表，并执行某项任务。

1 taskserver 是一个独立服务器，用于解决human task， http://hi.baidu.com/%CB%A7%D0%A1%B7%B2/blog/item/0ac709c80040063fbe09e65c.html 请看这篇文章

2 jbpm-console-server 仅仅把它当做一个web控制台，可以启动流程，关闭流程等。所有它能提供的功能我想可以自己利用jbpm5的api做出来，高手可以基于它做出自己的流程执行监视系统

初次尝试JBPM5_写给新手[User Task]: http://hi.baidu.com/wwwwcf/item/fd2ea02c9aa7f3d60e37f95b

2.1. 创建知识库

Java代码  

1. KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();   
2. kbuilder.add( ResourceFactory.newClassPathResource("MyProcess.bpmn2"),   
3. ResourceType.BPMN2 );   
4. KnowledgeBase kbase = kbuilder.newKnowledgeBase();  

KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
kbuilder.add( ResourceFactory.newClassPathResource("MyProcess.bpmn2"),
ResourceType.BPMN2 );
KnowledgeBase kbase = kbuilder.newKnowledgeBase();

2.2. 创建会话启动流程
流程启动需要显式调用 startProcess 方法。

Java代码  

1. StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();   
2. ksession.startProcess("com.sample.hello");  

StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();
ksession.startProcess("com.sample.hello");

参数 com.sample.hello 代表流程 ID。
startProcess(String processId, Map parameters) 方法的 Map 参数可传入额外的参数,这些参数是键值对。注意这些参数将被复制到流程实例,作为流程的 顶级变量。顶级变量是指变量的作用或是顶级的。

2.3. 结点类型的细节解释
流程有如下属性:
ID: 惟一
NAME: 显示名称
VERSION: 版本
Package: 命名空间
Variables: 变量,用于传递数据
Swimlanes: 泳道(专用通道),指定执行人工任务的 actor
Connection Layout 连接布局
Manual :人工
Shortest path :最短路径
Manhattan:曼哈顿

BMPN 支持结点类型如下:
开始事件与结束事件: 开始事件与结束事件, 一个流程必须有一个开始事件,一个或多个结束事件。结束事件的 Terminate 如果为TRUE,那么将结束整个流程,否则若有多个结束事件只会结束对应结束事件的路径。

Rule Task 代表需要执行一组规则集。规则定义在多个分离的文件中,格式要求为 Drools rule format。规则可以成为标准规则流组的一部分通过在头部使用 ruleflow-group 属性。ruleflow-group 的执行可认为是一个队列。新来的必须等前面的执行完才会执行。

Diverging Gateway 分支结点,一进多出。Gateway 不好翻译,所以省略。
AND parallel 与,并行,两个都要满足(同步)
XOR or exclusive 异或,排斥,只选择其中一个
OR or inclusive 或,包含,至少只要有一个满足即可(不同步)

Converging Gateway 合并结点,多进一出。
AND parallel 与,并行,两个都要满足(同步)
XOR or exclusive 异或,排斥,只选择其中一个

Reusable Sub-Process 可复用子流程
Wait for completion 等待完成
On-entry and on-exit actions:绑定入口与出品 action.
Parameter in/out mapping: in 表示输入参数 out 表示输入参数和返回,只有当 Wait for completion 为 true 时,out 才可以使用。

Script Task 代表一个可执行的脚本。支持 Java , MVEL 方言。脚本绑定到 Action. Action: 绑定的 Action.

Timer Event 定时器事件,
Timer delay 延迟时间 ms

Error Event 异常事件
FaultName 异常处理器名
FaultVariable 异常变量

Message Event 消息事件, 没有输入
EventType 监听事件类型
VariableName 事件数据
Scope internal 流程内部事件 external 外部事件

User Task 用户任务(人工任务)
ActorId 责任人,多个人用逗号“,”分隔
GroupId 组,多个组用逗号“,”分隔
Skippable 表示这个任务是否可忽略,即不执行就结束。
Swimlane 泳道
On.entry /on-exit actions: 绑定入口、出口 Action
Parameter mapping 传入参数
Result mapping 返回结果
Content: 任务数据
Sub-Process 子流程
Multiple Instances 多实例子流程,特殊的子流程,允许执行多次
Service Task(Work Item node)代表一个抽象的任务。可通过它扩展任务。
Additional parameters 扩展参数定义。
Data 变量,顶级、子级,继承树
约束:包括代码约束和规则约束

Actions: Action 可以访问全局,流程变量,知识库上下文预定义变量,访问运行时,启动流程,分发事件,插入数据。

Events: 事件类型 - 事件监听(消息事件) - 事件处理(action)
事件分发: 内部事件 流程管理
外部事件: action

Timers: 定时器

更新流程

Java代码  

1. // create the session and start the process "com.sample.process"   
2. KnowledgeBuilder kbuilder = ...   
3. StatefulKnowledgeSession ksession = ...   
4. ProcessInstance processInstance = ksession.startProcess("com.sample.process");   
5. // add a new version of the process "com.sample.process2"   
6. kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();   
7. kbuilder.add(..., ResourceType.BPMN2);   
8. kbase.addKnowledgePackages(kbuilder.getKnowledgePackages());   
9. // migrate process instance to new version   
10. Map<String, Long> mapping = new HashMap<String, Long>();   
11. // top level node 2 is mapped to a new node with id 3   
12. mapping.put("2", 3L);   
13. // node 2, which is part of composite node 5, is mapped to a new node with id 4   
14. mapping.put("5.2", 4L);   
15. WorkflowProcessInstanceUpgrader.upgradeProcessInstance(   
16. ksession, processInstance.getId(),"com.sample.process2", mapping);  

// create the session and start the process "com.sample.process"
KnowledgeBuilder kbuilder = ...
StatefulKnowledgeSession ksession = ...
ProcessInstance processInstance = ksession.startProcess("com.sample.process");
// add a new version of the process "com.sample.process2"
kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
kbuilder.add(..., ResourceType.BPMN2);
kbase.addKnowledgePackages(kbuilder.getKnowledgePackages());
// migrate process instance to new version
Map<String, Long> mapping = new HashMap<String, Long>();
// top level node 2 is mapped to a new node with id 3
mapping.put("2", 3L);
// node 2, which is part of composite node 5, is mapped to a new node with id 4
mapping.put("5.2", 4L);
WorkflowProcessInstanceUpgrader.upgradeProcessInstance(
ksession, processInstance.getId(),"com.sample.process2", mapping);

人工任务/用户服务
流程包含的任务由人工角色来执行。用户任务代表一个有人工角色来执行的最初任务。它应该有一个输入连接和一个输出链接。用户任务可以被用来和 Swimlance 泳道相结合来给同一个角色分配多个人工任务。在 human tasks 章节可以查到更多的细节。一个用户服务就是一个服务节点特有类型。

人工任务规范 http://download.boulder.ibm.com/ibmdl/pub/software/dw/specs/ws-bpel4people/WS-HumanTask_v1.pdf
jBPM5 使用 UserTask 结点表示人工任务(需要与 actor 交互的任务)。
UserTask 任务结点支持定义任务类型、 actors 和任务关联的数据。通过 Task Service 可管理 UserTask。
为了使用人工任务,你必须定义 UserTask 结点。一个 UserTask 表示一个需要 actor 执行的自动化任务。人工任务其实可以简单认为是任何类型的外部服务。外部服务需要被调用,可看成特殊类型的 work item 实现。
人工任务惟一的特色是支持泳道来简化给用户分配任务。
UserTask 结点属性:
* Id: 结点惟一标识
* Name: 结点名称
* TaskName:  任务名称
* Priority:  优先级(整数)
* Comment:  任务注释
* ActorId: actor, 多个使用逗号","分隔
* Skippable: 任务可跳过(不执行就结束)
* Content: 任务关联的数据
* Swimlane:  泳道（专用通道）,可以简化分配多个人工任务给同一个actor
* Wait for completion: 是否等待人工任务执行完成,若为 False,则创建完人工任务后继续流程。
* On-entry and on-exit actions: 绑定入口、出品事件处理器-action
* Parameter mapping: 参数
* Result mapping: 结果
* Timers: 定时器
* ParentId: 父人工服务 ID


人工任务生命周期
当一个流程实例的人工任务结点被触发,人工任务实例将被创建。当创建完成后,人工任务进入 Created 状态。
当人工任务的 Wait for completion 属性为 False 时,流程会立即继续执行,否则要等待任务完成或终止。

进入 Created 状态,任务将显示所有负责执行的 actors。等待他们来获取任务。一旦有一个 actor 获取任务,任务进入 Reserved 状态。用户决定开始执行任务,此时任务进入 InProgress 状态。任务开始执行,执行完成后,用户必须完成任务。此时用户进入 Completed 状态。用户也可以决定任务已经失败,此时任务进入 Failed 状态。
上面介绍的正常的生命周期,其它包括:
Delegating /forwarding 任务, 分配任务给另外一个 actor 来处理
Revoking 回滚任务
Temporarly suspending and resuming 临时挂起或继续任务
Stopping a task in progress 停止正在执行的任务
Skipping 跳过(不执行)

脚本任务
代表一个脚本在流程中应该被执行。一个脚本任务应该有一个输入链接和一个输出链接。相关联的动作应该指定什么要被执行,还有编码动作的方言,和正在的动作代码。这段代码可以访问任何变量和全局参数。这还有一个提前定义的变量 kcontext 从ProcessContext 对象引入。在流程中,当一个脚本任务被访问时,它将会执行动作,然后继续到下一个节点。
注意:你可以在脚本代码内部写任何有效地 java 代码。这基本上允许你在脚本代码内做
任何事。然而,这里也有一些警告:
•当你试着去创建一个高级的业务流程时,你应该确定能够被业务用户所理解,在流程内部避免低级的执行细节将会是明智的。包括在脚本任务的内部。脚本任务仍然可以用来快速处理变量等。但是像服务任务等其他的任务能够被用来在高级方式中建模更加复杂的行为。
•脚本应该是 immediate(这里不知道翻译成什么好),他们使用引擎线程来执行脚本。脚本的执行可能会花一些时间,它的执行可能会被以异步的服务任务方式来进行。
•你应该尽量避免通过脚本节点和外部服务相关联。这不仅仅违法了前面两个的警告,它将会影响除了 knowledge 引擎之外的其他外部服务,这将会产生问题,特别是在持久化和转换时。 总的来说,使用服务任务来和外部的服务相关联是相当明智的。
•脚本不应该抛出异常。运行时异常应该被捕获,例如在脚本内部进行管理,或者转换成信号,或者产生的错误能够在流程内部处理。

服务任务
代表一个在流程中应该被执行的工作单元。在流程引擎外部执行的所有的工作都应该使用服务任务来描绘或执行。BPMN 2.0 已经提前定义了不同的服务类型,例如发送邮件服务,消息日志等等。用户可以定义特有域的服务或工作条目,使用唯一的名称并定义所用到的参数,最终的输出和工作类型相关。查看 domain-specific processes 章节你可以获得更多的细节解释和在你的流程中怎样去定义和使用工作条目的说明。

指南里面的一些概念
--------------------------------------------------------------------------------------
knowledge base
一个 knowledge base 能够通过会话来共享并且通常只需要在应用启动时创建一次。knowledge base 能够动态的更改。
jBPM 应该被用来创建一个 knowledge base,其包含你的流程定义,再就是创建一个用来启动新的流程实例、单独存在的,或者注册监听器等等的会话。
jBPM 允许你先创建一个 knowledge base。这个 knowledge base 应该包含你所有的流程定义,就是需要被会话执行的流程。创建一个 knowledge base,先用 knowledge builder来连接不同资源的流程,然后从 builder 创建一个新的 knowledge base。

Java代码  

1. KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();   
2. kbuilder.add(ResourceFactory.newClassPathResource("MyProcess.bpmn"),   
3. ResourceType.BPMN2);   
4. KnowledgeBase kbase = kbuilder.newKnowledgeBase();  

KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
kbuilder.add(ResourceFactory.newClassPathResource("MyProcess.bpmn"),
ResourceType.BPMN2);
KnowledgeBase kbase = kbuilder.newKnowledgeBase();

流程知识库
如果你想在你的应用中启动多个业务流程,特别是你想要有能力动态更新他们,一个流程知识库将是你的 BPM 体系的重要组成部分。流程知识库是用来存储和管理你的业务流程。因为他们不能够作为你应用的一部分,因为他们有自己的生命周期,意味着你能够动态的更新业务流程, 不能改变应用代码。
注意:流程知识库不仅仅是一个用来存储你流程定义的数据。它几乎扮演着源代码管理系统、内容管理系统、协作组件、开发和测试环境的结合体的角色。

会话
这个会话用来和流程引擎联系。会话需要有一个从 knowledge base 引用,包含了所有相关流程定义的引用。这个 knowledge base是用来在任何有必要的时候来查看流程的定义。要去创建一个会话,你首先需要去创建一个 knowledge base,链接到所有的必需已定义的流程,然后初始化一个会话。
一旦你装载了 knowledge base,你应该创建一个会话来和引擎结合。然后会话就能够被来启动一个流程或单独的事件。下面的代码片段展现了基于先前创建的 knowledgebase 来创建一个会话是多么的容易,并可以通过 id 来启动流程。
StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();
ProcessInstance processInstance = ksession.startProcess("com.sample.MyProcess");

事件
会话提供了监听器的注册和删除的方法,一个流程事件监听器可以被用来监听和流程相关的事件,比如开始或完成一个流程,进入或离开一个节点等等。

抛出错误事件
一个错误事件可以在流程中发出一个异常信号。它应该有一个输入连接而没有输出链接。在流程中当一个错误事件发生的时候,它将抛出一个错误并给出错误名称。而流程将会搜索能够使得解决这种错误的处理方法。如果没有错误处理被发现,流程实例将会被终止。

获取定时器事件
代表着在给出一段时间后定时器会引发一次或多次。一个计时器事件应该有一个输入连接和一个输出链接。计时器延迟指定了应该等待多长时间之后第一时间引发。在流程中,当一个计时器事件发生的时候,流程将会和计时器相关联。如果计时器节点被取消,那么计时器也将被取消。

获取信号事件
在流程的执行当中,一个信号事件可以用来作为对内部或外部事件的回应。它指定了预期事件的类型。无论这个事件类型什么时候被探测到,与它相连接的事件节点都将被触发。

脚本任务 代表一个脚本在流程中应该被执行。

服务任务
代表一个在流程中应该被执行的工作单元。在流程引擎外部执行的所有的工作都应该使用服务任务来描绘或执行。BPMN 2.0 已经提前定义了不同的服务类型,例如发送邮件服务,消息日志等等。服务任务能够通过映射变量到流出参数来传递流程变量的值到外部(或者另一流程实例)

用户服务
流程包含的任务由人工角色来执行。用户任务代表一个有人工角色来执行的最初任务。

重用的子流程 代表当前流程中的另一个流程的调用。

业务规则任务
代表一组规则需要被“evaluated”(这里不知道怎么翻译好)。当节点被链接到时,规则会被“evaluated”。一个规则任务应该有一个进入链接和一个退出链接。

嵌入子流程
一个子流程就是一个能够包含其他节点的节点,事实上讲就是一个节点容器。这不仅仅允许在这样一个子流程节点嵌入流程的一部分,而且可以添加容器内所有节点都可以访问的变量。一个子流程应该有一个进入链接和一个退出链接。它也应该包含一个开始节点,这个开始节点定义了在进入子流程时应该从哪里启动。它当然也应该包含一个或多个结束事件。
注意:如果你在子流程内部使用了终止节点,你将终止高一级的流程实例,而不仅仅是子流程,所有,你应该在子流程内使用非终止节点。在子流程中如果没有活动节点存在,那么这个子流程将会结束。

多实例子流程
一个多实例子流程是一个指定类型的子流程,它允许你多次执行所包含的流程片段,每一个元素都会在集合当中。一个多个实例子流程应该有一个进入链接和一个退出链接。在继续执行之前,要等嵌入的流程片段中给出的集合中每一个元素都被完成才能继续。

分支网关 允许你在你的流程中创建一个分支。一个分支网关应该有一个进入链接和两个或多个流出链接。

合并网关 允许你同步多个分支。一个合并网关应该有两个或多个进入链接和一个流出链接。

为了能够执行你应用中的流程,你需要做两件事:(1)你需要创建一个 Knowledge Base,要包含一个流程定义;(2)你需要通过创建一个 session来启动流程,并通过 session 来和流程引擎链接。
1. 创建一个 Knowledge Base:你需要有一个可用的流程,然后添加流程到 KnowledgeBase:
KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
kbuilder.add( ResourceFactory.newClassPathResource("MyProcess.bpmn2"),
ResourceType.BPMN2 );
在添加所有的流程到 builder 之后,你可以像下面一样创建一个新的 Knowledge base:
KnowledgeBase kbase = kbuilder.newKnowledgeBase();
2. 启动一个流程:启动一个指定的流程,你需要用你的的 session 去调用 startProcess方法并传递你想要启动的流程的 id。
StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();
ksession.startProcess("com.sample.hello");

数据
虽然流程表关注于指定的流程控制流向,但是从数据的角度来查看流程一般也是很有必要的。一个流程的执行,数据能够获得、存储、传递和使用。

约束
流程可以用在你流程的各种地方。例如在一个分离网关中。jBPM 支持两种类型的约束:
•Code constraint:代码约束就是布尔表达,直接判断他们什么时候到达。我们现在对于表达这种代码约束支持两种方言:Java 和 MEVL。Java 和 MVEL 代码约束都可以直接的访问在流程中定义的全局变量和变量。
•规则约束等同于正常的 Drools rule 条件。用 Drools Rule 语言的语法来表达可能复杂的
约束。就像其他的规则一样,这些规则能够在工作内存中引用数据。当然也可以直接引
用全局变量。

动作脚本
动作脚本可以以不同的方式使用:
•在脚本任务中使用
•作为一个进入或退出动作

事件
流程应该响应那些不是被流程引擎直接请求的事件。明确的描绘在流程中的事件,允许流程作者去指定对于这种事件流程应该做出如何反应。
事件有一个类型并可能有和他们相关的数据。用户可以自由的定义他们自己的事件类型和他们相关的数据。
一个流程能够通过使用 Message Event 来指定对事件应该如何响应。一个事件节点需要去指定事件的类型。它也能够定义变量的名称,用来接收和事件相关的数据。这就允许在流程中的并发节点去访问事件数据并基于这些数据采取响应的动作。

计时器
计时器是在触发之前等待提起定义的时间量,它允许执行一次或重复执行。计时器能够被用来在一个特定周期之后触发特定的逻辑,或者在特定的间隔内重复某些动作。

更新流程
在经过一段之后,流程可以要优化,例如由于流程自身需要改进,又或者因为需求的改变。实际上,你不能够真正的升级一个流程,你仅仅能够配置一个新版本的流程,旧版本的流程将仍然存在。因为已经存在的流程实例可能仍然需要定义好的流程。所以新的流程应该有一个不同的 id,但是名称可以相同。你可以使用版本参数来显示一个流程被升级了。

持久化
配置 jBPM 引擎在任何必要的时候来保存引擎的状态。最简单的方式就是使用 JPAKnowledgeService 来创建你的 knowledge session,基于 knowledge base,一个 knowledge session 和一个环境。环境需要包含从你的 Entity Manager Factory 来索引。

Java代码  

1. // create the entity manager factory and register it in the environment   
2. EntityManagerFactory emf =   
3. Persistence.createEntityManagerFactory( "org.jbpm.persistence.jpa" );   
4. Environment env = KnowledgeBaseFactory.newEnvironment();   
5. env.set( EnvironmentName.ENTITY_MANAGER_FACTORY, emf );   
6. // create a new knowledge session that uses JPA to store the runtime state   
7. StatefulKnowledgeSession ksession =   
8. JPAKnowledgeService.newStatefulKnowledgeSession( kbase, null, env );   
9. int sessionId = ksession.getId();   
10. // invoke methods on your method here   
11. ksession.startProcess( "MyProcess" );   
12. ksession.dispose();   
13. 你也可以使用 JPAKnowledgeService 来基于一个特定的 session id 来重新创建一个session:   
14. // recreate the session from database using the sessionId   
15. ksession = JPAKnowledgeService.loadStatefulKnowledgeSession( sessionId, kbase, null,env );  

// create the entity manager factory and register it in the environment
EntityManagerFactory emf =
Persistence.createEntityManagerFactory( "org.jbpm.persistence.jpa" );
Environment env = KnowledgeBaseFactory.newEnvironment();
env.set( EnvironmentName.ENTITY_MANAGER_FACTORY, emf );
// create a new knowledge session that uses JPA to store the runtime state
StatefulKnowledgeSession ksession =
JPAKnowledgeService.newStatefulKnowledgeSession( kbase, null, env );
int sessionId = ksession.getId();
// invoke methods on your method here
ksession.startProcess( "MyProcess" );
ksession.dispose();
你也可以使用 JPAKnowledgeService 来基于一个特定的 session id 来重新创建一个session:
// recreate the session from database using the sessionId
ksession = JPAKnowledgeService.loadStatefulKnowledgeSession( sessionId, kbase, null,env );

注意:我们只保存流程实例在之后的点需要继续执行的最小限度的状态。这就意味着它不会保存已经执行的节点的信息,如果这些节点再也不会用的,又或者已经完成的实例,或者中止并从数据库删除的情况都不会保存。

流程定义
流程定义文件通常是使用 XML 格式编写的。在开发中,这些文件能够很容易的存储在文件系统中。无论你想什么时候使你的 knowledge 访问产品中的一个或多个引擎,我们建议使用 knowledge repository(知识库),知识库就是集中你的 knowledge 到一个或多个知识库中。
Guvnor 是 Drools 子项目所提供的工具。它由一个存储各种不同类型的 knowledge、流程定义、rules、对象模型的 repository 知识库组成的。使用 WebDAV 或一个 knowledge代理都很容易检索 knowledge,当专家一个 knowledge base 的时候,knowledge 代理将会从 Guvnor 下载信息,并提供了一个 web 应用来允许业务用例来查看并有可能在knowledge repository 中更新信息。

历史日志
很多情况下,历史日志用来存储流程实例执行相关的信息,以至于这些信息在之后可以用来核实一个指定的流程实例的动作执行的内容,或者用来监视和分析一个特定流程的效率。存储历史信息到运行时的数据库不是一个很好的注意,这有可能造成运行时数据的不断增加,并且监视和分析查询会影响运行时引擎的执行。这就是为什么关于流程实例执行的历史信息要分开存储了。

将流程事件存储到数据库
jbpm-bam 模块包含了一个事件监听器,这个监听器使用 JPA 或者 Hibernate 来直接存储流程相关信息。数据库包含两个表,一个用来存储流程实例信息,一个用来存储节点实例信息。
1. ProcessInstanceLog:这个表包括所有流程实例的 id、流程 id、开始时间和结束时间。
2. NodeInstanceLog:这个表包含节点在每个流程实例中实际执行的节点的更多详细信息。无论什么时候,节点实例都是从它的进入链接中进入,从它的推出链接中推出,这些信息都存储在这个表中。存储流程实例的 id,正在执行的流程实例的流程 id,节点实例的 id,和相应的节点 id,并且事件的类型和事件的状态都也会被存储。
为了记录历史信息到数据库当中,你需要在你的 session 中注册一个记录器,像下面所示:

Java代码  

1. StatefulKnowledgeSession ksession = ...;   
2. JPAWorkingMemoryDbLogger logger = new JPAWorkingMemoryDbLogger(ksession);   
3. // invoke methods one your session here   
4. logger.dispose();  

StatefulKnowledgeSession ksession = ...;
JPAWorkingMemoryDbLogger logger = new JPAWorkingMemoryDbLogger(ksession);
// invoke methods one your session here
logger.dispose();

注意:
这个记录器和其他的核查记录器一样,这就意味着你能够添加一个或多个过滤器,通过调用 addFilter 方法来确保只有相关的信息被存储在数据库中。信息只能被所有的过滤器访问。你应该在不再需要记录的时候去除记录器。
编辑 persistence.xml 文件来指定存储信息的数据库,这个文件也包括审核日志的类型。


任务生命周期
无论一个任务什么时候被创建,它都是从“Created”开始。
它会自动转换到“Ready”状态,在这一点的时候,任务将会被展示在所有参与者的任务列表上,并允许参与者执行任务。这里是正在等待这些参与者中一个来认领任务,这就表示他正在执行任务。
一旦一个用户认领了一个任务,状态就会更改为“Rserved”。注意:一个任务仅仅有一个潜在的参与者,在自动分配给参与者之前就创建了任务。
任务认领任务之后,用户能够在某一点开始执行任务,这种情况下任务的状态会被更改为“Inprigress”。
最后,一旦任务完成,用户必须完成任务,这种情况下状态被更改为“Completed”。
如果任务没有完成,用户也显示使用了错误的响应,那么执着情况下状态就被更改为“Failed”。

特定领域
特定的领域扩展就是简单的在一个特定领域的应用中开发。这个指南描述了开发特定领域的流程的第一步。注意:你不需要是一个 jBPM 专家就能够定义你自己的特定领域节点,这应该是一个综合的代码,只要是有一些 jBPM 开发的经验就能够自己完成。
特定领域语言的目标是针对于特定应用领域,因此能够提供和用户尝试解决的问题紧紧相关的构造。这就使得流程更容易理解。我们将展现给你如何定义特定领域工作条目,这代表需要被执行的工作原子单元。这些服务接待将指定在发布的行为流程的上下文中将有执行测工作,并指出了在高一级需要执行的内容并隐藏了实现细节。

业务活动监视器
你需要积极的监控你的流程来确保你能够察觉到任何的异常,并对不期望的事件尽可能快的的做出反应。业务活动监视器和你的流程监视器与干预选项有直接的关系,甚至可能自动的,基于这些事件来分析。
jBPM 允许用户通过流程引擎并基于事件的产生来定义报告,并且使用复杂事件流程规则可能直接的介入到特定的情形中,就像下面两部分介绍的一样。未来 jBPM 平台的发布将包括对所有业务活动监视器需求的支持,包括能够被用来和运行中流程引擎交互,查看它的状态,产生报告等等的基于 web 的应用。