fndcz http://fndcz.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 jBPM学习（八）----liferay4.2.2下的jBPM开发 fndcz 作者: fndcz  链接：http://fndcz.javaeye.com/blog/114455  发表时间: 2007年08月20日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

八、liferay4.2.2下的jBPM开发
liferay4.2.2中对jBPM3.1.2进行了集成，并且多jpdl语言做了扩展，主要表现在对表单数据类型的支持。表现形式为在原有变量表示的基础上为每个变量名加上前缀。下面我们通过一个稍微复杂的例子来具体讲解。（这里liferay在eclipse下的工程名为portal，扩展工程名为ext）
1.         数据库的迁移
数据库的生成这里不再赘述，请参考前面章节建立数据库。数据库建立之后，修改portal\jbpm-web\docroot\WEB-INF\classes\hibernate.cfg.xml文件，此文件为liferay下的jbpm数据库配置文件，注释掉<!-- Hypersonic -->下的属性，根据数据库配置<!-- SQL Server -->下属性，我的配置如下：
xml 代码
  1. <property name="hibernate.dialect">org.hibernate.dialect.SQLServerDialect</property>  
  2. <property name="hibernate.connection.driver_class">net.sourceforge.jtds.jdbc.Driver</property>  
  3. <property name="hibernate.connection.url">jdbc:jtds:sqlserver://127.0.0.1:1433;DatabaseName=lportal</property>  
  4. <property name="hibernate.connection.username">liferay</property>  
  5. <property name="hibernate.connection.password"></property>  
完成后保存文件。
2.         流程定义
在portal\jbpm-web\docroot\WEB-INF\definitions下右键新建一个流程，命名为MessageSend。按照下图所示建立基本流程，具体过程参照前面。
3.         定义泳道
定义一个名为user的泳道：
4.         定义任务
对照下图为各个节点创建任务，并将所有任务赋予泳道user。
5.         定义任务变量
下面分别介绍各个任务中的变量：
任务comment：
任务input-name：
任务input-message-one：
任务input-message-two：
任务show-message：
这里说明一下：liferay的workflow portlet对jbpm的变量定义经行了扩展，可以看到每个变量的名字都由多部分组成其中用冒号分隔，workflow portlet会根据变量的前缀自动为该变量生成html中的表单。
值得注意的是jbpm并不会区分前缀与变量名，而是将这个字符串作为该变量的名字。如：上图中text:message name，变量名就为“text:message name”。在程序中对该变量的引用也应使用“text:message name”。
具体每种数据类型的表示方法如下表：
6.         定义Handler及Action
在流程中我们有一个decision节点，这里需要自定义一个类来对decision逻辑进行处理。首先，我们切换到source视图，找到decision标签，在标签中添加一个handler标签，该标签用来指定处理逻辑的类，具体内容如下：
xml 代码
  1. <decision name="more message">  
  2. <handler class="com.liferay.jbpm.handler.MessageSendDecision"></handler>  
  3.    <transition name="no" to="end"></transition>  
  4.    <transition name="yes" to="message-name-input"></transition>  
  5. </decision>  
从上面可以看出定义的类为：MessageSendDecision，此类的主要任务是通过判断用户的选项来决定将令牌具体传递给哪一个transition，下面我们实现这个类。
       我们在portal工程中新建一个java文件
portal\jbpm-web\docroot\WEB-INF\src\com\liferay\jbpm\handler\MessageSendDecision.java，内容如下：
java 代码
  1. package com.liferay.jbpm.handler;   
  2.     
  3. import org.jbpm.context.exe.ContextInstance;   
  4. import org.jbpm.graph.exe.ExecutionContext;   
  5. import org.jbpm.graph.node.DecisionHandler;   
  6.     
  7. public class MessageSendDecision implements DecisionHandler {   
  8.     
  9.        public String decide(ExecutionContext executionContext) throws Exception {   
  10.               //获取当前令牌所处的上下文   
  11. ContextInstance instance = executionContext.getContextInstance();   
  12.     
  13.               String decision = null;   
  14.               //获取该上下文中的变量radio:more info:yes,no   
  15.               String response = (String) instance.getVariable("radio:more info:yes,no");   
  16.               //对该变量进行判断   
  17.               if (response.equalsIgnoreCase("yes") || response.equalsIgnoreCase("no"))   
  18.                      decision = response;   
  19.               else  
  20.                      decision = "no";   
  21.               System.out.println(decision);   
  22.               //返回decision   
  23. //返回的decision必须与定义的transition名相对应，否则执行默认transition   
  24.               return decision;   
  25.        }   
  26. }   
 
保存该文件，至此该流程的定义结束，我们可以看到jbpm-web目录下多了4个文件：
7.         部署流程
Jboss提供的IDE没有支持在liferay下自动部署流程，因此通过jbpm-web下的ant命令进行部署。
将jbpm-web下的build.xml文件拖入ant窗口，依次执行命令compile编译我们定义的 java类。之后执行deploy命令，将类和流程的定义部署到web应用中。打开tomcat下的webapp/jbpm-web，就可以找到新添加的相应文件。
启动tomcat，登录liferay，添加workflow portlet，点击definition选项，点击add：
将刚才定义的流程的processdenfinition.xml中的内容全部拷贝到文本框中，点击save new version，如下：
提交成功后，可以看到列表中多了一项：
点击add instance，为该流程添加一个新实例，对该流程进行验证。

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Mon, 20 Aug 2007 23:12:29 +0800 http://fndcz.javaeye.com/blog/114455 http://fndcz.javaeye.com/blog/114455 jBPM学习（七）----jBPM相关概念 fndcz 作者: fndcz  链接：http://fndcz.javaeye.com/blog/114451  发表时间: 2007年08月20日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

七、jBPM相关概念

1.         JPDL的流程定义元素
1)        第一层：GraphElement
这个容易理解,因为在画流程定义时,每个拖拉的对象都是一个graph的元素。GraphElement有四个属性：
(1)processDefine 表示当前元素属于哪个流程定义
(2)events 表示可以接收哪些event
(3)name 名字
(4)exceptionHandlers 异常处理类集合(List)
2)        第二层：node、processDefinition、Transition、Task
它们都继承自GraphElement
(1)processDefinition表示流程定义(implements NodeCollection),它有下面的属性:name、version、nodes、startState。nodes表示流程中所有的node，startState用于启动流程时找到首节点。
(2)Transition表示转移，它有三个属性：from(Node)，to(Node)，supportedEventTypes表示支持的event类型
(3)node表示节点，它有四个属性：leaving transitions、arriving transitions、action、superState。
(4)Task 定义任务
3)        第三层：各种不同的node
它们都继承自node。 Decision、EndState、Fork、Join、Merge、Milestone、 InterleaveEnd、InterleaveStart、ProcessState、State。
 
2.         jBPM的token
jbpm中最重要的概念，应该是令牌(Token)和信令(Signal)。在整个流程实例运行过程中，我们可以迅速的利用token得到其当前的current state。在解决“并行”等（比如Fork）问题时，jBpm让Token对象维护了父子关系，这种关系在涉及到Fork的时候会产生。 jBpm让Token这个对象身兼了多种使命：
（1）快速定位current state
（2）用于fork，join算法
（3）用于告知任务执行者的任务索引。
如下代码:
//pd是process definition,pi是process instance ProcessInstance
pi = new ProcessInstance( pd );
//得到根令牌
Token token = pi.getRootToken();
//发信令
token.signal();
Token的signal方法也可以传入transition参数,这个方法把信令发送给Token,这样,令牌将被激活,并沿指定的transition离开当前的状态(如果没有指定transition,将沿缺省的transition 离开当前状态)。
jbpm是怎么实现的呢?其实很简单:
1)Token记录了当前的状态（current state）,只有当前的状态(或称节点)拥有该令牌
2)向TOKEN发signal后,当前状态收到该signal
3)当前状态把令牌传给signal中指定的transition
4)transition收到令牌后,不强占,马上把令牌传给下个状态.
5)根据令牌的位置,流程的状态已经发生改变.
 
 
3.         process definition
一个process definition代表了一个正式的业务流程，它以一个流程图为基础。这个流程图由许多node和transition组成。每个node在这个流程图里都有着各自特殊的类型，这些不同的类型决定了node在运行时的不同行为。一个process definition只有一个start state 。
4.         token
一个token代表了一条执行路径，它包含了这条执行路径的当前的执行状态（current state）。
5.         process instance
一个process instance（流程实例）即一个process definition（流程定义）的流程执行实例。一个process definition可以对应多个process instance。当一个process instance被创建的时候，一个主执行路径token同时被创建，这个token叫做root token，它指向流程定义的start state（processDefinition.getStartState()==token.getNode()）。
6.         signal
一个signal 发送给token通知token 继续流程的执行。如果signal 没有指定transition，token将沿缺省的transition离开当前状态,如果signal 指定transition，token将沿指定的transition离开当前的状态。看源代码可以看到发给process instance的signal 其实都是发送给了root token。
7.         Actions
jbpm提供了灵活的action ，当流程执行，token 进入node和transition时，会触发相应的一些event（事件）。在这些event上附上我们自己写的action，就会带动action 的执行。action里是我们自己的相关java操作代码，非常方便。注意的是event（事件）是内置的，无法扩展。另外，action也可以直接挂在node上，而不依赖于event（事件）的触发，这个很重要。
8.         node
一个流程图由许多node和transition组成。每个node都有一种类型，这个类型决定了当流程执行到这个node时的不同行为。jbpm有一组node type可以供你选择，当然你可以定制自己node 。
node的作用
node有两个主要的作用：
1）执行java代码，比如说创建task instance（任务实例）、发出通知、更新数据库等等。很典型的就是在node 上挂上我们的action
2) 控制流程的执行：
A、等待状态：流程进入到这个node时将处于等待状态，直到一个signal 的发出
B、流程将沿着一个leaving transition越过这个node，这种情况特殊一点，需要有个action挂在这个node上（注意这个action不是event触发的！），action中将会调用到API里 executionContext.leaveNode(String transitionName)，transitionName即这里的leaving transition名字。
C、创建新的执行路径：
很典型的就是fork node。流程在这里会分叉，产生新的执行路径。这样就创建了新的token，每个新的token代表一个新的执行路径。注意的是，这些新的token和产生前的token是父子关系！
D、结束执行路径：一个node可以结束一条执行路径，这同样意味着相应的token的结束和流程的结束。
9.         流程图中的node type
1)        task-node
一个task-node可以包含一个或多个task，这些task分配给特定的user。当流程执行到task-node时，task instance将会被创建，一个task对应一个task instance。task instances 创建后，task-node就处于等待状态。当所有的task instances被特定的user执行完毕后，将会发出一个新的signal 到token，即流程继续执行。
2)        state
state是一个纯粹的wait state(等待状态）。它和task-node的区别就是它不会创建task instances。很典型的用法是，当进入这个节点时（通过绑定一个action到node-enter event），发送一条消息到外部的系统，然后流程就处于等待状态。外部系统完成一些操作后返回一条消息，这个消息触发一个signal 到token，然后流程继续执行。（不常用）
3)        decision
当需要在流程中根据不同条件来判断执行不同路径时，就可以用decision节点。两种方法：最简单的是在transitions里增加condition elements（条件），condition是beanshell script写的，它返回一个boolean。当运行的时候，decision节点将会在它的 leaving transitions里循环，同时比较 leaving transitions里的condition，最先返回'true'的condition，那个leaving transitions将会被执行；作为选择，你可以实现DecisionHandler接口，它有一个decide()方法，该方法返回一个String(leaving transition的名字）。
4)        fork
fork节点把一条执行路径分离成多条同时进行（并发）的执行路径，每条离开fork节点的路径产生一个子token。
5)        join
默认情况下，join节点会认为所有到达该节点的token都有着相同的父token。join 节点会结束每一个到达该节点的token,当所有的子token都到达该节点后，父token会激活。当仍然有子token处于活动状态时，join 节点是wait state(等待状态）。
6)        node
node节点就是让你挂自己的action用的（注意：不是event触发！），当流程到达该节点时，action会被执行。你的action要实现ActionHandler接口。同样，在你的action里要控制流程。
 
10.     Actions的说明
存在两种action，一种是 event触发的action，一种是挂在node 节点的action。要注意它们的区别，event触发的action无法控制流程，也就是说它无法决定流程经过这个节点后下一步将到哪一个leaving transition；而挂在node 节点的action就不同，它可以控制流程。不管是哪一种action都要实现ActionHandler接口。
11.     Task（任务）
jbpm一个相当重要的功能就是对任务进行管理。Task（任务）是流程定义里的一部分，它决定了task instance的创建和分配。Task（任务）可以在task-node节点下定义，也可以挂在process-definition节点下。最普遍的方式是在task-node节点下定义一个或多个任务。默认情况下，流程在task-node节点会处于等待状态，直到所有的任务被执行完毕。任务的名称在整个流程中必须是唯一的。一个TaskNode对应多个Task。
对于这样的流程定义：
xml 代码
  1. <task-node name='a'>    
  2. <task name='laundry' />    
  3. <task name='dishes' />    
  4. <task name='change nappy' />    
  5. <transition to='b' />    
  6. </task-node>    
只有当节点中的三个任务都完成后，流程才进入后面的节点

对于这样的流程定义：
xml 代码
  1. <task-node name='a' signal='first'>>    
  2. <task name='laundry' />    
  3. <task name='dishes' />    
  4. <task name='change nappy' />    
  5. <transition to='b' />    
  6. </task-node>    
当第一个任务完成后，token就指向后面的节点

对于这样的流程定义：
xml 代码
  1. <task-node name='a' signal='never'>>    
  2. <task name='laundry' />    
  3. <task name='dishes' />    
  4. <task name='change nappy' />    
  5. <transition to='b' />    
  6. </task-node>    
三个任务都完成后，token仍然不会指向后面的节点；需要自己手动调用processInstance.signal()才会驱动流程到下面的节点。

对于这样的流程定义：
xml 代码
  1. <task-node name='a' signal='unsynchronized'>>    
  2. <task name='laundry' />    
  3. <task name='dishes' />    
  4. <task name='change nappy' />    
  5. <transition to='b' />    
  6. </task-node>    
token不会在本节点停留，而是直接到后面的节点
 
12.     jbpm的任务管理实现
一个Task instance（任务实例）可以被分配给一个actorId (java.lang.String)。所有的Task instance都被保存在数据库中的表jbpm_taskinstance里。当你想得到特定用户的任务清单时，你就可以通过一个与用户关联的actorId来查询这张表。
一个流程定义有一个TaskMgmtDefinition；一个TaskMgmtDefinition对应多个swimlane,同时对应多个task;一个swimlane有多个task,可以从TaskMgmtDefinition中通过task的名称直接获取相应的task;
swimlane对象有四个属性，分别是name（名字）、assignmentDelegation（分配代理类）、taskMgmtDefinition、tasks（Set 对应多个task),可以增加task
task对象主要的属性：taskMgmtDefinition、swimlane、assignmentDelegation、taskNode，需要注意的是swimlane和assignmentDelegation中间只是可以一个属性有值，因为它们都和任务的分配有关系。
一个流程实例有一个TaskMgmtInstance；一个TaskMgmtInstance对应多个swimlaneInstance,同时对应多个taskInstance;一个swimlaneInstance有多个taskInstance,可以从TaskMgmtInstance中直接获取相应的taskInstance;
swimlaneInstance对象主要有五个属性，分别是name、actorId、pooledActors（Set）、swimlane、taskMgmtInstance。
taskInstance对象的主要属性：name、actorId、task、swimlaneInstance、taskMgmtInstance、pooledActors。
当对任务进行分配时，一般需要实现AssignmentHandler这个接口，这个接口的方法只有一个：
void assign( Assignable assignable, ExecutionContext executionContext ) throws Exception;
一个典型的实现（把名字是'change nappy'的任务交给NappyAssignmentHandler这个类来分配）
xml 代码
  1. <task name='change nappy'>    
  2. <assignment class='org.jbpm.tutorial.taskmgmt.NappyAssignmentHandler' />    
  3. task>    NappyAssignmentHandler类：
    java 代码
    1. public void assign(Assignable assignable, ExecutionContext executionContext) {    
    2. assignable.setActorId("papa");    
    3. }    
    同样，    Assignable只是一个接口，它有两个方法：setActorId()和setPooledActors()，Assignable的具体实现类也是两个：swimlaneInstancehe和taskInstance。这样就不不难理解整个任务分配流程了：

1、流程进入TaskNode节点，执行TaskNode类的execute()方法，该方法首先获得TaskMgmtInstance实例，然后通过它来创建TaskInstance。taskMgmtInstance.createTaskInstance(task, executionContext);
2、在上面的createTaskInstance(task, executionContext)里，该方法调用了taskInstance.assign(executionContext)对taskInstance进行分配。
3、在assign(executionContext)方法里，首先会判断task属性里是否存在swimlane，如果有的话，这个taskInstance就会分配给swimlane指定的ActorId或 PooledActors；如果不存在，再去找task属性里 assignmentDelegation（分配代理类）通过代理类（即我们自己写的实现AssignmentHandler这个接口的类）指定ActorId或 PooledActors。
 
13.     jbpm的用户角色管理
jbpm在用户角色管理上共设计了四个类：Entity、Membership、Group、User。
Entity类是其他三个类的父类，它包含了两个属性：name(String)、permissions(Set)；
User类继承Entity类，包含三个属性：password(String)、email(String)、memberships(Set)；
Group类继承Entity类，包含四个属性: type(String)、parent(Group)、children(Set)、memberships(Set)；
Membership类继承Entity类，包含三个属性:role(String)、user(User)、group(Group)
很明显，一个user对应一个用户，一个group对应一个用户组，它们之间通过membership关联，并且一个user可以属于多个不同类型（type)的group，user和 group之间是多对多的关系。Membership类的role属性个人感觉用途不大，反倒是name属性代表了user在group里的role（角色）。

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Mon, 20 Aug 2007 23:08:50 +0800 http://fndcz.javaeye.com/blog/114451 http://fndcz.javaeye.com/blog/114451 jBPM学习（六）----Hello World fndcz 作者: fndcz  链接：http://fndcz.javaeye.com/blog/114450  发表时间: 2007年08月20日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

六、开发自己的工作流（Hello World）
1.         eclipse插件安装
jbpm提供了在eclipse下的一个可视化插件，通过它我们可以方便的定义工作流，打开jbpm-starters-kit-3.1.4\jbpm-designer\jbpm-gpd-feature目录，我们可以看到下面有一个eclipse文件夹，这里我们通过link的方式为eclipse添加该插件。
在{eclipse_home}/link文件夹下新建jbpm-designer.link文件，用记事本打开该文件加入如下一行：
path=D:\\jbpm-starters-kit-3.1.4\\jbpm-designer\\jbpm-gpd-feature
后面的路径即为该插件的存放路径，根据个人情况修改。注意，这里的分隔符使用双斜杠\\。
2.         新建jbpm项目
主菜单“文件－＞新建－＞项目”，在弹出的对话框里，有“ Process Project ”项，如下图所示：
选上，单击“下一步”，工程起名“myjbpm”，点击下一步为此工程指定一个jbpm location，如果时第一次运行该插件，系统会提示你设置一个jbpm location。这里我们将location设置为D:\jbpm-starters-kit-3.1.4\jbpm.3。然后就可以单击“完成”了。然后就生成了如下图所示的一个项目结构：
这个项目和通常Eclipse的项目结构有点不同，不过这是一个现在非常流行的项目结构，src/main/java存放源文件，src/test/java存放相应的JUnit单元测试代码，src/main/jpdl存放我们定义的工作流文件。
       项目创建起了，介绍一下里面的文件吧：
l         MessageActionHandler，自动生成的一个 ActionHandler。
l         hibernate.cfg.xml 　jBPM是用Hibernate进行工作流的数据存储的，这个就是Hibernate 的配置文件。后面我们将讲到如何配置这个文件。
l         jbpm.cfg.xml 　 jbpm本身的配置文件。现在是空的，它用的是缺省配置，你想知道有哪些配置就去看这个文件
D:\jbpm-starters-kit- 3.1.4\jbpm.3\src\java.jbpm\org\jbpm\default.jbpm.cfg.xml
l         log4j.properties 　这个是日志 API 包 log4j 的配置文件，用过 log4j 的都知道。
l         SimpleProcessTest.java 　这个是对最重要的流程配置文件的processdefinition.xml单元测试代码。
l         gpd.xml 　用于生成流程图的定义文件。都是一些方框的坐标和长宽
l         processdefinition.xml 　这个是对最重要的流程配置文件，以后写流程要经常和它打交道。
l         processimage.jpg 　一个流程图
3.         简单工作流定义
展开myjbpm工程，选中src/main/jpdl包，单击鼠标右键，new->other，如下图：
新建一个Process Definition，process命名为HelloWorld，单击finish，结果如下图：
右面的窗口为工作流定义的可视化窗口。选中该窗口单击eclipse菜单栏view->show Grid为该窗口添加网格，方便后面开发。
1)        定义基本流程
分别向编辑区拖入，start、task node、end节点，用transition将他们依次连起来，并分别修改task node名为show message，end节点名为end，两个transition分别命名为send和ok，得到如下所示结果：
2)        定义泳道(swimlane)
我们为该流程定义一个名为user的泳道(swimlane)，点击编辑窗口左下角的swimlanes按钮，得到添加泳道界面，单击add按钮，按照下图配置相关信息，这样我们就将用户grover加入到了泳道user中：
3)        定义节点任务
打开eclipse中的outline视图，我们可以看到一个名为HelloWorld的process节点，展开该节点，如下图：
右击start节点，选择add task
我们看到start节点下多出了一个名为task的task节点：
双击该节点，打开节点编辑窗口，将该task改名为input message，如下：
选择左边的controller我们为该流程定义一个名为message的变量，这个变量就是我们后面要传递的信息，照下图配置该变量：
点击ok，完成start节点下的任务定义。
       按照以上步骤，我们再为message show节点定义一个名为show message的任务，这里的变量名也为message，但是属性只有read，我们通过这个任务读取前面所输入的message信息。注意两个任务的变量名要相对应，如下图：
      
下来点击assignment菜单，配置该任务的分配方式，如下图所示，将该任务分配给名为user的swimlane，此swimlane包含了grover用户。结果如下图：
单击ok，我们就完成了该流程的任务定义。这里我们看到多出了两个task，如图：
 
4)        保存流程定义
单击保存按钮，我们保存该流程定义。保存成功后我们可以看到，在流程定义的包中多出了一个名为processimage.jpg的图像文件，该文件为我们定义流程的流程图，如下：
点击编辑窗口下的source按钮，我们可以查看通过图形编辑界面自动生成的该流程的xml定义，即processdefinition.xml中的内容。如下：
xml 代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <process-definition  
  3.  xmlns="urn:jbpm.org:jpdl-3.1" name="HelloWorld">  
  4.    <swimlane name="user">  
  5.       <assignment expression="user(grover)"></assignment>  
  6.    </swimlane>  
  7.    <start-state name="start">  
  8.       <task name="input message">  
  9.          <controller>  
  10.             <variable name="message" access="read,write,required"></variable>  
  11.          </controller>  
  12.       </task>  
  13.       <transition name="send" to="message show"></transition>  
  14.    </start-state>  
  15.    <task-node name="message show">  
  16.       <task name="show message" swimlane="user">  
  17.          <controller>  
  18.             <variable name="message" access="read"></variable>  
  19.          </controller>  
  20.       </task>  
  21.       <transition name="OK" to="end"></transition>  
  22.    </task-node>  
  23.    <end-state name="end"></end-state>  
  24. </process-definition>  
对照刚才的流程定义，我们很容易可以看出各个xml标签所对应的意义。具体细节我们将在后面介绍。
5)        部署流程定义
首先我们要启动jboss服务，待服务启动成功后单击编辑窗口下的deployment按钮，按照下图配相应参数，然后点击test connection，如果弹出成功窗口，说明服务器连接正常，否则请检查你的参数设置。
测试连接成功后，我们点击下面的deploy process archive按钮，如果得到成功信息，恭喜你，说明我们定义的工作流已经成功的部署到了jboss上，如下图：
6)        使用工作流
打开IE浏览器，在地址栏中输入http://localhost:8080/jbpm，以cookie monster身份登陆系统。我们看到Start New Process Execution里面多了一项Hello World，这就是我们刚才部署过的工作流。
 
点击input message我们会看到以下画面：
 
注意到左面有个一名为message的文本框，这个文本框就是我们在流程定义里定义的变量message。右面是本流程的流程图，红色的框代表该流程现在运行到哪一步。我们在文本框内输入Hello!Congratulations!。然后点击save and close task按钮，提交该内容。之后页面跳转，我们会在上面看到这样一行提示信息：A new task has been assigned to ‘grover’。说明第一步流程已完成，将下一步任务委派给泳道user中的grover。我们点击屏幕左上角的login as another user。如图所示：
以grover身份登陆系统，我们可以看到在grover的主界面下的tasklist里多出了一项：
 
单击该任务，我们可以看到同样有一个名为message的文本框，但是他的内容是不可编辑的，这和我们定义工作流变量时的设置有关，并且里面的内容正是上一步中cookie monster用户所输入的内容。我们还可以注意到，右面流程图中标明该流程已经进入第二步。
继续点击save and close task按钮，页面跳转，得到信息：The process has finished。并且tasklist中刚才的任务项也不存在了。至此，整个工作流程执行完毕。
7)        工作流管理
Jbpm为我们提供了简单的工作流管理，单击左面菜单栏的monitoring进入monitoring界面，点击链接Process Definitions list，如下：
得到如下界面，这里我们可以看到目前为止所有的工作流定义以及他们所拥有的实例数。通过该图可以得知Hello World目前只有一个实例，即我们刚才执行过的那个实例。
我们点击实例数1，得到Hello World下所有的实例列表，如下图：
我们只初始化过一个实例，因此这里只有一项，start和end分别表示该实例开始和结束的时间，我们点击前面的Id号，查看该实例的详细信息：
其中，task列表列出了该实例所有的task，其中name表示task的名字，actorId表示由谁执行该task，date表示该task结束的时间。Variables列表列出了该task中所有的变量及其值。我们在流程定义里只定义了一项变量，因此这里只有message，它的值即为刚才输入的内容。我们还可以通过update按钮向列表中添加修改变量。
下面的图，即为该流程的流程图。红色的框标明此实例已经结束。
       至此，一个简单的工作流就完成了，相信大家从中可以大致的了解jbpm定义工组流的基本过程，在后面的章节我们将进一步介绍更多的内容。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Mon, 20 Aug 2007 23:06:36 +0800 http://fndcz.javaeye.com/blog/114450 http://fndcz.javaeye.com/blog/114450 jBPM学习（五）----面向图的程序设计 fndcz 作者: fndcz  链接：http://fndcz.javaeye.com/blog/114447  发表时间: 2007年08月20日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

五、面向图的程序设计
Jbpm的流程设计语言是面向图的，下面介绍一些面向图程序设计的概念。
1.         图的结构
1)        Node和transition
首先，图的结构由node和transition组成。每个transition都是有向的，所以node可以有一个leaving transition或者arriving transition。每个node是可以看成一项任务，每个node都有execute方法。Node的子类必须重载这个方法来为该类型的node实现特定的任务。
2)        Execution
在图结构中定义的execution模型和有限自动机还有uml状态图相似。一个execution（也可称为token，下面我们称其为令牌）具有对当前node的一个引用。
 
Transition通过take方法可以将一个令牌(token)从源node传递到目标node。
 
当一个令牌到达一个node的时候，这个node就被执行（通过execute方法）。Node的execute方法也可以经行繁殖。繁殖在这里的意思是一个node可以将到达的令牌通过该node中的一个transition传向下一个node。
当一个node的execute方法没有传递令牌的时候，它就处于等待(wait)状态。同样的，当一个令牌在开始节点创建的时候，它就处于等待状态，等待一些事件(event)。令牌的一个事件可以触发令牌进行传递。如果事件是指向当前节点的一个leaving transition的话，那么令牌将沿着这个transition传递。令牌将不断的传递，知道遇到下个状态为wait的节点。
3)        流程定义语言
在wait状态下，一个令牌指向图中的一个node。此时，流程图和令牌都可以进行持久话，例如通过hibernate将其存入数据库。流程定义语言就是一个Node-implementation的集合。每个Node-implementation对应一个流程结构。
这里我们给出一个例子，该流程语言由4个process组成：一个start state，一个decision，一个task和一个end state。
我们可以通过上面定义的语言来具体描述一个流程，其中冒号前为该节点的描述，冒号后为该节点的具体类型：
当为该流程创建一个新的实例的时候，我们通过将令牌放入该过程的开始节点(start node)。当令牌没有接收到一个事件的时候，这个令牌将一直留在次节点中。
       现在我们来看看当一个事件发生(事件点燃)时，会出现什么情况。在初始情况下，我们通过调用令牌的event方法来点燃一个默认事件，它和默认transition相对应。Event方法可以找到默认的leaving transition，然后通过调用transition的take方法将令牌沿着该tranistion传递。
       这个transition将令牌传递到decision节点并且调用该节点的execute方法。我们假设decision的execute方法通过计算后向令牌传递了一个yes事件。这将使令牌继续沿着’yes’ transition进行传递，之后令牌将到达doublieCheck节点。
       我们假设doubleCheck任务节点的execute方法向checker的任务列表中添加一个实体，然后等待checher的输入，而并不将令牌继续传递。
       现在令牌将在doubleCheck节点停留。
4)        Action
一个Acition同样也有一个execute方法。Action可以和event相联系。在节点被执行的时候有两个基本的事件被触发：node leave和node enter。
每一个event都可以和一系列action相联系，当事件被触发的时候，这些action也将被执行。

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Mon, 20 Aug 2007 23:04:02 +0800 http://fndcz.javaeye.com/blog/114447 http://fndcz.javaeye.com/blog/114447 jBPM学习（四）----体验jbpm fndcz 作者: fndcz  链接：http://fndcz.javaeye.com/blog/114445  发表时间: 2007年08月20日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

四、体验jbpm

进入jbpm主页面后，以 cookie monster 用户登录，在右面我们可以清楚的看到整个定货业务的流程。选择“ create new web sale order ”可以创建一个定单。如下图所示，在图左边是填写的定单情况，右边一整个定货流程的示意图，红色框表示流程进行到哪一步了。填写好定单好，选择“ Save and Close Task ”，完成定单提交。