jBPM用户指南-CH06

第六章 配置

配置jBPM的最简单的方式是将jbpm.cfg.xml配置文件放到classpath的根目录中。如果那个文件不能作为一个资源被找到，包含在 jbpm库中的默认的最小化配置将被使用。记住最小化的配置没有任何持久化的配置信息。
jBPM配置通过org.jbpm.JbpmConfiguration类来描述。最简单的获取JbpmConfiguration的方式是使用单态实例方法JbpmContext.getInstance();
如果你想从另一个来源装载配置信息，你可以使用JbpmConfiguration。parseXxxx方法。

static JbpmConfinguration jbpmConfiguration = JbpmConfinguration.getInstance();
JbpmConfiguration是线程安全的，因此可以是一个静态成员。所有的线程都可以用JbpmConfiguration作为JbpmContext对象的一个工厂。一个JbpmContext典型地代表了一个事务。JbpmContext使得在一个context块中的服务可用。一个context块看起来就像这样：
try {
  // This is what we call a context block.
  // Here you can perform workflow operations

} finally {
  jbpmContext.close();
}
JbpmContext使得一系列的服务和配置对于JBPM可用。这些服务在jbpm.cfg.xml配置文件中配置，并使得jBPM可以运行在任何Java环境且在那个环境中无论使用哪个服务都可用。
这是一个JbpmContext典型的配置，你可以在src/config.files/jbpm.cfg.xml中找到它：
<jbpm-configuration>

  <jbpm-context>
    <service name='persistence' factory='org.jbpm.persistence.db.DbPersistenceServiceFactory' />
    <service name='message' factory='org.jbpm.msg.db.DbMessageServiceFactory' />
    <service name='scheduler' factory='org.jbpm.scheduler.db.DbSchedulerServiceFactory' />
    <service name='logging' factory='org.jbpm.logging.db.DbLoggingServiceFactory' />
    <service name='authentication' factory='org.jbpm.security.authentication.DefaultAuthenticationServiceFactory' />
  </jbpm-context>

  <!-- configuration resource files pointing to default configuration files in jbpm-{version}.jar -->
  <string name='resource.hibernate.cfg.xml' value='hibernate.cfg.xml' />
  <!-- <string name='resource.hibernate.properties' value='hibernate.properties' /> -->
  <string name='resource.business.calendar' value='org/jbpm/calendar/jbpm.business.calendar.properties' />
  <string name='resource.default.modules' value='org/jbpm/graph/def/jbpm.default.modules.properties' />
  <string name='resource.converter' value='org/jbpm/db/hibernate/jbpm.converter.properties' />
  <string name='resource.action.types' value='org/jbpm/graph/action/action.types.xml' />
  <string name='resource.node.types' value='org/jbpm/graph/node/node.types.xml' />
  <string name='resource.parsers' value='org/jbpm/jpdl/par/jbpm.parsers.xml' />
  <string name='resource.varmapping' value='org/jbpm/context/exe/jbpm.varmapping.xml' />

  <int name='jbpm.byte.block.size' value="1024" singleton="true" />
  <bean name='jbpm.task.instance.factory' class='org.jbpm.taskmgmt.impl.DefaultTaskInstanceFactoryImpl' singleton='true' />
  <bean name='jbpm.variable.resolver' class='org.jbpm.jpdl.el.impl.JbpmVariableResolver' singleton='true' />
  <long name='jbpm.msg.wait.timout' value='5000' singleton='true' />

</jbpm-configuration>
在文件中你可以看到3个部分：
第一个片段用一些列服务的实现配置了jbpm上下文，可能的配置选项在涵盖特定服务实现的章节中有介绍。
第二部分是对配置资源的所有的引用映射。如果你想定制其中一个配置文件，那么资源引用可以被更新。典型的，你制作默认配置的一个拷贝，这个默认配置是在jbpm-3.x.jar中，切放置在classpath的某个地方。那么你在这个文件更新了引用，那么jbpm将使用你定制的那个配置文件的版本。
第三部分是在jbpm使用的一些别称（miscallanious）。这些配置选项在涵盖了指定主题的章节有描述。

服务的默认配置集合的目标定位是最小的web应用环境和最小的依赖。持久化服务将获取一个jdbc连接，且所有其他的服务将使用相同的连接来完成他们的服务。所以你的所有工作流操作将被集中到1个JDBC连接事务内，而不再需要一个事务管理器。

JbpmContext包含了大多数流程操作的方便的方法：
  public void deployProcessDefinition(ProcessDefinition processDefinition) {...}//流程部署
  public List getTaskList() {...}//获取任务列表
  public List getTaskList(String actorId) {...}//通过actorId获取任务列表
  public List getGroupTaskList(List actorIds) {...}//通过一个actorId列表来获取一组工作列表
  public TaskInstance loadTaskInstance(long taskInstanceId) {...}//装载任务实例
  public TaskInstance loadTaskInstanceForUpdate(long taskInstanceId) {...}//装载任务实例以更新
  public Token loadToken(long tokenId) {...}//装载令牌
  public Token loadTokenForUpdate(long tokenId) {...}//装载令牌以更新
  public ProcessInstance loadProcessInstance(long processInstanceId) {...}//装载流程实例
  public ProcessInstance loadProcessInstanceForUpdate(long processInstanceId) {...}//装载流程实例以更新
  public ProcessInstance newProcessInstance(String processDefinitionName) {...}//产生新的流程实例
  public void save(ProcessInstance processInstance) {...}//保存流程实例
  public void save(Token token) {...}//保存令牌
  public void save(TaskInstance taskInstance) {...}//保存任务实例
  public void setRollbackOnly() {...}//设置回滚

注意XxxForUpdate方法将注册装载的对象以自动保存，所以你不必再明确地调用一个save方法。

可以指定多个jbpm-context，但另一方面你必须确保每一个jbpm-context必须拥有一个唯一的name属性。命名的上下文可以用JbpmConfiguration.createContext(String name)来获取。
一个service项指定了一个服务的名字和服务的service factory。这个服务将只在用JbpmContext.getServices().getService(String name)方法要求创建时被创建。
工厂也可以被指定为一个element元素来替代attribute属性，那可能需要在factory对象注入一些配置信息。负责解析XML,创建和写入对象的组件成为对象工厂（the object factory）。

6.1. Configuration properties

jbpm.byte.block.size: 文件附件和二进制变量存储在数据库中。不是作为二进制大对象（blob）存储，而是作为一些固定大小的二进制对象列表。这是为了达到在不同的数据库中提高移植性和提高jBPM的总体嵌入性。这个参数控制了这个固定长度块的大小。

jbpm.task.instance.factory: 为了定制任务实例的创建方式，在这个属性中指定了完全限定类名。当你想要定制TaskInstance bean且要添加一个新的properties到TaskIntance Bean时可能需要这么做。（请看Section 11.10，“定制任务实例”），指定的类需要实现org.jbpm.taskmgmt.TaskIntanceFactory.

jbpm.variable.resolver: 为了定制jBPM将要查找的在JSF形式的表达式第一项的方法。

jbpm.msg.wait.timout: To customize the time inbetween polls for messages. 

6.2. Configuration 文件
这是在jBPM可定制的所有配置文件的简短描述。

6.2.1. Hibernate cfg xml 文件
这个文件包含hibernate配置和hibernate映射资源文件的引用。
位置：hibernate.cfg.xml除非特别指定，否则在jbpm.properties文件的jbpm.hibernate.cfg.xml属性指定。在jbpm工程，默认的hibernate.cfg.xml文件处在src/config.files/hibernate.cfg.xml目录下。


6.2.2. Hibernate 查询配置文件
该文件包含hibernate查询，这些查询在jBPM 会话 org.jbpm.db.*Session中使用。
位置:org/jbpm/db/hibernate.queries.hbm.xml 

6.2.3. 节点类型配置文件
该文件XML节点元素到节点实现类的映射。
位置：org/jbpm/graph/node/node.types.xml


6.2.4. Action 类型配置文件
该文件包含了XML action元素到Action实现类的映射
位置：org/jbpm/graph/action/action.types.xml


6.2.5. 业务日历配置文件
包含了业务时间和自由时间的配置
位置：org/jbpm/calendar/jbpm.business.calendar.properties
Location: org/jbpm/calendar/jbpm.business.calendar.properties

6.2.6. 变量映射配置文件
指定流程变量(java对象)的值如何被转化为实例变量来存储到jbpm数据库中。
位置：org/jbpm/context/exe/jbpm.varmapping.xml


6.2.7. Converter 配置文件
指定id-to-classname映射。id存储在数据库中。org.jbpm.db.hibernate.ConverterEnumType用来映射id到单独的对象。
位置：org/jbpm/db/hibernate/jbpm.converter.properties


6.2.8. 默认 modules 配置文件
指定那个modules被默认添加到一个新的流程定义中。
位置： org/jbpm/graph/def/jbpm.default.modules.properties

6.2.9. 流程归档解析配置文件
指定流程归档解析安排。
位置： org/jbpm/jpdl/par/jbpm.parsers.xml

6.3.对象工厂(Object factory)
对象工厂能通过beans-like XML配置文件来创建对象。配置文件指定对象应该如何被创建、配置和连接在一起来形成一个完整的对象图。对象工厂可以注入配置和其他bean到一个bean中。
在最简单的形式下，对象工厂能通过如下的配置来创建基本类型和java beans。

<beans>
  <bean name="task" class="org.jbpm.taskmgmt.exe.TaskInstance"/>
  <string name="greeting">hello world</string>
  <int name="answer">42</int>
  <boolean name="javaisold">true</boolean>
  <float name="percentage">10.2</float>
  <double name="salary">100000000.32</double>
  <char name="java">j</char>
  <null name="dusttodust" />
</beans>

---------------------------------------------------------

ObjectFactory of = ObjectFactory.parseXmlFromAbove();
assertEquals(TaskInstance.class, of.getNewObject("task").getClass());
assertEquals("hello world", of.getNewObject("greeting"));
assertEquals(new Integer(42), of.getNewObject("answer"));
assertEquals(Boolean.TRUE, of.getNewObject("javaisold"));
assertEquals(new Float(10.2), of.getNewObject("percentage"));
assertEquals(new Double(100000000.32), of.getNewObject("salary"));
assertEquals(new Character('j'), of.getNewObject("java"));
assertNull(of.getNewObject("dusttodust"));
Also you can configure lists:

<beans>
  <list name="numbers">
    <string>one</string>
    <string>two</string>
    <string>three</string>
  </list>
</beans>
和 maps

<beans>
  <map name="numbers">
    <entry><key><int>1</int></key><value><string>one</string></value></entry>
    <entry><key><int>2</int></key><value><string>two</string></value></entry>
    <entry><key><int>3</int></key><value><string>three</string></value></entry>
  </map>
</beans>
Beans可以用直接的域注入和通过property的setter被配置。

<beans>
  <bean name="task" class="org.jbpm.taskmgmt.exe.TaskInstance" >
    <field name="name"><string>do dishes</string></field>
    <property name="actorId"><string>theotherguy</string></property>
  </bean>
</beans>
Beans可以被引用。引用它的对象不必是一个bean，它也可以是一个字符串，整数或任何其它的对象。

<beans>
  <bean name="a" class="org.jbpm.A" />
  <ref name="b" bean="a" />
</beans>
Beans可以用任何构造器进行构造。

<beans>
  <bean name="task" class="org.jbpm.taskmgmt.exe.TaskInstance" >
    <constructor>
      <parameter class="java.lang.String">
        <string>do dishes</string>
      </parameter>
      <parameter class="java.lang.String">
        <string>theotherguy</string>
      </parameter>
    </constructor>
  </bean>
</beans>
...或通过bean上的一个对象方法

<beans>
  <bean name="taskFactory" 
         class="org.jbpm.UnexistingTaskInstanceFactory" 
         singleton="true"/>

  <bean name="task" class="org.jbpm.taskmgmt.exe.TaskInstance" >
    <constructor factory="taskFactory" method="createTask" >
      <parameter class="java.lang.String">
        <string>do dishes</string>
      </parameter>
      <parameter class="java.lang.String">
        <string>theotherguy</string>
      </parameter>
    </constructor>
  </bean>
</beans>
...或用一个类上的静态工厂方法...

<beans>
  <bean name="task" class="org.jbpm.taskmgmt.exe.TaskInstance" >
    <constructor factory-class="org.jbpm.UnexistingTaskInstanceFactory" method="createTask" >
      <parameter class="java.lang.String">
        <string>do dishes</string>
      </parameter>
      <parameter class="java.lang.String">
        <string>theotherguy</string>
      </parameter>
    </constructor>
  </bean>
</beans>
每一个命名的对象可以用属性siglenton="true"来标记为单态。那意味着一个给定的对象工厂对于每一个请求将总是返回同一个对象。注意，单台在两个不同的对象工厂中不被共享。

单态的特征带来了getObject和getNewObject方法的区别。典型的对象工厂用户将使用getNewObject.这意味着第首先对象工厂的对象缓存在一个新的对象图构造之前被清空，存储在对象工厂缓存的非单态对象允许被一个对象共享引用。单态对象缓存不同于普通的对象缓存。单台缓存从不被清空，而普通对象缓存在每一个getNewObject方法启动时被清空。