BlogJava-LuckyStar 家园-文章分类-Jbpm

如何在Web应用中启动后台任务

礼物 — Tue, 11 Sep 2007 02:13:00 GMT

摘要
　　
　　我们常常在Web应用中需要启动一个自己写的服务，本文的目的是给你提供一个解决方案。
　　
　　原理
　　
　　本方案的原理是写一个实现了ServletContextListener接口的类，该类中有两个方法：public void contextInitialized(ServletContextEvent sce)，它是在应用启动时调用；另一个方法是：public void contextDestroyed(ServletContextEvent sce)，该方法是在应用结束时调用。把我们要启动的后台应用逻辑放在contextInitialized方法中实现；把释放后台应用占用资源的工作放在contextDestroyed来处理。但我们启动的后台任务常常是有要求的，比如时间，频率等，我在这里使用了一个开源组件：quartz。
　　
　　步骤
　　
　　1.写业务调用类：
　　
　　// DumbJob.java
　　import org.quartz.*;
　　import java.util.*;
　　public class DumbJob implements Job {
　　public DumbJob() {
　　}
　　public void execute(JobExecutionContext context)
　　throws JobExecutionException
　　{
　　//在这里写业务处理代码。什么，你不知道？那你别问我！！:-<
　　}
　　}
　　
　　本类的主要功能是由quartz中调度类按照指定的规则进行调用执行必要的业务逻辑。
　　
　　2.写调度类
　　
　　// TestShedule.java
　　import org.quartz.*;
　　import java.util.*;
　　
　　public class TestShedule{
　　static SchedulerFactory schedFact = new org.quartz.impl.StdSchedulerFactory();
　　static Scheduler sched;
　　
　　public static void run()throws Exception{
　　sched = schedFact.getScheduler();　　//获取调度管理器
　　JobDetail jobDetail = new JobDetail("myJob",
　　sched.DEFAULT_GROUP,
　　DumbJob.class);//创建工作
　　CronTrigger trigger = new CronTrigger("myTrigger","test","0/10 * * * * ?");//创建触发器
　　sched.scheduleJob(jobDetail, trigger);　　//添加到调度管理器中
　　sched.start();//启动调度管理器
　　}
　　
　　public static void　　 stop()throws Exception{
　　sched.shutdown();
　　}
　　}
　　本类的目的是设置调用规则，在这里我用了“0/10 * * * * ?”表示每10秒钟就执行一次，有关表达式的说明请参阅quartz的api文档。
　　
　　3.编写服务启动类：
　　
　　//ServiceLoader.java
　　import javax.servlet.ServletContextEvent;
　　import javax.servlet.ServletContextListener;
　　
　　public class ServiceLoader implements ServletContextListener {
　　public void contextInitialized(ServletContextEvent sce) {
　　try{
　　TestShedule.run();
　　}catch(Exception ex){
　　System.out.println(ex.getMessage());
　　}
　　}
　　
　　public void contextDestroyed(ServletContextEvent sce) {
　　try{
　　TestShedule.stop();
　　}catch(Exception ex){
　　System.out.println(ex.getMessage());
　　}
　　}
　　}
　　在contextInitialized中调用TestShedule.run()启动后台任务；在contextDestroyed中调用TestShedule.stop()停止后台任务。
　　
　　4.部署服务启动类
　　
　　在web.xml文件中增加如下一行配置：
　　
　　
　　

root

ServiceLoader

index.html

　　
　　5.启动web服务即可。
　　
　　总结
　　
　　其实实现这个功能的方法很多，我在这里是应用了ServletContextListener接口和开源api quartz，希望能对你的开发有所帮助。

礼物 2007-09-11 10:13 发表评论

jbpm oracle 数据库脚本

礼物 — Thu, 06 Sep 2007 10:40:00 GMT

/*
SQLyog Enterprise - MySQL GUI v5.02
Host - 5.0.27-community-nt : Database - jbpm
*********************************************************************
Server version : 5.0.27-community-nt
*/

create database if not exists `jbpm`;

USE `jbpm`;

SET FOREIGN_KEY_CHECKS=0;

/*Table structure for table `jbpm_action` */

DROP TABLE IF EXISTS `jbpm_action`;

CREATE TABLE `jbpm_action` (
`ID_` bigint(20) NOT NULL auto_increment,
`class` char(1) NOT NULL,
`NAME_` varchar(255) default NULL,
`ISPROPAGATIONALLOWED_` integer(1) default NULL,
`ACTIONEXPRESSION_` varchar(255) default NULL,
`ISASYNC_` integer(1) default NULL,
`REFERENCEDACTION_` bigint(20) default NULL,
`ACTIONDELEGATION_` bigint(20) default NULL,
`EVENT_` bigint(20) default NULL,
`PROCESSDEFINITION_` bigint(20) default NULL,
`TIMERNAME_` varchar(255) default NULL,
`DUEDATE_` varchar(255) default NULL,
`REPEAT_` varchar(255) default NULL,
`TRANSITIONNAME_` varchar(255) default NULL,
`TIMERACTION_` bigint(20) default NULL,
`EXPRESSION_` mediumtext,
`EVENTINDEX_` int(11) default NULL,
`EXCEPTIONHANDLER_` bigint(20) default NULL,
`EXCEPTIONHANDLERINDEX_` int(11) default NULL,
PRIMARY KEY (`ID_`),
KEY `IDX_ACTION_EVENT` (`EVENT_`),
KEY `IDX_ACTION_ACTNDL` (`ACTIONDELEGATION_`),
KEY `IDX_ACTION_PROCDF` (`PROCESSDEFINITION_`),
KEY `FK_ACTION_EVENT` (`EVENT_`),
KEY `FK_ACTION_EXPTHDL` (`EXCEPTIONHANDLER_`),
KEY `FK_ACTION_PROCDEF` (`PROCESSDEFINITION_`),
KEY `FK_CRTETIMERACT_TA` (`TIMERACTION_`),
KEY `FK_ACTION_ACTNDEL` (`ACTIONDELEGATION_`),
KEY `FK_ACTION_REFACT` (`REFERENCEDACTION_`),
CONSTRAINT `FK_ACTION_REFACT` FOREIGN KEY (`REFERENCEDACTION_`) REFERENCES `jbpm_action` (`ID_`),
CONSTRAINT `FK_ACTION_ACTNDEL` FOREIGN KEY (`ACTIONDELEGATION_`) REFERENCES `jbpm_delegation` (`ID_`),
CONSTRAINT `FK_ACTION_EVENT` FOREIGN KEY (`EVENT_`) REFERENCES `jbpm_event` (`ID_`),
CONSTRAINT `FK_ACTION_EXPTHDL` FOREIGN KEY (`EXCEPTIONHANDLER_`) REFERENCES `jbpm_exceptionhandler` (`ID_`),
CONSTRAINT `FK_ACTION_PROCDEF` FOREIGN KEY (`PROCESSDEFINITION_`) REFERENCES `jbpm_processdefinition` (`ID_`),
CONSTRAINT `FK_CRTETIMERACT_TA` FOREIGN KEY (`TIMERACTION_`) REFERENCES `jbpm_action` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_bytearray` */

DROP TABLE IF EXISTS `jbpm_bytearray`;

CREATE TABLE `jbpm_bytearray` (
`ID_` bigint(20) NOT NULL auto_increment,
`NAME_` varchar(255) default NULL,
`FILEDEFINITION_` bigint(20) default NULL,
PRIMARY KEY (`ID_`),
KEY `FK_BYTEARR_FILDEF` (`FILEDEFINITION_`),
CONSTRAINT `FK_BYTEARR_FILDEF` FOREIGN KEY (`FILEDEFINITION_`) REFERENCES `jbpm_moduledefinition` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_byteblock` */

DROP TABLE IF EXISTS `jbpm_byteblock`;

CREATE TABLE `jbpm_byteblock` (
`PROCESSFILE_` bigint(20) NOT NULL,
`BYTES_` blob,
`INDEX_` int(11) NOT NULL,
PRIMARY KEY (`PROCESSFILE_`,`INDEX_`),
KEY `FK_BYTEBLOCK_FILE` (`PROCESSFILE_`),
CONSTRAINT `FK_BYTEBLOCK_FILE` FOREIGN KEY (`PROCESSFILE_`) REFERENCES `jbpm_bytearray` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_comment` */

DROP TABLE IF EXISTS `jbpm_comment`;

CREATE TABLE `jbpm_comment` (
`ID_` bigint(20) NOT NULL auto_increment,
`VERSION_` int(11) NOT NULL,
`ACTORID_` varchar(255) default NULL,
`TIME_` datetime default NULL,
`MESSAGE_` mediumtext,
`TOKEN_` bigint(20) default NULL,
`TASKINSTANCE_` bigint(20) default NULL,
`TOKENINDEX_` int(11) default NULL,
`TASKINSTANCEINDEX_` int(11) default NULL,
PRIMARY KEY (`ID_`),
KEY `IDX_COMMENT_TOKEN` (`TOKEN_`),
KEY `IDX_COMMENT_TSK` (`TASKINSTANCE_`),
KEY `FK_COMMENT_TOKEN` (`TOKEN_`),
KEY `FK_COMMENT_TSK` (`TASKINSTANCE_`),
CONSTRAINT `FK_COMMENT_TSK` FOREIGN KEY (`TASKINSTANCE_`) REFERENCES `jbpm_taskinstance` (`ID_`),
CONSTRAINT `FK_COMMENT_TOKEN` FOREIGN KEY (`TOKEN_`) REFERENCES `jbpm_token` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_decisionconditions` */

DROP TABLE IF EXISTS `jbpm_decisionconditions`;

CREATE TABLE `jbpm_decisionconditions` (
`DECISION_` bigint(20) NOT NULL,
`TRANSITIONNAME_` varchar(255) default NULL,
`EXPRESSION_` varchar(255) default NULL,
`INDEX_` int(11) NOT NULL,
PRIMARY KEY (`DECISION_`,`INDEX_`),
KEY `FK_DECCOND_DEC` (`DECISION_`),
CONSTRAINT `FK_DECCOND_DEC` FOREIGN KEY (`DECISION_`) REFERENCES `jbpm_node` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_delegation` */

DROP TABLE IF EXISTS `jbpm_delegation`;

CREATE TABLE `jbpm_delegation` (
`ID_` bigint(20) NOT NULL auto_increment,
`CLASSNAME_` mediumtext,
`CONFIGURATION_` mediumtext,
`CONFIGTYPE_` varchar(255) default NULL,
`PROCESSDEFINITION_` bigint(20) default NULL,
PRIMARY KEY (`ID_`),
KEY `IDX_DELEG_PRCD` (`PROCESSDEFINITION_`),
KEY `FK_DELEGATION_PRCD` (`PROCESSDEFINITION_`),
CONSTRAINT `FK_DELEGATION_PRCD` FOREIGN KEY (`PROCESSDEFINITION_`) REFERENCES `jbpm_processdefinition` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_event` */

DROP TABLE IF EXISTS `jbpm_event`;

CREATE TABLE `jbpm_event` (
`ID_` bigint(20) NOT NULL auto_increment,
`EVENTTYPE_` varchar(255) default NULL,
`TYPE_` char(1) default NULL,
`GRAPHELEMENT_` bigint(20) default NULL,
`PROCESSDEFINITION_` bigint(20) default NULL,
`NODE_` bigint(20) default NULL,
`TRANSITION_` bigint(20) default NULL,
`TASK_` bigint(20) default NULL,
PRIMARY KEY (`ID_`),
KEY `FK_EVENT_PROCDEF` (`PROCESSDEFINITION_`),
KEY `FK_EVENT_NODE` (`NODE_`),
KEY `FK_EVENT_TRANS` (`TRANSITION_`),
KEY `FK_EVENT_TASK` (`TASK_`),
CONSTRAINT `FK_EVENT_TASK` FOREIGN KEY (`TASK_`) REFERENCES `jbpm_task` (`ID_`),
CONSTRAINT `FK_EVENT_NODE` FOREIGN KEY (`NODE_`) REFERENCES `jbpm_node` (`ID_`),
CONSTRAINT `FK_EVENT_PROCDEF` FOREIGN KEY (`PROCESSDEFINITION_`) REFERENCES `jbpm_processdefinition` (`ID_`),
CONSTRAINT `FK_EVENT_TRANS` FOREIGN KEY (`TRANSITION_`) REFERENCES `jbpm_transition` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_exceptionhandler` */

DROP TABLE IF EXISTS `jbpm_exceptionhandler`;

CREATE TABLE `jbpm_exceptionhandler` (
`ID_` bigint(20) NOT NULL auto_increment,
`EXCEPTIONCLASSNAME_` text,
`TYPE_` char(1) default NULL,
`GRAPHELEMENT_` bigint(20) default NULL,
`PROCESSDEFINITION_` bigint(20) default NULL,
`GRAPHELEMENTINDEX_` int(11) default NULL,
`NODE_` bigint(20) default NULL,
`TRANSITION_` bigint(20) default NULL,
`TASK_` bigint(20) default NULL,
PRIMARY KEY (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_id_group` */

DROP TABLE IF EXISTS `jbpm_id_group`;

CREATE TABLE `jbpm_id_group` (
`ID_` bigint(20) NOT NULL auto_increment,
`CLASS_` char(1) NOT NULL,
`NAME_` varchar(255) default NULL,
`TYPE_` varchar(255) default NULL,
`PARENT_` bigint(20) default NULL,
PRIMARY KEY (`ID_`),
KEY `FK_ID_GRP_PARENT` (`PARENT_`),
CONSTRAINT `FK_ID_GRP_PARENT` FOREIGN KEY (`PARENT_`) REFERENCES `jbpm_id_group` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_id_membership` */

DROP TABLE IF EXISTS `jbpm_id_membership`;

CREATE TABLE `jbpm_id_membership` (
`ID_` bigint(20) NOT NULL auto_increment,
`CLASS_` char(1) NOT NULL,
`NAME_` varchar(255) default NULL,
`ROLE_` varchar(255) default NULL,
`USER_` bigint(20) default NULL,
`GROUP_` bigint(20) default NULL,
PRIMARY KEY (`ID_`),
KEY `FK_ID_MEMSHIP_GRP` (`GROUP_`),
KEY `FK_ID_MEMSHIP_USR` (`USER_`),
CONSTRAINT `FK_ID_MEMSHIP_USR` FOREIGN KEY (`USER_`) REFERENCES `jbpm_id_user` (`ID_`),
CONSTRAINT `FK_ID_MEMSHIP_GRP` FOREIGN KEY (`GROUP_`) REFERENCES `jbpm_id_group` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_id_permissions` */

DROP TABLE IF EXISTS `jbpm_id_permissions`;

CREATE TABLE `jbpm_id_permissions` (
`ENTITY_` bigint(20) NOT NULL,
`CLASS_` varchar(255) default NULL,
`NAME_` varchar(255) default NULL,
`ACTION_` varchar(255) default NULL
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_id_user` */

DROP TABLE IF EXISTS `jbpm_id_user`;

CREATE TABLE `jbpm_id_user` (
`ID_` bigint(20) NOT NULL auto_increment,
`CLASS_` char(1) NOT NULL,
`NAME_` varchar(255) default NULL,
`EMAIL_` varchar(255) default NULL,
`PASSWORD_` varchar(255) default NULL,
PRIMARY KEY (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_job` */

DROP TABLE IF EXISTS `jbpm_job`;

CREATE TABLE `jbpm_job` (
`ID_` bigint(20) NOT NULL auto_increment,
`CLASS_` char(1) NOT NULL,
`VERSION_` int(11) NOT NULL,
`DUEDATE_` datetime default NULL,
`PROCESSINSTANCE_` bigint(20) default NULL,
`TOKEN_` bigint(20) default NULL,
`TASKINSTANCE_` bigint(20) default NULL,
`ISSUSPENDED_` integer(1) default NULL,
`ISEXCLUSIVE_` integer(1) default NULL,
`LOCKOWNER_` varchar(255) default NULL,
`LOCKTIME_` datetime default NULL,
`EXCEPTION_` mediumtext,
`RETRIES_` int(11) default NULL,
`NAME_` varchar(255) default NULL,
`REPEAT_` varchar(255) default NULL,
`TRANSITIONNAME_` varchar(255) default NULL,
`ACTION_` bigint(20) default NULL,
`GRAPHELEMENTTYPE_` varchar(255) default NULL,
`GRAPHELEMENT_` bigint(20) default NULL,
`NODE_` bigint(20) default NULL,
PRIMARY KEY (`ID_`),
KEY `IDX_JOB_TSKINST` (`TASKINSTANCE_`),
KEY `IDX_JOB_PRINST` (`PROCESSINSTANCE_`),
KEY `IDX_JOB_TOKEN` (`TOKEN_`),
KEY `FK_JOB_TOKEN` (`TOKEN_`),
KEY `FK_JOB_NODE` (`NODE_`),
KEY `FK_JOB_PRINST` (`PROCESSINSTANCE_`),
KEY `FK_JOB_ACTION` (`ACTION_`),
KEY `FK_JOB_TSKINST` (`TASKINSTANCE_`),
CONSTRAINT `FK_JOB_TSKINST` FOREIGN KEY (`TASKINSTANCE_`) REFERENCES `jbpm_taskinstance` (`ID_`),
CONSTRAINT `FK_JOB_ACTION` FOREIGN KEY (`ACTION_`) REFERENCES `jbpm_action` (`ID_`),
CONSTRAINT `FK_JOB_NODE` FOREIGN KEY (`NODE_`) REFERENCES `jbpm_node` (`ID_`),
CONSTRAINT `FK_JOB_PRINST` FOREIGN KEY (`PROCESSINSTANCE_`) REFERENCES `jbpm_processinstance` (`ID_`),
CONSTRAINT `FK_JOB_TOKEN` FOREIGN KEY (`TOKEN_`) REFERENCES `jbpm_token` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_log` */

DROP TABLE IF EXISTS `jbpm_log`;

CREATE TABLE `jbpm_log` (
`ID_` bigint(20) NOT NULL auto_increment,
`CLASS_` char(1) NOT NULL,
`INDEX_` int(11) default NULL,
`DATE_` datetime default NULL,
`TOKEN_` bigint(20) default NULL,
`PARENT_` bigint(20) default NULL,
`MESSAGE_` mediumtext,
`EXCEPTION_` mediumtext,
`ACTION_` bigint(20) default NULL,
`NODE_` bigint(20) default NULL,
`ENTER_` datetime default NULL,
`LEAVE_` datetime default NULL,
`DURATION_` bigint(20) default NULL,
`NEWLONGVALUE_` bigint(20) default NULL,
`TRANSITION_` bigint(20) default NULL,
`CHILD_` bigint(20) default NULL,
`SOURCENODE_` bigint(20) default NULL,
`DESTINATIONNODE_` bigint(20) default NULL,
`VARIABLEINSTANCE_` bigint(20) default NULL,
`OLDBYTEARRAY_` bigint(20) default NULL,
`NEWBYTEARRAY_` bigint(20) default NULL,
`OLDDATEVALUE_` datetime default NULL,
`NEWDATEVALUE_` datetime default NULL,
`OLDDOUBLEVALUE_` double default NULL,
`NEWDOUBLEVALUE_` double default NULL,
`OLDLONGIDCLASS_` varchar(255) default NULL,
`OLDLONGIDVALUE_` bigint(20) default NULL,
`NEWLONGIDCLASS_` varchar(255) default NULL,
`NEWLONGIDVALUE_` bigint(20) default NULL,
`OLDSTRINGIDCLASS_` varchar(255) default NULL,
`OLDSTRINGIDVALUE_` varchar(255) default NULL,
`NEWSTRINGIDCLASS_` varchar(255) default NULL,
`NEWSTRINGIDVALUE_` varchar(255) default NULL,
`OLDLONGVALUE_` bigint(20) default NULL,
`OLDSTRINGVALUE_` mediumtext,
`NEWSTRINGVALUE_` mediumtext,
`TASKINSTANCE_` bigint(20) default NULL,
`TASKACTORID_` varchar(255) default NULL,
`TASKOLDACTORID_` varchar(255) default NULL,
`SWIMLANEINSTANCE_` bigint(20) default NULL,
PRIMARY KEY (`ID_`),
KEY `FK_LOG_SOURCENODE` (`SOURCENODE_`),
KEY `FK_LOG_TOKEN` (`TOKEN_`),
KEY `FK_LOG_OLDBYTES` (`OLDBYTEARRAY_`),
KEY `FK_LOG_NEWBYTES` (`NEWBYTEARRAY_`),
KEY `FK_LOG_CHILDTOKEN` (`CHILD_`),
KEY `FK_LOG_DESTNODE` (`DESTINATIONNODE_`),
KEY `FK_LOG_TASKINST` (`TASKINSTANCE_`),
KEY `FK_LOG_SWIMINST` (`SWIMLANEINSTANCE_`),
KEY `FK_LOG_PARENT` (`PARENT_`),
KEY `FK_LOG_NODE` (`NODE_`),
KEY `FK_LOG_ACTION` (`ACTION_`),
KEY `FK_LOG_VARINST` (`VARIABLEINSTANCE_`),
KEY `FK_LOG_TRANSITION` (`TRANSITION_`),
CONSTRAINT `FK_LOG_TRANSITION` FOREIGN KEY (`TRANSITION_`) REFERENCES `jbpm_transition` (`ID_`),
CONSTRAINT `FK_LOG_ACTION` FOREIGN KEY (`ACTION_`) REFERENCES `jbpm_action` (`ID_`),
CONSTRAINT `FK_LOG_CHILDTOKEN` FOREIGN KEY (`CHILD_`) REFERENCES `jbpm_token` (`ID_`),
CONSTRAINT `FK_LOG_DESTNODE` FOREIGN KEY (`DESTINATIONNODE_`) REFERENCES `jbpm_node` (`ID_`),
CONSTRAINT `FK_LOG_NEWBYTES` FOREIGN KEY (`NEWBYTEARRAY_`) REFERENCES `jbpm_bytearray` (`ID_`),
CONSTRAINT `FK_LOG_NODE` FOREIGN KEY (`NODE_`) REFERENCES `jbpm_node` (`ID_`),
CONSTRAINT `FK_LOG_OLDBYTES` FOREIGN KEY (`OLDBYTEARRAY_`) REFERENCES `jbpm_bytearray` (`ID_`),
CONSTRAINT `FK_LOG_PARENT` FOREIGN KEY (`PARENT_`) REFERENCES `jbpm_log` (`ID_`),
CONSTRAINT `FK_LOG_SOURCENODE` FOREIGN KEY (`SOURCENODE_`) REFERENCES `jbpm_node` (`ID_`),
CONSTRAINT `FK_LOG_SWIMINST` FOREIGN KEY (`SWIMLANEINSTANCE_`) REFERENCES `jbpm_swimlaneinstance` (`ID_`),
CONSTRAINT `FK_LOG_TASKINST` FOREIGN KEY (`TASKINSTANCE_`) REFERENCES `jbpm_taskinstance` (`ID_`),
CONSTRAINT `FK_LOG_TOKEN` FOREIGN KEY (`TOKEN_`) REFERENCES `jbpm_token` (`ID_`),
CONSTRAINT `FK_LOG_VARINST` FOREIGN KEY (`VARIABLEINSTANCE_`) REFERENCES `jbpm_variableinstance` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_moduledefinition` */

DROP TABLE IF EXISTS `jbpm_moduledefinition`;

CREATE TABLE `jbpm_moduledefinition` (
`ID_` bigint(20) NOT NULL auto_increment,
`CLASS_` char(1) NOT NULL,
`NAME_` mediumtext,
`PROCESSDEFINITION_` bigint(20) default NULL,
`STARTTASK_` bigint(20) default NULL,
PRIMARY KEY (`ID_`),
KEY `IDX_MODDEF_PROCDF` (`PROCESSDEFINITION_`),
KEY `FK_TSKDEF_START` (`STARTTASK_`),
KEY `FK_MODDEF_PROCDEF` (`PROCESSDEFINITION_`),
CONSTRAINT `FK_MODDEF_PROCDEF` FOREIGN KEY (`PROCESSDEFINITION_`) REFERENCES `jbpm_processdefinition` (`ID_`),
CONSTRAINT `FK_TSKDEF_START` FOREIGN KEY (`STARTTASK_`) REFERENCES `jbpm_task` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_moduleinstance` */

DROP TABLE IF EXISTS `jbpm_moduleinstance`;

CREATE TABLE `jbpm_moduleinstance` (
`ID_` bigint(20) NOT NULL auto_increment,
`CLASS_` char(1) NOT NULL,
`VERSION_` int(11) NOT NULL,
`PROCESSINSTANCE_` bigint(20) default NULL,
`TASKMGMTDEFINITION_` bigint(20) default NULL,
`NAME_` varchar(255) default NULL,
PRIMARY KEY (`ID_`),
KEY `IDX_MODINST_PRINST` (`PROCESSINSTANCE_`),
KEY `FK_TASKMGTINST_TMD` (`TASKMGMTDEFINITION_`),
KEY `FK_MODINST_PRCINST` (`PROCESSINSTANCE_`),
CONSTRAINT `FK_MODINST_PRCINST` FOREIGN KEY (`PROCESSINSTANCE_`) REFERENCES `jbpm_processinstance` (`ID_`),
CONSTRAINT `FK_TASKMGTINST_TMD` FOREIGN KEY (`TASKMGMTDEFINITION_`) REFERENCES `jbpm_moduledefinition` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_node` */

DROP TABLE IF EXISTS `jbpm_node`;

CREATE TABLE `jbpm_node` (
`ID_` bigint(20) NOT NULL auto_increment,
`CLASS_` char(1) NOT NULL,
`NAME_` varchar(255) default NULL,
`DESCRIPTION_` mediumtext,
`PROCESSDEFINITION_` bigint(20) default NULL,
`ISASYNC_` integer(1) default NULL,
`ISASYNCEXCL_` integer(1) default NULL,
`ACTION_` bigint(20) default NULL,
`SUPERSTATE_` bigint(20) default NULL,
`SUBPROCNAME_` varchar(255) default NULL,
`SUBPROCESSDEFINITION_` bigint(20) default NULL,
`DECISIONEXPRESSION_` varchar(255) default NULL,
`DECISIONDELEGATION` bigint(20) default NULL,
`SCRIPT_` bigint(20) default NULL,
`SIGNAL_` int(11) default NULL,
`CREATETASKS_` integer(1) default NULL,
`ENDTASKS_` integer(1) default NULL,
`NODECOLLECTIONINDEX_` int(11) default NULL,
PRIMARY KEY (`ID_`),
KEY `IDX_PSTATE_SBPRCDEF` (`SUBPROCESSDEFINITION_`),
KEY `IDX_NODE_SUPRSTATE` (`SUPERSTATE_`),
KEY `IDX_NODE_PROCDEF` (`PROCESSDEFINITION_`),
KEY `IDX_NODE_ACTION` (`ACTION_`),
KEY `FK_PROCST_SBPRCDEF` (`SUBPROCESSDEFINITION_`),
KEY `FK_NODE_PROCDEF` (`PROCESSDEFINITION_`),
KEY `FK_NODE_SCRIPT` (`SCRIPT_`),
KEY `FK_NODE_ACTION` (`ACTION_`),
KEY `FK_DECISION_DELEG` (`DECISIONDELEGATION`),
KEY `FK_NODE_SUPERSTATE` (`SUPERSTATE_`),
CONSTRAINT `FK_NODE_SUPERSTATE` FOREIGN KEY (`SUPERSTATE_`) REFERENCES `jbpm_node` (`ID_`),
CONSTRAINT `FK_DECISION_DELEG` FOREIGN KEY (`DECISIONDELEGATION`) REFERENCES `jbpm_delegation` (`ID_`),
CONSTRAINT `FK_NODE_ACTION` FOREIGN KEY (`ACTION_`) REFERENCES `jbpm_action` (`ID_`),
CONSTRAINT `FK_NODE_PROCDEF` FOREIGN KEY (`PROCESSDEFINITION_`) REFERENCES `jbpm_processdefinition` (`ID_`),
CONSTRAINT `FK_NODE_SCRIPT` FOREIGN KEY (`SCRIPT_`) REFERENCES `jbpm_action` (`ID_`),
CONSTRAINT `FK_PROCST_SBPRCDEF` FOREIGN KEY (`SUBPROCESSDEFINITION_`) REFERENCES `jbpm_processdefinition` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_pooledactor` */

DROP TABLE IF EXISTS `jbpm_pooledactor`;

CREATE TABLE `jbpm_pooledactor` (
`ID_` bigint(20) NOT NULL auto_increment,
`VERSION_` int(11) NOT NULL,
`ACTORID_` varchar(255) default NULL,
`SWIMLANEINSTANCE_` bigint(20) default NULL,
PRIMARY KEY (`ID_`),
KEY `IDX_PLDACTR_ACTID` (`ACTORID_`),
KEY `IDX_TSKINST_SWLANE` (`SWIMLANEINSTANCE_`),
KEY `FK_POOLEDACTOR_SLI` (`SWIMLANEINSTANCE_`),
CONSTRAINT `FK_POOLEDACTOR_SLI` FOREIGN KEY (`SWIMLANEINSTANCE_`) REFERENCES `jbpm_swimlaneinstance` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_processdefinition` */

DROP TABLE IF EXISTS `jbpm_processdefinition`;

CREATE TABLE `jbpm_processdefinition` (
`ID_` bigint(20) NOT NULL auto_increment,
`CLASS_` char(1) NOT NULL,
`NAME_` varchar(255) default NULL,
`DESCRIPTION_` mediumtext,
`VERSION_` int(11) default NULL,
`ISTERMINATIONIMPLICIT_` integer(1) default NULL,
`STARTSTATE_` bigint(20) default NULL,
PRIMARY KEY (`ID_`),
KEY `IDX_PROCDEF_STRTST` (`STARTSTATE_`),
KEY `FK_PROCDEF_STRTSTA` (`STARTSTATE_`),
CONSTRAINT `FK_PROCDEF_STRTSTA` FOREIGN KEY (`STARTSTATE_`) REFERENCES `jbpm_node` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_processinstance` */

DROP TABLE IF EXISTS `jbpm_processinstance`;

CREATE TABLE `jbpm_processinstance` (
`ID_` bigint(20) NOT NULL auto_increment,
`VERSION_` int(11) NOT NULL,
`KEY_` varchar(255) default NULL,
`START_` datetime default NULL,
`END_` datetime default NULL,
`ISSUSPENDED_` integer(1) default NULL,
`PROCESSDEFINITION_` bigint(20) default NULL,
`ROOTTOKEN_` bigint(20) default NULL,
`SUPERPROCESSTOKEN_` bigint(20) default NULL,
PRIMARY KEY (`ID_`),
UNIQUE KEY `KEY_` (`KEY_`,`PROCESSDEFINITION_`),
KEY `IDX_PROCIN_ROOTTK` (`ROOTTOKEN_`),
KEY `IDX_PROCIN_SPROCTK` (`SUPERPROCESSTOKEN_`),
KEY `IDX_PROCIN_PROCDEF` (`PROCESSDEFINITION_`),
KEY `FK_PROCIN_PROCDEF` (`PROCESSDEFINITION_`),
KEY `FK_PROCIN_ROOTTKN` (`ROOTTOKEN_`),
KEY `FK_PROCIN_SPROCTKN` (`SUPERPROCESSTOKEN_`),
CONSTRAINT `FK_PROCIN_SPROCTKN` FOREIGN KEY (`SUPERPROCESSTOKEN_`) REFERENCES `jbpm_token` (`ID_`),
CONSTRAINT `FK_PROCIN_PROCDEF` FOREIGN KEY (`PROCESSDEFINITION_`) REFERENCES `jbpm_processdefinition` (`ID_`),
CONSTRAINT `FK_PROCIN_ROOTTKN` FOREIGN KEY (`ROOTTOKEN_`) REFERENCES `jbpm_token` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_runtimeaction` */

DROP TABLE IF EXISTS `jbpm_runtimeaction`;

CREATE TABLE `jbpm_runtimeaction` (
`ID_` bigint(20) NOT NULL auto_increment,
`VERSION_` int(11) NOT NULL,
`EVENTTYPE_` varchar(255) default NULL,
`TYPE_` char(1) default NULL,
`GRAPHELEMENT_` bigint(20) default NULL,
`PROCESSINSTANCE_` bigint(20) default NULL,
`ACTION_` bigint(20) default NULL,
`PROCESSINSTANCEINDEX_` int(11) default NULL,
PRIMARY KEY (`ID_`),
KEY `IDX_RTACTN_PRCINST` (`PROCESSINSTANCE_`),
KEY `IDX_RTACTN_ACTION` (`ACTION_`),
KEY `FK_RTACTN_PROCINST` (`PROCESSINSTANCE_`),
KEY `FK_RTACTN_ACTION` (`ACTION_`),
CONSTRAINT `FK_RTACTN_ACTION` FOREIGN KEY (`ACTION_`) REFERENCES `jbpm_action` (`ID_`),
CONSTRAINT `FK_RTACTN_PROCINST` FOREIGN KEY (`PROCESSINSTANCE_`) REFERENCES `jbpm_processinstance` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_swimlane` */

DROP TABLE IF EXISTS `jbpm_swimlane`;

CREATE TABLE `jbpm_swimlane` (
`ID_` bigint(20) NOT NULL auto_increment,
`NAME_` varchar(255) default NULL,
`ACTORIDEXPRESSION_` varchar(255) default NULL,
`POOLEDACTORSEXPRESSION_` varchar(255) default NULL,
`ASSIGNMENTDELEGATION_` bigint(20) default NULL,
`TASKMGMTDEFINITION_` bigint(20) default NULL,
PRIMARY KEY (`ID_`),
KEY `FK_SWL_ASSDEL` (`ASSIGNMENTDELEGATION_`),
KEY `FK_SWL_TSKMGMTDEF` (`TASKMGMTDEFINITION_`),
CONSTRAINT `FK_SWL_TSKMGMTDEF` FOREIGN KEY (`TASKMGMTDEFINITION_`) REFERENCES `jbpm_moduledefinition` (`ID_`),
CONSTRAINT `FK_SWL_ASSDEL` FOREIGN KEY (`ASSIGNMENTDELEGATION_`) REFERENCES `jbpm_delegation` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_swimlaneinstance` */

DROP TABLE IF EXISTS `jbpm_swimlaneinstance`;

CREATE TABLE `jbpm_swimlaneinstance` (
`ID_` bigint(20) NOT NULL auto_increment,
`VERSION_` int(11) NOT NULL,
`NAME_` varchar(255) default NULL,
`ACTORID_` varchar(255) default NULL,
`SWIMLANE_` bigint(20) default NULL,
`TASKMGMTINSTANCE_` bigint(20) default NULL,
PRIMARY KEY (`ID_`),
KEY `IDX_SWIMLINST_SL` (`SWIMLANE_`),
KEY `FK_SWIMLANEINST_TM` (`TASKMGMTINSTANCE_`),
KEY `FK_SWIMLANEINST_SL` (`SWIMLANE_`),
CONSTRAINT `FK_SWIMLANEINST_SL` FOREIGN KEY (`SWIMLANE_`) REFERENCES `jbpm_swimlane` (`ID_`),
CONSTRAINT `FK_SWIMLANEINST_TM` FOREIGN KEY (`TASKMGMTINSTANCE_`) REFERENCES `jbpm_moduleinstance` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_task` */

DROP TABLE IF EXISTS `jbpm_task`;

CREATE TABLE `jbpm_task` (
`ID_` bigint(20) NOT NULL auto_increment,
`NAME_` varchar(255) default NULL,
`DESCRIPTION_` mediumtext,
`PROCESSDEFINITION_` bigint(20) default NULL,
`ISBLOCKING_` integer(1) default NULL,
`ISSIGNALLING_` integer(1) default NULL,
`CONDITION_` varchar(255) default NULL,
`DUEDATE_` varchar(255) default NULL,
`PRIORITY_` int(11) default NULL,
`ACTORIDEXPRESSION_` varchar(255) default NULL,
`POOLEDACTORSEXPRESSION_` varchar(255) default NULL,
`TASKMGMTDEFINITION_` bigint(20) default NULL,
`TASKNODE_` bigint(20) default NULL,
`STARTSTATE_` bigint(20) default NULL,
`ASSIGNMENTDELEGATION_` bigint(20) default NULL,
`SWIMLANE_` bigint(20) default NULL,
`TASKCONTROLLER_` bigint(20) default NULL,
PRIMARY KEY (`ID_`),
KEY `IDX_TASK_TSKNODE` (`TASKNODE_`),
KEY `IDX_TASK_PROCDEF` (`PROCESSDEFINITION_`),
KEY `IDX_TASK_TASKMGTDF` (`TASKMGMTDEFINITION_`),
KEY `FK_TSK_TSKCTRL` (`TASKCONTROLLER_`),
KEY `FK_TASK_ASSDEL` (`ASSIGNMENTDELEGATION_`),
KEY `FK_TASK_TASKNODE` (`TASKNODE_`),
KEY `FK_TASK_PROCDEF` (`PROCESSDEFINITION_`),
KEY `FK_TASK_STARTST` (`STARTSTATE_`),
KEY `FK_TASK_TASKMGTDEF` (`TASKMGMTDEFINITION_`),
KEY `FK_TASK_SWIMLANE` (`SWIMLANE_`),
CONSTRAINT `FK_TASK_SWIMLANE` FOREIGN KEY (`SWIMLANE_`) REFERENCES `jbpm_swimlane` (`ID_`),
CONSTRAINT `FK_TASK_ASSDEL` FOREIGN KEY (`ASSIGNMENTDELEGATION_`) REFERENCES `jbpm_delegation` (`ID_`),
CONSTRAINT `FK_TASK_PROCDEF` FOREIGN KEY (`PROCESSDEFINITION_`) REFERENCES `jbpm_processdefinition` (`ID_`),
CONSTRAINT `FK_TASK_STARTST` FOREIGN KEY (`STARTSTATE_`) REFERENCES `jbpm_node` (`ID_`),
CONSTRAINT `FK_TASK_TASKMGTDEF` FOREIGN KEY (`TASKMGMTDEFINITION_`) REFERENCES `jbpm_moduledefinition` (`ID_`),
CONSTRAINT `FK_TASK_TASKNODE` FOREIGN KEY (`TASKNODE_`) REFERENCES `jbpm_node` (`ID_`),
CONSTRAINT `FK_TSK_TSKCTRL` FOREIGN KEY (`TASKCONTROLLER_`) REFERENCES `jbpm_taskcontroller` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_taskactorpool` */

DROP TABLE IF EXISTS `jbpm_taskactorpool`;

CREATE TABLE `jbpm_taskactorpool` (
`TASKINSTANCE_` bigint(20) NOT NULL,
`POOLEDACTOR_` bigint(20) NOT NULL,
PRIMARY KEY (`TASKINSTANCE_`,`POOLEDACTOR_`),
KEY `FK_TSKACTPOL_PLACT` (`POOLEDACTOR_`),
KEY `FK_TASKACTPL_TSKI` (`TASKINSTANCE_`),
CONSTRAINT `FK_TASKACTPL_TSKI` FOREIGN KEY (`TASKINSTANCE_`) REFERENCES `jbpm_taskinstance` (`ID_`),
CONSTRAINT `FK_TSKACTPOL_PLACT` FOREIGN KEY (`POOLEDACTOR_`) REFERENCES `jbpm_pooledactor` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_taskcontroller` */

DROP TABLE IF EXISTS `jbpm_taskcontroller`;

CREATE TABLE `jbpm_taskcontroller` (
`ID_` bigint(20) NOT NULL auto_increment,
`TASKCONTROLLERDELEGATION_` bigint(20) default NULL,
PRIMARY KEY (`ID_`),
KEY `FK_TSKCTRL_DELEG` (`TASKCONTROLLERDELEGATION_`),
CONSTRAINT `FK_TSKCTRL_DELEG` FOREIGN KEY (`TASKCONTROLLERDELEGATION_`) REFERENCES `jbpm_delegation` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_taskinstance` */

DROP TABLE IF EXISTS `jbpm_taskinstance`;

CREATE TABLE `jbpm_taskinstance` (
`ID_` bigint(20) NOT NULL auto_increment,
`CLASS_` char(1) NOT NULL,
`VERSION_` int(11) NOT NULL,
`NAME_` varchar(255) default NULL,
`DESCRIPTION_` mediumtext,
`ACTORID_` varchar(255) default NULL,
`CREATE_` datetime default NULL,
`START_` datetime default NULL,
`END_` datetime default NULL,
`DUEDATE_` datetime default NULL,
`PRIORITY_` int(11) default NULL,
`ISCANCELLED_` integer(1) default NULL,
`ISSUSPENDED_` integer(1) default NULL,
`ISOPEN_` integer(1) default NULL,
`ISSIGNALLING_` integer(1) default NULL,
`ISBLOCKING_` integer(1) default NULL,
`TASK_` bigint(20) default NULL,
`TOKEN_` bigint(20) default NULL,
`PROCINST_` bigint(20) default NULL,
`SWIMLANINSTANCE_` bigint(20) default NULL,
`TASKMGMTINSTANCE_` bigint(20) default NULL,
PRIMARY KEY (`ID_`),
KEY `IDX_TASKINST_TOKN` (`TOKEN_`),
KEY `IDX_TASKINST_TSK` (`TASK_`,`PROCINST_`),
KEY `IDX_TSKINST_TMINST` (`TASKMGMTINSTANCE_`),
KEY `IDX_TSKINST_SLINST` (`SWIMLANINSTANCE_`),
KEY `IDX_TASK_ACTORID` (`ACTORID_`),
KEY `FK_TSKINS_PRCINS` (`PROCINST_`),
KEY `FK_TASKINST_TMINST` (`TASKMGMTINSTANCE_`),
KEY `FK_TASKINST_TOKEN` (`TOKEN_`),
KEY `FK_TASKINST_SLINST` (`SWIMLANINSTANCE_`),
KEY `FK_TASKINST_TASK` (`TASK_`),
CONSTRAINT `FK_TASKINST_TASK` FOREIGN KEY (`TASK_`) REFERENCES `jbpm_task` (`ID_`),
CONSTRAINT `FK_TASKINST_SLINST` FOREIGN KEY (`SWIMLANINSTANCE_`) REFERENCES `jbpm_swimlaneinstance` (`ID_`),
CONSTRAINT `FK_TASKINST_TMINST` FOREIGN KEY (`TASKMGMTINSTANCE_`) REFERENCES `jbpm_moduleinstance` (`ID_`),
CONSTRAINT `FK_TASKINST_TOKEN` FOREIGN KEY (`TOKEN_`) REFERENCES `jbpm_token` (`ID_`),
CONSTRAINT `FK_TSKINS_PRCINS` FOREIGN KEY (`PROCINST_`) REFERENCES `jbpm_processinstance` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_token` */

DROP TABLE IF EXISTS `jbpm_token`;

CREATE TABLE `jbpm_token` (
`ID_` bigint(20) NOT NULL auto_increment,
`VERSION_` int(11) NOT NULL,
`NAME_` varchar(255) default NULL,
`START_` datetime default NULL,
`END_` datetime default NULL,
`NODEENTER_` datetime default NULL,
`NEXTLOGINDEX_` int(11) default NULL,
`ISABLETOREACTIVATEPARENT_` integer(1) default NULL,
`ISTERMINATIONIMPLICIT_` integer(1) default NULL,
`ISSUSPENDED_` integer(1) default NULL,
`LOCK_` varchar(255) default NULL,
`NODE_` bigint(20) default NULL,
`PROCESSINSTANCE_` bigint(20) default NULL,
`PARENT_` bigint(20) default NULL,
`SUBPROCESSINSTANCE_` bigint(20) default NULL,
PRIMARY KEY (`ID_`),
KEY `IDX_TOKEN_PROCIN` (`PROCESSINSTANCE_`),
KEY `IDX_TOKEN_SUBPI` (`SUBPROCESSINSTANCE_`),
KEY `IDX_TOKEN_NODE` (`NODE_`),
KEY `IDX_TOKEN_PARENT` (`PARENT_`),
KEY `FK_TOKEN_PARENT` (`PARENT_`),
KEY `FK_TOKEN_NODE` (`NODE_`),
KEY `FK_TOKEN_PROCINST` (`PROCESSINSTANCE_`),
KEY `FK_TOKEN_SUBPI` (`SUBPROCESSINSTANCE_`),
CONSTRAINT `FK_TOKEN_SUBPI` FOREIGN KEY (`SUBPROCESSINSTANCE_`) REFERENCES `jbpm_processinstance` (`ID_`),
CONSTRAINT `FK_TOKEN_NODE` FOREIGN KEY (`NODE_`) REFERENCES `jbpm_node` (`ID_`),
CONSTRAINT `FK_TOKEN_PARENT` FOREIGN KEY (`PARENT_`) REFERENCES `jbpm_token` (`ID_`),
CONSTRAINT `FK_TOKEN_PROCINST` FOREIGN KEY (`PROCESSINSTANCE_`) REFERENCES `jbpm_processinstance` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_tokenvariablemap` */

DROP TABLE IF EXISTS `jbpm_tokenvariablemap`;

CREATE TABLE `jbpm_tokenvariablemap` (
`ID_` bigint(20) NOT NULL auto_increment,
`VERSION_` int(11) NOT NULL,
`TOKEN_` bigint(20) default NULL,
`CONTEXTINSTANCE_` bigint(20) default NULL,
PRIMARY KEY (`ID_`),
KEY `IDX_TKVARMAP_CTXT` (`CONTEXTINSTANCE_`),
KEY `IDX_TKVVARMP_TOKEN` (`TOKEN_`),
KEY `FK_TKVARMAP_CTXT` (`CONTEXTINSTANCE_`),
KEY `FK_TKVARMAP_TOKEN` (`TOKEN_`),
CONSTRAINT `FK_TKVARMAP_TOKEN` FOREIGN KEY (`TOKEN_`) REFERENCES `jbpm_token` (`ID_`),
CONSTRAINT `FK_TKVARMAP_CTXT` FOREIGN KEY (`CONTEXTINSTANCE_`) REFERENCES `jbpm_moduleinstance` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_transition` */

DROP TABLE IF EXISTS `jbpm_transition`;

CREATE TABLE `jbpm_transition` (
`ID_` bigint(20) NOT NULL auto_increment,
`NAME_` varchar(255) default NULL,
`DESCRIPTION_` mediumtext,
`PROCESSDEFINITION_` bigint(20) default NULL,
`FROM_` bigint(20) default NULL,
`TO_` bigint(20) default NULL,
`CONDITION_` varchar(255) default NULL,
`FROMINDEX_` int(11) default NULL,
PRIMARY KEY (`ID_`),
KEY `IDX_TRANSIT_TO` (`TO_`),
KEY `IDX_TRANSIT_FROM` (`FROM_`),
KEY `IDX_TRANS_PROCDEF` (`PROCESSDEFINITION_`),
KEY `FK_TRANSITION_TO` (`TO_`),
KEY `FK_TRANS_PROCDEF` (`PROCESSDEFINITION_`),
KEY `FK_TRANSITION_FROM` (`FROM_`),
CONSTRAINT `FK_TRANSITION_FROM` FOREIGN KEY (`FROM_`) REFERENCES `jbpm_node` (`ID_`),
CONSTRAINT `FK_TRANSITION_TO` FOREIGN KEY (`TO_`) REFERENCES `jbpm_node` (`ID_`),
CONSTRAINT `FK_TRANS_PROCDEF` FOREIGN KEY (`PROCESSDEFINITION_`) REFERENCES `jbpm_processdefinition` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_variableaccess` */

DROP TABLE IF EXISTS `jbpm_variableaccess`;

CREATE TABLE `jbpm_variableaccess` (
`ID_` bigint(20) NOT NULL auto_increment,
`VARIABLENAME_` varchar(255) default NULL,
`ACCESS_` varchar(255) default NULL,
`MAPPEDNAME_` varchar(255) default NULL,
`PROCESSSTATE_` bigint(20) default NULL,
`TASKCONTROLLER_` bigint(20) default NULL,
`INDEX_` int(11) default NULL,
`SCRIPT_` bigint(20) default NULL,
PRIMARY KEY (`ID_`),
KEY `FK_VARACC_TSKCTRL` (`TASKCONTROLLER_`),
KEY `FK_VARACC_SCRIPT` (`SCRIPT_`),
KEY `FK_VARACC_PROCST` (`PROCESSSTATE_`),
CONSTRAINT `FK_VARACC_PROCST` FOREIGN KEY (`PROCESSSTATE_`) REFERENCES `jbpm_node` (`ID_`),
CONSTRAINT `FK_VARACC_SCRIPT` FOREIGN KEY (`SCRIPT_`) REFERENCES `jbpm_action` (`ID_`),
CONSTRAINT `FK_VARACC_TSKCTRL` FOREIGN KEY (`TASKCONTROLLER_`) REFERENCES `jbpm_taskcontroller` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

/*Table structure for table `jbpm_variableinstance` */

DROP TABLE IF EXISTS `jbpm_variableinstance`;

CREATE TABLE `jbpm_variableinstance` (
`ID_` bigint(20) NOT NULL auto_increment,
`CLASS_` char(1) NOT NULL,
`VERSION_` int(11) NOT NULL,
`NAME_` varchar(255) default NULL,
`CONVERTER_` char(1) default NULL,
`TOKEN_` bigint(20) default NULL,
`TOKENVARIABLEMAP_` bigint(20) default NULL,
`PROCESSINSTANCE_` bigint(20) default NULL,
`BYTEARRAYVALUE_` bigint(20) default NULL,
`DATEVALUE_` datetime default NULL,
`DOUBLEVALUE_` double default NULL,
`LONGIDCLASS_` varchar(255) default NULL,
`LONGVALUE_` bigint(20) default NULL,
`STRINGIDCLASS_` varchar(255) default NULL,
`STRINGVALUE_` varchar(255) default NULL,
`TASKINSTANCE_` bigint(20) default NULL,
PRIMARY KEY (`ID_`),
KEY `IDX_VARINST_TKVARMP` (`TOKENVARIABLEMAP_`),
KEY `IDX_VARINST_PRCINS` (`PROCESSINSTANCE_`),
KEY `IDX_VARINST_TK` (`TOKEN_`),
KEY `FK_VARINST_TK` (`TOKEN_`),
KEY `FK_VARINST_TKVARMP` (`TOKENVARIABLEMAP_`),
KEY `FK_VARINST_PRCINST` (`PROCESSINSTANCE_`),
KEY `FK_VAR_TSKINST` (`TASKINSTANCE_`),
KEY `FK_BYTEINST_ARRAY` (`BYTEARRAYVALUE_`),
CONSTRAINT `FK_BYTEINST_ARRAY` FOREIGN KEY (`BYTEARRAYVALUE_`) REFERENCES `jbpm_bytearray` (`ID_`),
CONSTRAINT `FK_VARINST_PRCINST` FOREIGN KEY (`PROCESSINSTANCE_`) REFERENCES `jbpm_processinstance` (`ID_`),
CONSTRAINT `FK_VARINST_TK` FOREIGN KEY (`TOKEN_`) REFERENCES `jbpm_token` (`ID_`),
CONSTRAINT `FK_VARINST_TKVARMP` FOREIGN KEY (`TOKENVARIABLEMAP_`) REFERENCES `jbpm_tokenvariablemap` (`ID_`),
CONSTRAINT `FK_VAR_TSKINST` FOREIGN KEY (`TASKINSTANCE_`) REFERENCES `jbpm_taskinstance` (`ID_`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

SET FOREIGN_KEY_CHECKS=1;

礼物 2007-09-06 18:40 发表评论

JBPM数据库表说明

礼物 — Thu, 06 Sep 2007 10:13:00 GMT

摘要: JBPM数据库表说明 1 流程配置类数据库表： 1.1 JBPM_PROCESSDEFINITION：流程模版表字段名字段含义 ... 阅读全文

礼物 2007-09-06 18:13 发表评论

一个JBPM工作流管理示例

礼物 — Thu, 06 Sep 2007 10:13:00 GMT

一个JBPM工作流管理示例

一个JBPM工作流管理示例

示例：
在某一公司中，部门员工要休假的话需要部门主管的批准。如果休假天数大于10天的话，在部门主管的同意后，还必须上级主管批准。如果是部门主管要休假只要上级主管批准即可。在休假被批准之前，申请人可以撤销休假申请。
每个员工还有多少天休假必须管理起来，在员工提交休假申请时要检查申请天数是否超过可用天数。申请批准后，要在可用天数里减去申请天数。每次休假申请结束之后，不管通过未通过或是否取消，都必须记录下来。主管在批复申请之后，系统要将批复结果Email给申请人。对于大于10天的申请，如果部门主管已批准同意而上级主管还未批准，这时申请人撤销申请后，系统应发Email通知部门主管申请已撤销。
  processdefinition.xml如下：

    "-//jBpm/jBpm Mapping DTD 2.0//EN"
    "http://jbpm.org/dtd/processdefinition-2.0.dtd">

  申请者

  部门主管


  上级主管




















































  有一个先到达即进行父Token




    根据请求的状态决定。
    （1）“主管或者老板批准”－‘approve’：修改员工休假的总天数，设定发给用户E-Mail的信息。
    （2）“主管或者老板否决”-“disapprove”：设定发给用户E－Mail的信息。
    （3）“撤销”-"cancel"－设定发给用户E－Mail的信息。如果主管批准，要发给主管消息说明已经撤销。

Action指明的是当前状态要执行的一些额外的操作，如记录log、发邮件等。
（1）Swimline的delegation要做的就是判别当前Actor的身份。
package kellerdu.jbpm.delegation;

import org.jbpm.delegation.*;
import kellerdu.jbpm.LogsFactory;
import org.apache.commons.logging.Log;

public class BossSwimlane implements AssignmentHandler {
public BossSwimlane() {
}

    /**
     * 当前的状态有哪个actor来具体负责处理，选择是老板的actor来处理。
     *
     * 如果王林是老板，那么他请假可以用他的名称来开始一个请假流程，当他检查他需要批示的
     * 请假时，使用actorId=boss来找出所有的批示。这时selectActor返回的值就是一个常量“boss”
     *
     *
     * @param assignmentContext AssignmentContext
     * @return String
     * @todo Implement this org.jbpm.delegation.AssignmentHandler method
     */
    public String selectActor(AssignmentContext assignmentContext) {
        Log log = LogsFactory.getLogInstance(this.getClass());
        log.info("任务分配给老板");
        return "boss";
    }
}
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
ackage kellerdu.jbpm.delegation;

import org.jbpm.delegation.*;
import kellerdu.jbpm.LogsFactory;
import org.apache.commons.logging.Log;

public class ChiefSwimlane implements AssignmentHandler {
public ChiefSwimlane() {
}

    /**
     * selectActor
     * @see BossSwimlane
     *
     * @param assignmentContext AssignmentContext
     * @return String
     * @todo Implement this org.jbpm.delegation.AssignmentHandler method
     */
    public String selectActor(AssignmentContext assignmentContext) {
       Log log = LogsFactory.getLogInstance(this.getClass());
        log.info("任务分配给上级主管");
       return "chief";
    }
}

（二）Decision
package kellerdu.jbpm.delegation;

import org.jbpm.delegation.*;
import kellerdu.jbpm.LogsFactory;
import org.apache.commons.logging.Log;
import kellerdu.jbpm.Constants;

public class ChiefDecision implements DecisionHandler {
public ChiefDecision() {
}

    /**
     * 判断是否需要主管批准，决定下一个要进行的transition
     *
     * @param executionContext ExecutionContext
     * @return String
     * @todo Implement this org.jbpm.delegation.DecisionHandler method
     */
    public String decide(ExecutionContext executionContext) {
        Log log=LogsFactory.getLogInstance(this.getClass());
        String ac=(String)executionContext.getVariable(Constants.USER_NAME);
        if(ac!=null&&(ac.equals("dali")||ac.equals("wang"))){
            log.info(ac+"需要老板批准！");
            return "BossApprove";
        }else{
            log.info(ac+"需要先经主管批准");
            return "ChiefApprove";
        }
    }
}
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
（三）fork
package kellerdu.jbpm.delegation;

import org.jbpm.*;
import org.jbpm.delegation.*;
import org.jbpm.model.execution.*;
import java.util.*;

public class DecidedJoin implements JoinHandler {
public DecidedJoin() {
}

    /**
     * fork，只要一个分支到达，即可进行下一步操作，同时取消其它同时进行的分支。
     * 这里就是用户如果取消，请假就取消。如果用户请假批准，则用户不能取消。
     *
     * @param forkContext ForkContext
     * @throws ExecutionException
     * @todo Implement this org.jbpm.delegation.ForkHandler method
     */
    public void join(JoinContext joinContext) throws ExecutionException {
        Iterator it=joinContext.getConcurrentTokens().values().iterator();
        Token arrivingToken = joinContext.getToken();
        while(it.hasNext()){
            Token to=(Token)it.next();
            if(to.getId().equals(arrivingToken.getId())){
                //取消其它执行的Token
                joinContext.getExecutionService().cancelToken(to.getId());
            }
        }
         // reactivate the parent token.
          joinContext.reactivateToken( arrivingToken.getParent() );
    }
}

（一）开始一个请假流程
       //user是请假人的actorId
       ExecutionService es=JbpmServiceFactory.getInstance().openExecutionService(user);
        HashMap vs=new HashMap();
       //一些参数
        vs.put(Constants.REQUEST_STATUS,String.valueOf(0));
        vs.put(Constants.REQUEST_RETURN_INFO,"No info!");
        vs.put(Constants.USER_NAME,EncodeTransfer.toISO(user));
        vs.put(Constants.REQUEST_DAYS,String.valueOf(rea.getDays()));
        try {
           //开启请假流程
            es.startProcessInstance(Constants.WORK_NAME, vs);
            log.info("["+user+"]"+"申请假期开始！请假"+rea.getDays()+"天！");
            return am.findForward("main");
        } catch (ExecutionException ex) {
            ex.printStackTrace();
            log.error("请假进程无法开始！");
            return am.findForward("error");
        }finally{
            es.close();
        }
（二）当前执行任务
    对于部门经理或者老板，找到要处理的请假。
      String actorId = (String) req.getSession().getAttribute(Constants.USER);
            if(actorId.equals("wang")){
                actorId="boss";
            }else if(actorId.equals("bigli")){
                actorId="chief";
            }
            // get the execution service
            ExecutionService executionService = JbpmServiceFactory.getInstance().
                                                openExecutionService(actorId);

            // get the tasklist from jbpm for user
            List tasks = new ArrayList();
            // add the jbpm tasks
            tasks.addAll(executionService.getTaskList(actorId));
            // put the tasklist into the form
            mf.setTasks(tasks);
            // get the tasklist from jbpm for user
            List definitions = new ArrayList();
            // add the jbpm definitions
            definitions.addAll(executionService.getLatestDefinitions());
            // put the tasklist into the form
            mf.setRequests(definitions);
            // close the execution service
            executionService.close();
            req.getSession().setAttribute("mainForm",mf);
            log.debug("任务: " + tasks);
            log.debug("当前可以执行的请求: " + definitions);
（三）处理请假
           String actorId = (String) reqrest.getSession().getAttribute(Constants.
                    USER);
            Long tokenId=new Long(req.getParameter("tokenId"));
            // get the execution service
            ExecutionService executionService = JbpmServiceFactory.getInstance().
                                                openExecutionService(actorId);
            Map hm=executionService.getVariables(tokenId);//变量
            String act=req.getParameter("action");//进行转换的transition
            executionService.endOfState(tokenId,hm,act);
            executionService.close();

礼物 2007-09-06 18:13 发表评论

JBPM的一些资料

礼物 — Thu, 06 Sep 2007 10:11:00 GMT

标题：JBPM的一些资料
出处：汐忆时空：：CHIRS：：蝶衣人生
时间：Tue, 20 Jun 2006 09:53:24 +0000
作者：chirs@zhoujin.com
地址：www.zhoujin.com/read.php/18.htm

内容：
jPDL的流程定义元素
第一层级:GraphElement

这个容易理解,因为在画流程定义时,每个拖拉的对象都是一个graph的元素.

GraphElement有四个属性:1)processDefine 表示当前元素属于哪个流程定义

2)events 表示可以接收哪些event

3)name 名字

4)exceptionHandlers 异常处理类集合(List)

第二层级:node;processDefinition;Transition;Task 它们都inherited from 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 定义任务

第三层级:各种不同的node,它们都inherited from node decision;EndState;Fork;Join;Merge;Milestone; InterleaveEnd;InterleaveStart;ProcessState;State 这些都是见名知义,和xpdl差不多.
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)根据令牌的位置,流程的状态已经发生改变.

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（事件）的触发，这个很重要！
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的结束和流程的结束。

流程图中的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里要控制流程！

Actions的说明

存在两种action，一种是 event触发的action，一种是挂在node 节点的action。要注意它们的区别，event触发的action无法控制流程，也就是说它无法决定流程经过这个节点后下一步将到哪一个leaving transition；而挂在node 节点的action就不同，它可以控制流程。不管是哪一种action都要实现ActionHandler接口。
variable的管理

流程实例中,存有contextInstance来管理token和variable.
contextInstance是通过一个map来进行管理的,这个map的key是token,value是一个TokenVariableMap的对象.

TokenVariableMap本身并不是个map,而是一个普通的Object

TokenVariableMap有三个属性,一个是contextInstance,一个是Token对象本身,还有一个是
一个Map,用来放variableInstance,这个Map的名称为variableInstances.

variableInstances是一个map,它的key是variable的名称,如"a",value是一个VariableInstance对象,VariableInstance对象放了四个属性,一个是token对象本身,一个是variable的名称,一个是TokenVariableMap对象，还有一个是processInsance,你可能会奇怪：variable的value放到哪里呢？实际上VariableInstance是一个抽象类，具体的实现是它根据value的class类型选择它的子类，子类中有个属性叫value。这个variable的value,如 new Integer(3).

一个流程实例可以有多个Token,Token间是有父子关系的:
Token tokenAB=new Token(tokenA,"ab");
上行代码的意思是在tokenA下面建立一个TokenAB,该新建的
Token的名字是"ab".

ci.createVariable(tokenA, "a", new Integer(3));
表示在tokenA范围内建立一个variable,它的名称为"a",
值为new Integer(3)
建立这个variable后,tokenA下面的token都可以看到该
variable,而上面的token则看不到.

只有createVariable可以在某个token上建立variable,其它的
方法只可以在rootToken上建立variable.
如:ci.setVariable(tokenA, "a", new Integer(3));
其实是在rootToken上建立了一个名称为"a"的variable
Map variables = new HashMap();
variables.put("a", new Integer(3));
variables.put("b", new Integer(4));
ci.addVariables(variables);
上面四行代码在rootToken上建立了两个variable.
实际上在ExecutionContext中只有两个方法：
public void setVariable(String name, Object value) {
getContextInstance().setVariable(name, value, token);
}
public Object getVariable(String name) {
return getContextInstance().getVariable(name, token);
}
可以在子token中修改父token中建立的variable.

Task（任务）

jbpm一个相当重要的功能就是对任务进行管理。
Task（任务）是流程定义里的一部分，它决定了task instance的创建和分配。
Task（任务）可以在task-node节点下定义，也可以挂在process-definition节点下。最普遍的方式是在task-node节点下定义一个或多个任务。默认情况下，流程在task-node节点会处于等待状态，直到所有的任务被执行完毕。任务的名称在整个流程中必须是唯一的。

一个TaskNode对应多个Task
对于这样的流程定义：

只有当节点中的三个任务都完成后，流程才进入后面的节点

对于这样的流程定义：
>

当第一个任务完成后，token就指向后面的节点

对于这样的流程定义：
>

三个任务都完成后，token仍然不会指向后面的节点；需要自己手动调用

processInstance.signal()才会驱动流程到下面的节点

对于这样的流程定义：
>

token不会在本节点停留，而是直接到后面的节点

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这个类来分配）

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。
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（角色）！

Generated by Bo-blog 2.0.2 RC 1

礼物 2007-09-06 18:11 发表评论

JBPM部署在tomcat中

礼物 — Thu, 06 Sep 2007 10:10:00 GMT

首先，确认手边有一份jbpm3的user guide，有一份还有JBPM3.0源码的压缩包

JBPM中是通过org.jbpm.db. JbpmSessionFactory.getInstance()返回一个JbpmSessionFactory实例，

下面通过分析getInstance()的过程，说明怎么设置相关配置文件

1、JbpmSessionFactory.getInstance()方法首先查找类路径中的jbpm.properties文件

jbpm.scheduler.service.factory=org.jbpm.scheduler.impl.SchedulerServiceImpl

jbpm.task.instance.class=org.jbpm.taskmgmt.exe.TaskInstance

# uncomment the next line if JbpmSessionFactory.getInstance()

# should lookup the singleton instance from JNDI instead of creating

# a default one.

jbpm.session.factory.jndi.name=java:/jbpm/JbpmSessionFactory

# uncomment the next line to use the file system instead of the database for

# storing files related to a process definition

# jbpm.files.dir=c:/jbpm.data

# resource path to a properties file that will overwrite all the hibernate

# properties. For database specific builds in db project there is a different

# hibernate.properties file on the classpath for each database. You could change

# the default database for any testing runs by uncommenting the next line and

# adding a hibernate.properties file in the basedir.

jbpm.hibernate.cfg.xml=jbpm.hibernate.cfg.xml

jbpm.hibernate.properties=jbpm.hibernate.properties

找到最基本的设置，jbpm.session.factory.jndi.name=java:/jbpm/JbpmSessionFactory

这行表示从jndi获取一个JbpmSessionFactory的一个实例，如果你可以用JBPM3 demo中java:/jbpm/JbpmSessionFactory是与DataSource DefaultDS绑定在一起的（在jboss-service.xml中）。要部署在tomcat中，这行必须注释掉。

name="jboss.jbpm:name=DefaultJbpm,service=JbpmService"

description="Default jBPM Service">

java:/jbpm/JbpmSessionFactory

jboss.jca:service=DataSourceBinding,name=DefaultDS

jboss-service.xml文件内容，如果你用源码包成功部署了websale的话，可以在JBOSS_HOME"server"jbpm"deploy"jbpm.sar"META-INF"目录下找到该文件

2、如果getInstance()没有找到jbpm.session.factory.jndi.name的值，会继续查找jbpm.hibernate.properties的值，找到jbpm.hibernate.properties的值后，会用该值作为配置文件取创建JbpmSessionFactory

jbpm.hibernate.properties内容：

hibernate.dialect=org.hibernate.dialect.HSQLDialect

hibernate.connection.datasource=java:/DefaultDS

# hibernate.show_sql=true

是用DataSource来创建JbpmSessionFactory，DataSource需要在Server.xml中配置，如果你不想配置DataSource的话，把这行也注释掉

3、上面两项内容都被注释掉的话，getInstance()会查找jbpm.hibernate.cfg.xml的值，用该值作为配置文件创建一个JbpmSessionFactory。

说明，这里只是讲了怎么配置相关文件，没有说到怎么部署，关于这方面内容，请参考User Guide chapter 5

礼物 2007-09-06 18:10 发表评论

jBPM3.1 +Oracle10g+Tomcat-5.0.30安装实践

礼物 — Thu, 06 Sep 2007 10:09:00 GMT

jBPM3.1 +Oracle10g+Tomcat-5.0.30安装实践

环境：
jdk1.5.0_05
jakarta-tomcat-5.5.9
apache-ant-1.6.5(1.6.0会报错)
mysql-5.0.16-win32
jbpm-3.0.2

一、JBPM_HOME即为解开的jbpm-3.0.2.zip文件
%JBPM_HOME%"lib下，建mysql目录，将mysql的jdbc驱动拷入；
在mysql中建数据库 CREATE DATABASE jbpm;

二、为ant创建jbpm相关数据库修改相关配置文件
1、%JBPM_HOME%"src"resources目录下，将“hsqldb”目录改名为“mysql”，并修改create.db.hibernate.properties文件，形如：
# these properties are used by the build script to create
# a hypersonic database in the build/db directory that contains
# the jbpm tables and a process deployed in there

hibernate.dialect=org.hibernate.dialect.MySQLDialect
hibernate.connection.driver_class=com.mysql.jdbc.Driver
hibernate.connection.url=jdbc:mysql://localhost:3306/jbpm
hibernate.connection.username=root
hibernate.connection.password=
hibernate.c3p0.min_size=1
hibernate.c3p0.max_size=3
hibernate.show_sql=true

2、修改%JBPM_HOME%"build.deploy.xml文件中“target”为“create.db” 的內容，删除“db.start”，“db.stop”，将所有的“hsqldb”替换为“mysql”
形如：

三、为ant创建jbpm.war包修改相关配置文件
1、修改%JBPM_HOME%"src"config.files"hibernate.cfg.xml文件中数据库连接配置部分，形如：
……

org.hibernate.dialect.MySQLDialect
com.mysql.jdbc.Driver
jdbc:mysql://localhost:3306/jbpm
root
rootrootrootroot

1
3

true
……

2、修改%JBPM_HOME%"src"resources"jbpm.sar"jbpm.properties，形如：
jbpm.scheduler.service.factory=org.jbpm.scheduler.impl.SchedulerServiceImpl
jbpm.task.instance.class=org.jbpm.taskmgmt.exe.TaskInstance

# uncomment the next line if JbpmSessionFactory.getInstance()
# should lookup the singleton instance from JNDI instead of creating
# a default one.
#
# jbpm.session.factory.jndi.name=java:/jbpm/JbpmSessionFactory

# uncomment the next line to use the file system instead of the database for
# storing files related to a process definition
#
# jbpm.files.dir=c:/jbpm.data

# resource path to a properties file that will overwrite all the hibernate
# properties. For database specific builds in db project there is a different
# hibernate.properties file on the classpath for each database. You could change
# the default database for any testing runs by uncommenting the next line and
# adding a hibernate.properties file in the basedir.
#
jbpm.hibernate.cfg.xml=jbpm.hibernate.cfg.xml
# jbpm.hibernate.properties=jbpm.hibernate.properties

3、修改%JBPM_HOME%"src"resources"jbpm.sar"jbpm.hibernate.properties，只用hibernate.cfg.xml来配置hibernate，因此全部注释掉，形如：
# hibernate.dialect=org.hibernate.dialect.HSQLDialect
# hibernate.connection.datasource=java:/DefaultDS
# hibernate.show_sql=true

4、修改%JBPM_HOME%"build.deploy.xml文件，“target”为“build.webapp”的內容，原文件相关的jar包未包含全，因此补全，形如：

四、执行Ant
1、创建并初始化jbpm例子所需的table
ant create.db -buildfile build.deploy.xml
2、生成jbpm.war
ant build.webapp -buildfile build.deploy.xml

五、tomcat拥抱jbpm
将%JBPM_HOME%"build"jbpm.war文件复制到Tomcat的webapp目录下，启动Tomcat自动部署jbpm，访问http://localhost:8080/jbpm，出现登录页面，配置成功。

礼物 2007-09-06 18:09 发表评论

表的中文意思

礼物 — Thu, 06 Sep 2007 10:00:00 GMT

附上中表的中文意思
JBPM_ACTION action记录表
JBPM_DECISIONCONDITIONS 结果条件表
JBPM_DELEGATION 委托表
JBPM_EVENT 事件表处理进入或者离开事件
JBPM_EXCEPTIONHANDLER 异常处理表
JBPM_ID_GROUP 用户组表
JBPM_ID_MEMBERSHIP 用户成员表表现用户和组之间的多对多关系
JBPM_ID_PERMISSIONS 用户权限表
JBPM_ID_USER 用户表
JBPM_MODULEDEFINITION 模块定义表
JBPM_MODULEINSTANCE 模块实例表
JBPM_NODE 流程节点表
JBPM_POOLEDACTOR 汇集参与着表
JBPM_PROCESSDEFINITION 流程定义表
JBPM_PROCESSFILE 流程文件表
JBPM_PROCESSFILEBLOCK 流程文件块表
JBPM_PROCESSINSTANCE 流程实例表
JBPM_RUNTIMEACTION 运行中行为表
JBPM_SCRIPTVARIABLES 脚本变量表
JBPM_SWIMLANE 泳道表
JBPM_SWIMLANEINSTANCE 泳道实例表
JBPM_TASK 任务表
JBPM_TASKACTORPOOL 用户行为汇总
JBPM_TASKINSTANCE 任务实例
JBPM_TIMER 计时表
JBPM_TOKEN 令牌表
JBPM_TOKENVARIABLEMAP 令牌变量影射表
JBPM_TRANSITION 转换表
JBPM_VARIABLEINSTANCE 变量实例表
JBPM_VARIABLEINSTANCEBLOCK 变量实例块表
JBPM_VARIABLEMAPPING 变量影射表

礼物 2007-09-06 18:00 发表评论

对Jbpm数据库应用的简单分析和在Mysql上实现的demo

礼物 — Thu, 06 Sep 2007 09:59:00 GMT

摘要: 对HelloWorldDbTest的分析在Eclipse中到如jbpm-starters-kit-3.1"jbpm工程后，在src"examples"org"jbpm"db底下有一个HelloWorldDbTest.java的实例。我从这个实例分析开始，构建自己的jbpm工程在Mysql下的应用。首先我们来先分析一下HelloWorldDbTest实例。基本流程 HelloWorld... 阅读全文

礼物 2007-09-06 17:59 发表评论

spring+hibernate+jbpm整合成功

礼物 — Thu, 06 Sep 2007 09:58:00 GMT

最后的配置结果是：

hibernate.cfg.xml、jbpm.cfg.xml在关联spring后保持不变，只需要更改spirng的配置文件就好了。

xml version="1.0" encoding="UTF-8"?>
DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName">
            <value>com.mysql.jdbc.Drivervalue>
        property>
        <property name="url">

            <value>jdbc:mysql://localhost:3306/testvalue>
        property>
        <property name="username">
            <value>rootvalue>

        property>
        <property name="password">
            <value/>

        property>
    bean>

    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource">
            <ref local="dataSource"/>
        property>
        <property name="mappingLocations">
           <value>classpath*:/org/jbpm/**/*.hbm.xmlvalue>
           property>
        <property name="hibernateProperties">
           <props>
               <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialectprop>
               <prop key="hibernate.hbm2ddl.auto">updateprop>
               <prop key="hibernate.jdbc.batch_size">0prop>

           props>
       property>
    bean>

    <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory">
            <ref local="sessionFactory"/>
        property>
    bean>


    <bean id="websaleWorkflow1" class="org.springmodules.workflow.jbpm31.definition.ProcessDefinitionFactoryBean">
        <property name="definitionLocation"    value="processdefinition.xml"/>
    bean>

    <bean id="jbpmConfiguration" class="org.springmodules.workflow.jbpm31.LocalJbpmConfigurationFactoryBean">

        <property name="sessionFactory" ref="sessionFactory"/>
        <property name="configuration" value="jbpm.cfg.xml"/>
        <property name="processDefinitions">
            <list>
                <ref local="websaleWorkflow1"/>
            list>
        property>
        <property name="createSchema" value="true"/>
    bean>

    <bean id="jbpmTemplate" class="org.springmodules.workflow.jbpm31.JbpmTemplate">
        <constructor-arg index="0" ref="jbpmConfiguration"/>
        <constructor-arg index="1" ref="websaleWorkflow1"/>
    bean>

beans>

其中

<property name="mappingLocations">
<value>classpath*:/org/jbpm/**/*.hbm.xmlvalue>

property>

很关键，我就是想spring会通过jbpm找到hibernate.cfg.xml而没有设置，才失败的。

礼物 2007-09-06 17:58 发表评论

jbpm例子

礼物 — Thu, 06 Sep 2007 09:57:00 GMT

摘要: 1. jBPM的简单介绍 jBPM是JBOSS下的一个开源java工作流项目，该项目提供eclipse插件，基于Hibernate实现数据持久化存储。参考 http://www.jboss.com/products/jbpm 2. jBPM和... 阅读全文

礼物 2007-09-06 17:57 发表评论

jbpm用户指南翻译：第6章　配置

礼物 — Thu, 06 Sep 2007 09:52:00 GMT

摘要: 第6章配置 jBPM配置由java类org.jbpm.JbpmConfiguration来描述，获取JbpmConfiguration的最简单方式是使用单态实例方法JbpmConfiguration.getInstance()。如果你想从另外一个源加载配置，你可以使用JbpmConfiguration.parseXxxx方法。 static JbpmConfinguration jb... 阅读全文

礼物 2007-09-06 17:52 发表评论

jBPM3.12用户指南中文翻译----第五章部署

礼物 — Thu, 06 Sep 2007 04:36:00 GMT

这是Jboss 的jBPM3.12框架的用户指南的中文翻译。我的翻译风格是中英文对照，只翻译部分我认为重要的，不翻译简单的英文，以免浪费你我的时间。同时，对于其中的部分内容，我会在翻译中做出解释和写上我的理解。

Chapter 5. Deployment部署

jBPM is an embeddable BPM engine, which means that you can take jBPM and embed it into your own java project, rather then installing a separate product and integrate with it. One of the key aspects that make this possible is minimizing the dependencies. This chapter discusses the jbpm libraries and their dependencies.

jBPM是一个嵌入式的BPM（业务程序管理）引擎。本章讨论jbpm库和它的依赖库。

5.1. Java runtime environment

jBPM 3 requires J2SE 1.4.2+

5.2. jBPM libraries

jbpm-[version].jar is the library with the core jbpm functionality.是jbpm的核心功能库。

jbpm-identity-[version].jar is the (optional) library containing an identity component as described in Section 11.11, “The identity component”.

可选的，这个库包含了身份验证组件。用于流程的参与者的管理。

5.3. Third party libraries第三方库

In a minimal deployment, you can create and run processes with jBPM by putting only the commons-logging and dom4j library in your classpath. Beware that persisting processes to a database is not supported. The dom4j library can be removed if you don't use the process xml parsing, but instead build your object graph programatically.

最小的jbpm部署，只需要核心jbpm库和commons-logging库，以及dom4j库到你的classpath中。此时，不支持持久化业务程序到数据库。

Table 5.1.

Library库	Usage用途	Description描述	Directory目录
commons-logging.jar	logging in jbpm and hibernate	The jBPM code logs to commons logging. The commons logging library can be configured to dispatch the logs to e.g. java 1.4 logging, log4j, ... See the apache commons user guide for more information on how to configure commons logging. if you're used to log4j, the easiest way is to put the log4j lib and a log4j.properties in the classpath. commons logging will automatically detect this and use that configuration.	`lib/jboss (from jboss 4.0.3)`
dom4j-1.6.1.jar	process definitions and hibernate persistence	xml parsing	`lib/dom4j`

A typical deployment for jBPM will include persistent storage of process definitions and process executions. In that case, jBPM does not have any dependencies outside hibernate and its dependent libraries.

典型的jBPM部署包括持久化业务程序定义和执行的功能。需要Hibernate

Of course, hibernate's required libraries depend on the environment and what features you use. For details refer to the hibernate documentation. The next table gives an indication for a plain standalone POJO development environment.

下面的表给出了简单的标准POJO部署环境需要的第三方库。

jBPM is distributed with hibernate 3.1 final. But it can also work with 3.0.x. In that case, you might have to update a few hibernate queries in the hibernate.queries.hbm.xml configuration file. For more info about customizing queries, see Section 7.6, “Customizing queries”

Table 5.2.

Library库	Usage	Description	Directory
hibernate3.jar	hibernate persistence	the best O/R mapper	`lib/hibernate (hibernate 3.1 final)`
antlr-2.7.5H3.jar	used in query parsing by hibernate persistence	parser library	`lib/jboss (from jboss 4.0.3)`
cglib-2.1_2jboss.jar	hibernate persistence	reflection library used for hibernate proxies	`lib/jboss (from jboss 4.0.3)`
commons-collections.jar	hibernate persistence		`lib/jboss (from jboss 4.0.3)`
ehcache-1.1.jar	hibernate persistence (in the default configuration)	second level cache implementation.二级缓存实现。 When configuring a different cache provider for hibernate, this library is not required.	`lib/hibernate`
jaxen-1.1-beta-4.jar	process definitions and hibernate persistence	XPath library (used by dom4j)	`lib/hibernate`
jdbc2_0-stdext.jar	hibernate persistence		`lib/hibernate`
asm.jar	hibernate persistence	asm byte code library 二进制代码修改库	`lib/hibernate`
asm-attrs.jar	hibernate persistence	asm byte code library	`lib/hibernate`

The beanshell library is optional. If you don't include it, you won't be able to use the beanshell integration in the jbpm process language and you you'll get a log message saying that jbpm couldn't load the Script class and hence, the script element won't be available.

Beanshell库是可选的。

Table 5.3.

Library	Usage	Description	Directory
bsh-1.3.0.jar	beanshell script interpreter	Only used in the script's and decision's. When you don't use these process elements, the beanshell lib can be removed, but then you have to comment out the Script.hbm.xml mapping line in the `hibernate.cfg.xml`	`lib/jboss`

礼物 2007-09-06 12:36 发表评论

jBPM3.12用户指南中文翻译----第四章面向图表编程

礼物 — Thu, 06 Sep 2007 04:33:00 GMT

摘要: 这是Jboss 的jBPM3.12框架的用户指南的中文翻译。我的翻译风格是中英文对照，只翻译部分我认为重要的，不翻译简单的英文，以免浪费你我的时间。同时，对于其中的部分内容，我会在翻译中做出解释和写上我的理解。 Chapter 4. Graph Oriented Programming面向图表编程 4.1. Introductio... 阅读全文

礼物 2007-09-06 12:33 发表评论

jBPM3.12用户指南中文翻译----第二章起步

礼物 — Thu, 06 Sep 2007 04:30:00 GMT

这是Jboss 的jBPM3.12框架的用户指南的中文翻译。我的翻译风格是中英文对照，只翻译部分我认为重要的，不翻译简单的英文，以免浪费你我的时间。
同时，对于其中的部分内容，我会在翻译中做出解释和写上我的理解。

Chapter 2. Getting started起步

This chapter takes you through the first steps of getting JBoss jBPM and provides the initial pointers to get up and running in no time.

初始化JBpm3.12

2.1. Downloadables Overview

Listed below are the different jBPM packages that are available today. Each of these packages contains one or more downloadable files. Along with each of these files goes a description of its contents and a pointer to any relevant installation instructions if they are available.

All downloads described below can be found on the sourceforge jbpm downloads page.

2.1.1. jBPM 3

Download JBoss jBPM 3 at sourceforge.net. This is the main distribution package containing the core engine and a number of additional modules that you may need to work with jBPM. 包括JBpm核心和其他包。

The Starters Kit (jbpm-starters-kit-.zip): If you want to get started with jBPM quickly, this is the file you want to download. It contains all the other modules of this package plus the graphical designer in one single download. Extract the zipped archive into a folder of your choice and read the file named 'readme.html' for more info and further installation instructions. With this starters kit you can immediately get started with the Chapter 3, Tutorial.

包含了包括图形化设计器在内的所有模块，能够帮助你快速启动。

Core Engine and Identity Component (jbpm-.zip): The download contains the jBPM core engine as well as the identity component for actor and group management. To start working with it, extract the archive into a folder of your choice. You will find pointers to the User's Guide and other important information resources in the 'readme.html' file in the 'jbpm-' folder.

核心，包括核心引擎和身份组建，内有用户指南文档。

Database Extensions (jbpm-db-.zip):数据库扩展 The database extension pack contains the jBPM core engine as well as the identity component for actor and group management. To start working with it, extract the archive into a folder of your choice. You will find pointers to the User's Guide and other important information resources in the 'readme.html' file in the 'jbpm-' folder.

2.1.2. jBPM Process Designer

jBPM过程设计器

Download JBoss jBPM Process Designer at sourceforge.net. The designer is an eclipse plugin and enables you to author 创作your process definitions过程定义 and to easily deploy them. The plug-in is available for download either as a zipped Eclipse feature or as a zipped Eclipse update site. There is no difference in content, the only difference is in the way you have to do the installation.

Eclipse Update Site (jbpm-gpd-site-.zip): If you want to be absolutely sure that the designer installation goes smoothly, we recommend to use the update site mechanism together with a new Eclipse installation. Of cource the Eclipse version should match the downloaded update site archive. To get started with the designer plugin, follow the instructions in the 'readme.html' file included in the archives root folder to succesfully install the GPD.

使用本地站点更新方式部署。

Eclipse Feature (jbpm-gpd-feature-.zip): If you are tired of each time having to do a fresh Eclipse installation and you are willing to cope with some possible issues, you can try the feature download. In this case installation is as easy as extracting the archive into your Eclipse installation (make sure the included 'plugins' and 'features' folders end up in the same location of your Eclipse installation) overwriting the files and folders with the same name that are possibly already present. This installation is very easy, but you could run into incompatibility issues when you overwrite plugins already present in your installation because of other features that you did install. Though they have the same name it could happen that the versions of these colliding plugins are not equal, hence the possible incompatibilities. The installation instructions are repeated in the 'readme.html' file.

这个是手工部署。

2.1.3. jBPM BPEL extension

Download JBoss jBPM BPEL extension at sourceforge.net. It contains only one file : jbpm-bpel-.zip. To get started with the BPEL extensions, look in the User's Guide in the 'doc' subfolder of the toplevel folder.

jbpm-bpel：含有JBoss jBPM的BPEL扩展件方面的信息。

BPEL是一个规范的SOA组件。因为与JBoss jBPM使用的许可证不同，所以被独立了出来。

2.2. The JBoss jBPM project directory

professional support: JBoss is the company that backs this project with professional support, training and consultancy services.
user guide: is the document you're reading and serves as the main entry point into the project.
forums: get in contact with the community, ask questions and discuss jBPM 论坛，社区。
wiki: extra information, mostly provided by the community
issue tracker: for submitting bugs and feature requests
downloads: sourceforge download page for jBPM
mailing lists: mailing lists are used for announcements
javadocs: part of the download in the doc/javadoc directory.

2.3. CVS access

2.3.1. Anonymous CVS access

Alternatively, you can get JBoss jBPM from cvs with the following information:

Connection type: pserver
User: anonymous
Host: anoncvs.forge.jboss.com
Port: 2401 (which is the default)
Repository path: /cvsroot/jbpm
Label: :pserver:anonymous@anoncvs.forge.jboss.com:/cvsroot/jbpm

2.3.2. Developer CVS access

To get cvs developer access, you must sign contributors agreement and you need an ssh key. More information on both can be found on the JBoss cvs repository wiki page

Connection type: ext over ssh (extssh in eclipse)
User: sf.net username or jboss username
Host: cvs.forge.jboss.com
Port: 2401 (which is the default)
Repository path: /cvsroot/jbpm
Label: :pserver:anonymous@cvs.forge.jboss.com:/cvsroot/jbpm

礼物 2007-09-06 12:30 发表评论

jBPM3.12用户指南中文翻译----第三章指南

礼物 — Thu, 06 Sep 2007 04:29:00 GMT

这是Jboss 的jBPM3.12框架的用户指南的中文翻译。我的翻译风格是中英文对照，只翻译部分我认为重要的，不翻译简单的英文，以免浪费你我的时间。
同时，对于其中的部分内容，我会在翻译中做出解释和写上我的理解。

Chapter 3. Tutorial指南

This tutorial will show you basic process constructs 过程建造in jpdl and the usage of the API for managing the runtime executions.

这本指南将告诉你使用jpdl语言构建基本的工作流程，以及管理运行时执行的API的用法。

The format of this tutorial is explaining a set of examples. The examples focus on a particular topic and contain extensive comments. The examples can also be fond in the jBPM download package in the directory src/java.examples.

这篇指南解释一系列的例子。例子聚焦于一个特殊的主题和包含很多的注释。

The best way to learn is to create a project and experiment by creating variations on the examples given.

最好的学习方式是在例子的基础上创建一个略为不同的项目。

To get started for eclipse users: download jbpm-3.0-[version].zip and unzip it to your sytem. Then do "File" --> "Import..." --> "Existing Project into Workspace". Click "Next" Then, browse for the jBPM root directory and click "Finish". Now you have a jbpm.3 project in your workspace. You can now find the examples of the tutorial in src/java.examples/.... When you open these examples, you can run them with "Run" --> "Run As..." --> "JUnit Test"

用Junit运行自带的例子。

jBPM includes a graphical designer tool for authoring 创作the XML that is shown in the examples. You can find download instructions指令 for the graphical designer in Section 2.1, “Downloadables Overview”. You don't need the graphical designer tool to complete this tutorial.

State machines can be

你不需要图形设计器就能完成这篇指南。图形设计器仅仅帮助你制作xml流程定义文件。

3.1. Hello World example

A process definition is a directed graph, made up of nodes and transitions. The hello world process has 3 nodes. To see how the pieces fit together, we're going to start with a simple process without the use of the designer tool. The following picture shows the graphical representation of the hello world process:

一个过程定义是一个直接的图表，由“节点”和“转向”组成。Hello world这个例子的过程定义有3个节点。

下面的图像显示了hello world过程定义的图形化表示。

V:SHAPE id=_x0000_i1025 style="WIDTH: 63.75pt; HEIGHT: 120pt" type="#_x0000_t75">

Figure 3.1. The hello world process graph

Hello world业务处理图表

publicvoid testHelloWorldProcess() {

// This method shows a process definition and one execution

// of the process definition. The process definition has

// 3 nodes: an unnamed start-state, a state 's' and an

// end-state named 'end'.

//这个方法显示了一个过程定义和这个过程定义的执行。

// The next line parses a piece of xml text into a

// ProcessDefinition. A ProcessDefinition is the formal

// description of a process represented as a java object.

/*

* 下一行把一段xml文本解析进ProcessDefinition对象。ProcessDefinition是

* 过程作为一个Java对象在内存中的正式的描述

* */

ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(

" " +

" " +

" " +

" " +

" " +

" " +

" " +

" " +

" "

);

// The next line creates one execution of the process definition.

// After construction, the process execution has one main path

// of execution (=the root token) that is positioned in the

// start-state.

/**

*下一行使用代表过程定义的Model对象--ProcessDefinition实例，创建一个业务处理定义的执行

*构造之后，在开始状态/节点，业务处理执行对象有一个主要的执行路径

*

*/

ProcessInstance processInstance =

new ProcessInstance(processDefinition);

// After construction, the process execution has one main path

// of execution (=the root token).

/*记号，得到主要的执行路径。

* Token记号类，代表一条过程的执行路径和在过程定义中维护一个指向节点的指针

*

* */

Token token = processInstance.getRootToken();

// Also after construction, the main path of execution is positioned

// in the start-state of the process definition.

assertSame(processDefinition.getStartState(), token.getNode());

// Let's start the process execution, leaving the start-state

// over its default transition.

/*

* token.signal();用来执行一步状态，利用“转向”跳到下一步状态。

*

* */

token.signal();

// The signal method will block until the process execution

// enters a wait state.

// The process execution will have entered the first wait state

// in state 's'. So the main path of execution is not

// positioned in state 's'

assertSame(processDefinition.getNode("s"), token.getNode());

// Let's send another signal. This will resume execution by

// leaving the state 's' over its default transition.

/*

* 让我们发送另一个信号。这将执行离开状态s的转向。

* */

token.signal();

// Now the signal method returned because the process instance

// has arrived in the end-state.

assertSame(processDefinition.getNode("end"), token.getNode());

}

参考：

1，记号类，代表一个工作处理定义的一条工作流程。

public class Token

extends java.lang.Object

implements java.io.Serializable

represents one path of execution and maintains a pointer to a node in the ProcessDefinition. Most common way to get a hold of the token objects is with ProcessInstance.getRootToken() or ProcessInstance.findToken(String).

这个类代表了一个过程的执行流程。使用

public void signal()

provides a signal to the token. this method activates this token and leaves the current state over the default transition.

方法执行一步。

2，工作处理实例类

public class ProcessInstance

extends java.lang.Object

implements java.io.Serializable

is one execution of a ProcessDefinition. To create a new process execution of a process definition, just use the ProcessInstance(ProcessDefinition).

这个类根据作为Model数据容器类的ProcessDefinition工作处理定义类的一个实例创建。代表一个工作处理定义的执行。主要关注于工作处理相关的操作。

getRootToken
public TokengetRootToken()
得到工作处理定义的从start状态开始的一条记号----工作流程。

findToken
public TokenfindToken(java.lang.String tokenPath)
looks up the token in the tree, specified by the slash-separated token path.

Parameters:

tokenPath - is a slash-separated name that specifies a token in the tree.

Returns:

the specified token or null if the token is not found.

在工作处理定义的树中，根据记号路径/工作流程路径得到一条工作流程

。

3.2. Database example

数据库例子

One of the basic features of jBPM is the ability to persist executions of processes in the database when they are in a wait state. The next example will show you how to store a process instance in the jBPM database. The example also suggests a context in which this might occur. Separate methods are created for different pieces of user code. E.g. an piece of user code in a web application starts a process and persists the execution in the database. Later, a message driven bean loads the process instance from the database and resumes its execution.

jBPM的一个基本的特性是，它能够在业务处理处于等待状态时，把业务处理的执行结果储存到数据库中。下一个例子讲告诉你怎样把一个业务处理的实例保存进jBPM数据库。例子也展示了可能发生这种情况的场景。如，用户的业务处理代码由几个独立的方法组成，例如，一部分用户代码是，在一个Web应用程序中开始一个处理，并且把这个处理保存进数据库。然后，一个消息驱动的bean从数据库中引导这个业务处理实例----也就是业务处理定义的一个执行的实例（注意:ProcessDefinition业务处理定义是一个Model，保存xml格式的业务处理图表，一种DSL特定领域语言；而ProcessInstance业务处理实例，也是一个Model，它是保存业务处理定义的一次执行的信息。具体的操作由从它得到的Token记号类执行。Token类是Action类，真正执行业务处理的流程。Token类应该叫做“工作流程类”，代表了业务处理的一条工作流程），恢复它的执行。

这样，jBPM的业务处理具有分段、异步执行的能力。

More about the jBPM persistence can be found in Chapter 7, Persistence.

API参考：

1,Jbpm配置

public class JbpmConfiguration

extends java.lang.Object

implements java.io.Serializable

configuration of one jBPM instance.一个jBPM实例的配置。也就是说，jBPM可以使用多个jBPM配置。基本上，一个jBPM的业务处理可以使用一个JbpmConfiguration对象的实例。

During process execution, jBPM might need to use some services. A JbpmConfiguration contains the knowledge on how to create those services.

在业务处理的执行过程中，jBPM可能需要使用一些服务。一个Jbpm配置类包含了怎样创建这些服务的知识。

A JbpmConfiguration is a thread safe object and serves as a factory for JbpmContexts, which means one JbpmConfiguration can be used to create JbpmContexts for all threads. The single JbpmConfiguration can be maintained in a static member or in the JNDI tree if that is available.

一个JbpmConfiguration能够被用来为所有的线程创建JbpmContext。JbpmConfiguration.createJbpmContext()；方法创建Jbpm上下文环境类的一个实例。

JbpmConfiguration应该使用单例，如静态成员，或者JNDI树，或者IOC容器管理的单例等。

A JbpmConfiguration can be obtained in following ways:

from a resource (by default jbpm.cfg.xml is used):
· JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance();

or

String myXmlResource = "...";

JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance(myXmlResource);

from an XML string:
· JbpmConfiguration jbpmConfiguration = JbpmConfiguration.parseXmlString(

· "" +

· ...

· ""

· );

By specifying a custom implementation of an object factory. This can be used to specify a JbpmConfiguration in other bean-style notations such as used by JBoss Microcontainer or Spring.
通过指定一个对象工厂的定制实现。被用在JBoss或者Spring容器中。

· ObjectFactory of = new MyCustomObjectFactory();

· JbpmConfiguration.Configs.setDefaultObjectFactory(of);

· JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance();

JbpmConfigurations can be configured using a spring-like XML notation (in relax ng compact notation):

datatypes xs = "http://www.w3.org/2001/XMLSchema-datatypes"

start = element beans { element object* }

object = {

jbpm-context |

bean |

ref |

map |

list |

string |

int |

long |

float |

double |

char |

bool |

true |

false |

null

}

jbpm-context = element jbpm-context {

( attribute name {xsd:string},

service*,

save-operations?

)

}

service = element service {

( attribute name {xsd:string},

( attribute factory {xsd:string} ) |

( factory )

)

}

factory = element factory {

( bean |

ref

)

}

save-operations = element save-operations {

( save-operation* )

}

save-operation = element save-operation {

( ( attribute class {xsd:string} ) |

( bean |

ref

)

)

}

bean = element bean {

( attribute ref-name {xsd:string} ) |

( attribute name {xsd:string}?,

attribute class {xsd:string}?,

attribute singleton { "true" | "false" }?,

constructor*,

field*,

property*

)

}

ref = element ref {

( attribute bean (xsd:string) )

}

constructor = element constructor {

attribute class {xsd:string}?,

( attribute factory {xsd:string},

attribute method {xsd:string}

)?,

parameter*

}

parameter = element parameter {

attribute class {xsd:string},

object

}

field = element field {

attribute name {xsd:string},

object

}

property = element property {

( attribute name {xsd:string} |

attribute setter {xsd:string}

),

object

}

map = element map {

entry*

}

entry = element entry {

key,

value

}

key = element key {

object

}

value = element value {

object

}

list = element list {

object*

}

string = element string {xsd:string}

int = element integer {xsd:integer}

long = element long {xsd:long}

float = element float {xsd:string}

double = element string {xsd:double}

char = element char {xsd:character}

bool = element bool { "true" | "false" }

true = element true {}

false = element false {}

null = element null {}

Other configuration properties

jbpm.msg.wait.timout

jbpm.files.dir

jbpm.types

2，Jbpm上下文环境

public class JbpmContext

extends java.lang.Object

implements java.io.Serializable

is used to surround persistent operations to processes.

被用来负责业务处理的持久化操作。它底层使用Hibernate等数据库持久化技术来与数据库中的保存业务处理图表、业务处理的执行等的数据库表交互。

Obtain JbpmContext's via JbpmConfiguration.createJbpmContext() and put it in a try-finally block like this:

作为一个数据库持久化资源，必须要关闭。

JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();

try {

TaskInstance taskInstance = ...

...do your process operations...

// in case you update a process object that was not fetched

// with a ...ForUpdate method, you have to save it.

/*

*/

jbpmContext.save(processInstance);

finally {

jbpmContext.close();

}

A JbpmContext separates jBPM from a sprecific environment. For each service that jBPM uses, there is an interface specified in the jBPM codebase. jBPM also includes implementations that implement these services by using services in a specific environment. e.g. a hibernate session, a JMS asynchronous messaging system, ...

JbpmContext从一个jBPM实例的环境中分离而来。每一个jBPM使用的服务，在jBPM的代码库中有指定的借口。jBPM也包括在一个特定环境中使用这些服务的实现类。

A JbpmContext can demarcate a transaction. When a PersistenceService is fetched from the JbpmContext, the default implementation for the persistence service will create a hibernate session and start a transaction. So that transactions can be configured in the hibernate configuration.

JbpmContext能够使用事务。如果一个持久化服务是从JbpmContext中来的，那么默认的持久化实现是Hibernate，那么将会创建一个Hibernate会话和事务。

A JbpmContext allows the user to overwrite重写 (or make complete) the configuration by injecting objects programmatically编程注入对象. like e.g. a hibernate session factory or a hibernate session or any other resource that can be fetched or created from the configuration.

Last but not least, JbpmContext provides convenient方便的 access to the most common operations such as getTaskList(String), newProcessInstance(String)loadTaskInstanceForUpdate(long) and save(ProcessInstance).

All the ...ForUpdate(...) methods will automatically save the loaded objects at jbpmContext.close();

所有这些涉及到数据库更新的操作，都会在jbpmContext.close()调用时被自动保存到数据库中。

3，GraphSession类业务处理图表会话类，更确切的名字：业务处理定义会话类

/*

* JBoss, Home of Professional Open Source

* Copyright 2005, JBoss Inc., and individual contributors as indicated

* by the @authors tag. See the copyright.txt in the distribution for a

* full listing of individual contributors.

*

* This is free software; you can redistribute it and/or modify it

* under the terms of the GNU Lesser General Public License as

* published by the Free Software Foundation; either version 2.1 of

* the License, or (at your option) any later version.

*

* This software is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public

* License along with this software; if not, write to the Free

* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

* 02110-1301 USA, or see the FSF site: http://www.fsf.org.

*/

package org.jbpm.tutorial.db;

import java.util.List;

import junit.framework.TestCase;

import org.jbpm.JbpmConfiguration;

import org.jbpm.JbpmContext;

import org.jbpm.db.GraphSession;

import org.jbpm.graph.def.ProcessDefinition;

import org.jbpm.graph.exe.ProcessInstance;

import org.jbpm.graph.exe.Token;

public class HelloWorldDbTest extends TestCase {

static JbpmConfiguration jbpmConfiguration = null;

static {

// An example configuration file such as this can be found in

// 'src/config.files'. Typically the configuration information is in the

// resource file 'jbpm.cfg.xml', but here we pass in the configuration

// information as an XML string.

// First we create a JbpmConfiguration statically. One JbpmConfiguration

// can be used for all threads in the system, that is why we can safely

// make it static.

/**

*单例对象。

*JbpmConfiguration能够被系统中所有线程所使用。

*jbpm.cfg.xml这个命名方式和Hibernate配置文件的命名方式一致。

*

*/

jbpmConfiguration = JbpmConfiguration.parseXmlString(

"" +

// A jbpm-context mechanism separates the jbpm core

// engine from the services that jbpm uses from

// the environment.

/*jbpm-context机制在环境中把jbpm核心引擎和jbpm使用的服务分开。

* 持久化服务是jbpm核心引擎使用的一个服务。

*

* */

" " +

" " +

" " +

// Also all the resource files that are used by jbpm are

// referenced from the jbpm.cfg.xml

/*

*string，配置了所有jbpm使用的资源文件的路径。

* */

" " +

" " +

" " +

" " +

" " +

" " +

" " +

""

);

}

public void setUp() {

//创建计划

jbpmConfiguration.createSchema();

}

public void tearDown() {

//删除计划

jbpmConfiguration.dropSchema();

}

public void testSimplePersistence() {

// Between the 3 method calls below, all data is passed via the

// database. Here, in this unit test, these 3 methods are executed

// right after each other because we want to test a complete process

// scenario情节. But in reality, these methods represent different

// requests to a server.

// Since we start with a clean, empty in-memory database, we have to

// deploy the process first. In reality, this is done once by the

// process developer.

/**

* 这个方法把业务处理定义通过Hibernate保存到数据库中。

*/

deployProcessDefinition();

// Suppose we want to start a process instance (=process execution)

// when a user submits a form in a web application...

/*假设当一个用户提交一个表单时，我们要开始一个业务处理的实例/执行。

* 这可以在Action中执行处理。

*/

processInstanceIsCreatedWhenUserSubmitsWebappForm();

// Then, later, upon the arrival of an asynchronous message the

// execution must continue.

/*

* 然后，直到异步消息来到，才继续执行业务处理实例的余下的工作流程。

* */

theProcessInstanceContinuesWhenAnAsyncMessageIsReceived();

}

public void deployProcessDefinition() {

// This test shows a process definition and one execution

// of the process definition. The process definition has

// 3 nodes: an unnamed start-state, a state 's' and an

// end-state named 'end'.

/*

* 这个方法把业务处理定义通过Hibernate保存到数据库中。

*

* */

ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(

" " +

" " +

" " +

" " +

" " +

" " +

" " +

" " +

" "

);

// Lookup the pojo persistence context-builder that is configured above

JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();

try {

// Deploy the process definition in the database

jbpmContext.deployProcessDefinition(processDefinition);

} finally {

// Tear down the pojo persistence context.

// This includes flush the SQL for inserting the process definition

// to the database.

/*

* 关闭jbpm上下文。删除pojo持久化上下文。

* 这包括刷新SQL来真正的把业务处理定义插入到数据库中。

* */

jbpmContext.close();

}

}

public void processInstanceIsCreatedWhenUserSubmitsWebappForm() {

// The code in this method could be inside a struts-action

// or a JSF managed bean.

// Lookup the pojo persistence context-builder that is configured above

JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();

try {

/*

* 图表会话，是图表定义/业务处理定义相关的数据库层面的会话。应该也是一个Hibernate会话。

* 可以从JBpm上下文这个数据库----业务处理定义、实例等得到业务处理定义会话。

*

* */

GraphSession graphSession = jbpmContext.getGraphSession();

//从数据库中根据业务处理定义的名字得到一个业务处理定义。

ProcessDefinition processDefinition =

graphSession.findLatestProcessDefinition("hello world");

// With the processDefinition that we retrieved from the database, we

// can create an execution of the process definition just like in the

// hello world example (which was without persistence).

/*

* 创建业务处理定义的一个实例。

*

* */

ProcessInstance processInstance =

new ProcessInstance(processDefinition);

Token token = processInstance.getRootToken();

assertEquals("start", token.getNode().getName());

// Let's start the process execution

token.signal();

// Now the process is in the state 's'.

assertEquals("s", token.getNode().getName());

// Now the processInstance is saved in the database. So the

// current state of the execution of the process is stored in the

// database.

/*

* 执行一步工作流程后，使用jbpmContext保存这个业务处理实例进数据库。

* 所以现在就把业务处理实例的执行状态也保存进了数据库。

* 因为，业务处理定义的实例这个类也是一个Model类，用于管理一个业务处理定义的执行的所有信息，

* 是一个多例模式的Model。

*

* */

jbpmContext.save(processInstance);

// The method below will get the process instance back out

// of the database and resume execution by providing another

// external signal.

} finally {

// Tear down the pojo persistence context.

jbpmContext.close();

}

}

public void theProcessInstanceContinuesWhenAnAsyncMessageIsReceived() {

// The code in this method could be the content of a message driven bean.

//这个方法可能在消息驱动Bean这个远程业务代理类中。

// Lookup the pojo persistence context-builder that is configured above

JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();

try {

GraphSession graphSession = jbpmContext.getGraphSession();

// First, we need to get the process instance back out of the database.

// There are several options to know what process instance we are dealing

// with here. The easiest in this simple test case is just to look for

// the full list of process instances. That should give us only one

// result. So let's look up the process definition.

ProcessDefinition processDefinition =

graphSession.findLatestProcessDefinition("hello world");

// Now, we search for all process instances of this process definition.

/*

* 根据业务处理定义的id得到数据库中所有的业务处理实例。这表明，数据库中应该存在2张表

* 它们是一对多的关系。

*

* */

List processInstances =

graphSession.findProcessInstances(processDefinition.getId());

// Because we know that in the context of this unit test, there is

// only one execution. In real life, the processInstanceId can be

// extracted from the content of the message that arrived or from

// the user making a choice.

ProcessInstance processInstance =

(ProcessInstance) processInstances.get(0);

// Now we can continue the execution. Note that the processInstance

// delegates signals to the main path of execution (=the root token).

processInstance.signal();

// After this signal, we know the process execution should have

// arrived in the end-state.

assertTrue(processInstance.hasEnded());

// Now we can update the state of the execution in the database

jbpmContext.save(processInstance);

} finally {

// Tear down the pojo persistence context.

jbpmContext.close();

}

}

}

3.3. Context example: process variables

上下文例子：处理变量

The process variables contain the context information during process executions. The process variables are similar to a java.util.Map that maps variable names to values, which are java objects. The process variables are persisted as a part of the process instance. To keep things simple, in this example we only show the API to work with variables, without persistence.

ContextInstance类的实例保存在ProcessInstance中。是它的一个成员对象。是一个Map，保存名值对。它们会被保存在数据库中。应该是一个独立的表。和业务处理定义的实例/执行表是“一对多”的关系！

可以在这里保存一些必要的信息，用于工作流程处理的交流的需要！

More information about variables can be found in Chapter 10, Context

publicclass ContextTest extends TestCase {

publicvoid testContext() {

// Also this example starts from the hello world process.

// This time even without modification.

ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(

" " +

" " +

" " +

" " +

" " +

" " +

" " +

" " +

" "

);

ProcessInstance processInstance =

new ProcessInstance(processDefinition);

// Fetch the context instance from the process instance

// for working with the process variableInstances.

//得到一个map，业务处理实例的上下文实例Map。包含业务处理实例的一些上下文信息。

ContextInstance contextInstance =

processInstance.getContextInstance();

// Before the process has left the start-state,

// we are going to set some process variableInstances in the

// context of the process instance.

contextInstance.setVariable("amount", new Integer(500));

contextInstance.setVariable("reason", "i met my deadline");

// From now on, these variableInstances are associated with the

// process instance. The process variableInstances are now accessible

// by user code via the API shown here, but also in the actions

// and node implementations. The process variableInstances are also

// stored into the database as a part of the process instance.

processInstance.signal();

// The variableInstances are accessible via the contextInstance.

assertEquals(new Integer(500),

contextInstance.getVariable("amount"));

assertEquals("i met my deadline",

contextInstance.getVariable("reason"));

}

}

3.4. Task assignment example任务委派例子

In the next example we'll show how you can assign a task to a user. Because of the separation between the jBPM workflow engine and the organisational model, an expression language for calculating actors would always be too limited. Therefore, you have to specify an implementation of AssignmentHandler for including the calculation of actors for tasks.

在下一个例子中，我们将高叔你怎样给一个用户分配任务。因为jBPM工作流引擎和组织的模型时各自独立的，用一种表达式语言来计算动作执行者总是太受限了。因此，你必须指定一个分派处理器的实现来包括任务执行者的计算工作。

API参考：

1，任务实例

public class TaskInstance

extends VariableContainer

implements Assignable

is one task instance that can be assigned to an actor (read: put in someones task list) and that can trigger the coninuation of execution of the token upon completion.

是一个任务实例，它能够被分配给一个用户，能够触发工作流的继续执行。

publicclass TaskAssignmentTest extends TestCase {

publicvoid testTaskAssignment() {

// The process shown below is based on the hello world process.

// The state node is replaced by a task-node. The task-node

// is a node in JPDL that represents a wait state and generates

// task(s) to be completed before the process can continue to

// execute.

/*

* 任务节点是一个JPDL的节点，它表示一个等待状态，生成任务被完成之前，业务处理将不能执行。

*

* */

ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(

" " +

" " +

" " +

" " +

" " +

" " +

" " +

" " +

" " +

" " +

" " +

" "

);

// Create an execution of the process definition.

ProcessInstance processInstance =

new ProcessInstance(processDefinition);

Token token = processInstance.getRootToken();

// Let's start the process execution, leaving the start-state

// over its default transition.

token.signal();

// The signal method will block until the process execution

// enters a wait state. In this case, that is the task-node.

assertSame(processDefinition.getNode("t"), token.getNode());

// When execution arrived in the task-node, a task 'change nappy'

// was created and the NappyAssignmentHandler was called to determine

// to whom the task should be assigned. The NappyAssignmentHandler

// returned 'papa'.

// In a real environment, the tasks would be fetched from the

// database with the methods in the org.jbpm.db.TaskMgmtSession.

// Since we don't want to include the persistence complexity in

// this example, we just take the first task-instance of this

// process instance (we know there is only one in this test

// scenario.

/*

* 执行到任务时，需要执行指定的类。这个类设置了执行者的id。

* 在真实环境中，应该是从数据库中返回任务，

* org.jbpm.db.TaskMgmtSession

* TaskInstance包含：id,任务名，用户id。

* 业务处理实例---任务

* 1 n

*

* 用户-------====任务

* 1 n

*

* */

TaskInstance taskInstance = (TaskInstance)

processInstance

.getTaskMgmtInstance()

.getTaskInstances()

.iterator().next();

// Now, we check if the taskInstance was actually assigned to 'papa'.

assertEquals("papa", taskInstance.getActorId() );

// Now suppose that 'papa' has done his duties and marks the task

// as done.

taskInstance.end();

// Since this was the last (only) task to do, the completion of this

// task triggered the continuation of the process instance execution.

assertSame(processDefinition.getNode("end"), token.getNode());

}

}

3.5. Custom action example定制动作例子

Actions are a mechanism to bind your custom java code into a jBPM process. Actions can be associated with its own nodes (if they are relevant in the graphical representation of the process). Or actions can be placed on events like e.g. taking a transition, leaving a node or entering a node. In that case, the actions are not part of the graphical representation, but they are executed when execution fires the events in a runtime process execution.

We'll start with a look at the action implementation that we are going to use in our example : MyActionHandler. This action handler implementation does not do really spectacular things不是真的做伟大的事情... it just sets the boolean variable isExecuted to true. The variable isExecuted is static so it can be accessed from within the action handler as well as from the action to verify it's value.

More information about actions can be found in Section 9.5, “Actions”

// MyActionHandler represents a class that could execute

// some user code during the execution of a jBPM process.

publicclass ActionTest extends TestCase {

// Each test will start with setting the static isExecuted

// member of MyActionHandler to false.

publicvoid setUp() {

MyActionHandler.isExecuted = false;

}

publicvoid testTransitionAction() {

// The next process is a variant of the hello world process.

// We have added an action on the transition from state s

// to the end-state. The purpose of this test is to show

// how easy it is to integrate java code in a jBPM process.

ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(

" " +

" " +

" " +

" " +

" " +

//转向执行时，执行该动作

" " +

" " +

" " +

" " +

" " +

" "

);

// Let's start a new execution for the process definition.

ProcessInstance processInstance =

new ProcessInstance(processDefinition);

// The next signal will cause the execution to leave the start

// state and enter the state 's'

processInstance.signal();

// Here we show that MyActionHandler was not yet executed.

assertFalse(MyActionHandler.isExecuted);

// ... and that the the main path of execution is positioned in

// the state 's'

assertSame(processDefinition.getNode("s"),

processInstance.getRootToken().getNode());

// The next signal will trigger the execution of the root

// token. The token will take the transition with the

// action and the action will be executed during the

// call to the signal method.

processInstance.signal();

// Here we can see that MyActionHandler was executed during

// the call to the signal method.

assertTrue(MyActionHandler.isExecuted);

}

The next example shows the same action, but now the actions are placed on the enter-node进入节点事件 and leave-node events 离开节点事件respectively. Note that a node has more then one event type in contrast to a transition, which has only one event. Therefore actions placed on a node should be put in an event element.

Transition转向只有一个节点。

publicvoid testNodeActions() {

ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(

" " +

" " +

" " +

" " +

" " +

//节点进入事件，进入节点时，事件激活。执行该动作。

" " +

" " +

" " +

//节点离开事件，离开节点时，事件激活。执行该动作。

" " +

" " +

" " +

" " +

" " +

" " +

" "

);

ProcessInstance processInstance =

new ProcessInstance(processDefinition);

assertFalse(MyActionHandler.isExecuted);

// The next signal will cause the execution to leave the start

// state and enter the state 's'. So the state 's' is entered

// and hence因此 the action is executed.

processInstance.signal();

assertTrue(MyActionHandler.isExecuted);

// Let's reset the MyActionHandler.isExecuted

MyActionHandler.isExecuted = false;

// The next signal will trigger execution to leave the

// state 's'. So the action will be executed again.

processInstance.signal();

// Voila.

assertTrue(MyActionHandler.isExecuted);

}

}

动作类

publicclass MyActionHandler implements ActionHandler {

privatestaticfinallongserialVersionUID = 1L;

// Before each test (in the setUp), the isExecuted member

// will be set to false.

publicstaticbooleanisExecuted = false;

// The action will set the isExecuted to true so the

// unit test will be able to show when the action

// is being executed.

publicvoid execute(ExecutionContext executionContext) {

isExecuted = true;

}

}

API参考：

1，

ExecutionContext 执行上下文类。

作为参数回调模式的参数，用于得到业务处理实例的东西。

JbpmContext
getJbpmContext()

Node
getNode()

ProcessDefinition
getProcessDefinition()

ProcessInstance
getProcessInstance()

可以通过它得到所有“业务处理”相关的对象。

礼物 2007-09-06 12:29 发表评论

jBPM3.12用户指南中文翻译----第一章绪论

礼物 — Thu, 06 Sep 2007 04:19:00 GMT

这是Jboss 的jBPM3.12框架的用户指南的中文翻译。其中第一章的译文，是我在网上找到的。其他几章都是我自己做的翻译。我的翻译是中英文对照，只翻译部分我认为重要的，不翻译简单的英文，以免浪费你我的时间。
同时，对于其中的部分内容，我会在翻译中做出解释。
下面是从网络上找到的第一章，这是jBPM3.0的用户指南的译文。但是第一章，3.0和3.1内容相差不大，我就不做翻译了。直接使用这一篇。

第一章绪论

JBoss jBPM 是一个灵活的，易扩展的工作流管理系统。JBoss jBPM有一套直观的流程建模语言，这套语言能用任务（task），异步通信的等待状态（wait state ），定时器（timer），自动化的动作（automated action）等来图形化的表示业务流程。为了把这些操作集成在一

起，JBoss jBPM拥有强大的，易扩展的控制流程机制。

JBoss jBPM对外依赖程度很小，你完全可以像用java的类库一样用它。并且它也可以被部署在高性能的J2EE集群应用服务器上。

JBoss jBPM能配置在任何数据库上，并且能被部署在任何的应用服务器上。

1.1 总览

工作流和业务流程处理功能的核心部分被打包成一个简单的java类库。这个类库包括了这样一个服务：流程信息的存储，更新，和从数据库中重新取回。

图1.1：JBoss jBPM组成模块的概略图

1.2 JBoss jBPM starter kit

starter kit是一个包含jbpm所有模块的下载包。这个下载包中包括以下模块：

· jbpm-server, 一个预选配置好的jboss应用服务器。

· jbpm-designer, 图形化定制流程的eclipse插件。

· jbpm-db, jBPM的数据库兼容包 (见后边论述)。

· jbpm, jbpm的核心模块，其中包括libs文件夹和这个用户说明。

· jbpm-bpel, JBoss jBPM对BPEL扩展的一些参考资料

预先配置好的JBoss应用服务器具有如下组成部分：

jBPM核心模块，被打包成一个用于提供服务的存档文件

带有jbpm表的集成数据库：默认的hypersonic数据库拥有jbpm表，并且这个表已经拥有一个流程了。

Jbpm的web控制台，它既可以被Jbpm管理员用也可以被流程的参与者使用。

执行定时器的Jbpm的调度程序，这个调度程序在starter kit里边被配置成一个servlet。这个servlet会产生一个新的线程来监视和执行定时器。

一个具体流程的例子，它已经被部署在jbpm数据库中了。

1.3 JBoss jBPM 流程图形定制器

JBoss jBPM还拥有一套图形化的设计工具。这个设计器是一个图形化的业务流程定制工具。

JBoss jBPM流程图形定制器是eclipse的一个插件。单独安装这个定制器非常简单。

这个图形设计器最重要的特性是：业务分析人员也能像技术开发人员一样用它来完成任务。这使得业务流程建模能平滑的转换到具体技术实现。

这个插件可以利用eclipse的一般升级机制通过一个升级站点得到安装（zip文件格式）。也可以通过解压一个特定的包到eclipse的安装目录来安装此插件。

1.4 JBoss jBPM的核心模块

JBoss jBPM的核心模块是一个用来管理流程定义和流程实例的执行环境的普通java程序。

JBoss jBPM是一个java类库。所以它可以被用在任何java环境中，比如：web应用程序，swing应用程序，EJB，web service……。JBPM类库还可以被打包并被当成无状态会话EJB（stateless session EJB）使用。这样可使它被部署在集群上并且适应高性能应用。这些无状态会话EJB必须符合J2EE1.3规范这样才能使它可以被部署在任何应用服务器上。

JBoss jBPM的核心模块被打包成一个简单的java库文件。依你功能的需要，jbpm-3.0.jar这个库文件对一些第三方的类库比如hibernate, dom4j有所依赖。这些依赖在第五章（部署）中作了详细的说明。

至于持久化，JBPM在内部用了hibernate。除了传统的O/R映射功能，hibernate还解决了不同数据SQL dialect差异的问题，这使得JBPM能适应现在所有的数据库。

JBoss jBPM API可以被你工程中任何的java代码调用，比如，你的web应用程序，EJB，web service 模块，消息驱动bean或其它任何java模块。

1.5 JBoss jBPM web应用程序的控制台

jBPM web应用程序的控制台提供两种服务。首先，它被用来当作一个用来和流程执行过程中产生的任务进行交互的主要用户接口，其次，它还是一个用来检查和操作运行实例的管理和监控平台。

1.6 JBoss jBPM人员组织模块

JBoss jBPM可以和任何包括人员和其他组织信息的公司结构集成在一起。但是对那些组织结构信息模块很难获取的项目，JBoss jBPM提供了这个模块。这个模块使用的模型要比传统的servlet, ejb,portlet模型丰富的多。

更多信息，请参照第九章第九节人员组织模块

1.7 JBoss jBPM调度程序

JBoss jBPM调度程序是一个用来监测和执行在流程执行过程中设置的定时器的模块。

定时器模块被打包在jbpm的核心包中，但是它必须被部署在以下环境中：或者你必须订制一个调度servlet，它来产生一个监测线程，或者你必须启动一个单独的JVM来执行调度程序。

1.8 JBoss jBPM 数据库兼容包

JBoss jBPM 数据库兼容包是一个下载包，它包括所有的资料，drivers和scripts,用这些你可以使jbpm运行在你选择的数据库上。

1.9 JBoss jBPM BPE的扩展

JBoss jBPM BPE的扩展是一个为了支持BPEL独立的扩展包。BPEL的本质就是一组用来参照别的web service写web service的xml脚本语言。

礼物 2007-09-06 12:19 发表评论

BlogJava-LuckyStar 家园-文章分类-Jbpm

如何在Web应用中启动后台任务

jbpm oracle 数据库脚本

JBPM数据库表说明

一个JBPM工作流管理示例

JBPM的一些资料

JBPM部署在tomcat中

jBPM3.1 +Oracle10g+Tomcat-5.0.30安装实践

表的中文意思

对Jbpm数据库应用的简单分析和在Mysql上实现的demo

spring+hibernate+jbpm整合成功

jbpm例子

jbpm用户指南翻译：第6章 配置

jBPM3.12用户指南中文翻译----第五章 部署

Chapter 5. Deployment部署

5.1. Java runtime environment

5.2. jBPM libraries

5.3. Third party libraries第三方库

jBPM3.12用户指南中文翻译----第四章 面向图表编程

jBPM3.12用户指南中文翻译----第二章 起步

jBPM3.12用户指南中文翻译----第三章 指南

jBPM3.12用户指南中文翻译----第一章 绪论

jbpm用户指南翻译：第6章　配置

jBPM3.12用户指南中文翻译----第五章部署

jBPM3.12用户指南中文翻译----第四章面向图表编程

jBPM3.12用户指南中文翻译----第二章起步

jBPM3.12用户指南中文翻译----第三章指南

jBPM3.12用户指南中文翻译----第一章绪论