jbpm介绍流程

对jBPM来讲，工作流由一些节点和用户定义的Hander组成。一个工作流从start-state开始，中间经过若干个节点（state、fork、milestone、process-state、decision和join），最后结束于end-state。节点之间通过transient来连接，指明当前节点下面要经过的节点。经过节点时，jBPM会触发相应的Hander来完成用户指定的工作。Hander包括各种事件的ActionHander；指定节点指定操作Actor的AssignmentHandler；定义节点工作的Hander，包括fork节点ForkHander，Join节点JoinHander，decision节点的DecisionHander，process-state节点的ProcessInvocationHandler。jBPM对Hander都有缺省的实现，如果用户没有指定相应Hander，jBPM就使用缺省Hander。

定义工作流程的时候，可以根据实际业务流程，先画UML状态图，然后根据活动图和jpdl编写processdefinition.xml－jBPM工作流定义文件。状态图的节点可以对应到jpdl的相应节点，比如状态对应于state、转换（分叉）对于fork。流程定义文件设计的时候，可以将一些业务处理放在Hander处理。

    jBPM节点实际上是XPDL规范中Activity的细化，是一种特殊的Activity。start-state与end-state节点，是由jBPM负责处理，jBPM从start-state节点开始工作流程，在end-state结束工作流程。

state节点要外部的参与才能进入到下一个状态，比如请假流程中需要经理批准的步骤。

Join相当于activity transition 的join，fork相当于activity transition 的fork，但是采用怎样join和fork，用户可以自己定义。缺省的fork相当于XPDL 的AND FORK，每个分叉都走；缺省的join 相当于XPDL的AND JOIN，所有分叉都到达后，才进入下一节点。

Decision相当于编程语言中的判断，由DecisionHander决定下一个要经过的节点。通过自己定义DecisionHander，用户可以借助decision节点实现自动节点，即流程到这里，执行一定操作，自动进入下一个节点。

Process-state相当于subflow activity，ProcessInvocationHandler负责处理具体调用子流程的过程，比如子流程名称，传递的参数等。jBPM没有规定子流程的调用过程，只是提供了一个DefaultProcessInvocationHandler，给出了一个调要的范例。

Milestone是一种特殊的节点，用于同步两个执行路径，比如执行到milestone节点后，jBPM就等待，等到另外一条路径上某个节点发出可以继续的信号后，jBPM才进入milestone的下一个节点。节点通过MilestoneReachedActionHandler来发消息。

工作流中用到的所有变量通过Variable来说明，变量类型通过type来定义。类型定义必须要继承org.jbpm.delegation.Serializer接口。变量是作为字符串存储在数据库中的，因此类型要提供与字符串类型相互转换的方法。jBPM变量的作用域是工作流本身。

流程执行到某个节点的时候，会触发节点的相应事件。事件类型包括process-start、process-end、state-enter、state-leave、state-after-assignment、milestone-enter、milestone-leave、decision-enter、decision-leave、fork-enter、fork-every-leave、join-every-enter、join-leave、transition。事件具体执行的操作，用户通过继承ActionHander接口来指定。

1、process definition
   一个process definition代表了一个正式的业务流程，它以一个流程图为基础。这个流程图由  许多node和transition组成。每个node在这个流程图里都有着各自特殊的类型，这些不同的类型决定了node在运行时的不同行为。一个process definition只有一个start state 。
2、token
   一个token代表了一条执行路径，它包含了这条执行路径的当前的执行状态（current state）。 
3、process instance
   一个process instance（流程实例）即一个process definition（流程定义）的流程执行实例。一个process definition可以对应多个process instance。当一个process instance被创建的时候，一个主执行路径token同时被创建，这个token叫做root token，它指向流程定义的start state（processDefinition.getStartState()==token.getNode()）。
4、signal 
   一个signal 发送给token通知token 继续流程的执行。如果signal 没有指定transition，token将沿缺省的transition离开当前状态,如果signal 指定transition，token将沿指定的transition离开当前的状态。看源代码可以看到发给process instance的signal 其实都是发送给了root token。 
5、Actions 
   jbpm提供了灵活的action ，当流程执行，token 进入node和transition时，会触发相应的一些event（事件）。在这些event上附上我们自己写的action，就会带动action 的执行。action里是我们自己的相关java操作代码，非常方便。注意的是event（事件）是内置的，无法扩展。另外，action也可以直接挂在node上，而不依赖于event（事件）的触发，这个很重要！

一个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这个类来分配）
   <task name='change nappy'>
      <assignment class='org.jbpm.tutorial.taskmgmt.NappyAssignmentHandler' />
   </task>
NappyAssignmentHandler类：
  public void assign(Assignable assignable, ExecutionContext executionContext) {
    assignable.setActorId("papa");
  }
同样，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。

· State中定义参与者，state是流程的主要环节，必须要人机参与处理，调用ExecutionService . endOfState ()来结束活动，使jBPM引擎流转。action是用来扩展的，action的定义如下

<!ELEMENT action ( delegation ) >

<!ATTLIST action event-type (process-start|process-end|state-enter|state-leave|state-after-assignment|milestone-enter|milestone-leave|decision-enter|decision-leave|process-state-enter|process-state-leave|fork-enter|fork-every-leave|join-every-enter|join-leave|transition) #IMPLIED>

<!ELEMENT delegation ( #PCDATA ) >

<!ATTLIST delegation class CDATA #REQUIRED>

state的Action支持state-enter，state-leave和state-after-assignment事件，可以对每个事件处理不同业务。实现Action必须实现接口org.jbpm.delegation. ActionHandler.

 process-state, decision, fork, join跟Action一样都可以支持事件机制

process,fork,decision,join是jBPM引擎自动完成的，完成执行的操作就是节点的delegation里面注册的类. 如果没有就是用系统默认的。

工作流引擎与应用的接口原理

应用调用ExecutionService. StartProcessInstance()启动流程，引擎产生任务。等待任务的所有者调用ExecutionService. endOfState ()指令来完成任务。当endOfState指令被调用后，引擎就进行运算产生的新的任务，然后继续等待endOfState指令的调用直到流程结束。

引擎只对State产生任务，对其他的节点比如：process-state,fork,decision,join都不产生任务。只对他们进行运算，执行每个节点的Delegation和Action.

jbpm中最重要的概念,应该是令牌(Token)和信令(Signal)技术,这个在计算机网络中到处可见
的技术,在工作流引擎中也大放异彩.

我们看如下代码:
//pd是process definition,pi是process instance
ProcessInstance pi = new ProcessInstance( pd );
//启动流程
pi.start();
//得到根令牌
Token token = pi.getRootToken();
//发信令
token.signal();

Token的signal方法也可以传入transition参数,这个方法把信令发送给Token,这样,令牌将被激活,并沿指定的transition离开当前的状态(如果没有指定transition,将沿缺省的transition离开当前状态).

jbpm是怎么实现的呢?其实很简单:
1)Token记录了当前的状态,只有当前的状态(或称节点)拥有该令牌
2)向TOKEN发signal后,当前状态收到该signal
3)当前状态把令牌传给signal中指定的transition
4)transition收到令牌后,不强占,马上把令牌传给下个状态.
5)根据令牌的位置,流程的状态已经发生改变

JBPM数据库中每一个表都有一个主键－ID（Long类型）。这个ID是可以由用户自己产生，也可以由JBPM产生。这个数值在所有表的ID中是唯一的。用户通过设定jbpm.id.generator属性来设定id产生的类。

        JBPM中ID产生的基本原理是：用表JBPM_SEQUENCEBLOCK存储当前可用的ID值，JBPM需要使用ID时，从数据库中取得这个ID，然后增加一定的数量作为当前可用ID值，并存储在数据库中。JBPM的ID可以用于服务器集群的情况。hibernate中产生ID的函数IncrementGenerator，原理与JBPM产生ID相似，但不能应用到集群的情况。

        JBPM_SEQUENCEBLOCK表有两个字段ID和NextID，前者为主键，表示当前节点在集群中的ID号码，后者为当前节点可以使用数据段的最小数。表由类org.jbpm.persistence.hibernate.SequenceBolck代表，org.jbpm.persistence.hibernate.SequenceBolckIdGenerator维护。

SequenceBolckIdGenerator主要函数：

（1）   public SequenceBlockIdGenerator(JbpmConfiguration jbpmConfiguration)

初始化，包括初始化nodeId 和blockSize变量。nodeId指明当前的节点在集群中的Id号（0-65535），用户可以通过jbpm.id.nodeId设定，缺省值是0。BlockSize指明当前节点使用长整形数段的一个数据块大小，用户可以通过jbpm.id.bolckSize设定，缺省值是100。

（2）  public long getNextId() //得到当前可用ID，JBPM使用它得到ID

                {

                return getNextId(sessionFactory, nodeId, blockSize);

                  }

（3）public static synchronized long getNextId(SessionFactory sessionFactory,

                                            long nodeId, long blockSize)

最重要的函数，用于计算当前可用ID。

    基本思路：将1－Long.MaxValue范围内数，按大小blockSize*MaxNodes分段，然后再将每一段按blockSize大小分成MaxNodes块，各节点按照节点号分块使用，如节点号为0的只能使用第一块，节点号为1的使用第二块，依次类推。MaxNodes为当前集群中的节点总数，为65535。

取值算法：

        （1）       取出节点当前可以使用数块的首数（块的最小数）；

        （2）       首数＋blockSize×NodeId（节点号码，0－65535）为当前可以使用的Id（nextId）；

        （3）       nextId+blockSize-1为当前可以使用的最后一个Id（lastId）

        （4）       调用getNextId()函数时，如果nextId<=lastId，则返回nextId，然后将nextId＋＋；否则取出下一数据块进行1－3的计算。

    说明：

        （1）       读取一次数据库，可以使用blockSize个Id，不用每次使用ID都读取一次数据库。

        （2）       表的NextID字段存储的是当前可使用块而不是使用过块的首数。每个节点使用块的首数按节点号码分别存储。

        （3）       对于每一个数块，每个节点只使用其中一部分，范围是（首数＋blockSize×NodeId）－（首数＋blockSize×（NodeId＋1）－1），从而保证了每个节点使用的ID值在数据库中是唯一的。

    为了保证产生ID的唯一性，JBPM要求对表JBPM_SEQUENCEBLOCK进行操作的数据库Session必须是独立的，不能用于其它的数据库操作。如果JBPM使用数据库连接池，则必须要设定jbpm.id.generator.configuration属性，提供进行数据库直接连接的hibernate配置文件。默认情况下，JBPM使用一个全局静态Session进行除JBPM_SEQUENCEBLOCK以外表的操作，而对JBPM_SEQUENCEBLOCK表进行操作的Session是在类SequenceBolckIdGenerator初始化时临时建立的。.

acceptToken是JBPM工作流引擎中的核心函数，它在每个节点中都有具体的实现。这个函数主要决定该节点如何处理到达该节点的令牌。理解了acceptToken，JBPM工作流的运行过程就懂得了一半。acctpToken在各节点类中具体实现的功能如下所示：

一、TransitionImpl

1)        触发Transition事件；

2)        将到达节点作为当前执行上下文节点；

3)        达到节点接受令牌（执行节点的acceptToken）。

二、DecisionImpl

1)        触发DECISION_ENTER事件；

2)        调用DecisionHandler得到要执行的转换（Transition）；

3)        触发DECISION_LEAVE事件；

4)        转换接受令牌（执行节点的acceptToken）。

三、Fork

1)        触发FORK_ENTER事件；

2)        将运行上下文中令牌的State和ActorId置null；

3)        调用ForkHander；

缺省的ForkHander，对于每一个它的转换按顺序执行以下操作：

l         触发FORK_EVERY_LEAVE事件；

l         创建令牌，上下文中的令牌与新建令牌为父子关系；

l         子令牌数据库持久化；

l         将上下文中的令牌置为子令牌，上下文的当前节点备份；

l         当前转换接受令牌；

l         将上下文中的令牌置为父令牌，节点还原；

l         子令牌reactiveJoin属性设定为将父令牌中的correspondingJoin。

四、Join

1)        如果当前上下文中的令牌没有结束，结束令牌（包括该令牌的所有子令牌）；

2)        触发JOIN_EVERY_ENTER事件；

3)        清楚上下文中的临时变量；

4)        将令牌、当前Join节点置为当前运行上下文中的令牌和节点；

5)        执行JoinHander。

缺省的JoinHander在所有兄弟令牌都到达该Join节点后，激活父令牌，执行Join的转换。父令牌激活时会触发JOIN_LEAVE事件。

五、StateImpl、StartStateImpl

1)        将上下文中令牌的状态设定为当前状态；

2)        触发STATE_ENTER事件；

3)        如果状态设定了swimlane属性，从swimlane中取出actorId值设定为上下文中令牌的actorId值；

4)        如果State要求必须assignment但actorId为null，则报错；

5)        记录StateLog在令牌中；

6)        触发STATE_AFTER_ASSIGNMENT事件。

六、EndStateImpl

1)        将lastLog置空；

2)        上下文中的令牌置为当前令牌；

3)        结束令牌（会触发PROCESS_END事件）。

七、MilestoneImpl

1)        将上下文中令牌的状态设定为当前状态；

2)        触发MILESTONE_ENTER事件；

3)        从上下文中取出名称为Milestone名称的变量；

4)        如果变量存在（不为null），触发MILESTONE_LEAVE事件，执行Milestone转换（进入下一个状态）；否则，将令牌中的actorId值置空，在令牌中记录日志（等待）。

八、ProcessStateImpl

1)        在上下文令牌中记录状态日志；

2)        取得ProcessInvocationHandler，启动子工作流程；

3)        工作流启动成功后，将上下文中令牌actorId置空，当前状态设定为令牌当前状态，令牌子进程实例设定为已经启动成功的子工作流程；否则报错。

ExecutionServiceImpl是JBPM的核心类，通过它用户可以启动工作流、使工作流进入下一个节点等等。

一、InvocationLog startProcessInstance(Long definitionId, Map variables, 

                                           String transitionName)

功能：启动一个工作流示例。
1)        根据definitionId得到工作流定义并初始化一个流程实例；

        2)        得到示例的根令牌，并在令牌中记录InvocationLog；

        3)        流程实例持久化；

        4)        初始化执行上下文；

        5)        如果根令牌分配了actor，则将actor存储在上下文中；

        6)        触发PROCESS_START事件；

        7)        找到开始状态的转换，让其接收令牌。

<?XML:namespace prefix = o ns = "urn:schemas-microsoft-com:Office:office" /> 

二、InvocationLog endOfState(Long tokenId, Map variables,

                                 String transitionName)

功能：使工作流进入下一个状态。
1)        根据tokenId从数据库得到令牌；

        2)        检查令牌是否满足认证要求；

        3)        创建记录InvocationLog；

        4)        创建运行上下文，并初始化上下文变量；

        5)        触发STATE_LEAVE事件；

        6)        令牌状态的转换接受令牌

SPRING+HIBERNATE3+JBPM+OC4J(初步实现整合)

整合SPRING与JBPM核心就是需要将JBPM的BEAN由SPRING来管理利用IOC来展现SPRING框架的优势!

这2天在研究怎样整合两者!在整合过程中也出现了不少意想不到的问题!在这里记录下来希望可以未对此感兴趣的朋友提供些帮助!

SPRING+JBPM

1)下载SPRING-JBPM MODULE

这个模块是SPRING支持JBPM使用的必要模块!现在还没有放入SPRING的发行版本中!不过通过她基本可以实现了对JBPM的操作!代码需要从SPRING的CVS下载

地址是:pserver:anonymous@cvs.sourceforge.net:/cvsroot/springframework

从中获取SPRING-JBPM MODULE即可.

2)SPRING加载JBPM资源

SPRING-CONFIG.XML(部分)

数据源
 <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean" destroy-method="close">
  <property name="jndiName" value="jdbc/jbpm"/>
 </bean>

HIBERNATE SESSION FACTORY

 <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
  <property name="dataSource">
   <ref local="dataSource" />
  </property>
  注意这里由于我使用的JBPM是以JAR的形式存在于CLASSPATH中的所以当加载其中的HIBERNATE实体描述文件的时候需要使用下面的写法
  <property name="mappingJarLocations">
   <list>
    <value>WEB-INF/lib/jbpm-3.0.1.jar</value>
    <value>WEB-INF/lib/jbpm-identity-3.0.1.jar</value>
   </list>
  </property>
  
  <property name="hibernateProperties">
   <props>
    <prop key="hibernate.dialect">org.hibernate.dialect.MySQLInnoDBDialect</prop>
    <prop key="hibernate.show_sql">true</prop>

为了使HIBERNATE3查询的时候使用正确的语法需要指明查询工厂类,如果不指定回出现

ClassNotFoundException: org.hibernate.hql.ast.HqlToken  的错误!

    <prop key="hibernate.query.factory_class">org.hibernate.hql.classic.ClassicQueryTranslatorFactory</prop>
   </props>
  </property>
 </bean>
 
 <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  <property name="sessionFactory">
   <ref local="sessionFactory"/>
  </property>
 </bean>

 下面红色的部分是SPRING管理JBPM的必要配置!里面的JBPMTEMPLATE是很重要的类

SPRING中使用JBPM基本都是通过她来完成的!
 <bean id="hibernateConfiguration" factory-bean="&amp;sessionFactory" factory-method="getConfiguration"/>

    <bean id="jbpmSessionFactory" class="org.springframework.workflow.jbpm.LocalJbpmSessionFactoryBean">
        <property name="hibernateSessionFactory" ref="sessionFactory"/>
        <property name="hibernateConfiguration" ref="hibernateConfiguration"/>
    </bean>
    
    <bean id="jbpmTemplate" class="org.springframework.workflow.jbpm.JbpmTemplate">
        <property name="jbpmSessionFactory" ref="jbpmSessionFactory"/>
    </bean>

这是JBPM的管理既纳入到了SPRING中!

3)使用SPRING操作JBPM

在我们的类中需要调用JBPM的功能时我们只需要将JBPMTEMPATE类注入到我们的类中

在jbpmTemplate中实现了不多的几个方法,有很多JBPM的方法没有实现不过没关系我们可以使用SPRING中最常见的CALLBACK机制来实现我们的需要,下面举出几个例子:

A)保存流程定义方法

利用SPRING将jbpmTemplate注入进我们的类中

private JbpmTemplate jbpmTemplate = null;

 public void setJbpmTemplate(JbpmTemplate jbpmTemplate) {
  this.jbpmTemplate = jbpmTemplate;
 }

 /**
  * 保存流程定义
  * @param xmlStr 流程定义的JPDL的XML字符串形式
  */
 public void saveWorkFlowDefinition(String xmlStr){
  
  log.debug("saveWorkFlowDefinition start");
  
  final ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(xmlStr);
  //call spring jbpm call back for save processdefinition
        jbpmTemplate.execute(new JbpmCallback(){        
            public Object doInJbpm(JbpmSession jbpmSession){
             jbpmSession.beginTransaction();
                GraphSession gSession = jbpmSession.getGraphSession();
                gSession.saveProcessDefinition(processDefinition);
                jbpmSession.commitTransaction();//这里我们只需要提交事物即可!关闭SESSION的工作JBPMTEMPLATE回帮助我们完成!
                return processDefinition;
            }});
  log.debug("saveWorkFlowDefinition end");
 }

B)取得所有的流程定义:

JBPM没有采用WfMC提出的流程定义语言XPDL，而是自己开发了一种称为JPDL的语言来定义流程。因此，在开发一个应用时我们最终需要生成一个符合该XML schema的文件processdefinition.xml来表示定义好的流程。它可以manually获得，也可以使用可视化的定义工具自动生成。

JBPM专门提供了一个开发流程的环境，称为process development environment(pde)。可以在jbpm根目录下执行命令ant create.pde来生成pde工作目录。生成的包结构如下所示：

 Build.xml文件用于配置一个流程，即利用ant工具解析processdefinition.xml文件，并将运行流程时所需的相关信息存储到数据库中。

Lib存放了开发和配置流程所需的全部库文件，包括数据库的jdbc驱动。

Src包括开发和配置流程的全部源文件和所需资源。

Src/config只有两个文件，jbpm.properties和log4j.properties。其中，jbpm.propertie文件包含了数据库的配置信息。因此，更换数据库或数据库的jdbc驱动都需要修改这里。

Scr/java存放java源文件。

Src/process存放工作流定义文件(processdefinition.xml)和相关的资源文件，如图片和form文件。

Src/test存放测试代码。

Target/classes是src/java中源码的输出目录，存放编译后的class文件。

Target/par存放用命令ant build.process.archives生成的par包。Par包实际上就是把src/process中的流程定义及相关文件打包成zip形式存储。

Target/test-classes存放测试程序的编译结果。

Target/test-report存放测试报告。

JBPM把负责执行流程的类库打包成jbpm.core.jar，它也是JBPM工作流引擎的核心。在开发一个工作流应用时，只需将该jar文件放到相应的lib目录下面。而开发人员就可以专注于开发一个流程模型，完成对流程的定义，而无需过多考虑流程执行的细节。

客户端组件的开发，需要一个应用服务器作为servlet container，我们这里选择了tomcat。JBPM将开发一个webapp所需的类打包成jbpm.web.jar，包括自定义的tag和Struts用到的类等等。开发应用时，将该jar放到WEB-INF/lib下面就可以了。

一个基于工作流的webapp应用的开发和普通webapp的开发方式很相似。包结构也保持一贯作风：

      
所以，我们需要做的主要工作是完成客户端应用所需的jsp页面的开发，可以选用Struts来进行开发。需要注意的是，我们要对lib目录下的jbpm.properties文件进行配置，主要是对数据库jdbc驱动的配置。

JBPM可以支持多种数据库系统，包括MSSQL,，Mysql，Oracle，hdbsql等。它提供了很灵活的配置方式，只需要修改jbpm.properties文件，同时将相应的JDBC Driver拷贝到lib目录就可以了。利用ant的generate.ddl命令，JBPM还支持自动生成用于创建系统表的sql脚本，而且可以生成对应于各种数据库系统的脚本，非常便于数据库系统的更换和系统数据库的创建。

环境配置如下：

JBPM 3.0

Ant 1.6.2

Tomcat 5.0.27

SQL Server 2000

SQL Server 2000 Driver for JDBC

仍以之前演示过的request a payraise为例（见下图），介绍一下利用JBPM开发一个工作流应用需要完成的工作。

1)首先，我们需要完成流程的定义。这不仅包括定义processdefinition.xml，还要对流程执行时使用到的其他资源进行定义。比如，在web应用中用到的图片，form等。还需要配置form.xml，该文件确定了流程中不同状态和form的关系，如request a payraise状态下，需要如下图所示的form：

补充Processdefinition.xml示例：

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE process-definition PUBLIC "-//jBpm/jBpm Mapping DTD 2.0//EN" "http://jbpm.org/dtd/processdefinition-2.0.dtd">

<process-definition name="pay raise process">

<!-- SWIMLANES -->
<swimlane name="requester" />

    <swimlane name="boss">
    <delegation class="org.jbpm.delegation.assignment.ActorAssignmentHandler">cg</delegation>
</swimlane>

    <swimlane name="erp operator">
    <delegation class="org.jbpm.delegation.assignment.ActorAssignmentHandler">pf</delegation>
</swimlane>

<!-- START-STATE -->
<start-state name="request a payraise" swimlane="requester">
    <transition to="evaluating"/>
  </start-state>

<!-- NODES -->
  <state name="evaluating">
    <assignment swimlane="boss" />
    <transition name="approve"     to="fork"/>
    <transition name="disapprove"  to="done"/>
  </state>
  
  <fork name="fork">
   <transition to="updating erp asynchronously" />
   <transition to="treating collegues on cake and pie" />
  </fork>

      <state name="updating erp asynchronously">
    <assignment swimlane="erp operator" />
    <transition to="join" />
  </state>

      <state name="treating collegues on cake and pie">
    <assignment swimlane="requester" />
    <transition to="join" />
  </state>
  
  <join name="join">
   <transition to="done" />
  </join>

<!-- END-STATE -->
  <end-state name="done" />

</process-definition>

2)       有了processdefinition.xml文件，我们就可以配置流程。即使用ant命令，解析这个文件并且将执行时需要的信息存储在数据库中。如下图：
3)       我们无需关心流程将怎么执行，完全交给jbpm.core.jar就好。

4)       剩下的另外一项比较繁重的工作就是开发一个用于该流程的客户端应用。前面已经提到过，我们需要做的主要工作是完成客户端应用所需的jsp页面的开发。包括登录页面，查看自己的tasklist页面，执行task的页面等。除此之外，还可以通过日志来完成流程的监控和管理界面。这些都由应用的需求来决定。

一个流程定义有一个TaskMgmtDefinition；一个TaskMgmtDefinition对应多个Actor,同时对应多个Task;
一个Actor有多个Task,可以从TaskMgmtDefinition中通过task的名称直接获取相应的task;

一个流程实例有一个TaskMgmtInstance；一个TaskMgmtInstance对应多个actorInstance,同时对应多个taskInstance;
一个actorInstance有多个taskInstance,可以从TaskMgmtInstance中直接获取相应的taskInstance;

一个TaskNode对例应多个Task
对于这样的流程定义：
 <task-node name='a'>
      <task name='laundry' />
      <task name='dishes' />
      <task name='change nappy' />
      <transition to='b' />
 </task-node>
 只有当节点中的三个任务都完成后，流程才进入后面的节点
 
  对于这样的流程定义：
 <task-node name='a' signal='first'>>
      <task name='laundry' />
      <task name='dishes' />
      <task name='change nappy' />
      <transition to='b' />
 </task-node>
 当第一个任务完成后，token就指向后面的节点
 
 对于这样的流程定义：
 <task-node name='a' signal='never'>>
      <task name='laundry' />
      <task name='dishes' />
      <task name='change nappy' />
      <transition to='b' />
 </task-node>
三个任务都完成后，token仍然不会指向后面的节点；需要自己手动调用processInstance.signal()
才会驱动流程到下面的节点

对于这样的流程定义：
 <task-node name='a' signal='unsynchronized'>>
      <task name='laundry' />
      <task name='dishes' />
      <task name='change nappy' />
      <transition to='b' />
 </task-node>
token不会在本节点停留，而是直接到后面的节点

jbpm用join/fork/merge/decision也可以实现同样的功能，不过它们的实现办法不同，一个是通过
NODE来实现，一个是通过TASK来实现

转自:http://blog.csdn.net/skyfly2424/article/details/2358130