jbpmAPI-8

8.1. Process Instance State

jBPM允许某些信息的持久性存储。本章描述了这些不同类型的持久性,以及如何配置它们。存储的信息的一个例子是运行时状态的过程。存储过程运行时状态是必要的,为了能够继续执行流程实例在任何时候,如果出现错误。此外,过程定义本身,和历史信息(日志的当前和以前的进程状态已经)也可以坚持。

8.1.1. Runtime State

每当开始一个过程,一个流程实例被创建时,它表示在特定上下文的执行过程。例如,当执行一个过程,指定如何处理销售订单,一个流程实例为每个销售创建请求。流程实例代表特定上下文的当前执行状态,和包含所有相关信息的流程实例。注意,它只包含运行时状态(最小限度的),需要继续执行,流程实例在后来的一些时间,但它并不包括流程实例的历史信息,如果信息不再需要在流程实例。
执行的运行时状态可以持续的过程,例如,在一个数据库中。这允许恢复执行所有正在运行的进程的状态以防意外的失败,或暂时删除运行实例从记忆和恢复他们在后来的一些时间。jBPM允许您插入不同的持久性策略。默认情况下,如果你不配置流程引擎否则,流程实例并不持久。

如果你配置引擎使用的持久性,它会自动存储运行时状态到数据库中。你不需要触发坚持自己,时,引擎将照顾这个持久性启用。当你调用引擎,它将确保任何更改存储调用结束时,在所谓的安全点。每当出现问题,你恢复从数据库引擎,你也不应该重新加载过程实例和触发手动恢复执行,流程实例将自动恢复执行,如果他们被触发,例如像计时器到期,完成一个任务所要求的流程实例,或一个信号被发送到流程实例。引擎将自动重新加载流程实例。
运行时持久性数据一般应考虑内部,这意味着你可能不应该直接访问这些数据库表,特别是不要直接修改这些(如改变流程实例的运行时状态没有引擎知道可能意想不到的副作用)。在大多数情况下,当前执行流程实例的状态信息是必需的,使用历史日志主要是推荐(见下文)。在某些情况下,它仍然可能是有用的,例如直接查询数据库表的内部,但是你只能这样做如果你知道你正在做什么。

 

8.1.1.1. Binary Persistence

jBPM使用二进制的持久性机制,或称为编组,流程实例的状态转换成二进制数据集。当你使用jBPM持久性,这种机制是用来保存或从数据库中检索流程实例的状态。相同的机制也应用于会话状态和任何工作项的状态。

当流程实例状态保存,会发生两件事情:
首先,流程实例信息转换为二进制blob。由于性能的原因,使用一个自定义的序列化机制,而不是普通的Java序列化。
然后该blob存储,与其他关于此流程实例元数据。这个元数据包括,除其他事项外,流程实例id,进程id,这个过程开始日期。

除了流程实例状态,会话本身也可以存储一些状态,如定时器工作的状态,或会话数据,任何业务规则将被评估。这个会话状态存储分别转换成一个二进制blob,会话的id和一些元数据。你可以随时恢复会话状态通过重载会话与给定id。可以使用检索会话id ksession.getId()。
注意,流程实例二进制数据集通常是相对较小的,因为他们只包含最小的执行流程实例的状态。对于一个简单的流程实例,这通常包含一个或几个节点实例,即。,目前正在执行的任何节点,任何现有的变量值。

 

由于jBPM使用编组,数据模型是简单的和小:

 

sessioninfo实体包含的状态(知识)会话的jBPM流程实例正在运行。

Table 8.1. SessionInfo

Field	Description	Nullable
id	主键	NOT NULL
lastmodificationdate	最后一次的实体被保存到数据库
rulesbytearray	二进制数据集包含会话的状态	NOT NULL
startdate	会议的开始时间
optlock	版本锁

processinstanceinfo实体包含jBPM流程实例的状态。

Table 8.2. ProcessInstanceInfo

Field	Description	Nullable
instanceid	主键	NOT NULL
lastmodificationdate	最后一次的实体被保存到数据库
lastreaddate	最后一次,从数据库中检索实体(读)
processid	流程的名称
processinstancebytearray	这是二进制数据集包含流程实例的状态	NOT NULL
startdate	开始时间
state	一个整数代表流程实例的状态	NOT NULL
optlock	版本锁

eventtypes实体包含有关事件,一个流程实例将接受或经历了。

Table 8.3. EventTypes

Field	Description	Nullable
instanceid	这引用processinstanceinfo主键,外键约束本专栏。	NOT NULL
eventTypes	一个文本字段相关过程经历了的一个事件。

workiteminfo实体包含工作项的状态。

Table 8.4. WorkItemInfo

Field	Description	Nullable
workitemid	主键	NOT NULL
creationDate	工作项的名称
name	工作项的名称
processinstanceid	The (primary key) id of the process: there is no foreign key constraint on this field.	NOT NULL
state	状态	NOT NULL
optlock	版本锁
workitembytearay	这是二进制数据集包含工作项的状态	NOT NULL

 

CorrelationKeyInfo实体包含相关信息的密钥分配给流程实例——松散的关系,因为这表是可选的只有当使用相关功能是必需的。
表8.5。CorrelationKeyInfo

Field	Description	Nullable
keyid	主键	NOT NULL
name	分配的名称
processinstanceid	The id of the process instance which is assigned to this correlation key	NOT NULL
optlock	版本锁

CorrelationPropertyInfo实体包含相关信息给相关的属性键分配给流程实例。

Table 8.6. CorrelationPropertyInfo

Field	Description	Nullable
propertyid	主键	NOT NULL
name	名称
value	值	NOT NULL
optlock	版本锁
correlationKey-keyid	Foregin key to map to correlation key	NOT NULL

ContextMappingInfo实体包含上下文信息信息映射到ksession。这是一个内部RuntimeManager的一部分,当不使用RuntimeManager可以被认为是可选的。

Table 8.7. ContextMappingInfo

Field	Description	Nullable
mappingid	主键	NOT NULL
context_id	上下文的标识符	NOT NULL
ksession?id	标识符的ksession映射到这个上下文	NOT NULL
optlock	版本锁

8.1.1.2. Safe Points

流程实例的状态存储在所谓的“安全点”过程的执行引擎。每当一个流程实例执行(例如当它开始或继续从先前的等待状态,发动机执行流程实例,直到没有可以执行更多的操作(即流程实例要么已经完成(或者是流产),或者它已经达到了一个等待状态的并行路径)。在这一点上,引擎已经达到下一个安全状态和流程实例的状态(以及所有其他可能受到影响的流程实例)进行持久存储。

8.2. Audit Log

在许多情况下,这将是有用的(如果不是必要的)来存储过程实例的执行信息,以便之后可以使用此信息。例如,有时我们想验证哪些动作已经执行一个特定的流程实例,或在一般情况下,我们希望能够监视和分析一个特定过程的效率。
然而,在运行时数据库中存储历史信息会导致数据库规模迅速增长,更不用说,监测和分析查询可能会影响您的运行时引擎的性能。这就是为什么可以单独存储过程执行历史信息。
这段历史日志执行信息创建基于流程引擎执行期间产生的事件。这是可能的,因为jBPM运行时引擎提供了一个通用的机制听事件。可以很容易地从这些事件中提取必要的信息,然后保存到数据库中。过滤器还可以用来限制登录信息的范围。

8.2.1. The jBPM Audit data model

jbpm-audit模块包含一个事件侦听器,存储过程相关信息在数据库中使用JPA。数据模型本身包含三个实体,一个流程实例信息,一个节点实例信息,一个(过程)变量实例信息。

Figure 8.2. jBPM Audit data model

ProcessInstanceLog表包含基本的日志信息流程实例。

Table 8.8. ProcessInstanceLog

Field	Description	Nullable
id	主键	NOT NULL
duration	此流程实例的实际期限开始日期以来
end_date	当适用时,结束日期的流程实例
externalId	可选的外部标识符用于关联——例如部署一些元素id
user_identity	可选的用户的标识符开始流程实例
outcome	流程实例的结果,例如错误代码的流程实例是完成错误事件
parentProcessInstanceId	父进程实例的流程实例id
processid	进程的id
processinstanceid	流程实例的ID	NOT NULL
processname	流程的名称
processversion	流程的版本
start_date	流程开始日期
status	状态

 

NodeInstanceLog表包含更多关于哪些节点的信息实际上是在每个流程实例执行。当一个节点实例输入从一个传入的连接或退出通过它的一个对外的连接,这些信息存储在这个表。

Table 8.9. NodeInstanceLog

Field	Description	Nullable
id	主键	NOT NULL
connection	的实际标识符序列流,导致该节点实例
log_date	事件的日期
externalId	可选的外部标识符用于关联——例如部署一些元素id
nodeid	流程节点ID
nodeinstanceid	流程实例ID
nodename	节点名称
nodetype	节点类型
processid	流程ID
processinstanceid	流程实例ID	NOT NULL
type	事件类型 (0 = enter, 1 = exit)	NOT NULL
workItemId	可选——只对特定的节点类型,工作项的标识符

VariableInstanceLog表包含变量的变化信息的实例。默认时只生成日志条目(后)一个变量变化。也可以日志条目在变量(值)的变化。

Table 8.10. VariableInstanceLog

Field	Description	Nullable
id	主键	NOT NULL
externalId	可选的外部标识符用于关联——例如部署一些元素id
log_date	事件开始时间
processid	流程ID
processinstanceid	流程实例ID	NOT NULL
oldvalue	变量的前一个值的时候,日志
value	变量的值的时候,日志
variableid	变量在流程定义id
variableinstanceid	变量在流程实例定义id

 

8.2.2. Storing Process Events in a Database

登录过程这样的历史信息数据库中,你需要注册日志记录器会话是这样的:

EntityManagerFactory emf = ...; 
StatefulKnowledgeSession ksession = ...; 
AbstractAuditLogger auditLogger = AuditLoggerFactory.newJPAInstance(emf); 
ksession.addProcessEventListener(auditLogger); 
// invoke methods one your session here 

 指定的数据库应该存储信息,修改文件持久化。persistence.xml文件包含审计日志类(ProcessInstanceLog,NodeInstanceLog和VariableInstanceLog),如下所示。

 

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 
 
 <persistence
   version="2.0"
   xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd
   http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
   xmlns="http://java.sun.com/xml/ns/persistence"
   xmlns:orm="http://java.sun.com/xml/ns/persistence/orm"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance>
 
   <persistence-unit name="org.jbpm.persistence.jpa" transaction-type="JTA">
     <provider>org.hibernate.ejb.HibernatePersistence</provider>
     <jta-data-source>jdbc/jbpm-ds</jta-data-source>
     <mapping-file>META-INF/JBPMorm.xml</mapping-file>
     <class>org.drools.persistence.info.SessionInfo</class>
     <class>org.jbpm.persistence.processinstance.ProcessInstanceInfo</class>
     <class>org.drools.persistence.info.WorkItemInfo</class>
     <class>org.jbpm.persistence.correlation.CorrelationKeyInfo</class>
     <class>org.jbpm.persistence.correlation.CorrelationPropertyInfo</class>
     <class>org.jbpm.runtime.manager.impl.jpa.ContextMappingInfo</class>
 
     <class>org.jbpm.process.audit.ProcessInstanceLog</class>
     <class>org.jbpm.process.audit.NodeInstanceLog</class>
     <class>org.jbpm.process.audit.VariableInstanceLog</class>
 
     <properties>
       <property name="hibernate.dialect" value="org.hibernate.dialect.H2Dialect"/>
       <property name="hibernate.max_fetch_depth" value="3"/>
       <property name="hibernate.hbm2ddl.auto" value="update"/>
       <property name="hibernate.show_sql" value="true"/>
       <property name="hibernate.transaction.jta.platform"
       value="org.hibernate.service.jta.platform.internal.BitronixJtaPlatform"/>
     </properties>
   </persistence-unit>
 </persistence>

所有这些信息可以很容易地查询和使用在很多不同的用例,从一个特定的流程实例创建一个历史记录日志分析的所有实例特定过程的性能。
这审计日志应该只被视为一个默认实现。我们不知道你需要什么信息存储进行分析之后,由于性能原因,建议只存储相关数据。根据你的用例,你可以定义自己的数据模型来存储所需要的信息,并使用事件监听器来提取信息的过程。

8.2.3. Storing Process Events in a JMS queue for further processing

处理事件存储在数据库同步,并在与实际流程实例执行相同的事务。显然需要一些时间特别是高度加载系统和数据库时可能会有一些影响历史记录和运行时数据都保存在相同的数据库。为存储过程提供一个替代的选择事件,提供了基于JMS的记录器。它可以配置为提交消息的JMS队列,而不是直接保存在数据库中。它可以配置为事务,以避免数据不一致问题的流程引擎事务回滚。

ConnectionFactory factory = ...; 
Queue queue = ...; 
StatefulKnowledgeSession ksession = ...; 
Map<String, Object> jmsProps = new HashMap<String, Object>(); 
jmsProps.put("jbpm.audit.jms.transacted", true); 
jmsProps.put("jbpm.audit.jms.connection.factory", factory); 
jmsProps.put("jbpm.audit.jms.queue", queue); 
AbstractAuditLogger auditLogger = AuditLoggerFactory.newInstance(Type.JMS, session, jmsProps); 
ksession.addProcessEventListener(auditLogger); 
// invoke methods one your session here 

 这只是一个可能的方法来配置JMS审计日志,看到javadocs AuditLoggerFactory为更多的细节。

8.3. Transactions

jBPM引擎支持JTA事务。它还支持本地事务只有当使用Spring。它不支持纯本地事务。关于使用Spring建立持久性的更多信息,请参见Drools的春天章集成指南。
每当你不提供应用程序事务边界内,引擎将自动执行每个方法调用引擎在一个单独的事务。如果这种行为是可以接受的,你不需要做任何其他的事情。但是,您可以自己指定事务边界。例如,这允许您将多个命令组合为一个事务。
你需要注册一个事务管理器在环境使用用户定义的事务。下面的示例代码使用了Bitronix事务管理器。接下来,我们使用Java事务API(JTA)指定事务边界,如下所示:

 

// 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 ); 
env.set( EnvironmentName.TRANSACTION_MANAGER, TransactionManagerServices.getTransactionManager() ); 
// create a new knowledge session that uses JPA to store the runtime state 
StatefulKnowledgeSession ksession = JPAKnowledgeService.newStatefulKnowledgeSession( kbase, null, env ); 
// start the transaction 
UserTransaction ut = (UserTransaction) new InitialContext().lookup( "java:comp/UserTransaction" ); 
ut.begin(); 
// perform multiple commands inside one transaction 
ksession.insert( new Person( "John Doe" ) ); 
ksession.startProcess( "MyProcess" ); 
// commit the transaction 
ut.commit(); 
    注意,如果你使用Bitronix作为事务管理器,你还应该添加一个简单的jndi。属性文件在你根类路径在JNDI注册Bitronix事务管理器。如果您使用的是jbpm-test模块,这是已经包含在默认情况下。如果不是,创建一个名为jndi的文件。属性有以下内容:

java.naming.factory.initial=bitronix.tm.jndi.BitronixInitialContextFactory
如果你想使用一个不同的JTA事务管理器,您可以更改持久化。xml文件使用您自己的事务管理器。例如,当运行在JBoss应用服务器版本5。x或v7。x,您可以使用JBoss事务管理器。您需要更改事务管理器属性inpersistence.xml:

<property name="hibernate.transaction.jta.platform" value="org.hibernate.transaction.JBossTransactionManagerLookup" />

8.3.1. Container managed transaction

时需要采取特殊的考虑嵌入jBPM内部的应用程序执行在容器管理的事务(CMT)模式,例如EJB bean。这尤其适用于应用程序服务器不允许UserTransaction实例时从JNDI访问容器管理事务的一部分,例如WebSphere application Server。因为默认实现事务管理器的jBPM UserTransaction获得交易状态是基于用于决定是否应该开始事务,环境,防止访问UserTrancation它不会做它的工作。确保正确执行在CMT的环境中提供了专用的事务管理器的实现:

org.jbpm.persistence.jta.ContainerManagedTransactionManager
这个事务经理预计,交易活跃,因此将始终返回调用getStatus方法时活跃。开始、提交、回滚操作方法等操作,事务管理器运行在管理事务,并不能影响它。
配置该事务管理器必须完成:
事务管理器和持久化上下文管理器插入环境创建/加载前会议

Environment env = EnvironmentFactory.newEnvironment();
env.set(EnvironmentName.ENTITY_MANAGER_FACTORY, emf);
env.set(EnvironmentName.TRANSACTION_MANAGER, new ContainerManagedTransactionManager());
env.set(EnvironmentName.PERSISTENCE_CONTEXT_MANAGER, new JpaProcessPersistenceContextManager(env));
env.set(EnvironmentName.TASK_PERSISTENCE_CONTEXT_MANAGER, new JPATaskPersistenceContextManager(env));
       

 配置JPA提供者(例如hibernate和WebSphere)

<property name="hibernate.transaction.factory_class" value="org.hibernate.transaction.CMTTransactionFactory"/>
<property name="hibernate.transaction.jta.platform" value="org.hibernate.service.jta.platform.internal.WebSphereJtaPlatform"/>

使用以下配置jBPM应该在CMT环境中正常运行。

8.3.1.1. CMT dispose ksession command

通常当运行在容器管理的事务处理ksession直接会导致异常事务完成,有一些事务同步注册由jBPM清理完成后调用。要解决这个问题一直providedorg.jbpm.persistence.jta专门的命令。ContainerManagedTransactionDisposeCommand允许简单地执行这个命令,而不是定期ksession。处理将确保ksession将在事务处理完成。

8.4. Configuration

默认情况下,发动机不拯救持续运行时数据。这意味着您可以使用引擎完全没有持久性(所以不需要一个在内存中数据库)如果有必要,例如由于性能的原因,或者当你想管理持久性。然而,可以配置引擎使用持久性配置它。这通常需要添加必要的依赖关系,配置数据源创建引擎和持久性配置。

8.4.1. Adding dependencies

您需要确保必要的依赖关系可用应用程序的类路径中如果你想用户持久性。默认情况下,持久性是基于Java persistence API(JPA),因此可以使用一些持久性机制。默认情况下我们使用Hibernate。
如果您正在使用Eclipse IDE和jBPM Eclipse插件,您应该确保必要的jar添加到您的jBPM运行时目录。你真的不需要做任何事情(如必要的依赖关系应该已经有)如果您使用jBPM运行时配置默认使用jBPM安装程序时,或者如果你下载并解压jBPM运行时工件(从下载)并指出jBPM插件目录。

如果你想手动将必要的依赖项添加到您的项目中,首先,你需要JAR filejbpm-persistence-jpa。保存jar,包含代码运行时状态时必要的。接下来,您还需要其他各种依赖关系,这取决于您所使用的持久性解决方案和数据库。为默认结合Hibernate使用H2 JPA持久性提供者和内存数据库和Bitronix JTA-based事务管理,下面的列表需要额外的依赖关系:

• jbpm-persistence-jpa (org.jbpm)
• drools-persistence-jpa (org.drools)
• persistence-api (javax.persistence)
• hibernate-entitymanager (org.hibernate)
• hibernate-annotations (org.hibernate)
• hibernate-commons-annotations (org.hibernate)
• hibernate-core (org.hibernate)
• commons-collections (commons-collections)
• dom4j (dom4j)
• jta (javax.transaction)
• btm (org.codehaus.btm)
• javassist (javassist)
• slf4j-api (org.slf4j)
• slf4j-jdk14 (org.slf4j)
• h2 (com.h2database)
• jbpm-test (org.jbpm) for testing only, do not include it in the actual application

8.4.2. Manually configuring the engine to use persistence

您可以使用JPAKnowledgeService会话创建您的知识。这是稍微复杂,但能给你完整的访问底层配置。您可以创建一个新的知识会话usingJPAKnowledgeService基于知识库,知识会话配置(如果需要)和一个环境。环境需要包含一个引用你的实体管理器工厂。例如:

// 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重新创建一个会话基于特定的会话id:

// recreate the session from database using the sessionId 
ksession = JPAKnowledgeService.loadStatefulKnowledgeSession(sessionId, kbase, null, env );


请注意,我们只保存所需的最小状态继续执行流程实例在后来的一些点。这意味着,例如,它不包含的信息已经执行节点如果信息不再是相关的,或者流程实例已经完成或中止从数据库中删除。如果你想寻找历史有关的信息,您应该使用历史记录,稍后解释。
您需要添加一个持久性配置到您的类路径配置JPA使用Hibernate和H2数据库(或者您自己的喜好),称为持久性。xml在meta - inf目录中,如下所示。更多细节关于如何改变这种为自己的配置,我们将JPA和Hibernate文档了解更多信息。

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <persistence
       version="2.0"
       xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd
       http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
       xmlns="http://java.sun.com/xml/ns/persistence"
       xmlns:orm="http://java.sun.com/xml/ns/persistence/orm"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance>
 
   <persistence-unit name="org.jbpm.persistence.jpa" transaction-type="JTA">
     <provider>org.hibernate.ejb.HibernatePersistence</provider>
     <jta-data-source>jdbc/jbpm-ds</jta-data-source>
     <mapping-file>META-INF/JBPMorm.xml</mapping-file>
     <class>org.drools.persistence.info.SessionInfo</class>
     <class>org.jbpm.persistence.processinstance.ProcessInstanceInfo</class>
     <class>org.drools.persistence.info.WorkItemInfo</class>
     <class>org.jbpm.persistence.correlation.CorrelationKeyInfo</class>
     <class>org.jbpm.persistence.correlation.CorrelationPropertyInfo</class>
     <class>org.jbpm.runtime.manager.impl.jpa.ContextMappingInfo</class>
 
     <properties>
       <property name="hibernate.dialect" value="org.hibernate.dialect.H2Dialect"/>
       <property name="hibernate.max_fetch_depth" value="3"/>
       <property name="hibernate.hbm2ddl.auto" value="update"/>
       <property name="hibernate.show_sql" value="true"/>
       <property name="hibernate.transaction.jta.platform"
                 value="org.hibernate.service.jta.platform.internal.BitronixJtaPlatform"/>
     </properties>
   </persistence-unit>
 </persistence>



这个配置文件是指称为“jdbc / jbpm-ds”的数据源。如果您运行您的应用程序在应用程序服务器(例如JBoss等),这些容器通常允许您轻松地使用一些配置设置数据源(例如删除数据源配置文件部署目录中)。请参考您的应用程序服务器文档了解如何做到这一点。
例如,如果你是应用服务器部署到JBoss v5。x,您可以创建一个数据源通过部署目录中删除一个配置文件,例如:

<?xml version="1.0" encoding="UTF-8"?>
 <datasources>
   <local-tx-datasource>
     <jndi-name>jdbc/jbpm-ds</jndi-name>
     <connection-url>jdbc:h2:tcp://localhost/~/test</connection-url>
     <driver-class>org.h2.jdbcx.JdbcDataSource</driver-class>
     <user-name>sa</user-name>
     <password></password>
   </local-tx-datasource>
 </datasources>

然而如果你执行一个简单的Java环境中,您可以使用JBPMHelper类来为你做这只测试(见下文)或者下面的代码片段可以用来建立一个数据源(我们使用H2内存数据库结合Bitronix在这种情况下)。

PoolingDataSource ds = new PoolingDataSource(); 
ds.setUniqueName("jdbc/jbpm-ds"); 
ds.setClassName("bitronix.tm.resource.jdbc.lrc.LrcXADataSource"); 
ds.setMaxPoolSize(3); 
ds.setAllowLocalTransactions(true); 
ds.getDriverProperties().put("user", "sa"); 
ds.getDriverProperties().put("password", "sasa"); 
ds.getDriverProperties().put("URL", "jdbc:h2:mem:jbpm-db"); 
ds.getDriverProperties().put("driverClassName", "org.h2.Driver"); 
ds.init();

8.4.3. Configuring the engine to use persistence using JBPMHelper - for tests only

您需要配置jBPM引擎使用持久性,通常只需使用适当的构造函数创建您的会话。有多种方法来创建一个会话(当我们试图尽可能容易使这对你和对你有几个实用程序类,例如不同如果你想写一个流程JUnit测试)。
最简单的方法是使用jbpm-test模块,允许您轻松地创建和测试流程。JBPMHelper类有一个方法来创建一个会话,并使用一个配置文件来配置这个会话,您是否想要使用持久性、要使用的数据源等。助手类将为你做所有的设置和配置。

配置的持久性,创建一个jBPM。属性文件和配置以下属性(注意,下面的例子是默认属性,使用一个H2内存数据库启用了持久性,如果你与所有这些属性很好,你不需要添加新属性文件,因为它将使用这些属性默认情况下):

# for creating a datasource
persistence.datasource.name=jdbc/jbpm-ds
persistence.datasource.user=sa
persistence.datasource.password=
persistence.datasource.url=jdbc:h2:tcp://localhost/~/jbpm-db
persistence.datasource.driverClassName=org.h2.Driver

# for configuring persistence of the session
persistence.enabled=true
persistence.persistenceunit.name=org.jbpm.persistence.jpa
persistence.persistenceunit.dialect=org.hibernate.dialect.H2Dialect

# for configuring the human task service
taskservice.enabled=true
taskservice.datasource.name=org.jbpm.task
taskservice.usergroupcallback=org.jbpm.services.task.identity.JBossUserGroupCallbackImpl
taskservice.usergroupmapping=classpath:/usergroups.properties

如果你想使用持久性,您必须确保数据源(thejBPM.properties文件中指定)正确地初始化。这意味着数据库本身必须启动并运行,注册和数据源应该使用正确的名字。如果你想使用一个H2内存数据库(通常是很容易做一些测试),您可以使用JBPMHelper类启动这个数据库,使用:

JBPMHelper.startH2Server();


注册数据源(这是你总是需要做的,即使你不使用H2作为您的数据库,检查下面的更多选项如何配置您的数据源),使用:

JBPMHelper.setupDataSource();


接下来,您可以使用JBPMHelper类来创建您的会话(创建知识库后,相同情况下当你不使用持久性):

StatefulKnowledgeSession ksession = JBPMHelper.newStatefulKnowledgeSession(kbase);

一旦你做了,你可以调用方法在这个ksession(比如startProcess)和发动机将保存所有的运行时状态创建数据源。
您还可以使用JBPMHelper类来创建您的会话(从数据库通过恢复状态,通过在会话id(您可以使用ksession.getId检索())):

StatefulKnowledgeSession ksession = JBPMHelper.loadStatefulKnowledgeSession(kbase, sessionId);