我们常常在Web应用中需要启动一个自己写的服务，本文的目的是l你提供一个解x案?br />
原理
本方案的原理是写一个实CServletContextListener接口的类Q该cM有两个方法：public void contextInitialized(ServletContextEvent sce)Q它是在应用启动时调用；另一个方法是Qpublic void contextDestroyed(ServletContextEvent sce)Q该Ҏ是在应用l束时调用。把我们要启动的后台应用逻辑攑֜contextInitializedҎ中实玎ͼ把释攑台应用占用资源的工作攑֜contextDestroyed来处理。但我们启动的后CQ务常常是有要求的Q比如时_频率{，我在q里使用了一个开源组Ӟquartz?br />
步骤
1.写业务调用类Q?/strong>
// DumbJob.java
import org.quartz.*;
import java.util.*;
public class DumbJob implements Job {
public DumbJob() {
}
public void execute(JobExecutionContext context)
throws JobExecutionException
{
//在这里写业务处理代码。什么，你不知道Q那你别问我Q！:-<
}
}
本类的主要功能是由quartz中调度类按照指定的规则进行调用执行必要的业务逻辑?br />
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(); //获取调度理?br /> JobDetail jobDetail = new JobDetail("myJob",
sched.DEFAULT_GROUP,
DumbJob.class);//创徏工作
CronTrigger trigger = new CronTrigger("myTrigger","test","0/10 * * * * ?");//创徏触发?br /> sched.scheduleJob(jobDetail, trigger); //d到调度管理器?br /> sched.start();//启动调度理?br /> }
public static void stop()throws Exception{
sched.shutdown();
}
}
本类的目的是讄调用规则Q在q里我用?#8220;0/10 * * * * ?”表示?0U钟执行一ơ，有关表达式的说明请参阅quartz的api文档?br />
3.~写服务启动c：
//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()启动后台dQ在contextDestroyed中调用TestShedule.stop()停止后台d?br />
4.部v服务启动c?/strong>
在web.xml文g中增加如下一行配|：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app id="WebApp">
<display-name>root</display-name>
<!--下边的listener部分是配置信息-->
<listener>
<listener-class>ServiceLoader </listener-class>
</listener>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
</web-app>
5.启动web服务卛_?/strong>
ȝ
其实实现q个功能的方法很多，我在q里是应用了ServletContextListener接口和开源api quartzQ希望能对你的开发有所帮助?br />
]]>
]]>
环境Q?/span>
jdk1.5.0_05
jakarta-tomcat-5.5.9
apache-ant-1.6.5(1.6.0会报?/span>)
mysql-5.0.16-win32
jbpm-3.0.2
一?/span>JBPM_HOME即ؓ解开?/span>jbpm-3.0.2.zip文g
%JBPM_HOME%"lib下，?/span>mysql目录Q将mysql?/span>jdbc驱动拷入Q?/span>
?/span>mysql中徏数据?/span> CREATE DATABASE jbpm;
二、ؓant创徏jbpm相关数据库修改相关配|文?/span>
1?/span>%JBPM_HOME%"src"resources目录下，?/span>“hsqldb”目录改名?/span>“mysql”Qƈ修改create.db.hibernate.properties文gQŞ如：
# 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、修?/span>%JBPM_HOME%"build.deploy.xml文g?/span>“target”?/span>“create.db” 的內容，删除“db.start”Q?/span>“db.stop”Q将所有的“hsqldb”替换?/span>“mysql”
形如Q?/span>
<target name="create.db" depends="declare.jbpm.tasks, db.clean" description="creates a hypersonic database with the jbpm tables and loads the processes in
there">
<jbpmschema actions="create" properties="${basedir}/src/resources/mysql/create.db.hibernate.properties"/>
<loadidentities file="${basedir}/src/resources/mysql/identity.db.xml" properties="${basedir}/src/resources/mysql/create.db.hibernate.properties"/>
<ant antfile="build.xml" target="build.processes" inheritall="false" />
<deploypar properties="${basedir}/src/resources/mysql/create.db.hibernate.properties">
<fileset dir="build" includes="*.par" />
</deploypar>
<!--antcall target="db.stop" /-->
</target>
三、ؓant创徏jbpm.war包修改相关配|文?/span>
1、修?/span>%JBPM_HOME%"src"config.files"hibernate.cfg.xml文g中数据库q接配置部分QŞ如：
……
<!-- jdbc connection properties -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/jbpm</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">rootrootrootroot</property>
<!-- c3p0 connection pooling properties -->
<property name="hibernate.c3p0.min_size">1</property>
<property name="hibernate.c3p0.max_size">3</property>
<!-- other hibernate properties -->
<property name="hibernate.show_sql">true</property>
……
2、修?/span>%JBPM_HOME%"src"resources"jbpm.sar"jbpm.propertiesQŞ如：
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、修?/span>%JBPM_HOME%"src"resources"jbpm.sar"jbpm.hibernate.propertiesQ只?/span>hibernate.cfg.xml来配|?/span>hibernateQ因此全部注释掉QŞ如：
# hibernate.dialect=org.hibernate.dialect.HSQLDialect
# hibernate.connection.datasource=java:/DefaultDS
# hibernate.show_sql=true
4、修?/span>%JBPM_HOME%"build.deploy.xml文gQ?/span>“target”?/span>“build.webapp”的內容，原文件相关的jar包未包含全，因此补全QŞ如：
<target name="build.webapp" description="builds jbpm.war">
<ant antfile="build.xml" target="build" /><!-- 原文件是target="build.webapp" -->
<mkdir dir="build/jbpm.war.dir" />
<copy todir="build/jbpm.war.dir">
<fileset dir="src/resources/jbpm.war" />
</copy>
<copy todir="build/jbpm.war.dir/WEB-INF/lib">
<fileset dir="build" includes="jbpm*.jar,converter.jar" excludes="*src*.jar" />
<fileset dir="lib/jsf" includes="*.jar" />
<fileset dir="lib/dom4j" includes="*.jar" />
<!--fileset dir="lib/jaxen" includes="*.jar" / included in lib/hibernate -->
<fileset dir="lib/hibernate" includes="*.jar" />
<fileset dir="lib/mysql" includes="*.jar" />
<fileset dir="lib/commons" includes="commons-digester-*.jar, commons-beanutils-*.jar" />
<fileset dir="lib/jboss" includes="*.jar" excludes="jboss*.jar,*servlet*.jar,*hsql*.jar,dom4j*.jar" />
</copy>
<jar destfile="build/jbpm.war">
<fileset dir="build/jbpm.war.dir" />
</jar>
</target>
四、执?/span>Ant
1、创建ƈ初始?/span>jbpm例子所需?/span>table
ant create.db -buildfile build.deploy.xml
2、生?/span>jbpm.war
ant build.webapp -buildfile build.deploy.xml
五?/span>tomcat拥抱jbpm
?/span>%JBPM_HOME%"build"jbpm.war文g复制?/span>Tomcat?/span>webapp目录下，启动Tomcat自动部vjbpmQ访?/span>http://localhost:8080/jbpmQ出现登录页面，配置成功?/span>
]]>
]]>
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.Driver</value> </property> <property name="url">
<value>jdbc:mysql://localhost:3306/test</value> </property> <property name="username"> <value>root</value>
</property> <property name="password"> <value/>
</property> </bean> <!-- Hibernate SessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="dataSource"> <ref local="dataSource"/> </property> <property name="mappingLocations"> <value>classpath*:/org/jbpm/**/*.hbm.xml</value> </property> <property name="hibernateProperties"> <props> <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop> <prop key="hibernate.hbm2ddl.auto">update</prop> <prop key="hibernate.jdbc.batch_size">0</prop>
</props> </property> </bean> <!-- Transaction manager for a single Hibernate SessionFactory (alternative to JTA) --> <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory"> <ref local="sessionFactory"/> </property> </bean> <!-- reading jBPM process definitions --> <bean id="websaleWorkflow1" class="org.springmodules.workflow.jbpm31.definition.ProcessDefinitionFactoryBean"> <property name="definitionLocation" value="processdefinition.xml"/> </bean> <!-- jBPM configuration--> <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> <!-- jBPM template --> <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.xml</value>
</property>
很关键，我就是想spring会通过jbpm扑ֈhibernate.cfg.xml而没有设|，才失败的?
]]>
]]>
]]>
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是一个嵌入式的BPMQ业务程序管理）引擎。本章讨论jbpm库和它的依赖库?/p>
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的核心功能库?/p>
jbpm-identity-[version].jar is the (optional) library containing an identity component as described in Section 11.11, “The identity component”.
可选的Q这个库包含了n份验证组件。用于流E的参与者的理?/p>
5.3. Third party librariesW三方库
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部vQ只需要核心jbpm库和commons-logging库，以及dom4j库到你的classpath中。此Ӟ不支持持久化业务E序到数据库?/p>
Table 5.1.
|
Library?/span> |
Usage用?/span> |
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部v包括持久化业务程序定义和执行的功能?需要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.
下面的表l出了简单的标准POJO部v环境需要的W三方库?/p>
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?/span> |
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.二~存实现?/span> 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库是可选的?/p>
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 |
v
]]>
]]>
Chapter 2. Getting startedh
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核心和其他包?/span>
- The Starters Kit (jbpm-starters-kit-<version>.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.
包含了包括图形化设计器在内的所有模块，能够帮助你快速启动?/span>
- Core Engine and Identity Component (jbpm-<version>.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-<version>' folder.
核心Q包括核心引擎和w䆾l徏Q内有用h南文档?/span>
- Database Extensions (jbpm-db-<version>.zip):数据库扩?/span> 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-<version>' folder.
2.1.2. jBPM Process Designer
jBPMq程设计?/span>
Download JBoss jBPM Process Designer at sourceforge.net. The designer is an eclipse plugin and enables you to author 创作your process definitionsq程定义 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-<version>.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.
使用本地站点更新方式部v?/span>
- Eclipse Feature (jbpm-gpd-feature-<version>.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.
q个是手工部|Ӏ?/span>
2.1.3. jBPM BPEL extension
Download JBoss jBPM BPEL extension at sourceforge.net. It contains only one file : jbpm-bpel-<version>.zip. To get started with the BPEL extensions, look in the User's Guide in the 'doc' subfolder of the toplevel folder.
jbpm-bpelQ含?/span>JBoss jBPM?/span>BPEL扩展件方面的信息?/span>
BPEL是一个规范的SOAlg。因ZJBoss jBPM使用的许可证不同Q所以被独立了出来?/span>
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 论坛Q社区?/span>
- 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
]]>
Chapter 3. Tutorial指南
This tutorial will show you basic process constructs q程建造in jpdl and the usage of the API for managing the runtime executions.
q本指南告诉你使用jpdl语言构徏基本的工作流E，以及理q行时执行的API的用法?br />
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.
q篇指南解释一pd的例子。例子聚焦于一个特D的主题和包含很多的注释?br />
The best way to learn is to create a project and experiment by creating variations on the examples given.
最好的学习方式是在例子的基上创Z个略Z同的目?br />
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"
用Junitq行自带的例子?br />
jBPM includes a graphical designer tool for authoring 创作the XML that is shown in the examples. You can find download instructions指o 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
你不需要图形设计器p完成q篇指南。图形设计器仅仅帮助你制作xml程定义文g?br />
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:
一个过E定义是一个直接的图表Q由“节点”?#8220;转向”l成。Hello worldq个例子的过E定义有3个节炏V?br />
下面的图像显CZhello worldq程定义的图形化表示?br />
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'.
//q个Ҏ昄了一个过E定义和q个q程定义的执行?br />
// 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.
/*
* 下一行把一Dxml文本解析qProcessDefinition对象。ProcessDefinition?br />
* q程作ؓ一个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.
/**
*下一行用代表过E定义的Model对象--ProcessDefinition实例Q创Z个业务处理定义的执行
*构造之后，在开始状?节点Q业务处理执行对象有一个主要的执行路径
*
*/
ProcessInstance processInstance =
new ProcessInstance(processDefinition);
// After construction, the process execution has one main path
// of execution (=the root token).
/*记号Q得C要的执行路径?br />
* Token记号c，代表一条过E的执行路径和在q程定义中维护一个指向节点的指针
*
* */
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();用来执行一步状态，利用“转向”跛_下一步状态?br />
*
* */
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的{向?br />
* */
token.signal();
// Now the signal method returned because the process instance
// has arrived in the end-state.
assertSame(processDefinition.getNode("end"), token.getNode());
}
参考：
1Q记LQ代表一个工作处理定义的一条工作流E?br />
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).
q个cM表了一个过E的执行程。?br />
public void signal()
provides a signal to the token. this method activates this token and leaves the current state over the default transition.
Ҏ执行一步?br />
2Q工作处理实?c?br />
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).
q个cL据作为Model数据容器cȝProcessDefinition工作处理定义cȝ一个实例创建。代表一个工作处理定义的执行。主要关注于工作处理相关的操作?br />
getRootToken
public TokengetRootToken()
得到工作处理定义的从start状态开始的一条记?---工作程?br />
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.
在工作处理定义的树中Q根据记可\?工作程路径得到一条工作流E?br />
?br />
3.2. Database example
数据库例?br />
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的一个基本的Ҏ是Q它能够在业务处理处于等待状态时Q把业务处理的执行结果储存到数据库中。下一个例子讲告诉你怎样把一个业务处理的实例保存qjBPM数据库。例子也展示了可能发生这U情늚场景。如Q用L业务处理代码由几个独立的Ҏl成Q例如，一部分用户代码是，在一个Web应用E序中开始一个处理，q且把这个处理保存进数据库。然后，一个消息驱动的bean从数据库中引D个业务处理实?---也就是业务处理定义的一个执行的实例Q注?ProcessDefinition业务处理定义是一个ModelQ保存xml格式的业务处理图表，一UDSL特定领域语言Q而ProcessInstance业务处理实例Q也是一个ModelQ它是保存业务处理定义的一ơ执行的信息。具体的操作׃它得到的Token记号cL行。TokencLActionc，真正执行业务处理的流E。Tokencd该叫?#8220;工作程c?#8221;Q代表了业务处理的一条工作流E）Q恢复它的执行?br />
q样QjBPM的业务处理具有分Dc异步执行的能力?br />
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配置。基本上Q一个jBPM的业务处理可以用一个JbpmConfiguration对象的实例?br />
During process execution, jBPM might need to use some services. A JbpmConfiguration contains the knowledge on how to create those services.
在业务处理的执行q程中，jBPM可能需要用一些服务。一个Jbpm配置cd含了怎样创徏q些服务的知识?br />
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能够被用来ؓ所有的U程创徏JbpmContext。JbpmConfiguration.createJbpmContext()Q方法创建Jbpm上下文环境类的一个实例?br />
JbpmConfiguration应该使用单例Q如静态成员，或者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容器中?br />
· 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
2QJbpm上下文环?br />
public class JbpmContext
extends java.lang.Object
implements java.io.Serializable
is used to surround persistent operations to processes.
被用来负责业务处理的持久化操作。它底层使用Hibernate{数据库持久化技术来与数据库中的保存业务处理图表、业务处理的执行{的数据库表交互?br />
Obtain JbpmContext's via JbpmConfiguration.createJbpmContext() and put it in a try-finally block like this:
作ؓ一个数据库持久化资源，必须要关闭?br />
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也包括在一个特定环境中使用q些服务的实现类?br />
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中来的，那么默认的持久化实现是HibernateQ那么将会创Z个Hibernate会话和事务?br />
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();
所有这些涉及到数据库更新的操作Q都会在jbpmContext.close()调用时被自动保存到数据库中?br />
3QGraphSessionc?业务处理图表会话c，更确切的名字Q业务处理定?会话c?br />
/*
* 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.
/**
*单例对象?br />
*JbpmConfiguration能够被系l中所有线E所使用?br />
*jbpm.cfg.xmlq个命名方式和Hibernate配置文g的命名方式一致?br />
*
*/
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使用的服务分开?br />
* 持久化服务是jbpm核心引擎使用的一个服务?br />
*
* */
"
"
"
// Also all the resource files that are used by jbpm are
// referenced from the jbpm.cfg.xml
/*
*stringQ配|了所有jbpm使用的资源文件的路径?br />
* */
"
"
"
"
"
"
"
"
);
}
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.
/**
* q个Ҏ把业务处理定义通过Hibernate保存到数据库中?br />
*/
deployProcessDefinition();
// Suppose we want to start a process instance (=process execution)
// when a user submits a form in a web application...
/*假设当一个用h交一个表单时Q我们要开始一个业务处理的实例/执行?br />
* q可以在Action中执行处理?br />
*/
processInstanceIsCreatedWhenUserSubmitsWebappForm();
// Then, later, upon the arrival of an asynchronous message the
// execution must continue.
/*
* 然后Q直到异步消息来刎ͼ才l执行业务处理实例的余下的工作流E?br />
* */
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'.
/*
* q个Ҏ把业务处理定义通过Hibernate保存到数据库中?br />
*
* */
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持久化上下文?br />
* q包括刷新SQL来真正的把业务处理定义插入到数据库中?br />
* */
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 {
/*
* 图表会话Q是图表定义/业务处理定义 相关的数据库层面的会话。应该也是一个Hibernate会话?br />
* 可以从JBpm上下文这个数据库----业务处理定义、实例等 得到 业务处理定义会话?br />
*
* */
GraphSession graphSession = jbpmContext.getGraphSession();
//从数据库中根据业务处理定义的名字得到一个业务处理定义?br />
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).
/*
* 创徏业务处理定义的一个实例?br />
*
* */
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.
/*
* 执行一步工作流E后Q用jbpmContext保存q个业务处理实例q数据库?br />
* 所以现在就把业务处理实例的执行状态也保存q了数据库?br />
* 因ؓQ业务处理定义的实例 q个cM是一个Modelc，用于理一个业务处理定义的执行的所有信息，
* 是一个多例模式的Model?br />
*
* */
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.
//q个Ҏ可能在消息驱动Beanq个q程业务代理cM?br />
// 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得到数据库中所有的业务处理实例。这表明Q数据库中应该存?张表
* 它们?一对多 的关pR?br />
*
* */
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.
ContextInstancecȝ实例保存 在ProcessInstance中。是它的一个成员对象。是一个MapQ保存名值对。它们会被保存在数据库中?应该是一个独立的表。和业务处理定义的实?执行??#8220;一对多”的关p！
可以在这里保存一些必要的信息Q用于工作流E处理的交流的需要！
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.
//得到一个mapQ业务处理实例的上下文实例Map。包含业务处理实例的一些上下文信息?br />
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 exampled委派例子
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.
在下一个例子中Q我们将高叔你怎样l一个用户分配Q务。因为jBPM工作引擎和l织的模型时各自独立的，用一U表辑ּ语言来计动作执行者L太受限了。因此，你必L定一个分z֤理器的实现来包括d执行者的计算工作?br />
API参考：
1QQ务实?br />
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.
是一个Q务实例，它能够被分配l一个用P能够触发工作的l箋执行?br />
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.
/*
* d节点是一个JPDL的节点，它表CZ个等待状态，生成d被完成之前，业务处理不能执行?br />
*
* */
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.
/*
* 执行CQ务时Q需要执行指定的cR这个类讄了执行者的id?br />
* 在真实环境中Q应该是从数据库中返回Q务，
* org.jbpm.db.TaskMgmtSession
* TaskInstance包含Qid,d名，用户id?br />
* 业务处理实例---d
* 1 n
*
* 用户-------====d
* 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(
"
"
"
"
"
//转向执行Ӟ执行该动?br />
"
"
"
"
"
"
);
// 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-nodeq入节点事g and leave-node events d节点事grespectively. 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转向只有一个节炏V?br />
publicvoid testNodeActions() {
ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(
"
"
"
"
"
//节点q入事gQ进入节ҎQ事件激zR执行该动作?br />
"
"
"
//节点d事gQ离开节点Ӟ事gȀzR执行该动作?br />
"
"
"
"
"
"
"
);
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);
}
}
动作c?br />
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参考：
1Q?br />
ExecutionContext 执行上下文类?br />
作ؓ参数回调模式的参敎ͼ用于得到业务处理实例的东ѝ?br />
JbpmContext
getJbpmContext()
Node
getNode()
ProcessDefinition
getProcessDefinition()
ProcessInstance
getProcessInstance()
可以通过它得到所?#8220;业务处理”相关的对象?br />
]]>
目录
W一?/span>l论
JBoss jBPM 是一个灵zȝQ易扩展的工作流理pȝ?/span>JBoss jBPM有一套直观的程建模语言Q这套语a能用dQ?/span>taskQ，异步通信的等待状态（wait state Q，定时器（timerQ，自动化的动作Q?/span>automated actionQ等来图形化的表CZ务流E。ؓ了把q些操作集成在一
PJBoss jBPM拥有强大的，易扩展的控制程机制?/span>
JBoss jBPM对外依赖E度很小Q你完全可以像用java的类库一L它。ƈ且它也可以被部v在高性能?/span>J2EE集群应用服务器上?/span>
JBoss jBPM能配|在M数据库上Qƈ且能被部|在M的应用服务器上?/span>
1.1 总览
工作和业务程处理功能的核心部分被打包成一个简单的javacd。这个类库包括了q样一个服务：程信息的存储，更新Q和从数据库中重新取回?/span>
?/span>1.1Q?/span>JBoss jBPMl成模块的概略图
1.2 JBoss jBPM starter kit
starter kit是一个包?/span>jbpm所有模块的下蝲包。这个下载包中包括以下模块：
· jbpm-server, 一个预选配|好的jboss应用服务器?/span>
· jbpm-designer, 囑Ş化定制流E的eclipse插g?/span>
· jbpm-db, jBPM的数据库兼容?(见后边论q??/span>
· jbpm, jbpm的核心模块，其中包括libs文g夹和q个用户说明?/span>
· jbpm-bpel, JBoss jBPM对BPEL扩展的一些参考资?/span>
预先配置好的JBoss应用服务器具有如下组成部分：
jBPM核心模块
Q被打包成一个用于提供服务的存档文g带有jbpm表的集成数据?/span>Q默认的hypersonic数据库拥?/span>jbpm表，q且q个表已l拥有一个流E了?/span>
Jbpm?/span>web控制?/span>Q它既可以被Jbpm理员用也可以被程的参与者用?/span>
执行定时器的Jbpm的调度程序，q个调度E序?/span>starter kit里边被配|成一?/span>servlet。这?/span>servlet会生一个新的线E来监视和执行定时器?/span>
一个具体流E的例子Q它已经被部|在jbpm数据库中了?/span>
1.3 JBoss jBPM 程囑Ş定制?/span>
JBoss jBPMq拥有一套图形化的设计工兗这个设计器是一个图形化的业务流E定制工兗?/span>
JBoss jBPM程囑Ş定制器是eclipse的一个插件。单独安装这个定制器非常单?/span>
q个囑Ş设计器最重要的特性是Q业务分析h员也能像技术开发h员一L它来完成d。这使得业务程建模能^滑的转换到具体技术实现?/span>
q个插g可以利用eclipse的一般升U机刉过一个升U站点得到安装（zip文g格式Q。也可以通过解压一个特定的包到eclipse的安装目录来安装此插件?/span>
1.4 JBoss jBPM的核心模?/span>
JBoss jBPM的核心模块是一个用来管理流E定义和程实例的执行环境的普?/span>javaE序?/span>
JBoss jBPM是一?/span>javacd。所以它可以被用在Q?/span>java环境中，比如Q?/span>web应用E序Q?/span>swing应用E序Q?/span>EJBQ?/span>web service……?/span>JBPMcdq可以被打包q被当成无状态会?/span>EJBQ?/span>stateless session EJBQ用。这样可使它被部|在集群上ƈ且适应高性能应用。这些无状态会?/span>EJB必须W合J2EE1.3规范q样才能使它可以被部|在M应用服务器上?/span>
JBoss jBPM的核心模块被打包成一个简单的java库文件。依你功能的需要，jbpm-3.0.jarq个库文件对一些第三方的类库比?/span>hibernate, dom4j有所依赖。这些依赖在W五章（部vQ中作了详细的说明?/span>
至于持久化，JBPM在内部用?/span>hibernate。除了传l的O/R映射功能Q?/span>hibernateq解决了不同数据SQL dialect差异的问题，q?/span>JBPM能适应现在所有的数据库?/span>
JBoss jBPM API可以被你工程中Q何的java代码调用Q比如，你的web应用E序Q?/span>EJBQ?/span>web service 模块Q消息驱?/span>bean或其它Q?/span>java模块?/span>
1.5 JBoss jBPM web应用E序的控制台
jBPM web应用E序的控制台提供两种服务。首先，它被用来当作一个用来和程执行q程中生的dq行交互的主要用h口，其次Q它q是一个用来检查和操作q行实例的管理和监控q_?/span>
1.6 JBoss jBPM人员l织模块
JBoss jBPM可以和Q何包括h员和其他l织信息的公司结构集成在一赗但是对那些l织l构信息模块很难获取的项目，JBoss jBPM提供了这个模块。这个模块用的模型要比传统?/span>servlet, ejb,portlet模型丰富的多?/span>
更多信息Q请参照W九章第九节人员l织模块
1.7 JBoss jBPM调度E序
JBoss jBPM调度E序是一个用来监和执行在流E执行过E中讄的定时器的模块?/span>
定时器模块被打包?/span>jbpm的核心包中，但是它必被部v在以下环境中Q或者你必须订制一个调?/span>servletQ它来生一个监线E，或者你必须启动一个单独的JVM来执行调度程序?/span>
1.8 JBoss jBPM 数据库兼容包
JBoss jBPM 数据库兼容包是一个下载包Q它包括所有的资料Q?/span>drivers?/span>scripts,用这些你可以?/span>jbpmq行在你选择的数据库上?/span>
1.9 JBoss jBPM BPE的扩?/span>
JBoss jBPM BPE的扩展是一个ؓ了支?/span>BPEL独立的扩展包?/span>BPEL的本质就是一l用来参照别?/span>web service?/span>web service?/span>xml脚本语言?/span>
]]>