jBPM3.2用户指南HelloWorld范例

本教程向你展示用jpdl构造的简单流程和使用API管理流程运行时执行的过程。

本教程的形式是解释一批范例。这些范例着眼于一个特定的主题并包含大量的注解。这些范例也能够在jBPM下载软件包的src/java.examples目录中找到。

最好的学习方式是创建一个项目，并通过创建下面的范例的变体来体验它。

在开始之前，首先下载和安装jBPM。

jBPM包含一个图形设计器工具，可用于创建在这些范例中显示的xml文件。你可以在《下载和安装jBPM》部分找到下载这个图形设计器的指南。你不需要为了完成本教程而使用这个图形设计工具。

Hello World范例

流程定义是一个有向图，由节点（node）和转移（transition）组成。Hello world流程有三个节点。为了看到这些代码片段如何组合在一起，我们从一个简单的流程开始，不使用图形设计工具。下面的图显示hello world流程的图形表示：

图 3.1. Hello world流程图

 
 
 
 
    
  
  
  
  
  1. public void testHelloWorldProcess() {  
    2.   
  
  
  
  2. // 本方法显示一个流程定义和此流程定义的执行。这个流程定义有三个节点：一个未命名的  
    3.   
  
  
  
  3. // start状态，一个状态s和一个名为end的结束状态。  
    4.   
  
  
  
  4. // 下面一行将一段xml文本解析为一个流程定义ProcessDefinition。流程定义是对流程  
    5.   
  
  
  
  5. // 的正式描述，表示为一个Java对象。  
    6.   
  
  
  
  6. ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(  
    7.   
  
  
  
  7.     "" +  
    8.   
  
  
  
  8.     "  " +  
    9.   
  
  
  
  9.     "    " +  
    10.   
  
  
  
  10.     "  " +  
    11.   
  
  
  
  11.     "  " +  
    12.   
  
  
  
  12.     "    " +  
    13.   
  
  
  
  13.     "  " +  
    14.   
  
  
  
  14.     "  " +  
    15.   
  
  
  
  15.     "" 
    16.   
  
  
  
  16. );  
    17.   
  
  
  
  17.  
    18.   
  
  
  
  18.   // 下面一行代码创建流程定义的一个执行。流程执行创建之后将拥有一个主执行  
    19.   
  
  
  
  19.   // 路径（=根token），指向开始状态节点。  
    20.   
  
  
  
  20.   ProcessInstance processInstance = new ProcessInstance(processDefinition);  
    21.   
  
  
  
  21.  
    22.   
  
  
  
  22.   // 流程执行创建之后，拥有一个主执行路径(=根token)。  
    23.   
  
  
  
  23.   Token token = processInstance.getRootToken();  
    24.   
  
  
  
  24.  
    25.   
  
  
  
  25.   // 流程执行创建之后，主执行路径指向流程定义的开始状态节点。  
    26.   
  
  
  
  26.   assertSame(processDefinition.getStartState(), token.getNode());  
    27.   
  
  
  
  27.  
    28.   
  
  
  
  28.   // 下面我们启动流程执行，从缺省转移路线离开开始状态节点。  
    29.   
  
  
  
  29.   token.signal();  
    30.   
  
  
  
  30.   // signal方法将阻塞，直至流程执行进入一个等待状态。  
    31.   
  
  
  
  31.   // 流程执行进入了第一个等待状态：状态s。所以主执行路径现在指向状态s。  
    32.   
  
  
  
  32.   assertSame(processDefinition.getNode("s"), token.getNode());  
    33.   
  
  
  
  33.  
    34.   
  
  
  
  34.   // 下面我们发送第二个信号。这将恢复流程执行，通过缺省的转移路径离开状态s。  
    35.   
  
  
  
  35.   token.signal();  
    36.   
  
  
  
  36.  
    37.   
  
  
  
  37.   // 现在signal方法返回了，因为流程实例到达了结束状态节点。  
    38.   
  
  
  
  38.     assertSame(processDefinition.getNode("end"), token.getNode());  
    39.   
  
  
  
  39. } 
    40.

数据库范例

jBPM的一个基本特征是把处于等待状态中的流程执行持久化到数据库中的能力。下面的范例将向你展示如何将一个流程实例保存到jBPM数据库中。本范例也暗示存在一个流程执行的上下文。下面各个方法在不同的用户代码片段中创建，例如，在web应用程序中的一段用户代码发起一个流程执行并将它持久化到数据库中，随后，一个消息驱动bean从数据库中装载这个流程实例并恢复其执行。

 
 
 
 
    
  
  
  
  
  1. public class HelloWorldDbTest extends TestCase {  
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.   static JbpmConfiguration jbpmConfiguration = null;   
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.   static {  
    6.   
  
  
  
  6.     // 像此处的范例配置文件能够在'src/config.files'中找到。典型地配置信息存在  
    7.   
  
  
  
  7.    // 于资源文件'jbpm.cfg.xml'中，但在这里我们直接传递一个XML字符串形式的配置信息。  
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9.     // 首先我们创建一个JbpmConfiguration静态对象。系统中的所有线程可以使用  
    10.   
  
  
  
  10.     // 同一个JbpmConfiguration，因此我们可以安全地把它设定为静态的。  
    11.   
  
  
  
  11.     jbpmConfiguration = JbpmConfiguration.parseXmlString(  
    12.   
  
  
  
  12.       "" +  
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.       // jbpm-context机制能够从jbmp使用的环境服务中分离出jbpm核心引擎。  
    15.   
  
  
  
  15.  
    16.   
  
  
  
  16.       "  " +  
    17.   
  
  
  
  17.       "      
  
  
  
  18.       "             factory='org.jbpm.persistence.db.DbPersistenceServiceFactory' />" +   
    19.   
  
  
  
  19.       "  " +  
    20.   
  
  
  
  20.  
    21.   
  
  
  
  21.       // 同样地，jbpm使用的所有资源文件可以从jbpm.cfg.xml中引用。  
    22.   
  
  
  
  22.  
    23.   
  
  
  
  23.       "    
  
  
  
  24.       "          value='hibernate.cfg.xml' />" +  
    25.   
  
  
  
  25.       "    
  
  
  
  26.       "          value='org/jbpm/calendar/jbpm.business.calendar.properties' />" +  
    27.   
  
  
  
  27.       "    
  
  
  
  28.       "          value='org/jbpm/graph/def/jbpm.default.modules.properties' />" +  
    29.   
  
  
  
  29.       "    
  
  
  
  30.       "          value='org/jbpm/db/hibernate/jbpm.converter.properties' />" +  
    31.   
  
  
  
  31.       "    
  
  
  
  32.       "          value='org/jbpm/graph/action/action.types.xml' />" +  
    33.   
  
  
  
  33.       "    
  
  
  
  34.       "          value='org/jbpm/graph/node/node.types.xml' />" +  
    35.   
  
  
  
  35.       "    
  
  
  
  36.       "          value='org/jbpm/context/exe/jbpm.varmapping.xml' />" +  
    37.   
  
  
  
  37.       "" 
    38.   
  
  
  
  38.     );  
    39.   
  
  
  
  39.   }  
    40.   
  
  
  
  40.  
    41.   
  
  
  
  41.   public void setUp() {  
    42.   
  
  
  
  42.     jbpmConfiguration.createSchema();  
    43.   
  
  
  
  43.   }  
    44.   
  
  
  
  44.  
    45.   
  
  
  
  45.   public void tearDown() {  
    46.   
  
  
  
  46.     jbpmConfiguration.dropSchema();  
    47.   
  
  
  
  47.   }  
    48.   
  
  
  
  48.  
    49.   
  
  
  
  49.   public void testSimplePersistence() {  
    50.   
  
  
  
  50.     // 在以下的三个方法调用之间，所有的数据通过数据库传递。在这个单元测试中，  
    51.   
  
  
  
  51.     // 这三个方法是顺序执行的，因为我们要测试一个完整的流程场景。但是在现实  
    52.   
  
  
  
  52.     //中，这些方法代表对服务器的不同请求。  
    53.   
  
  
  
  53.  
    54.   
  
  
  
  54.     // 因为我们从一个干净的、空的内存数据库中启动，必须首先部署流程。现实中，  
    55.   
  
  
  
  55.     // 流程部署是由流程开发者一次性完成的。  
    56.   
  
  
  
  56.     deployProcessDefinition();  
    57.   
  
  
  
  57.  
    58.   
  
  
  
  58.     // 假设当用户在web应用程序中提交一个form的时候，我们要启动一个流程实例……  
    59.   
  
  
  
  59.     processInstanceIsCreatedWhenUserSubmitsWebappForm();  
    60.   
  
  
  
  60.  
    61.   
  
  
  
  61.     // 随后，当异步消息到达之后，将继续执行流程。  
    62.   
  
  
  
  62.     theProcessInstanceContinuesWhenAnAsyncMessageIsReceived();  
    63.   
  
  
  
  63.   }  
    64.   
  
  
  
  64.  
    65.   
  
  
  
  65.   public void deployProcessDefinition() {  
    66.   
  
  
  
  66.     // 本测试展示一个流程定义和该流程定义的一个执行实例。这个流程定义有  
    67.   
  
  
  
  67.     // 三个节点：一个未命名的开始状态，一个状态s和一个名为end的结束状态。  
    68.   
  
  
  
  68.     ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(  
    69.   
  
  
  
  69.       "" +  
    70.   
  
  
  
  70.       "  " +  
    71.   
  
  
  
  71.       "    " +  
    72.   
  
  
  
  72.       "  " +  
    73.   
  
  
  
  73.       "  " +  
    74.   
  
  
  
  74.       "    " +  
    75.   
  
  
  
  75.       "  " +  
    76.   
  
  
  
  76.       "  " +  
    77.   
  
  
  
  77.       "" 
    78.   
  
  
  
  78.     );  
    79.   
  
  
  
  79.  
    80.   
  
  
  
  80.     // 查找在上面的过程中已配置好的POJO持久化上下文生成器。  
    81.   
  
  
  
  81.     JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();  
    82.   
  
  
  
  82.     try {  
    83.   
  
  
  
  83.       // 将流程定义部署到数据库。  
    84.   
  
  
  
  84.       jbpmContext.deployProcessDefinition(processDefinition);  
    85.   
  
  
  
  85.  
    86.   
  
  
  
  86.     } finally {  
    87.   
  
  
  
  87.       // 销毁POJO持久化上下文。  
    88.   
  
  
  
  88.      // 这包括刷新SQL，将流程定义插入到数据库中。  
    89.   
  
  
  
  89.       jbpmContext.close();  
    90.   
  
  
  
  90.     }  
    91.   
  
  
  
  91.   }  
    92.   
  
  
  
  92.  
    93.   
  
  
  
  93.   public void processInstanceIsCreatedWhenUserSubmitsWebappForm() {  
    94.   
  
  
  
  94.     // 本方法中的代码应存在于一个struts的action 或JSF托管的bean中。  
    95.   
  
  
  
  95.  
    96.   
  
  
  
  96.     //  查找在上面的过程中已配置好的POJO持久化上下文生成器。  
    97.   
  
  
  
  97.     JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();  
    98.   
  
  
  
  98.     try {  
    99.   
  
  
  
  99.  
    100.   
  
  
  
  100.       GraphSession graphSession = jbpmContext.getGraphSession();  
    101.   
  
  
  
  101.  
    102.   
  
  
  
  102.       ProcessDefinition processDefinition =   
    103.   
  
  
  
  103.           graphSession.findLatestProcessDefinition("hello world");  
    104.   
  
  
  
  104.  
    105.   
  
  
  
  105.       // 从数据库中取得流程定义之后，我们可以创建该流程定义的一个执行实例，  
    106.   
  
  
  
  106.       // 就像Hello world范例中一样（后者没有使用持久化）。  
    107.   
  
  
  
  107.       ProcessInstance processInstance =   
    108.   
  
  
  
  108.           new ProcessInstance(processDefinition);  
    109.   
  
  
  
  109.  
    110.   
  
  
  
  110.       Token token = processInstance.getRootToken();   
    111.   
  
  
  
  111.       assertEquals("start", token.getNode().getName());  
    112.   
  
  
  
  112.       // 下面启动流程执行  
    113.   
  
  
  
  113.       token.signal();  
    114.   
  
  
  
  114.       // 现在流程处于状态s。  
    115.   
  
  
  
  115.       assertEquals("s", token.getNode().getName());  
    116.   
  
  
  
  116.  
    117.   
  
  
  
  117.       // 现在流程实例被保存到数据库中，所以流程执行的当前状态被保存到数据库中了。  
    118.   
  
  
  
  118.       jbpmContext.save(processInstance);  
    119.   
  
  
  
  119.       // 下面的方法将从数据库中取回流程实例，通过提供另一个外部信号恢复流程的执行。  
    120.   
  
  
  
  120.  
    121.   
  
  
  
  121.     } finally {  
    122.   
  
  
  
  122.       // 销毁POJO持久化上下文。  
    123.   
  
  
  
  123.       jbpmContext.close();  
    124.   
  
  
  
  124.     }  
    125.   
  
  
  
  125.   }  
    126.   
  
  
  
  126.  
    127.   
  
  
  
  127.   public void theProcessInstanceContinuesWhenAnAsyncMessageIsReceived() {  
    128.   
  
  
  
  128.     // 本方法中的代码可以是一个消息驱动bean的内容。  
    129.   
  
  
  
  129.     //查找在上面的代码中已经配置好的POJO持久化上下文生成器  
    130.   
  
  
  
  130.     JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();  
    131.   
  
  
  
  131.     try {  
    132.   
  
  
  
  132.  
    133.   
  
  
  
  133.       GraphSession graphSession = jbpmContext.getGraphSession();  
    134.   
  
  
  
  134.       // 首先，我们需要从数据库中取回流程实例。为了知道哪个流程实例是我们这里要使用的，  
    135.   
  
  
  
  135.       // 有几个可选方法。在这个简单的测试案例中，最容易的方式是在整个流程实例列表中查  
    136.   
  
  
  
  136.       // 找，这将仅仅返回一个结果。所以，让我们获取这个流程定义。  
    137.   
  
  
  
  137.  
    138.   
  
  
  
  138.       ProcessDefinition processDefinition =   
    139.   
  
  
  
  139.           graphSession.findLatestProcessDefinition("hello world");  
    140.   
  
  
  
  140.  
    141.   
  
  
  
  141.       // 现在，我们查找这个流程定义中的所有流程实例。  
    142.   
  
  
  
  142.       List processInstances =   
    143.   
  
  
  
  143.           graphSession.findProcessInstances(processDefinition.getId());  
    144.   
  
  
  
  144.  
    145.   
  
  
  
  145.       // 因为我们知道，在这个单元测试测环境中只存在一个执行实例。在现实中，  
    146.   
  
  
  
  146.       // processInstanceId要从到达的消息内容中提取，或来自用户的选择。  
    147.   
  
  
  
  147.       ProcessInstance processInstance =   
    148.   
  
  
  
  148.           (ProcessInstance) processInstances.get(0);  
    149.   
  
  
  
  149.  
    150.   
  
  
  
  150.       // 现在我们可以继续流程执行了。记住流程实例将信号转发给主执行路径(=根token)。  
    151.   
  
  
  
  151.       processInstance.signal();  
    152.   
  
  
  
  152.  
    153.   
  
  
  
  153.       // 发出信号之后，我们知道流程执行到达了结束状态。  
    154.   
  
  
  
  154.       assertTrue(processInstance.hasEnded());  
    155.   
  
  
  
  155.  
    156.   
  
  
  
  156.       // 现在我们可以将流程执行的状态更新到数据库中  
    157.   
  
  
  
  157.       jbpmContext.save(processInstance);  
    158.   
  
  
  
  158.  
    159.   
  
  
  
  159.     } finally {  
    160.   
  
  
  
  160.       // 销毁POJO持久化上下文。  
    161.   
  
  
  
  161.       jbpmContext.close();  
    162.   
  
  
  
  162.     }  
    163.   
  
  
  
  163.   }  
    164.   
  
  
  
  164. } 
    165.

#p#

上下文（context）范例：流程变量

流程变量包含流程执行过程中的上下文信息。流程变量类似于java.util.Map，将变量名映射到值，值是java对象。流程变量作为流程实例的一部分被持久化。为了保持简单，在此范例中我们仅仅展示与流程变量有关的API，不考虑持久化。

 
 
 
 
    
  
  
  
  
  1. // 这个范例同样从Hello world流程开始。  
    2.   
  
  
  
  2. // 这次甚至没有修改。  
    3.   
  
  
  
  3. ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(  
    4.   
  
  
  
  4.   "" +  
    5.   
  
  
  
  5.   "  " +  
    6.   
  
  
  
  6.   "    " +  
    7.   
  
  
  
  7.   "  " +  
    8.   
  
  
  
  8.   "  " +  
    9.   
  
  
  
  9.   "    " +  
    10.   
  
  
  
  10.   "  " +  
    11.   
  
  
  
  11.   "  " +  
    12.   
  
  
  
  12.   "" 
    13.   
  
  
  
  13. );  
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15. ProcessInstance processInstance =  
    16.   
  
  
  
  16.   new ProcessInstance(processDefinition);  
    17.   
  
  
  
  17.  
    18.   
  
  
  
  18. // 从流程实例中取得上下文实例，以处理流程变量。  
    19.   
  
  
  
  19. ContextInstance contextInstance =   
    20.   
  
  
  
  20.   processInstance.getContextInstance();  
    21.   
  
  
  
  21.  
    22.   
  
  
  
  22. // 在流程离开开始状态之前，我们准备在流程实例的上下文中设置一些流程变量。  
    23.   
  
  
  
  23. contextInstance.setVariable("amount", new Integer(500));  
    24.   
  
  
  
  24. contextInstance.setVariable("reason", "i met my deadline");  
    25.   
  
  
  
  25.  
    26.   
  
  
  
  26. // 从现在开始，这些变量关联到这个流程实例了。现在这些变量可以通过用户代码  
    27.   
  
  
  
  27. // 使用在这里显示的API来访问了，但是，也可以在action和节点实现中访问。流  
    28.   
  
  
  
  28. // 程变量作为流程实例的一部分，也被存储到数据库中。  
    29.   
  
  
  
  29.  
    30.   
  
  
  
  30. processInstance.signal();  
    31.   
  
  
  
  31.  
    32.   
  
  
  
  32. // 流程变量可以通过contextInstance访问。  
    33.   
  
  
  
  33.  
    34.   
  
  
  
  34. assertEquals(new Integer(500),   
    35.   
  
  
  
  35.              contextInstance.getVariable("amount"));  
    36.   
  
  
  
  36. assertEquals("i met my deadline",   
    37.   
  
  
  
  37.              contextInstance.getVariable("reason")); 
    38.  
 
 
 
任务分配范例
在下面的例子中我们展示如何将任务分配给用户。因为jBPM工作流引擎和组织机构模型的分离，一个用于计算参与者（actor）的表达式语言总是太受限了。因此，你必须指定一个 AssignmentHandler接口的实现类来包含计算任务的参与者的过程。
 
 
 
 
    
  
  
  
  
  1. public void testTaskAssignment() {  
    2.   
  
  
  
  2.   // 下面的流程基于hello world流程。状态节点被任务节点取代。任务节点是jPDL中  
    3.   
  
  
  
  3.   // 的一种节点，表示一个等待状态，并创建在流程继续执行之前必须完成的任务。  
    4.   
  
  
  
  4.   ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(  
    5.   
  
  
  
  5.     "" +  
    6.   
  
  
  
  6.     "  " +  
    7.   
  
  
  
  7.     "    " +  
    8.   
  
  
  
  8.     "  " +  
    9.   
  
  
  
  9.     "  " +  
    10.   
  
  
  
  10.     "    " +  
    11.   
  
  
  
  11.     "      " +  
    12.   
  
  
  
  12.     "    " +  
    13.   
  
  
  
  13.     "    " +  
    14.   
  
  
  
  14.     "  " +  
    15.   
  
  
  
  15.     "  " +  
    16.   
  
  
  
  16.     "" 
    17.   
  
  
  
  17.   );  
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19.   // 创建流程定义的一个执行实例。  
    20.   
  
  
  
  20.   ProcessInstance processInstance =   
    21.   
  
  
  
  21.       new ProcessInstance(processDefinition);  
    22.   
  
  
  
  22.   Token token = processInstance.getRootToken();  
    23.   
  
  
  
  23.  
    24.   
  
  
  
  24.   // 下面开始流程执行，从缺省转换路径离开开始状态。  
    25.   
  
  
  
  25.   token.signal();  
    26.   
  
  
  
  26.   // signal方法将阻塞，直至流程执行进入一个等待状态。在这里，就是任务节点t。  
    27.   
  
  
  
  27.   assertSame(processDefinition.getNode("t"), token.getNode());  
    28.   
  
  
  
  28.  
    29.   
  
  
  
  29.   // 当流程执行到达任务节点，一个'换尿布（change nappy）'任务将被创建，  
    30.   
  
  
  
  30.   // NappyAssignmentHandler被调用以决定把这个任务分配给谁。  
    31.   
  
  
  
  31.   // NappyAssignmentHandler返回'（爸爸）papa'。  
    32.   
  
  
  
  32.  
    33.   
  
  
  
  33.   // 在真实的环境中，任务通过org.jbpm.db.TaskMgmtSession类中的方法从数据  
    34.   
  
  
  
  34.   // 库中取得。因为我们不想在本范例中包含持久化的复杂性，我们仅仅从流程实例中  
    35.   
  
  
  
  35.   // 取出第一个任务实例（我们知道在这个测试场景中只有一个任务实例）。  
    36.   
  
  
  
  36.   TaskInstance taskInstance = (TaskInstance)    
    37.   
  
  
  
  37.       processInstance  
    38.   
  
  
  
  38.         .getTaskMgmtInstance()  
    39.   
  
  
  
  39.         .getTaskInstances()  
    40.   
  
  
  
  40.         .iterator().next();  
    41.   
  
  
  
  41.  
    42.   
  
  
  
  42.   // 现在，我们检测任务实例是否真正被指派给'papa'.  
    43.   
  
  
  
  43.   assertEquals("papa", taskInstance.getActorId() );  
    44.   
  
  
  
  44.  
    45.   
  
  
  
  45.   // 现在我们假设爸爸已经完成他的任务，并把任务标记为已完成。  
    46.   
  
  
  
  46.   taskInstance.end();  
    47.   
  
  
  
  47.  
    48.   
  
  
  
  48.   // 因为这是最后（唯一）一个要完成的任务，这个任务的完成出发了流程实例的继续执行。  
    49.   
  
  
  
  49.   assertSame(processDefinition.getNode("end"), token.getNode());  
    50.   
  
  
  
  50. } 
    51.  
 
 
 
定制action范例
action是把你的客户java代码绑定到jBPM流程的一种机制。action能够关联到它自己的节点（如果它们在流程的图形表示中是相关的的话）。action也能够放置在事件（例如进入转换、离开节点、进入节点等）之中。在这种情况下，action不是流程的图形表示的一部分，但是，当运行时流程执行触发了这些事件的时候，这些action将被执行。
 
 
 
 
    
  
  
  
  
  1. // MyActionHandler代表一个能够在jBPM流程执行过程中执行某些用户代码的类。  
    2.   
  
  
  
  2. public class MyActionHandler implements ActionHandler {  
    3.   
  
  
  
  3.  
    4.   
  
  
  
  4.   // 在每个test之前(在setUp方法中), isExecuted成员将被设置为false。  
    5.   
  
  
  
  5.   public static boolean isExecuted = false;    
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7.   // action将把 isExecuted设置为true，使得单元测试能够显示action在什么时候被执行。  
    8.   
  
  
  
  8.   public void execute(ExecutionContext executionContext) {  
    9.   
  
  
  
  9.     isExecuted = true;  
    10.   
  
  
  
  10.   }  
    11.   
  
  
  
  11. } 
    12.  
 
 
 
我们从在下面的范例中将要用到的action实现：MyActionHandler开始。这个action处理器实现没有做真正有用的工作，仅仅把布尔变量isExecuted设置为true。变量isExecuted是静态的，所以能够同时从action处理器内部和要校验它的值的action中访问。
 
 
 
 
    
  
  
  
  
  1. // 每个测试将在开始时设置MyActionHandler的静态成员isExecuted为false。  
    2.   
  
  
  
  2. public void setUp() {  
    3.   
  
  
  
  3.   MyActionHandler.isExecuted = false;  
    4.   
  
  
  
  4. } 
    5.  
 
 
 
下面的例子显示同样的action，但是现在action被分别放在enter-node和leave-node事件之中。请注意与转换只有一个事件不同，节点拥有多个事件类型，因此被放置到节点中的action应该放在event元素之中。
 
 
 
 
    
  
  
  
  
  1. public void testTransitionAction() {  
    2.   
  
  
  
  2.     // 下面的流程是hello world流程的一个变体。我们把一个action加入从状态s到结束状  
    3.   
  
  
  
  3.     // 态的转换之中。本测试的目的是显示要把java代码集成到jBPM流程中是多么容易。  
    4.   
  
  
  
  4.     ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(  
    5.   
  
  
  
  5.       "" +  
    6.   
  
  
  
  6.       "  " +  
    7.   
  
  
  
  7.       "    " +  
    8.   
  
  
  
  8.       "  " +  
    9.   
  
  
  
  9.       "  " +  
    10.   
  
  
  
  10.       "    " +  
    11.   
  
  
  
  11.       "      " +  
    12.   
  
  
  
  12.       "    " +  
    13.   
  
  
  
  13.       "  " +  
    14.   
  
  
  
  14.       "  " +  
    15.   
  
  
  
  15.       "" 
    16.   
  
  
  
  16.     );  
    17.   
  
  
  
  17.  
    18.   
  
  
  
  18.     // 启动流程定义的一个新的执行实例。  
    19.   
  
  
  
  19.     ProcessInstance processInstance =   
    20.   
  
  
  
  20.       new ProcessInstance(processDefinition);  
    21.   
  
  
  
  21.  
    22.   
  
  
  
  22.     // 下一个信号将导致执行离开开始状态，到达状态s。  
    23.   
  
  
  
  23.     processInstance.signal();  
    24.   
  
  
  
  24.  
    25.   
  
  
  
  25.     // 这里我们显示 MyActionHandler还没有被执行。  
    26.   
  
  
  
  26.     assertFalse(MyActionHandler.isExecuted);  
    27.   
  
  
  
  27.     // ... 以及主执行路径指向状态s  
    28.   
  
  
  
  28.     assertSame(processDefinition.getNode("s"),   
    29.   
  
  
  
  29.                processInstance.getRootToken().getNode());  
    30.   
  
  
  
  30.  
    31.   
  
  
  
  31.     // 下一个信号将触发根token的执行。该token将取得包含action的转换，  
    32.   
  
  
  
  32.     // 该action将在调用signal方法的过程中执行。  
    33.   
  
  
  
  33.     processInstance.signal();  
    34.   
  
  
  
  34.  
    35.   
  
  
  
  35.     // 这里我们可以看到在signal方法被调用的时候， MyActionHandler被执行了。  
    36.   
  
  
  
  36.     assertTrue(MyActionHandler.isExecuted);  
    37.   
  
  
  
  37.   } 
    38.  
 
 
 


  
  
  
  
    
   
   
   
   
  1. ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(  
    2.    
   
   
   
  2.   "" +  
    3.    
   
   
   
  3.   "  " +  
    4.    
   
   
   
  4.   "    " +  
    5.    
   
   
   
  5.   "  " +  
    6.    
   
   
   
  6.   "  " +  
    7.    
   
   
   
  7.   "    " +  
    8.    
   
   
   
  8.   "      " +  
    9.    
   
   
   
  9.   "    " +  
    10.    
   
   
   
  10.   "    " +  
    11.    
   
   
   
  11.   "      " +  
    12.    
   
   
   
  12.   "    " +  
    13.    
   
   
   
  13.   "    " +  
    14.    
   
   
   
  14.   "  " +  
    15.    
   
   
   
  15.   "  " +  
    16.    
   
   
   
  16.   "" 
    17.    
   
   
   
  17. );  
    18.    
   
   
   
  18.  
    19.    
   
   
   
  19. ProcessInstance processInstance =   
    20.    
   
   
   
  20.   new ProcessInstance(processDefinition);  
    21.    
   
   
   
  21.  
    22.    
   
   
   
  22. assertFalse(MyActionHandler.isExecuted);  
    23.    
   
   
   
  23. // 下一个信号将导致流程执行离开开始状态，进入状态s。因此状态s被进入，action被执行。  
    24.    
   
   
   
  24. processInstance.signal();  
    25.    
   
   
   
  25. assertTrue(MyActionHandler.isExecuted);  
    26.    
   
   
   
  26.  
    27.    
   
   
   
  27. // 重置MyActionHandler.isExecuted。  
    28.    
   
   
   
  28. MyActionHandler.isExecuted = false;  
    29.    
   
   
   
  29.  
    30.    
   
   
   
  30. // 下一个信号将触发流程执行离开状态s，因此action将被再次执行。  
    31.    
   
   
   
  31. processInstance.signal();  
    32.    
   
   
   
  32. // 瞧……  
    33.    
   
   
   
  33. assertTrue(MyActionHandler.isExecuted); 
    34.   
  
  
  
            

                本文名称：jBPM3.2用户指南HelloWorld范例
                

                转载源于：http://www.shufengxianlan.com/qtweb/news33/465283.html
            

            

                网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                

            

                广告
                
            

            

                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                创新互联
            

        

        

            
猜你还喜欢下面的内容

            
        

    

    

        

            
App设计知识

            
        

        

            
各行业网站

            
        

    





    

        成都做网站　　 　移动APP　　 　网站维护　　 　网站改版　　 　卡多尼人工智　　 　铁科精智测控　　 　自贡电信机房　　 　温江网站建设　　 　成都成品网站　　 　成都企业网站定制　　 　成都工装公司　　 　注册域名　　 　域名注册　　 　微信公众号开发　　 　成都网站设计　　 　成都SEO公司　　 　云服务器香港　　 　小谭网创广告　　 　支点广告　　 　网站建设公司