BlogJava-网路冷眼@BlogJava-随笔分类-BPM

Activiti User Guide（Activiti用户指南)-Chapter 18. JBPM Migration（JBPM 迁移）（2）

网路冷眼@BlogJava — Tue, 08 Mar 2011 13:40:00 GMT

Extend the migration logic

扩展迁移逻辑

The migration logic is written in such a way, that it is easy to extend to suit your needs. The source code is available as a Maven 2 project in the srcsubfolder of the downloaded zip file. To build a new zip file, after having changed or extended the logic, simply execute a

迁移逻辑可以编写，以便轻松地满足你的需求。源代码在所下载zip文件里src子文件夹里作一个Maven 2项目来使用。为了构建一个新的zip文件，在已经改变或者扩展逻辑之后，简单执行下面指令

mvn clean install

to produce a new zip file in the target folder.

在target文件下产生一个新的zip文件。

Following picture gives a high-level overview of the classes in the migration logic.

下图提供了在迁移逻辑里类的高层次概貌。

Both the ProcessConversion and ProcessDataMigration classes have a main method that directly is called from the ant build script in the root of the migration zip.
ProcessConversion and ProcessDataMigration 这两个类都有在迁移zip的根目录下的ant构建脚本里调用的main方法。
These classes construct a ServiceFactory based on the two properties files, using a static factory method
通过使用静态的工厂方法，基于两个properties文件这些类构建一个ServiceFactory

ServiceFactory.configureFromProperties(jbpmDbProperties, activitiDbProperties);

The services are constructed by the ServiceFactory (eg. getProcessConversionService()) and are used to execute the migration logic:
通过ServiceFactory (eg. getProcessConversionService())构建这些服务，这些服务被用来执行迁移逻辑：

 1 public void execute() throws IOException {

 2     

 3   // convert processes

 4   ServiceFactory serviceFactory = createServiceFactory();

 5   ProcessConversionService processConversionService = serviceFactory.getProcessConversionService();

 6   Map<String, Document> migratedProcesses = processConversionService.convertAllProcessDefinitions();

 7   

 8   // write results to bpmn20.xml files

 9   writeConvertedProcesses(migratedProcesses, workingDir);

10     

11   // Deploy processes to Activiti

12   ActivitiService activitiService = serviceFactory.getActivitiService();

13   activitiService.deployConvertedProcesses(migratedProcesses);

14     

15   // data migration

16   

17 }

The ProcessConversionService is an interface that contains process conversion and process definition data retrievel operations. It uses an implementation of Jbpm3Dao. The default implementation of this class uses a Hibernate SessionFactory to retrieve all the data from jBPM 3 tables.

The ActivitiService offers operation needed to get the migrated data in the Activiti tables. For example, deploying the converted process definitions is such an operation

ProcessConversionService 是一个包含流程转换和数据检索的流程定义借口。它使用了 Jbpm3Dao.的实现。这个类的缺省实现使用了Hibernate的SessionFactory从jBPM 3的数据库表里检索所有的数据。

ActivitiService 提供需要从Activiti数据库表迁移数据的操作。例如，部署转换之后的流程定义就是如此的操作。

All these dependencies, ProcessConversionService, Jbpm3Dao, Sessionfactory, ActivitiService and ProcessEngine, are interfaces and can be implemented by your own implementation. You can inject them into the ServiceFactory using regular JavaBean setters. When no such custom implementation is set, the ServiceFactory will fall back to creating the default implementation:
所有这些依赖， ProcessConversionService, Jbpm3Dao, Sessionfactory, ActivitiService 和 ProcessEngine都是接口，并能由你自己实现。采用正常的JavaBean设置器，能将它们注入到ServiceFactory。当没有设置这些实现，ServiceFactory将后退一步，建立缺省的实现：

    1 public ProcessConversionService getProcessConversionService() {
 2   if (processConversionService == null) {

 3     this.processConversionService = createDefaultProcessConversionService();

 4   } 

 5   return processConversionService;

 6 }

 7 

 8 protected ProcessConversionService createDefaultProcessConversionService() {

 9   ProcessConversionServiceImpl service = new ProcessConversionServiceImpl(getJbpm3Dao());

10   return service;

11 }

网路冷眼@BlogJava 2011-03-08 21:40 发表评论

Activiti User Guide（Activiti用户指南)-Chapter 18. JBPM Migration（JBPM 迁移）（1）

网路冷眼@BlogJava — Mon, 07 Mar 2011 15:23:00 GMT

Chapter 18. JBPM Migration（JBPM 迁移）

Table of Contents

目录表

Database migration

数据迁移

Process conversion

流程转换

Extend the migration logic

扩展迁移逻辑

The jBPM migration is considered [EXPERIMENTAL].

jBPM迁移仅作[EXPERIMENTAL]之用。

It is possible to migrate an existing installation of jBPM version 3 to Activiti. The migration includes both process definition conversion (ie. from JPDL 3 to BPMN 2.0) and data migration.

将一个已安装的jBPM 版本3迁移到Activiti是有可能的。迁移包括流程定义转换（例如从JPDL3到BPMN 2.0）和数据迁移。

The migration tool is currently offered as a 'preview' only! The migration coverage is at this point in time not sufficient to be usable on production process definitions and databases. Also note that the migration is a 'best effort', which means that you may need to extend the migration logic to cover all your use cases.

迁移工具目前只作为‘预览’之用！当前迁移不能覆盖到产品的流程定义和数据。也要注意迁移是‘最大的努力’，这意味着你可以需要‘扩展迁移逻辑’来控制你所有的用例。

The migration tool is separately availbale as a zip file from the activiti.org download site. Once you have unzipped this file, you will see following files and folders:

迁移工具从activiti.org下载站点以zip文件方式分开下载。一旦加压这个文件，文件和文件夹如下所示：

build.xml: This ant buildfile contains the targets to execute the process definition conversion and database migration.
build.xml: 这个ant构建文件包含了执行流程定义转换和数据库迁移的目标。
activiti.db.properties and jbpm3.db.properties: these properties files contain the database connection parameters for the jBPM 3 and Activiti database. These properties files must be changed when executing a database migration.
activiti.db.properties and jbpm3.db.properties:这个特性文件包含了jBPM和Activiti数据库的数据库连接参数。当执行数据库迁移时，必须改变这些特性文件。
processes: when running a process definition conversion, the jBPM 3 process definition files must be placed in this folder.
processes:当运行流程定义转换时，jBPM3流程定义文件必须放置到这个文件夹。
src: this folder contains the source code of the migration tool. Read the extension section if you want to tailor or extend the migration code to your needs.
src:这个文件包含迁移工具的源代码。如果希望裁剪或者扩展迁移代码满足你自己的需求，请阅读扩展部分。
lib: this folder contains all jars required to execute the migration logic.
lib:这个文件夹包含执行迁移逻辑的全部jar包。

Database migration

数据库迁移

It is possible to migrate the data in the jBPM 3 database tables to the Activiti database schema. To do this, following properties files must be changed to point at the right database:

将jBPM3数据库表迁移到Activiti数据库schema是有可能的。为了完成这个任务，必须改变下面的properties文件，指向正确的数据库：

jbpm3.db.properties: contains the parameters to connect to the jBPM 3 database. Also the Hibernate dialect must be provided.
jbpm3.db.properties:包含了连接jBPM3数据库的参数。也必须提供Hibernate方言。
activiti.db.properties: contains the parameters to connect to database to which the migrated data will be written. This can be the same database schema as the jBPM schema (ie. there are no name-clashes between jBPM and Activiti tables, indexes, foreign keyes, etc).
activiti.db.properties: 包含了迁移将要写入数据库的连接参数。这个可能是和jBPM相同数据库schema（例如，在jBPM和Activiti数据库表名，索引名，外键名等等没有冲突）.

The database migration will use the data in the jBPM 3 tables to:

数据迁移将使用jBPM3数据库表的数据来做：

Convert the process definition to the BPMN 2.0 counterpart. This means that the converted process definition will be deployed to the Activiti tables as part of the migration. As a side-effect, it will also produce the BPMN 2.0 XML files, similar to what happens when executing theprocess conversion.
转换流程定义为BPMN 2.0对应物。这意味着转换之后的流程定义将作为迁移的一部分被部署到Activiti的数据库表。作为副作用，它也产生BPMN 2.0 XML文件，这和当执行流程转换时所发生的事相似。
Migrate runtime and history data of the processes to the Activiti tables. In this release, this is not yet implemented!
迁移流程的运行时和历史数据到Activiti数据库表。本次发布，这没有实现！

The data is retrieved from the jBPM 3 tables using Hibernate queries and the Hibernate mappings of jBPM itself.

使用Hibernate查询和jBPM自身的Hibernate映

射，可以从jBPM 3数据库表里检索到这些数据。

Process conversion

流程转换

It is possible to only convert the process definitions xml from JPDL to BPMN 2.0 that can be executed on the Activiti engine. To do this, place the jBPM 3 processes inside the processes folder. There can be any number of (nested) subfolders, the tool will scan every (sub)folder inside processes to discover processdefinition.xml files (file name must be processdefinition.xml!).

只将JPDL的流程定义xml转换为能在Activiti引擎执行的BPMN 2.0是有可能的。为了完成这个任务，请将jBPM 3放置到process 文件夹。可以有任何数量（内置）子文件夹，工具将扫描process每个（子）文件夹，来发现processdefinition.xml文件（文件名必须是processfinition.xml!）。

The discovered processes will be parsed and deployed to an in-memory databse, such that the logic of reverse engineering the process definition from the jBPM deployment tables contained in the database migration is used for both cases.

被发现的流程将被解析并部署到一个内存数据库，以便对包含在数据库迁移的jBPM部署数据库表的流程定义进行反向工程，以为解析和部署之用。

Once the jBPM 3 processes are placed in the processes folder, execute the convert.processes target in the root of the unzipped migration tool folder:

一旦jBPM 3流程被放置到process文件夹，那么执行在解压之后的迁移工具文件夹根目录下的convert.processes目标。

ant convert.processes

During conversion, you will see plenty logging passing by describing where and how the process conversion is being executed. At the end of the conversion, you will see following logging appear:

在转换过程中，通过描述流程转换执行是何地和何时转换的方式，可以观察到大量的日志。在转换的末尾，将观察到下列日志出现：

As shown in the logging, the resulting BPMN 2.0 processes can be find in the converted-process-xxxx folder, where the xxxx is the timestamp of the conversion.

正如日志所示，BPMN 2.0流程的结果可以在converted-process-xxxx文件夹里找到，这里xxxx是转换的时间戳。

In this release, only limited support for start, end, wait state and task-nodes is implemented. In the future, this coverage will expand.

在本次发布里，只实现了对开始，结束，等待和任务节点的有限支持。在将来，这个覆盖范围将要扩充。

网路冷眼@BlogJava 2011-03-07 23:23 发表评论

Activiti User Guide（Activiti用户指南)-Chapter 17. Activiti KickStart

网路冷眼@BlogJava — Mon, 10 Jan 2011 12:58:00 GMT

Chapter 17. Activiti KickStart

Table of Contents

Overview（概述）

Changing the database（变更数据库）

Overview（概述）

Activiti KickStart is a webbased tool to quickly create 'adhoc' business processes using a subset of constructs available to the Activiti engine. KickStart provides a simple UI that doesn't require to learn BPMN or any modeling environment, as it works with concepts that are familiar to every business user. However, the processes that are created using KickStart, are fully BPMN 2.0 compliant and can be used as a starting point for more complex BPM endeavours.

Activiti KickStart的是一个基于Web的工具，用Activiti引擎可用的构件（constructs）的子集提供给快速创建“即席（adhoc）”的业务流程。Kickstart提供了不必学习BPMN或者任何建模环境的简单UI，因为它树立了每个业务用户都熟悉的概念。但是，通过KickStart创建的的流程，是和BPMN 2.0兼容，并可作为更为复杂BPM努力的起点。

KickStart integrates perfectly with the Activiti engine. As such, processes created with KickStart are immediataly usable in Activiti Explorer and are visible in Probe.

KickStart能和Activiti引擎完美集成。因此，采用KickStart创建的流程在Activiti Explorer立即可用，并在Probe里面可见。

KickStart serves many business cases, but the following three are probably the most common:

KickStart服务许多商业案例，但以下三个可能是最常见：

Simple business processes: some processes are just simple by nature, and every company has them. Think about an expense process, a holiday leave process, a hiring process, etc... These kind of processes are probably already being done using paper or e-mail. KickStart allows to model these processes quickly and change them whenever it is needed. As such, KickStart really lowers the threshold to automate these business processes.
简单的业务流程：一些流程天然简单，并且每个公司都有。考虑到付费流程，请假流程，雇佣流程，等等…这些流程用书面或者e-mail的方式已经完成。Kickstart运行快速对这些流程建模，每当需要时改变它们。因此，Kickstart真正地降低了门槛，并让这些业务流程自动化。
Prototyping: before diving into complex BPMN 2.0 modeling and thinking about the corner cases of the process, it is often wise to get all people involved aligned and work out a prototype that shows the vision of what needs to be done. KickStart allows to do exatcly that: create a business process prototype on the fly, to get your ideas visible for everyone.
原型：在钻研复杂的BPMN 2.0建模和考虑流程的偏例之前，它往往是明智的，让所有参与的人平等，制定一个原型来展示所要完成的愿景。KickStart的允许恰恰如此：创建一个业务流程的原型，让大家看到你的想法。
Adhoc work: in some cases, coordination is required between different people or groups in a company. You know how it normally goes: sending an email here, doing a telephone there ... which often ends up in a tar pit of nobody knowing what or when something needs to be done. However, a business process management platform such as Activiti is an excellent way of distributing and follow-up everything, as it is intended to track exactly such things. KickStart allows you to create processes for adhoc work in a matter of minutes, and distribute and coordinate tasks between people easily.
即席工作：在一些情况，在一个公司里，不同的人员或组之间的协作是必要的。您知道正常时如何运作的：在这里发送邮件，在那里打电话…这经常终止于没有人知道需要完成什么或者何时完成这样的焦油坑。但是，诸如Activiti这样的业务流程管理平台是解决分发和后续事情的卓越解决之道，因为它的目的是准确跟踪这些事情。Kickstart允许您在数分钟之内创建即席工作的流程，并在人们之间分发和协调任务。

Following screenshots show the capabilities of Activiti KickStart. Take for example the next picture. It shows how an expense process is created in a matter of a few minutes.

下列屏幕截图展示了Activiti KickStart的能力。下图作为示例。它展示如何在几分钟之内创建一个付费流程。

After clicking the save button, the process is immediately usable in Activiti Explorer:

在点击“保存”按钮之后，这个流程立即在Activiti Explorer可用。

KickStart also allows to define forms for every task:

KickStart也允许为每个任务定义表单：

Which are obviously directly usable in Activiti Explorer:

这些明显直接在Activiti Explorer可用：

At any time during process creation, it is possible to view the corresponding BPMN 2.0 diagram of the business process:

在流程建立的任意时间，它可以查看相应的BPMN2.0业务流程图。

Whenever it is required, the processes defined with KickStart can be opened up and modified:

每当它是必需，与KickStart的定义的流程可被打开和修改：

Processes created with KickStart are fully compliant with the BPMN 2.0 XML, which means that the process can be imported into any BPMN 2.0 editor:

用KickStart的创建的流程是完全符合BPMN2.0的XML，这意味着该流程可以由任何兼容的BPMN2.0编辑器输入：

Changing the database（变更数据库）

Activiti KickStart is currently not yet using the REST API, but uses the service API by including the Activiti engine as a library. While Explorer, Probe and Cycle use the same mechanism for changing the database (see here), the same does not yet apply for KickStart.

Activiti KickStart当前还没有使用REST API，而是通过包括了Activiti引擎作为类库使用服务API。虽然Explorer，Probe和Cycle使用相同的机制改变数据（参见这里），但这不适于KickStart。

To change the database that KickStart uses in the demo setup, generate a new activiti.cfg.jar, and place it in the apps/apache-tomcat-6.x/webapps/activiti-kickstart/WEB-INF/lib folder.

为了改变演示安装里KickStart使用的数据库，产生一个新的activiti.cfg.jar,并将它放置到apps/apache-tomcat-6.x/webapps/activiti-kickstart/WEB-INF/lib文件夹。

网路冷眼@BlogJava 2011-01-10 20:58 发表评论

Activiti in Action（实战Activiti）-第一章 BPMN 2.0: what’s in it for developers?（11）

网路冷眼@BlogJava — Sat, 08 Jan 2011 03:49:00 GMT

摘要: 随着符合BPMN 2.0标准的BPMS流程引擎Activiti 5.0正式版推出，由Tijs Rademakers 和 Ron Van Liempd编写的‘实战Activiti’书籍昨天在“Manning Early Access Program”现身。目前第一章释出，可以先睹为快。呵呵，真棒！本篇是第一章之（11）阅读全文

网路冷眼@BlogJava 2011-01-08 11:49 发表评论

Activiti in Action（实战Activiti）-第一章 BPMN 2.0: what’s in it for developers?（10）

网路冷眼@BlogJava — Thu, 06 Jan 2011 13:26:00 GMT

网路冷眼@BlogJava 2011-01-06 21:26 发表评论

Activiti in Action（实战Activiti）-第一章 BPMN 2.0: what’s in it for developers?（9）

网路冷眼@BlogJava — Wed, 05 Jan 2011 13:01:00 GMT

摘要: 随着符合BPMN 2.0标准的BPMS流程引擎Activiti 5.0正式版推出，由Tijs Rademakers 和 Ron Van Liempd编写的‘实战Activiti’书籍昨天在“Manning Early Access Program”现身。目前第一章释出，可以先睹为快。呵呵，真棒！本篇是第一章之（9）阅读全文

网路冷眼@BlogJava 2011-01-05 21:01 发表评论

Activiti in Action（实战Activiti）-第一章 BPMN 2.0: what’s in it for developers?（8）

网路冷眼@BlogJava — Tue, 04 Jan 2011 15:12:00 GMT

摘要: 随着符合BPMN 2.0标准的BPMS流程引擎Activiti 5.0正式版推出，由Tijs Rademakers 和 Ron Van Liempd编写的‘实战Activiti’书籍昨天在“Manning Early Access Program”现身。目前第一章释出，可以先睹为快。呵呵，真棒！本篇是第一章之（8）阅读全文

网路冷眼@BlogJava 2011-01-04 23:12 发表评论

Activiti in Action（实战Activiti）-第一章 BPMN 2.0: what’s in it for developers?（7）

网路冷眼@BlogJava — Tue, 04 Jan 2011 12:43:00 GMT

摘要: 随着符合BPMN 2.0标准的BPMS流程引擎Activiti 5.0正式版推出，由Tijs Rademakers 和 Ron Van Liempd编写的‘实战Activiti’书籍昨天在“Manning Early Access Program”现身。目前第一章释出，可以先睹为快。呵呵，真棒！本篇是第一章之（7）阅读全文

网路冷眼@BlogJava 2011-01-04 20:43 发表评论

Activiti in Action（实战Activiti）-第一章 BPMN 2.0: what’s in it for developers?（6）

网路冷眼@BlogJava — Mon, 03 Jan 2011 09:59:00 GMT

摘要: 随着符合BPMN 2.0标准的BPMS流程引擎Activiti 5.0正式版推出，由Tijs Rademakers 和 Ron Van Liempd编写的‘实战Activiti’书籍昨天在“Manning Early Access Program”现身。目前第一章释出，可以先睹为快。呵呵，真棒！本篇是第一章之（6）阅读全文

网路冷眼@BlogJava 2011-01-03 17:59 发表评论

Activiti in Action（实战Activiti）-第一章 BPMN 2.0: what’s in it for developers?（5）

网路冷眼@BlogJava — Mon, 03 Jan 2011 08:06:00 GMT

摘要: 随着符合BPMN 2.0标准的BPMS流程引擎Activiti 5.0正式版推出，由Tijs Rademakers 和 Ron Van Liempd编写的‘实战Activiti’书籍昨天在“Manning Early Access Program”现身。目前第一章释出，可以先睹为快。呵呵，真棒！本篇是第一章之（5）阅读全文

网路冷眼@BlogJava 2011-01-03 16:06 发表评论

Activiti in Action（实战Activiti）-第一章 BPMN 2.0: what’s in it for developers?（4）

网路冷眼@BlogJava — Sun, 02 Jan 2011 14:39:00 GMT

摘要: 随着符合BPMN 2.0标准的BPMS流程引擎Activiti 5.0正式版推出，由Tijs Rademakers 和 Ron Van Liempd编写的‘实战Activiti’书籍昨天在“Manning Early Access Program”现身。目前第一章释出，可以先睹为快。呵呵，真棒！本篇是第一章之（4）阅读全文

网路冷眼@BlogJava 2011-01-02 22:39 发表评论

Activiti in Action（实战Activiti）-第一章 BPMN 2.0: what’s in it for developers?（3）

网路冷眼@BlogJava — Sat, 01 Jan 2011 14:52:00 GMT

摘要: 随着符合BPMN 2.0标准的BPMS流程引擎Activiti 5.0正式版推出，由Tijs Rademakers 和 Ron Van Liempd编写的‘实战Activiti’书籍昨天在“Manning Early Access Program”现身。目前第一章释出，可以先睹为快。呵呵，真棒！本篇是第一章之（3）阅读全文

网路冷眼@BlogJava 2011-01-01 22:52 发表评论

Activiti in Action（实战Activiti）-第一章 BPMN 2.0: what’s in it for developers?（2）

网路冷眼@BlogJava — Sat, 01 Jan 2011 07:40:00 GMT

摘要: 随着符合BPMN 2.0标准的BPMS流程引擎Activiti 5.0正式版推出，由Tijs Rademakers 和 Ron Van Liempd编写的‘实战Activiti’书籍昨天在“Manning Early Access Program”现身。目前第一章释出，可以先睹为快。呵呵，真棒！本篇是第一章之（2）阅读全文

网路冷眼@BlogJava 2011-01-01 15:40 发表评论

Activiti in Action（实战Activiti）-第一章 BPMN 2.0: what’s in it for developers?（1）

网路冷眼@BlogJava — Sat, 18 Dec 2010 13:54:00 GMT

网路冷眼@BlogJava 2010-12-18 21:54 发表评论

Activiti in Action（实战Activiti）-目录

网路冷眼@BlogJava — Thu, 16 Dec 2010 14:33:00 GMT

摘要: 随着符合BPMN 2.0标准的BPMS流程引擎Activiti 5.0正式版推出，由Tijs Rademakers 和 Ron Van Liempd编写的‘实战Activiti’书籍昨天在“Manning Early Access Program”现身。目前第一章释出，可以先睹为快。呵呵，真棒！本文是该书的目录。阅读全文

网路冷眼@BlogJava 2010-12-16 22:33 发表评论

Activiti Components（Activiti组件）

网路冷眼@BlogJava — Tue, 14 Dec 2010 12:56:00 GMT

摘要: Activiti是一个轻量级的工作流和业务流程管理（BPM，Business Process Management）平台。其项目主管及首席架构师为Tom Baeyens，原jBPM的创始人，Activiti为Tom另一力作。Activiti为业务人员提供Activiti Cycle工具，为开发人员提供Activiti 引擎，为系统管理员提供Activiti Probe（Activiti 探针，一个系统平台治理工具）。它的核心是一个针对Java平台基于BPMN 2的原生流程引擎，快若闪电，坚若磐石。它是开源软件，采用Apache许可分发。Activiti可运行在任何Java应用程序：在服务器，在集群，甚至在云计算环境均可运行。它可和Spring完美集成，体型轻盈（lightweight），概念简洁。本文是对它所包含组件的介绍。阅读全文

网路冷眼@BlogJava 2010-12-14 20:56 发表评论

流程周期层（The Process Cycle Layer）

网路冷眼@BlogJava — Mon, 13 Dec 2010 13:40:00 GMT

摘要: Activiti是一个轻量级的工作流和业务流程管理（BPM，Business Process Management）平台。其项目主管为Tom Baeyens，原jBPM的创始人，Activiti为Tom另一力作。Activiti为业务人员提供Activiti Cycle工具，为开发人员提供Activiti 引擎，为系统管理员提供Activiti Probe（Activiti 探针，一个系统平台治理工具）。它的核心是一个针对Java平台基于BPMN 2的原生流程引擎，快若闪电，坚若磐石。它是开源软件，采用Apache许可分发。Activiti可运行在任何Java应用程序：在服务器，在集群，甚至在云计算环境均可运行。它可和Spring完美集成，体型轻盈（lightweight），概念简洁。本文是Activiti网站上一篇文章“The Process Cycle Layer”的翻译。阅读全文

网路冷眼@BlogJava 2010-12-13 21:40 发表评论

关于Activiti的常见问题（翻译）

网路冷眼@BlogJava — Sat, 11 Dec 2010 12:40:00 GMT

摘要: 摘要: Activiti是一个轻量级的工作流和业务流程管理（BPM，Business Process Management）平台。其项目主管为Tom Baeyens，原jBPM的创始人，Activiti为Tom另一力作。Activiti为业务人员提供Activiti Cycle工具，为开发人员提供Activiti 引擎，为系统管理员提供Activiti Probe（Activiti 探针，一个系统平台治理工具）。它的核心是一个针对Java平台基于BPMN 2的原生流程引擎，快若闪电，坚若磐石。它是开源软件，采用Apache许可分发。Activiti可运行在任何Java应用程序：在服务器，在集群，甚至在云计算环境均可运行。它可和Spring完美集成，体型轻盈（lightweight），概念简洁。本文是Activiti网站上FAQ的翻译。阅读全文

网路冷眼@BlogJava 2010-12-11 20:40 发表评论

Activiti User Guide（Activiti用户指南)-Chapter 1. Introduction（简介）

网路冷眼@BlogJava — Sat, 04 Dec 2010 17:37:00 GMT

Chapter 1. Introduction（简介）

Table of Contents

License（授权）
Download（下载）
Sources（源代码）
Required software（依赖的软件）
Reporting problems（报告问题）
Experimental features（实验性特性）

License（授权）

Activiti is distributed under the Apache V2 license.

Download（下载）

http://activiti.org/download.html

Sources（源代码）

The distribution contains most of the sources as jar files. To find and build the full source codebase, please read the 'Building the distribution' wiki page

Required software（依赖的软件）

JVM 5+
Ant 1.7.1+

Reporting problems（报告问题）

Every self respecting developer should have read How to ask questions the smart way

每个自重的开发人与应当阅读 How to ask questions the smart way 。

After you've done that you can post questions and comments on the Users forum and create issues in our JIRA issue tracker

在the Users forum上完成粘贴问题和意见之后，在our JIRA issue tracker 上建立问题（issues).

Experimental features（实验性特性）

Sections marked with [EXPERIMENTAL] should not be considered stable.

（标记为 [EXPERIMENTAL] 的小节应当视为不稳定的。

网路冷眼@BlogJava 2010-12-05 01:37 发表评论

Activiti User Guide（Activiti用户指南)-Chapter 2. Getting Started（入门指南）

网路冷眼@BlogJava — Sat, 04 Dec 2010 17:35:00 GMT

Chapter 2. Getting Started（入门指南）

Table of Contents

Demo setup（安装演示）
Example projects in the workspace（工作区里的示例项目）
Library dependencies（库依赖）
Eclipse setup（Eclipse下的安装）
Inspecting the database（检查数据库）

Demo setup（安装演示）

Setup is an ant script located in directory setup that helps you get up and running with Activiti quickly.

安装是一个放置在目录里的脚本。它帮助用户快速建立并运行Activiti。

To run the script, you'll need a working Java runtime and Ant installation. Also make sure that the JAVA_HOME and ANT_HOME system variables are correctly set. The way to do this depends on your operating system, but the manual of ant gives a description on how to do this. The demo setup script is tested with Ant 1.7.1.

为了运行脚本，需要一个可以工作的安装。也要确保JAVA_HOME 和 ANT_HOME系统变量设置正确。虽然具体的设置方式根据操作系统不同而相异，但是为如何完成这些设置提供了描述。演示安装脚本在下测试通过。

To configure setup for your environment, update property files build.properties and build.{your-database}.properties . Check those files for more information on configurable properties and potential values.

为了针对你的环境配置安装，请更新属性文件build.properties 和 build.{your-database}.properties。为了获取更多可配置属性和潜在的值的信息，请仔细检查这些文件。

The easiest target to get started is open a command prompt in de setup folder and type:

入门最容易的目标是在setup文件夹打开一个命令提示并键入：

ant demo.start

This target will start tomcat and if you're using h2, it will also start the h2 database. The first time when that is executed, it will also perform the installation:

这个目标将启动Tomcat。如果正在使用H2数据库，它也将启动H2数据库。若是第一次执行安装，它也将执行下列安装：

(*) Build the webapps. All libraries are stored in ${actviti.home}/setup/files/dependencies/libs The webapps without the libs are stored in ${actviti.home}/setup/files/webapps. Building the webapps means that webapps are combined with the necessary libraries in ${actviti.home}/setup/build/webapps
(*)构建webapps。所有的库保存在${actviti.home}/setup/files/dependencies/libs。没带库的保存在${actviti.home}/setup/files/webapps。构建意味着在组合webapp和必须的库在${actviti.home}/setup/build/webapps目录里。
(*) Install the H2 in ${activiti.home}/apps/h2. This only happens if you're using h2 as your database. H2 is the default database.
(*) 将H2安装至目录里。只是采用H2数据库时才发生。H2是缺省的数据库。
Start the H2 database. Again, this is only done if using h2 as the database. If you're using a different database it is assumed that it is already up and running.
启动H2数据库。对了，如果采用H2数据库时，才完成这一步。如果采用不同的数据库，那么假定数据库已经启动并运行了。
(*) Create the Activiti tables in the database
(*) 在数据库里建立Activiti库表
(*) Insert the demo users and groups in the Activiti identity tables (see below)
(*) 将示例用户和组插入到 Activiti identity表（见下）。
(*) Deploy the example processes to the Activiti Engine DB
(*) 将示例流程部署至Activiti Engine DB。
(*) Download Tomcat if not available in the ${downloads.dir}
(*) 如果在目录里面没有Tomcat，就下载Tomcat
(*) Install Tomcat in ${activiti.home}/apps/apache-tomcat-${tomcat.version}
(*) 将Tomcat安装至${activiti.home}/apps/apache-tomcat-${tomcat.version}
(*) Create an Activiti configuration jar
建立一个 Activiti 配置jar包
(*) Deploy the REST interface webapp into tomcat
(*)部署REST接口webapp值Tomcat
(*) Download the Activiti Modeler webapp to ${activiti.home}/webapps
(*) 将Activiti Modeler webapp下载至${activiti.home}/webapps目录。
(*) Deploy the Probe, Explorer and Modeler webapps into tomcat.
(*) 将Probe, Explorer and Modeler webapps部署至Tomcat。
Start tomcat
启动Tomcat

(*) only performed the first time when running ant demo.start

After running this target H2 and Tomcat will be running in the background. To stop those processes run ant demo.stop.

The other targets in that build script can also be called individually and they will take the configurable properties into account. Run ant -p for more details.

在运行目标H2之后，Tomcat将在后台运行。为了停止这些进程，请运行 ant demo.stop。在构建脚本里的其它目标也能够单个调用。它们将考虑考虑可配置属性。详情可以运行ant -p 得到。

These are the demo users:

这些事示例用户：

Table 1.1. The demo users（示例用户）

UserId
Password
Security roles

kermit
kermit
admin

gonzo
gonzo
manager

fozzie
fozzie
user

Now you can access following web applications:

现在，你能访问下列web 应用程序:

Table 1.2. The webapp tools（webapp工具）

Webapp Name
URL
Description

Activiti Probe
http://localhost:8080/activiti-probe
The admin management console. Use this tool to see if the configured process engine is correctly initialized, DB tables contents.

Activiti Explorer
http://localhost:8080/activiti-explorer
The process engine user console. Use this tool to view your personal and candidate task lists and to complete tasks.

Activiti Cycle
http://localhost:8080/activiti-cycle
The process cycle layer. Use this to browse repositories, execute transformations between model formats.

Activiti Modeler powered by Signavio
http://localhost:8080/activiti-modeler
The web based process designer tool. Use this tool to graphically author BPMN 2.0 compliant process definitions files.

Note that the Activiti demo setup is a way of showing the capabilities and functionality of Activiti as easy and as fast as possible. This does however, not mean that it is the only way of using Activiti. As Activiti is 'just a jar', it can be embedded in any Java environment: with swing or on a Tomcat, JBoss, WebSphere, etc. Or you could very well choose to run Activiti as a typical, standalone BPM server. If it is possible in Java, it is possible with Activiti!

注意Activiti示例安装时为了尽快，尽容易展现Activiti功能和能力的一种方式。但是这并不意味着这是采用Activiti的唯一方式。Activiti只是一个jar包，它可以嵌入到任何Java环境：Swing或者Tomcat，JBoss,WebSphere等等。或者你能选择将Activiti作为一个典型的，独立的BPM服务器。Java若在，Activiti就在！

Example projects in the workspace（工作区里的示例项目）

The distribution contains a workspace directory containing a couple of example java projects:

发行包包含一个许多java项目的工作区目录。

activiti-engine-examples: This set of examples show the most common usage of Activiti: BPMN process definitions and process executions are stored in a DB and the examples make use of the persistent API.
This project contains the eclipse project files, an ant build file and a maven pom file. The ant build file is independent of the maven pom. Both are there to show how you can use ant and maven respectively for building and deploying processes as part of your build.
activiti-engine-examples: 把这一系列示例展示了Activiti的通用用法：保存在DB里的BPMN流程定义和流程执行。还有持久化API使用的示例。
这个项目包含了eclipse的项目文件，一个ant构建文件和一个maven pom文件。ant 构建文件和maven pom文件相互独立。作为你的构建部分，为了构建和部署流程，两者展示了能够使用ant和maven进行构建。
activiti-spring-examples: These examples show how you can use the Activiti Engine in a Spring environment.
activiti-spring-examples: 这些示例展示在Spring环境下如何使用Activiti引擎。
activiti-groovy-examples: These examples show the library dependencies for groovy and an example process with groovy scripting.
activiti-groovy-examples: dd这些示例展示了groovy的依赖库和用groovy脚本处理的示例流程。
activiti-jpa-examples: These examples show library dependencies and how you can work with JPA in Activiti.
activiti-jpa-examples: 这些示例展示了JPA的依赖库，以及在Activiti里采用JPA是如何工作的。
activiti-cycle-examples: This is a project containing an demo example project for Activiti Cycle
activiti-cycle-examples: 这是一个包含针对Activiti Cycle的示例项目。
activiti-modeler-examples: This is a file based model repository to which the Activiti Modeler is configured in the demo setup.
activiti-modeler-examples:
activiti-modeler-examples: 这是一个在示例安装里配置Activiti Modeler所需的基于模型的仓库。

the section called “Eclipse setup（Eclipse下的安装）” shows how you can set up your eclipse environment to play with these example projects.

the section called “Eclipse setup（Eclipse下的安装）” 展示了如何安装eclipse环境来熟悉这些示例项目。

As part of the demo.start, the examples will be inflated. This means that all the libs and configuration files will be put in place. If you don't run the demo.start and you want to inflate the examples with libs in the appropriate place, run this command in the setup directory:

作为 demo.start的部分，将展开这些事例。这意味着所有的库和配置文件将安置就位。如果不运行demo.start而将示例和库展开到合适的位置，运行安装目录下的这个命令：

ant inflate.examples

Once you've done that the activiti-engine-examples and activiti-spring-examples will contain libs-runtime and libs-test directories containing the runtime dependency jars and test time dependency jars respectively.

一旦完，将包含 activiti-engine-examples 成activiti-spring-examples目录。这些目录相应地包含而来运行时所依赖的jar包和测试时依赖的jar包。

Library dependencies（库依赖）

In order to prevent that the distribution file becomes too big by libraries that are included multiple times, all the libraries are grouped into a single directory somewhere in the setup/files.

吧为了防止由于库包含多次而使发布文件变得太大，所有的库被分组到setup/files下单个的目录。

The ant scripts in the setup/build.xml can inflate the examples (target inflate.examples) with the libs and they will include the appropriate libs when building the webapps.

在 setup/build.xml文件里面的ant 脚本能够展开示例 (target inflate.examples) 及其库。当构建webapp时，它们将包含合适的库。

All the libs are located in setup/files/dependencies/libs And the following files in setup/files/dependencies describe the library dependencies:

所有库放置在 setup/files/dependencies/libs ，并且在setup/files/dependencies 目录里下列文件描述了库依赖：

libs.engine.runtime.txt: The library runtime dependencies to run the Activiti Engine.
libs.engine.runtime.txt: 运行Activiti引擎的运行时依赖库。
libs.engine.runtime.test.txt: The libraries that need to be added to the ones in libs.engine.runtime.txt to run the tests
libs.engine.runtime.test.txt: 为了运行测试，需要加入到libs.engine.runtime.txt 的库
libs.engine.runtime.feature.groovy.txt: The libraries that need to be added to the ones in libs.engine.runtime.txt to use the groovy scripting capabilities.
libs.engine.runtime.feature.groovy.txt: 为了使用groovy脚本能力，需要加入到libs.engine.runtime.txt 的库。
libs.engine.runtime.txt: The libraries that need to be added to the ones in libs.engine.runtime.txt to use the JPA variable reference capabilities.
libs.engine.runtime.txt: 为了使用JPA变量引用能力，需要加入到libs.engine.runtime.txt 的库。
libs.spring.runtime.txt: The library runtime dependencies to run the Activiti Engine in a Spring environment. (This list includes the libs in libs.engine.runtime.txt)
libs.spring.runtime.txt: 在Spring环境下运行Activiti引擎的运行期依赖库。（这个列表包含了libs.engine.runtime.txt）
libs.spring.runtime.test.txt: The libraries that need to be added to the ones in libs.spring.runtime.txt to run tests in a Spring environment
libs.spring.runtime.test.txt: 在Spring环境下，为了测试，需要加入到libs.spring.runtime.txt 下的库。
libs.cycle.runtime.test.txt, libs.webapp.rest.txt and libs.webapp.ui.txt: The full list of libraries dependencies for the respective components cycle, the rest webapp and the UI webapps like Activiti Explorer, Activiti Probe and Activiti Cycle
libs.cycle.runtime.test.txt, libs.webapp.rest.txt和 libs.webapp.ui.txt: 相关组件cycle，rest webapp和像Activiti Explorer, Activiti Probe 和 Activiti Cycle之类的UI Webapp所需依赖库的全部列表。

Eclipse setup（Eclipse下的安装）

To run and play with the examples in your eclipse, follow these simple instructions:

为了在eclipse里运行示例，遵从这些简单的指令：

File --> Import...

Select General --> Existing Projects into Workspace and click Next

选择 General --> Existing Projects into Workspace并点击Next

Click 'Browse...', select the directory ${activiti.home}/workspace and you'll see the example projects being automatically selected.

点击 'Browse...'，选择目录 ${activiti.home}/workspace ，那么将自动选择示例项目。

Then you can click Finish in the Import dialog and you're all set.

吧然后你在输出对话框能点击按钮，所有都设置好了。

For more convenience, open the ant view (Window --> Show View --> Ant) and drag the file activiti-engine-examples/build.xml into the ant window. Now you'll be able to activate the build targets by just double clicking on them.

为了更加方便起见，打开ant视图（Window --> Show View --> Ant）并将文件拽至ant窗口。通过在它们上面双击，现在你能激活构建目标。

If you want BPMN 2.0 XML auto-completion and validation while typing, you can add the BPMN 2.0 XML Schema to the XML catalog. Go to Preferences --> XML --> XML Catalog --> Add, and select the XML Schema from the file system in the folder docs/xsd/BPMN20.xsd.

如果你想当输入时，BPMN 2.0 XML自动完成和校验，可以将BPMN 2.0 XML Schema 加入到XML分类里面。导航至Preferences --> XML --> XML Catalog --> Add，从文件系统里的文件夹里的docs/xsd/BPMN20.xsd选择XML Schema。

Inspecting the database（检查数据库）

To check out the database while trying out the demo setup, run the following Ant target in the setup folder:

当尝试示例安装时，为了检查数据库，运行在文件夹下的Ant目标：

ant h2.console.start

This will boot the H2 web console. Note that the Ant target doesn't return, so a 'CTRL + C' is required to shutdown the console. Fill in the following URL in the JDBC URL field and click connect:

这将引导H2 Web控制台。注意Ant 目标并不返回，所以为了关闭控制台，需要键入'CTRL + C'。在 JDBC URL字段里填入URL，并点击“connect”：

jdbc:h2:tcp://localhost/activiti

You are now able to browse the Activiti database schema and check the content of the tables.

现在你能浏览Activiti数据库结构并检查数据库表里面的内容。

To change the database, see ???

为了改变数据库，参见 ???。

网路冷眼@BlogJava 2010-12-05 01:35 发表评论

Activiti User Guide（Activiti用户指南)-Chapter 3. Configuration（配置）

网路冷眼@BlogJava — Sat, 04 Dec 2010 17:32:00 GMT

Chapter 3. Configuration（配置）

Table of Contents

Creating a ProcessEngine（建立一个流程引擎）
ProcessEngineConfiguration bean
Database configuration（数据库配置）
Job executor activation（作业执行器激活）
Mail server configuration（邮件服务器配置）
History configuration（历史配置）
Supported databases（支持的数据库）
Changing the database（改变数据库）
Downloading the Oracle driver（下载Oracle）

Creating a ProcessEngine（建立一个流程引擎）

The Activiti process engine is configured through a xml file called activiti.cfg.xml. Note that this is not applicable if you're using the Spring style of building a process engine.

Activiti流程引擎通过一个叫做的xml文件来配置。注意你采用构建流程引擎的Spring风格的方式the Spring style of building a process engine，这种方式并不适合

The easiest way to obtain a ProcessEngine, is to use the org.activiti.engine.ProcessEngines class:

获取ProcessEngine最容易的方式是使用org.activiti.engine.ProcessEngines类：

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine()

This will look for an activiti.cfg.xml file on the classpath and construct an engine based on the configuration in that file. The following snippet shows an example configuration. The following sections will give a detailed overview of the configuration properties.

这将在classpath上寻找 activiti.cfg.xml文件，并在那个文件的配置之上构建一个引擎。下列片段显示了一个示例配置。下面部分将给出详细的配置特性的总体概观。

Note that the configuration xml is in fact a Spring configuration. This does not mean that Activiti can only be used in a Spring environment! We are simply leveraging the parsing and dependency injection capabilitities of Spring internally for building up the engine.

注意配置文件事实上是一个Spring配置。这并不意味着Activiti只能在Spring环境下使用! 为了构建引擎，我们在内部简单地平衡了解析和Spring的依赖注入的能力。

The ProcessEngineConfiguration object can also be created programmatically using the configuration file. It is also possible to use a different bean id (eg. see line 3).

通过使用配置文件，也能通过编程方式建立ProcessEngineConfiguration对象。使用一个不同的bean id也是可能的。（例如，见第3行）。

ProcessEngineConfiguration.createProcessEngineConfigurationFromResourceDefault();
ProcessEngineConfiguration.createProcessEngineConfigurationFromResource(String resource);
ProcessEngineConfiguration.createProcessEngineConfigurationFromResource(String resource, String beanName);
ProcessEngineConfiguration.createProcessEngineConfigurationFromInputStream(InputStream inputStream);
ProcessEngineConfiguration.createProcessEngineConfigurationFromInputStream(InputStream inputStream, String beanName);

It is also possible not to use a configuration file, and create a configuration based on defaults (see the different supported classes for more information).

不使用配置文件也是可能的，基于缺省建立一个配置（详情参见不同支持的类（the different supported classes））

ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();
ProcessEngineConfiguration.createStandaloneInMemProcessEngineConfiguration();

All these ProcessEngineConfiguration.createXXX() methods return a ProcessEngineConfiguration that can further be tweaked if needed. After calling the buildProcessEngine() operation, aProcessEngine is created:

如果需要所有 ProcessEngineConfiguration.createXXX()的方法返回一个能进一步配置的ProcessEngineConfiguration 。在调用操作之后，建立一个ProcessEngine 。

ProcessEngine processEngine = ProcessEngineConfiguration.createStandaloneInMemProcessEngineConfiguration()
.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_FALSE)
.setJdbcUrl("jdbc:h2:mem:my-own-db;DB_CLOSE_DELAY=1000")
.setJobExecutorActivate(true)
.buildProcessEngine();

ProcessEngineConfiguration bean

The activiti.cfg.xml must contain a bean that has the id 'processEngineConfiguration'.

dd activiti.cfg.xml 必须包括具有id 'processEngineConfiguration'的bean。

This bean is then used to construct the ProcessEngine. There are multiple classes available that can be used to define the processEngineConfiguration. These classes represent different environments, and set defaults accordingly. It's a best practice to select the class the matches (the most) your environment, to minimalise the number of properties needed to configure the engine. Following classes are currently available (more will follow in future releases):

得到这个bean然后用来构建e ProcessEngine。可以定义processEngineConfiguration的类有多个。这些类表示不同的环境，响应地设置为缺省。为了减少需要配置引擎的属性数量，选择的类以匹配环境是最佳实践。当前可获得的类如下（将来的版本将推出新的类）

org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration: the process engine is used in a standalone way. Activiti will take care of the transactions. By default, the database will only be checked when the engine boots (and an exception is thrown if there is no Activiti schema or the schema version is incorrect).

org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration:以独立方式运行的流程引擎。Activiti将考虑事务。缺省地，只有在引擎引导时检查数据库（如果没有Activiti schema或者schema版本不正确，将抛出异常）。
org.activiti.engine.impl.cfg.StandaloneInMemProcessEngineConfiguration: this is a convience class for unit testing purposes. Activiti will take care of the transactions. An H2 in-memory database is used by default. The database will be created and dropped when the engine boots and shuts down. When using this, probably no additional configuration is needed (except when using for example the job executor or mail capabilities).

org.activiti.engine.impl.cfg.StandaloneInMemProcessEngineConfiguration: 这是一个针对单元测试目的的便捷类。Activiti将考虑事务。缺省使用H2内存数据库。当引擎引导并关闭时，数据库将被建立和删除。当使用时，可能需要额外的配置（当使用作业执行器或者邮件能力的示例除外）
org.activiti.spring.SpringProcessEngineConfiguration: To be used when the process engine is used in a Spring environment. See the Spring integration section for more information.

org.activiti.spring.SpringProcessEngineConfiguration: 当在Spring环境下使用流程引擎时使用。详情参见Spring集成部分the Spring integration section。
org.activiti.engine.impl.cfg.JtaProcessEngineConfiguration: ([EXPERIMENTAL]) to be used when the engine runs in standalone mode, with JTA transactions.

org.activiti.engine.impl.cfg.JtaProcessEngineConfiguration: ([EXPERIMENTAL])当引擎以带有JTA事务的单独模式运行时使用。

Database configuration（数据库配置）

There are two ways to configure the database that the Activiti engine will use. The first option is to define the jdbc properties of the database:

有两种方式类配置引擎将使用的数据库。第一个选项是定义数据库的jdbc属性：

jdbcUrl: jdbc url of the database.

jdbcUrl: 数据库的jdbc url。
jdbcDriver: implementation of the driver for the specific database type.

jdbcDriver: 特定数据库驱动的实现。
jdbcUsername: username to connect to the database.

jdbcUsername: 连接到数据的用户名。
jdbcPassword: password to connect to the database.

jdbcPassword: 连接到数据库的密码。

The datasource that is constructed based on the provided jdbc properties will have the default MyBatis connection pool settings. Following attributes can optionally be set to tweak that connection pool (taken from the MyBatis documentation):

基于所提供的jdbc属性所构建的数据源将有的连接池设置。

jdbcMaxActiveConnections: The number of active connections that the connection pool at maximum at any time can contain. Default is 10.

jdbcMaxActiveConnections: 在任何时刻连接池最大能够包含的可以激活的连接数。缺省为10.
jdbcMaxIdleConnections: The number of idle connections that the connection pool at maximum at any time can contain.

jdbcMaxIdleConnections:在任何时刻连接池最大能够包含的空闲的连接数
jdbcMaxCheckoutTime: The amount of time in milliseconds a connection can be 'checked out' from the connection pool before it is forcefully returned. Default is 20000 (20 seconds).

jdbcMaxCheckoutTime: 在连接强制返回之前，能够从连接池检出一个连接所需的以毫秒计算的时间值。
jdbcMaxWaitTime: This is a low level setting that gives the pool a chance to print a log status and re-attempt the acquisition of a connection in the case that it’s taking unusually long (to avoid failing silently forever if the pool is misconfigured) Default is 20000 (20 seconds).

jdbcMaxWaitTime: 这是一个底层的设置，给连接池一个打印日志状态并重试连接获取的机会。在这种情况下通常占用很长时间（以避免如果连接池位置不好导致导致悄无声息地失败），缺省时20000（20秒）。

Example database configuration:

示例数据库配置：

Alternatively, a javax.sql.DataSource implementation can be used (eg. DBCP from ):

可选，可以使用 javax.sql.DataSource的实现（例如Apache Commons的DBCP）：

...

Note that Activiti does not ship with a library that allows to define such datasource. So you have to make sure that the libraries (eg. from DBCP) are on your classpath.

注意Activiti并不包含允许定义如此数据源的Java库。所以，确保这些（例如，从DBCP而来）在你的classpath里面。

Following properties can be set, regardless of using the jdbc or datasource approach:

不管采用jdbc还是数据源方法，可以设置下列属性：

databaseType: indicates the type of database. This property is required when not using the default H2 database This setting will determine which create/drop scripts and queries will be used. See the 'supported databases' section for an overview of which types are supported.

databaseType: 指示数据库类型。当不是采用缺省的H2数据库时xuyao 需要。这个设置将决定将要使用哪个建立/删除脚本。要了解支持哪些类型的概要，请参见the 'supported databases' section 。
databaseSchemaUpdate: allows to set the strategy to handle the database schema on process engine boot and shutdown.

databaseSchemaUpdate：允许当流程引擎引导和关闭时，设置处理数据库结构采取的策略。
- false (default): Checks the version of the DB schema against the library when the process engine is being created and throws an exception if the versions don't match.
  
  false （缺省）：当流程引擎建立时，检查DB和库的版本。如果版本不匹配，将抛出异常。
- true: Upon building of the process engine, a check is performed and an update of the schema is performed if it is necessary. If the schema doesn't exist, it is created.
  
  true:一旦流程引擎构建完成，执行一个检查。如果有必要，更新数据库的结构。如果结构不存在，就创建它。
- create-drop: Creates the schema when the process engine is being created and drops the schema when the process engine is being closed.
  
  create-drop：在流程引擎创建时创建结构；当流程引擎时到达删除结构。

Job executor activation（作业执行器激活）

The JobExecutor is a component that manages a couple of threads to fire timers (and later also asynchronous messages). For unit testing scenarios, it is cumbersome to work with multiple threads. Therefor the API allows to query for (ManagementService.createJobQuery) and execute jobs (ManagementService.executeJob) through the API so that job execution can be controlled from within a unit test. To avoid that the job executor interferes, it can be turned off.

作业执行器是一个管理点火定时器一对线程的组件（之后也叫异步消息）。对于单元测试场景，和多个线程一道工作是麻烦的。所以API允许通过API查询 (ManagementService.createJobQuery) 并执行作业 (ManagementService.executeJob) 以便从一个单元测试里控制作业执行。为了避免作业干扰，可以关掉它。

By default, the JobExecutor is activated when the process engine boots. Specify

缺省地，当流程引擎引导时激活JobExecutor。指定

when you don't want the JobExecutor to be activated upon process engine boot.

当流程引擎引导时，并不想激活 JobExecutor。

Mail server configuration（邮件服务器配置）

Optional. Activiti supports sending e-mails in business processes. To actually send an e-mail, a valid SMTP mail server configuration is required. See the e-mail task for the configuration options.

可选。. Activiti 支持在业务流程里发送电子邮件。事实上，为了发送邮件，需要配置一个有效的SMTP邮件服务器配置。这个配置可选项参见e-mail task 。

History configuration（历史配置）

Optional. Allows to tweak settings that influence the history capabilities of the engine. See history configuration for more details.

可选项。允许影响引擎的历史能力history capabilities的设置。详情参见history configuration 。

Supported databases（支持的数据库）

Following are the types (case sensitive!) that Activiti uses to refer to databases.

下表是Activiti所使用的数据库表类型（大小写敏感的）。

Table 1.1. Supported databases

Activiti database type
Versions tested
Notes

h2
1.2.132
Default configured database

mysql
5.1.11

oracle
10.2.0

postgres
8.4

db2
not yet supported (coming soon, see ACT-330)

mssql
not yet supported (coming soon)

Changing the database（改变数据库）

One of the things you probably want to do at some point, is configuring Activiti to use a different database. To configure the demo setup or to generate a configuration file for a different database, follow these steps:

在某些点你可能想做的其中一件事是配置来使用不同的数据库。为了配置演示安装或者为不同数据库产生一个配置文件，遵从这些步骤：

Edit setup/build.properties and change the db parameter to your type of database {oracle | mysql | postgresql | h2}.

编辑 setup/build.properties 并将db参数变为你的数据库的类型 {oracle | mysql | postgresql | h2}。
Edit setup/build.${db}.properties and change the JDBC connection parameters to those of your database installation.

编辑setup/build.${db}.properties并将JDBC连接参数变为你所安装数据库的那些参数。

To create a configuration file for your database based on the properties you've specified in the build.*.properties files run

为了建立一个基于你所指定build.*.properties 文件的属性的配置文件。请运行

ant cfg.create

from within the setup folder. The generate configuration file can now be found in setup/build/activiti-cfg. Also, for convenience, a jar called containing the configuration file can be found in setup/build

在setup 文件夹。产生的配置文件在setup/build/activiti-cfg里能够找到。为了方便起见，一个叫activiti-cfg.jar的jar包包含了能够在setup/build 里找到的配置文件。

If you want to run the demo setup on another database, first stop the demo setup with

如果你想在另一个数据库上运行演示安装，首先用下面的命令停止示例安装

ant demo.stop demo.clean demo.start

Then clean and re-start the demo setup with

然后清除并重新启动演示安装：

ant demo.clean demo.start

Downloading the Oracle driver（下载Oracle）

When you want to run the demo setup using oracle as datasource, an extra step is required BEFORE you call the ant target demo.start.

当你想使用oracle作为数据源来运行演示安装，在调用ant目标 demo.start之前，必须要有额外的步骤：

Since we cannot redistribute the Oracle JDBC driver due to its licence, you should download it manually: http://www.oracle.com/technetwork/database/enterprise-edition/jdbc-112010-090769.html. Make sure you download ojdbc5.jar (our tests run against 10g ojdbc using version 11.2.0.1).

因为由于Oracle JDBC Driver的授权原因，我们不能重新分发它，所以你应当手动下载：http://www.oracle.com/technetwork/database/enterprise-edition/jdbc-112010-090769.html。确保下载的是ojdbc5.jar（）
Copy the downloaded ojdbc5.jar to setup/files/dependencies/libs/ This filename is

拷贝下载的ojdbc5.jar至setup/files/dependencies/libs/。

网路冷眼@BlogJava 2010-12-05 01:32 发表评论

Activiti User Guide（Activiti用户指南)-Chapter 4. Spring integration（Spring集成）

网路冷眼@BlogJava — Sat, 04 Dec 2010 17:30:00 GMT

Chapter 4. Spring integration（Spring集成）

Table of Contents

ProcessEngineFactoryBean
Transactions（事务）
Expressions（表达式）
Automatic resource deployment（自动资源部署）
Unit testing（单元测试）

While you definitely can use Activiti without Spring, we've provided some very nice integration features that are explained in this chapter.

尽管你肯定能够不用使用Spring而使用Activiti，但是本章将解释一些优秀的Spring集成特性。

ProcessEngineFactoryBean

The ProcessEngine can be configured as a regular Spring bean. The starting point of the integration is the class org.activiti.spring.ProcessEngineFactoryBean. That bean takes a process engine configuration and creates the process engine. This means that the way and all configuration properties documented in the configuration section are exactly the same as for Spring:

ProcessEngine能够配置为一个普通的Spring bean。集成的开始点是类org.activiti.spring.ProcessEngineFactoryBean。那个bean提取一个流程并建立流程引擎。这意味着方法和所有在配置部分的归档的配置属性，完全和Spring相同：

...

Do note that the processEngineConfiguration bean now uses the org.activiti.spring.SpringProcessEngineConfiguration class.

一定要注意：processEngineConfiguration bean现在使用org.activiti.spring.SpringProcessEngineConfiguration 类。

Transactions（事务）

We'll explain the SpringTransactionIntegrationTest found in the spring examples of the distribution step by step. Here is the spring configuration file that we use in this example (located in SpringTransactionIntegrationTest-context.xml). The quoted section contains the dataSource, transactionManager, processEngine and the Activiti Engine services.

我们将一步一步地解释在发行包中的Spring示例的SpringTransactionIntegrationTest 。这里是这个示例里所使用的配置文件(位置在SpringTransactionIntegrationTest-context.xml）。引号部分包含了数据源，事务管理器，流程引擎和Activiti引擎服务。

...

The remainder of that spring configuration file contains the beans and configuration that we'll use in this particular example:

Spring配置文件的其余部分包含了bean和在这个示例所使用的配置：

...

First the application context is created with any of the Spring ways to do that. In this example you could use a classpath XML resource to configure our Spring application context:

首先，用任何Spring方式建立应用程序上下文。在本例，能够使用一个classpath XML 资源来配置我们的Spring应用程序上下文：

ClassPathXmlApplicationContext applicationContext =
new ClassPathXmlApplicationContext("org/activiti/examples/spring/SpringTransactionIntegrationTest-context.xml");

or since it is a test:

或者它是一个测试：

@ContextConfiguration("classpath:org/activiti/spring/test/transaction/SpringTransactionIntegrationTest-context.xml")

Then we can get the service beans and invoke methods on them. The ProcessEngineFactoryBean will have added an extra interceptor to the services that applies Propagation.REQUIRED transaction semantics on the Activiti service methods. So we can use for example the repositoryService to deploy a process like this:

然后我们能够得到服务bean并调用它们之上的方法。将对一个应用繁殖的，在Activiti服务方法之上必要的事务语义服务增加一个额外的拦截器。所以我们能够像下面来部署一个流程来使用 repositoryService：

RepositoryService repositoryService = (RepositoryService) applicationContext.getBean("repositoryService");
String deploymentId = repositoryService
.createDeployment()
.addClasspathResource("org/activiti/spring/test/hello.bpmn20.xml")
.deploy()
.getId();

The other way around also works. In this case, the Spring transaction will be around the userBean.hello() method and the Activiti service method invocation will join that same transaction.

其它方法也可工作。在这种情况下， Spring事务将包围在方法附近。Activiti服务方法调用将加入同一事务。

UserBean userBean = (UserBean) applicationContext.getBean("userBean");
userBean.hello();

The UserBean looks like this. Remember from above in the Spring bean configuration we injected the repositoryService into the userBean.

UserBean看起来如此。记得吗，在上面的Spring bean配置里，已将repositoryService注入到userBean。

public class UserBean {
/** injected by Spring */
private RuntimeService runtimeService;
@Transactional
public void hello() {
// here you can do transactional stuff in your domain model
// and it will be combined in the same transaction as
// the startProcessInstanceByKey to the Activiti RuntimeService
runtimeService.startProcessInstanceByKey("helloProcess");
}
public void setRuntimeService(RuntimeService runtimeService) {
this.runtimeService = runtimeService;
}
}

Expressions（表达式）

When using the ProcessEngineFactoryBean, by default, all expressions in the BPMN processes will also 'see' the Spring beans. For example, the SpringTransactionIntegrationTest hello.bpmn20.xml shows how a method on a Spring bean can be invoked using a UEL method expression:

当使用ProcessEngineFactoryBean时，缺省地，在BPMN流程的所有表达式也将看见Spring beans。例如，SpringTransactionIntegrationTest hello.bpmn20.xml展示了如何能用一个UEL方法表达式调用在Spring bean上一个方法。





activiti:expression="#{printer.printMessage()}" />

Where Printer looks like this:

这里 Printer 看起来如下：

public class Printer {
public void printMessage() {
System.out.println("hello world");
}
}

And the Spring bean configuration (also shown above) looks like this:

Spring bean配置（如上所示）看起来如下：

...

Automatic resource deployment（自动资源部署）

Spring integration also has a special feature for deploying resources. In the process engine configuration, you can specify a set of resources. When the process engine is created, all those resources will be scanned and deployed. There is filtering in place that prevents duplicate deployments. Only when the resources actually have changed, will new deployments be deployed to the Activiti DB. This makes sense in a lot of use case, where the Spring container is rebooted often (eg testing).

Spring集成也为部署资源提供一个特殊的特性。在流程引擎配置里，你能指定一系列资源。当建立资源引擎时，将扫描并部署所有这些资源。存在一个防止复制部署的过滤器。只有当资源实际上已经发生变化时，才将新的部署才部署到Activiti 数据库里。这个需要Spring容器需要经常重新引导（比如测试）的地方才有意义。

Here's an example

这里有个示例

...

Unit testing（单元测试）

When integrating with Spring, business processes can be tested very easily using the standard Activiti testing facilities. Following example shows how a business process is tested in a typical Spring-based unit test:

当和Spring集成时，采用标准的测试设施Activiti testing facilities让业务流程的测试轻而易举。下例展示在一个典型基于Spring的单元测试里面一个业务流程是如何测试的。

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:org/activiti/spring/test/junit4/springTypicalUsageTest-context.xml")
public class MyBusinessProcessTest {
@Autowired
private RuntimeService runtimeService;
@Autowired
private TaskService taskService;
@Autowired
@Rule
public ActivitiRule activitiSpringRule;
@Test
@Deployment
public void simpleProcessTest() {
runtimeService.startProcessInstanceByKey("simpleProcess");
Task task = taskService.createTaskQuery().singleResult();
assertEquals("My Task", task.getName());
taskService.complete(task.getId());
assertEquals(0, runtimeService.createProcessInstanceQuery().count());
}
}

Note that for this to work, you need to define a org.activiti.engine.test.ActivitiRule bean in the Spring configuration (which is injected by auto-wiring in the example above).

注意：为了让这个能够工作，需要在Spring配置里面定义一个org.activiti.engine.test.ActivitiRule bean（在上例里通过auto-wiring 注入）。

网路冷眼@BlogJava 2010-12-05 01:30 发表评论

Activiti User Guide（Activiti用户指南)-Chapter 5. API

网路冷眼@BlogJava — Sat, 04 Dec 2010 17:27:00 GMT

Chapter 5. API

Table of Contents

Engine API（引擎API ）
Exception strategy（异常处理策略）
Unit testing（单元测试）
The process engine in a webapplication（在Web应用里的流程引擎）
Process Virtual Machine API（流程虚拟机API）
Expressions（表达式）

Engine API（引擎API ）

The engine API is the most common way of interacting with Activiti. The central starting point is the ProcessEngine, which can be created in several ways as described in theconfiguration section. From the ProcessEngine, you can obtain the various services that contain the workflow/BPM methods. ProcessEngine and the services objects are thread safe. So you can keep a reference to 1 of those for a whole server.

引擎API是与Activiti交互的最公共的方式。 ProcessEngine是中心启动点。如在 configuration section章节里描述的那样，它可以用几种方法建立。从 ProcessEngine 里能够获得包括工作流/BPM方法的各种各样的服务。因为ProcessEngine和服务对象是线程安全的，所以能够为整个服务器范围保留这些服务的引用为1。

ProcessEngine processEngine = new ProcessEngineBuilder()
.configureFromPropertiesResource(configurationResource)
.buildProcessEngine();
RuntimeService runtimeService = processEngine.getRuntimeService();
RepositoryService repositoryService = processEngine.getRepositoryService();
TaskService taskService = processEngine.getTaskService();
ManagementService managementService = processEngine.getManagementService();
IdentityService identityService = processEngine.getIdentityService();
HistoryService historyService = processEngine.getHistoryService();
FormService formService = processEngine.getFormService();

The names of the service are quite self-explanatory. For detailed information on the services and the engine API, see the javadocs.

服务名是自解释的，相当明了。要了解服务和引擎API的详情，参见 the javadocs.

Exception strategy（异常处理策略）

The base exception in Activiti is the org.activiti.engine.ActivitiException, an unchecked exception. This exception can be thrown at all times by the API, but 'expected' exceptions that happen in specific methods are documented in the the javadocs. For example, an extract from TaskService:

Activiti的基本异常是org.activiti.engine.ActivitiException, 一个unchecked异常。尽管在所有时间API都可抛出这个异常，但是某些方法产生'expected'异常。在 the javadocs里面对这种异常进行了文档化。例如，下面是一个从 TaskService 抽取一段代码：

 /**
* Called when the task is successfully executed.
* @param taskId the id of the task to complete, cannot be null.
* @throws ActivitiException when no task exists with the given id.
*/
void complete(String taskId);

In the example above, when an id is passed for which no task exists, an exception will be thrown. Also, since the javadoc explicitly states that taskId cannot be null, anActivitiException will be thrown when null is passed.

在上例，当传递一个不存在的任务的id，将会抛出一个异常。当然，javadoc 明明白白说明taskId不能为null，当传递null时，将抛出 ActivitiException 。

Even though we want to avoid a big exception hierarchy, the following subclasses were added which are thrown in specific cases:

尽管我们竭力避免一个庞大的异常层次体系，但还是在特殊情况下增加了如下的子类。

ActivitiWrongDbException: Thrown when the Activiti engine discovers a mismatch between the database schema version and the engine version.

ActivitiWrongDbException: 当Activiti引擎发现数据库结构版本和引擎版本之间不匹配时，将抛出这个异常。
ActivitiOptimisticLockingException: Thrown when an optimistic locking occurs in the datastore caused by concurrent access of the same data entry.

ActivitiOptimisticLockingException: 当数据库里由对相同的数据项并发访问导致乐观锁定时发生。

Unit testing（单元测试）

Business processes are an integral part of software projects and they should be tested in the same way normal application logic is tested: with unit tests. Since Activiti is an embeddable Java engine, writing unit test for business processes is as simple as writing regular unit tests.

业务流程是软件项目的一个集成部分，那么应当采用正常应用逻辑测试：采用单元测试。因为Activiti是一个嵌入式Java引擎，所以编写业务流程的单元测试像编写正常的单元测试一样简单。

Activiti supports both Junit versions 3 and 4 style of unit testing. In the Junit 3 style, the org.activiti.engine.test.ActivitiTestCase must be extended. This will make the processEngine and the services available through protected member fields. In the setup() of the test, the processEngine will be initialized by default with the activiti.cfg.xmlresource on the classpath. To specify a different configuration file, override the getConfigurationResource() method. Process engines are be cached statically over multiple unit tests when the configuration resource is the same.

Activiti支持单元测试的Junit版本3和4风格。在Junit 3风格里，必须扩展org.activiti.engine.test.ActivitiTestCase。这将使得通过保护成员字段获得流程引擎和服务。在测试的setup()里，缺省地流程引擎将通过classpath上的 activiti.cfg.xml 资源初始化流程引擎。为了指定不同的配置文件，覆盖 getConfigurationResource() 方法。当配置资源是相同时，流程引擎静态地缓存多个单元测试。

By extending ActivitiTestCase, you can annotate test methods with org.activiti.engine.test.Deployment. Before the test is run, a resource file of the formtestClassName.testMethod.bpmn20.xml in the same package as the test class, will be deployed. At the end of the test, the deployment will be deleted, including all related process instances, tasks, etc. The Deployment annotation also supports setting the resource location explicitly. See the Javadocs for more details.

通过扩展 ActivitiTestCase ，你能用org.activiti.engine.test.Deployment标注测试方法。在运行测试以前，将同一包里部署的 testClassName.testMethod.bpmn20.xml作为测试类。在测试结束，将删除包括所有相关的流程实例，任务等等部署。Deployment 标注也支持显式设置资源的位置。详情参见 the Javadocs。

Taking all that in account, a Junit 3 style test looks as follows.

将上面所有的情况考虑进去，Junit 3风格的测试方式如下所示。

public class MyBusinessProcessTest extends ActivitiTestCase {
@Deployment
public void testSimpleProcess() {
runtimeService.startProcessInstanceByKey("simpleProcess");
Task task = taskService.createTaskQuery().singleResult();
assertEquals("My Task", task.getName());
taskService.complete(task.getId());
assertEquals(0, runtimeService.createProcessInstanceQuery().count());
}
}

To get the same functionality when using the Junit 4 style of writing unit tests, the org.activiti.engine.test.ActivitiRule Rule must be used. Through this rule, the process engine and services are available through getters. As with the ActivitiTestCase (see above), including this Rule will enable the use of the org.activiti.engine.test.Deploymentannotation (see above for an explanation of its use and configuration) and it will look for the default configuration file on the classpath. Process engines are statically cached over multiple unit tests when using the same configuration resource.

当使用Junit 4风格编写单元测试时，为了获得相同的功能，必须使用 org.activiti.engine.test.ActivitiRule 规则。采用这个规则，通过getter获得流程引擎和服务。采用 ActivitiTestCase（如上），包括使用 org.activiti.engine.test.Deployment （它的使用和配置如上）标注的这个规则，它将在classpath上寻找缺省的配置。当使用相同配置资源时，流程引擎静态地缓存多个单元测试。

Following code snippet shows an example of using the Junit 4 style of testing and the usage of the ActivitiRule.

下面代码片段展示了采用的Junit 4风格的测试和 ActivitiRule用法的示例。

public class MyBusinessProcessTest {
@Rule
public ActivitiRule activitiRule = new ActivitiRule();
@Test
@Deployment
public void ruleUsageExample() {
RuntimeService runtimeService = activitiRule.getRuntimeService();
runtimeService.startProcessInstanceByKey("ruleUsage");
TaskService taskService = activitiRule.getTaskService();
Task task = taskService.createTaskQuery().singleResult();
assertEquals("My Task", task.getName());
taskService.complete(task.getId());
assertEquals(0, runtimeService.createProcessInstanceQuery().count());
}
}

The process engine in a webapplication（在Web应用里的流程引擎）

The ProcessEngine is a thread-safe class and can easily be shared among multiple threads. In a webapplication, this means it is possible to create the process engine when the container boots and shut down the engine when the container goes down.

ProcessEngine 是一个线程安全的类并能在多个线程里面轻易共享。在一个Web应用里面，这意味着当容器引导和关闭引擎时，可能建立这个流程引擎。

The following code snippet how this is done in a regular Servlet environment, using a ServletContextListener:

下列代码通过使用 ServletContextListener，展示了在一个普通的 Servlet 环境下如何完成这个工作的。

public class ProcessEnginesServletContextListener implements ServletContextListener {
public void contextInitialized(ServletContextEvent servletContextEvent) {
ProcessEngines.init();
}
public void contextDestroyed(ServletContextEvent servletContextEvent) {
ProcessEngines.destroy();
}
}

The contextInitialized will delegate to ProcessEngines.init(). That will look for activiti.cfg.xml resource files on the classpath, and create a ProcessEngines for the given configurations (eg. multiple jars with a configuration file). If you have multiple such resource files on the classpath, make sure they all have different names. When the process engine is needed, it can be fetched using

将contextInitialized委托给 ProcessEngines.init()。它将在classpath上寻找 activiti.cfg.xml 资源文件，并且为给定的配置建立 ProcessEngines。如果在classpath上具有多个如此的资源文件，确保它们都具有不同的名字。当需要流程引擎时，它将采用下面的方法来取得

ProcessEngines.getDefaultProcessEngine()

或

ProcessEngines.getProcessEngine("myName");

Of course, it is also possible to use any of the variants of creating a process engine, as described in the configuration section.

当然，采用建立流程引擎的变体也是可能的。如 configuration section所示。

The contextDestroyed of the context-listener delegates to ProcessEngines.destroy(). That will properly close all initialized process engines.

context-listener 的contextDestroyed 委托给ProcessEngines.destroy()

。那将正常关闭所有以初始化的流程引擎。

Process Virtual Machine API（流程虚拟机API）

The API exposes the POJO core of the Process Virtual Machine. Reading and playing with it is interesting for education purposes to understand the internal workings of Activiti. And the POJO API can also be used to build new process languages.

流程虚拟机（Process Virtual Machine ）API暴露流程虚拟机的POJO核心。为了理解Activiti的内部工作机制的教育目的，阅读并把玩API是有趣的。并且POJO API也能用来构建新的流程语言。

For example:

例如：

PvmProcessDefinition processDefinition = new ProcessDefinitionBuilder()
.createActivity("a")
.initial()
.behavior(new WaitState())
.transition("b")
.endActivity()
.createActivity("b")
.behavior(new WaitState())
.transition("c")
.endActivity()
.createActivity("c")
.behavior(new WaitState())
.endActivity()
.buildProcessDefinition();
PvmProcessInstance processInstance = processDefinition.createProcessInstance();
processInstance.start();
PvmExecution activityInstance = processInstance.findExecution("a");
assertNotNull(activityInstance);
activityInstance.signal(null, null);
activityInstance = processInstance.findExecution("b");
assertNotNull(activityInstance);
activityInstance.signal(null, null);
activityInstance = processInstance.findExecution("c");
assertNotNull(activityInstance);

Expressions（表达式）

Activiti uses UEL for expression-resolving. UEL stands for Unified Expression Language and is part of the EE6 specification ()see the EE6 specification for detailed information). To support all features of latest UEL spec on ALL environements, we use a modified version of JUEL.

Activiti使用UEL进行表达式解析。UEL代表统一表达式（Unified Expression Language ），它是JAVA EE 6规范（ the EE6 specification ）的一部分。为了在所有环境支持最新的UEL规范，我们采用了JUEL的修改版本。

Expressions can be used in for example Java Service tasks, Execution Listeners, Task Listeners and Conditional sequence flows. Although there are 2 types of expressions, value-expression and method-expression, activiti makes abstraction of this and they can both be used where an expression is needed.

表达式能够在下列示例中使用： Java Service tasks, Execution Listeners, Task Listeners 和 Conditional sequence flows。尽管存在两种表达式：值表达式和方法表达式。但是，Activiti对此进行了抽象，在需要表达式的地方两者均可使用。

Value expression: resolves to a value. By default, all process variables are available to use. Also all spring-beans (if using Spring) are available to use in expressions. On top of that, the DelegateExecution is also available in the expression-context and can be accessed using the name execution. Since the execution is exposed as execution, all variables and spring-beans with name execution are hidden and cannot be used in an expression. Some examples:

值表达式（Value expression）: 解析为一个值。缺省地，所有的流程均可使用。表达式里也可使用所有的spring bean（如果使用Spring）。在此之上，在表达式上下文里也可获得DelegateExecution。因为，执行暴露为execution，带有名称execution的所有变量和spring-beans将被隐藏，并且不能在表达式里使用。例如：
```
${myVar}
    ${myBean.myProperty}
```
Method expression: invokes a method, with or without parameters. When invoking a method without parameters, be sure to add empty parentheses after the method-name. The passed parameters can be literal values or expressions that are resolved themselves. Examples:

方法表达式：调用一个方法，带不带参数均可。当调用没有参数的方法，确保在方法名之后加入空括号。这些传入的参数可以字面值或者被解析解释的表达式。例如：

Method expression:

方法表达式：
```
${printer.print()}
    ${myBean.addNewOrder('orderName')}
    ${myBean.doSomething(myVar, execution)}
    
```

Note that these expressions support resolving primitives (incl. comparing them), beans, lists, arrays and maps.

注意这些表达式支持解析原型（包括对它们进行比较），beans，列表，数组和map.

For more concrete usage and examples, check out Expressions in Spring, Java Service tasks, Execution Listeners, Task Listeners or Conditional sequence flows.

为了更多的具体的用法和示例，请浏览 Expressions in Spring，Java Service tasks，Execution Listeners， Task Listeners 或者Conditional sequence flows。

网路冷眼@BlogJava 2010-12-05 01:27 发表评论

Activiti User Guide（Activiti用户指南)-Chapter 6. Deployment（部署）

网路冷眼@BlogJava — Sat, 04 Dec 2010 17:23:00 GMT

Chapter 6. Deployment（部署）

Table of Contents

Business archives（业务档案）
Java classes（Java类）
Deploying programmatically（编程式部署）
Deploying with ant（以ant方式部署）
Deploying with Activiti Probe（以Activiti Probe部署)
Versioning of process definitions（流程定义的版本管理）

Business archives（业务档案）

To deploy processes, they have to be wrapped in a business archive. A business archive is the unit of deployment to an Activiti Engine. Basically a business archive is equivalent to a zip file. It can contain BPMN 2.0 processes, task forms, rules and any other type of file. In general, a business archive contains a collection of named resources.

为了部署流程，必须将流程打包为流程档案。一个流程档案是Activiti引擎的部署单元。基本来说，一个流程档案等价于一个zip文件。它包含了BPMN 2.0流程，任务表单，规则和其它文件类型。通常，流程档案包含一个命名资源的集合。

When a business archive is deployed, it is scanned for BPMN files with a extension. Each of those will be parsed and potentially contains multiple process definitions.

当部署业务档案时，以.bpmn20.xml 扩展名为的BPMN文件方式扫描来扫描它。每个BMPN文件被扫描，它包含多个流程定义。

Note that Java classes present in the business archive will not be added to the classpath. All custom classes used in process definitions in the business archive (for example Java service tasks or event listener implementations) should be present on the activiti-engine's classpath in order to run the processes.

注意业务档案存在的Java类将不会加入到classpath。为了运行流程，业务档案里面的流程定义的所有定制类（例如Java服务类或者事件监听器实现）应当包含在Activiti引擎的classpath里面。

Java classes（Java类）

All custom classes that are used in your process (eg. JavaDelegates used in servicetaks or event-listeners, TaskListeners, ...) should be present on the engine's classpath when an instance of the process is started. It's not nessecairy to have those classes on the classpath when deploying the process-definition into the engine.

当启动一个流程实例（例如serviceTask或者event-listener，TaskListener）时，定义在流程里面的所有定制类应当包含在引擎的classpath上面。当把流程定义部署到引擎时，不必将哪些类放到classpath上。

When you are using the demo setup and you want to add your custom classes, you should add a jar containing your classes to the activiti-rest webapp lib. Don't forget to include the dependencies of your custom classes (if any) as wel. This is the same location where the activiti-engine jar is located. You can find this folder inside your distro at the folowing location:

当正在使用demo setup并要加入你自己的定制类时，你应当将包含这些类的jar包添加至activiti-rest webapp lib里面。也不要忘记包含定制类的依赖包（如果有的话），这个和activiti-engine.jar位置相同。在发行版本中的如下位置找到这个文件夹：

${activiti distro}/apps/apache-tomcat-6.0.29/webapps/activiti-rest/lib/

Deploying programmatically（编程式部署）

Deploying a business archive from a zip file can be done like this:

以如下方式完成从zip文件来部署流程档案：

String barFileName = "path/to/process-one.bar";
ZipInputStream inputStream = new ZipInputStream(new FileInputStream(barFileName));
repositoryService.createDeployment()
.name("process-one.bar")
.addZipInputStream(inputStream)
.deploy();

It's also possible to build a deployment from individual resources. See javadocs for more details.

也可能从单个资源来构建部署。详情参见javadoc。

Deploying with ant（以ant方式部署）

To deploy a business archive with ant, first the deploy-bar task needs to be defined. Make sure that the configuration jar is on the classpath, as well as the Activiti jar and all its dependencies:

为了以ant方式来部署业务档案，首先需要定义 deploy-bar 任务。确保配置jar包，Activiti jar及其所有的依赖都在classpath路径里面。

Deploying with Activiti Probe（以Activiti Probe部署)

It's possible to deploy process definitions through probe, this is described in Activiti Probe - Deployments.

通过Probe也可以部署流程定义，这在Activiti Probe - Deployments里面描述。

Versioning of process definitions（流程定义的版本管理）

BPMN doesn't have a notion of versioning. And that is good because the executable BPMN process file will probably live in an SVN repository as part of your development project. Versions of process definitions are created during deployment. During deployment, Activiti will assign a version to the ProcessDefinition before it is stored in the Activiti DB.

BPMN没有版本管理的概念。这是好事，因为可执行的BPMN流程文件将作为开发项目的一部分驻留在一个SVN的仓库里，所以在部署时，才建立流程定义的版本。在部署期间，在ProcessDefinition 保存到Activiti DB之前，Activiti将为它分布一个版本号。

For each process definition in a business archive the following steps are performed to initialize the properties key, version, name and id:

对于业务档案里的每个流程定义，执行下列步骤初始化 key, version, name 和 id 这些属性：

The process id attribute is used as the process definition key property

流程id 属性用作为流程定义的key特性
The process name attribute is used as the process definition name property. If the name attribute is not specified, then id attribute is used as the name.

流程name 属性用作为流程定义的特性 name 。如果没有指定name属性，那么id属性作为名称使用。
The first time a process with a particular key is deployed, version 1 is assigned. For all subsequent deployments of process definitions with the same key, the version will be set 1 higher then the max currently deployed version. The key property is used to distinct process definitions.

当一个带有特殊key的流程第一次部署时，版本分配为1。对带有相同key的流程定义，在后续部署时，每部署一次，在当前最大部署版本号上加1。key特性用来区分流程定义。
The id property is set to {processDefinitionKey}:{processDefinitionVersion}

id特性设置为{processDefinitionKey}:{processDefinitionVersion}

网路冷眼@BlogJava 2010-12-05 01:23 发表评论

Activiti User Guide（Activiti用户指南)-Chapter 7. BPMN

网路冷眼@BlogJava — Sat, 04 Dec 2010 17:19:00 GMT

摘要: Chapter 7. BPMN Table of Contents What is BPMN?（何为BPMN） Examples（示例） Defining a process（定义一个流程） Getting started: 10 minute tutorial（开始：10分钟教程） Use case（用例） Process diagram（流程图） XML representat... 阅读全文

网路冷眼@BlogJava 2010-12-05 01:19 发表评论

Activiti User Guide（Activiti用户指南)-Chapter 08. Forms（表单）

网路冷眼@BlogJava — Sun, 28 Nov 2010 11:49:00 GMT

Chapter 08. Forms（表单）

Table of Contents

Build-in form rendering（内置表单渲染）
External form rendering（外部表单渲染）
Form properties（表单属性）

Activiti provides a convenient and flexible way to add forms for the manual steps of your business processes. We support two strategies to work with forms: Build-in form rendering and external form rendering

Activiti为你的业务流程的手动步骤提供了一个方便和灵活的增加表单的方法。我们为表单的工作支持两种策略：内置渲染和外部渲染。

Build-in form rendering（内置表单渲染）

Build-in form rendering is the simplest to get started with. We'll explain it with an example.

最简单的开始的方式是内置表单的渲染。我们将以一个示例进行解释。

The demo setup script installs the vacationRequest business process as an example of using task forms through Activiti Explorer. Please check the example for the complete source code. The business process diagram looks like this:

作为通过Activiti Explorer使用任务表单的一个示例，demo setup脚本安装了业务流程。请检查示例的完整的源代码。业务流程图如下所示：

To use the build-in rendering, the form files have to be included in the deployment. That can be done programmatically like this:

为了使用内置的渲染，在部署中必须包括表单文件。通过如下的编程方式来完成：

Deployment deployment = repositoryService.createDeployment()
.addClasspathResource("org/activiti/examples/taskforms/VacationRequest.bpmn20.xml")
.addClasspathResource("org/activiti/examples/taskforms/approve.form")
.addClasspathResource("org/activiti/examples/taskforms/request.form")
.addClasspathResource("org/activiti/examples/taskforms/adjustRequest.form")
.deploy();

Or that can be done with an ant task by first building a business archive zip file that contains the process and forms like above and then deploy it like this:

或者，首先通过构建一个包含如上所示的流程和表单的业务档案zip文件，然后，如下部署这个文件。这些通过一个ant任务来完成。

The BPMN 2.0 specification does not specify how tasks or task forms should be rendered, as such forms are defined using Activiti specific constructs. There is the attributeuserTasksthat can be specified on startEvents and userTasks.

BPMN 2.0 规范并没有指明任务或者任务表单应当如何渲染，使用Activiti特定的构造型来定义如此的表单。在和 startEvents和 userTask之上能够制定这个属性 userTask。

activiti:formKey="org/activiti/examples/taskforms/request.form" />

activiti:formKey="org/activiti/examples/taskforms/approve.form" >

Vacation request by ${employeeName}

...

The activiti:formKey attribute can contain any text value which you use to identify your form in case you do your own form rendering. But the build-in form rendering expects the activiti:formKey to be a reference to a resource in the same business archive (= deployment).

当你采用自己的渲染时，属性能够包含你所用来表明你的表单的任何文本值。但是内置的表单渲染器猜想activiti:formKey 引用到同一业务档案（=部署）的一个资源。

Activiti Explorer uses the build-in form rendering engines. Currently, there is only one form rendering engine configured, which is Juel. So it resolves resource files as a Juel expression and the resulting HTML String is sent to the client. In the future, we hope to add a FreeMarker form engine, but that will require more library dependencies so we opt for Juel as the default form engine.

Activiti Explorer使用内置的表单渲染引擎。当前，只有一个以配置的表单渲染器。这个渲染器叫Juel。所以它把资源文件解析为a Juel expression 。解析结果 HTML String 被发送到客户。未来，我们希望加入表单引擎，但是它需要更多的库依赖，所以我们优选把Juel作为缺省的表单引擎。

Here is the rendered form defined in resource org/activiti/examples/taskforms/request.form. Its a form to capture the data necessary to start a new process instance.

这里是在资源org/activiti/examples/taskforms/request.form里定义的渲染过的表单。它是一个捕获启动一个新的流程实例所必须的数据的表单。

And here is the contents of that form file:

这里是那个表单文件的内容：

Vacation Request
Employee Name:



Number of days:



First day of vacation:



Date of return to work:



Vacation pay requested
 Vacation pay requested

Motivation:

The hidden fields provide extra information to the Activiti Explorer client application. So the Javascript in the browser will use the hidden fields and enhance the corresponding input fields. For example, it's possible to specify that a certain text field is a date and Activiti Explorer will add a date picker.

隐藏字段提供Activiti Explorer 客户应用程序的额外信息。这样浏览器将使用这些隐藏字段并加强相应输入字段。例如，制定某一文本字段是date，Activiti Explorer 将加入一个日期选取器是可能的。

Variable names must be camel-cased.

变量名必须是骆驼方式的。
The default type of the process variable that is stored is string. Use a hidden field with the input variable name followed by '_type' to define the type (and hence also the conversion from the HTML input to the variable):

保存的流程变量的缺省值是 string。使用一个输入变量后面跟有'_type' 的隐藏字段来定义类型（这样将HTML的输入约定为这个变量）：
Currently supported are String, Integer, Boolean, Date.

当前支持的类型为：String, Integer, Boolean, Date。
Input variables can be made required by adding a hidden field with the input variable name followed by '_required':

通过使用一个输入变量后面跟有'_type' 的隐藏字段来产生必须的输入变量。
In Activiti-Explorer, the Date type validates to ISO 8601 (YYYY-MM-DD). This field will also use any native date picker tools in the browser (using the HTML5 input type="date") and fall back on a pop-up date picker using the YUI calendar widget. It is, of course still possible to manually enter your own date, which is validated as you type.

在Activiti-Explorer里，Date类型用ISO 8601 (YYYY-MM-DD)来验证。这个字段也将使用浏览器里的任何本地日期拾取器（使用HTML5的input type="date"）。通过YUI calendar widget返回一个弹出日期拾取器。当然，也可能手动输入你自己的日期，由你输入的验证方法。
The Integer form field in the demo has also been enhanced to make use of HTML5 input type=number, which provides native validation and custom input fields in the supported browser(s), although Activiti-Explorer provides client side validation as well.

在demo里面的Integer表单字段也已经被加强产生HTML 5 input type=number。尽管Activiti-Explorer 提供客户端验证，但是在可支持HTML5的浏览器也提供内置验证和定制输入字段。

It is expected that Activiti Explorer in the future will use FormService.getStartFormData instead of these hidden field values to enhance the form input fields. That's why the hidden fields part is marked as experimental.

可以预料， Activiti Explorer 在未来将会使用 FormService.getStartFormData来代替这些隐藏字段值来加强表单输入字段。那是为什么隐藏字段被标记为实验性的原因。.

Use FormService.getRenderedStartForm to get the rendered form string with the API:

通过API，使用 FormService.getRenderedStartForm 来获取渲染表单字符串。

String FormService.getRenderedStartForm(String processDefinitionId)

Use FormService.submitStartFormData to start a new process instance with the properties that the user provided as input for the form:

以一个用户为表单输入的属性，采用 FormService.submitStartFormData来启动一个新的流程实例。

ProcessDefinition FormService.submitStartFormData(String processDefinitionId, Map properties)

To learn about the difference between starting a new process instance with this FormService method in comparison with the ProcessInstance RuntimeService.startProcessInstanceById(String processDefinitionId), read the section called “Form properties（表单属性）”

为了了解和 ProcessInstance RuntimeService.startProcessInstanceById(String processDefinitionId)比较，以这个 FormService 方法启动一个新的流程实例之间的差异，请参见 read the section called “Form properties（表单属性）” 。

After submitting the form, a process instance is started and now someone of the management team needs to handle the request.

在提交这个表单之后，一个流程实例被启动。管理小组的有些人需要处理这个请求。

The corresponding user task has a task form attached to it, which uses the variables which were given as input by the employee in the start form. These variables are referenced as expressions and are resolved at runtime to their text representation.

相关的用户任务具有和它绑定的任务表单。。这些作为表达式引用，在运行期解析为它们的文本表示。

Vacation Approval

${employeeName} would like to take ${numberOfDays} day(s) of vacation.


Motivation: ${vacationMotivation}


Do you approve this?





Motivation:

The manager will now indicate in the form whether the vacation request is approved or not, by selecting the appropriate input in the form.

通过在表单里面选择合适的输入，经理将在表单里面指示休假请求是否批注。

The result is stored in as a process variable, which is then used in the exclusive gateway after the form is submitted.

结果作为一个流程变量保存，在表单提交之后在总网关里使用。


${!vacationApproved}

Depending on the input of the manager in the user task, the employee will now get a new task in his personal task list, stating that the vacation request was disapproved and it needs can be refilled if wanted.

依赖在用户任务里面经理的输入，雇员现在将在他的个人任务列表里面得到一个新的任务。说明休假请求被拒绝。如果再想休假，需要重填。

The employee can now choose to resend the vacation request, which brings process execution again in the user task for the manager. Or the employee can throw away the request, ending the process.

雇员现在能够选择重发休假请求。这样让经理的用户流程重新执行。或者雇员可以抛弃这个请求，终止这个流程。

Adjust vacation Request

Your manager has disapproved your vacation request for ${numberOfDays} days.
Reason: ${managerMotivation}

Number of days:

External form rendering（外部表单渲染）

Above we showed the build-in task form rendering. But the API also allows for you to perform your own task form rendering outside of the Activiti Engine. These steps explain the hooks that you can use to render your task forms yourself.

上面我们展示了内置的任务表单渲染。但是API也允许你从 Activiti Engine之外执行你自己的任务表单渲染器。这些步骤解释了你能使用的渲染你的任务表单的钩子。

Essentially, all the data that's needed to render a form is assembled in one of these two service methods: StartFormData FormService.getStartFormData(String processDefinitionId) andTaskFormdata FormService.getTaskFormData(String taskId).

必要的，渲染一个表单所需的所有数据被组装在这连个服务方法的其中之一：StartFormData FormService.getStartFormData(String processDefinitionId) 和TaskFormdata FormService.getTaskFormData(String taskId)

Submitting form properties can be done with ProcessInstance FormService.submitStartFormData(String processDefinitionId, Map properties) and void FormService.submitStartFormData(String taskId, Map properties)

通过ProcessInstance FormService.submitStartFormData(String processDefinitionId, Map properties) 和 void FormService.submitStartFormData(String taskId, Map properties)方法能够完成提交表单的属性。

To learn about how form properties map to process variables, see the section called “Form properties（表单属性）”

为了学习表单属性如何映射到流程变量，参见the section called “Form properties（表单属性）” 。

You can just stick any form template resource inside the business archives that you deploy (in case you want to store them versioned with the process). It will be available as a resource in the deployment. You can use the String ProcessDefinition.getDeploymentId() and InputStream RepositoryService.getResourceAsStream(String deploymentId, String resourceName); to obtain the file that you included in the deployments. That could be your form template definition file.

Btw, you can use this capability of accessing the deployment resources beyond task forms for any other purposes as well.

随便，为了其它任何目的，你能使用出除了任务表单之外访问部署资源的能力。

The attribute is exposed by the API through String FormService.getStartFormData(String processDefinitionId).getFormKey() and String FormService.getTaskFormData(String taskId).getFormKey(). You could for instance store a generic key in the form attribute and apply an algorithm or transformation to get to the actual template that needs to be used. This might be handy when you want to render different forms for different UI technologies like e.g. one form for usage in a web app of normal screen size, one form for mobile phone's small screens and maybe even a template for a IM form or an email form.

属性通过 String FormService.getStartFormData(String processDefinitionId).getFormKey() 和 String FormService.getTaskFormData(String taskId).getFormKey()被API 暴露。你可能为实例在表单里面保存一个通用键，应用一个算法或者转换来得到实际所需的模板。当你想从不同的UI技术渲染不同的表单，这可能方便。例如，一个表单用来在正常屏幕大小的Web应用使用；一个表单在手机小屏幕使用，甚至是IM表单或者email表单的一个模板。 Form properties（表单属性） All information relevant to a business process is either included in the process variables themselves or referenced through the process variables. Activiti supports complex Java objects to be stored as process variables like Serializable objects, JPA entities or whole XML documents as Strings. 与业务流程相关的所有信息既可包含流程变量自己，也可通过流程变量包括它们的引用。Activiti支持将复杂的Java对象保存为像 Serializable 对象，JPA实体或者作为String 的整个XML文档的流程变量。 Starting a process and completing tasks is where people are involved into a process. Communicating with people requires forms to be rendered in some UI technology. In order to facilitate multiple UI technologies easy, the process definition can includes the logic of transforming of the complex Java typed objects in the process variables to aMap of properties. 启动一个流程和完成任务是人们介入到流程的地方。和人通信需要采用一些UI技术来渲染表单。为了让多个UI技术和平共处，流程定义能够包含转化逻辑：将流程变量里面的复杂对象传化为一个属性的Map 。 Any UI technology can then build a form on top of those properties. The properties can provide a dedicated (and more limited) view on the process variables. The properties needed to display a form are available in the FormData returnvalues of StartFormData FormService.getStartFormData(String processDefinitionId) and TaskFormdata FormService.getTaskFormData(String taskId). Those properties are obtained from the process variables. 然后任何UI技术能在这些属性之上构建一个表单。这些属性能在这些流程变量之上提供一个专有（有更多限制）视图。显示一个表单所需的属性在返回StartFormData FormService.getStartFormData(String processDefinitionId) 和 TaskFormdata FormService.getTaskFormData(String taskId). 的FormData 值里。这些属性从流程变量取得。 By default, the build-in form engines, will 'see' the properties as well as the process variables. So there is no need to declare task form properties if they match 1-1 with the process variables. For example, with the following declaration: 缺省地，内置的表单引擎，将‘看见‘属性，正如看见流程变量一样。所以，如果任务表单属性和流程变量是1-1的匹配关系，没有必要对它声明。 A form will see all the process variables but the formService.getStartFormData(String processDefinitionId).getFormProperties() will be empty. In the above case, all the submitted properties will be stored as process variables. This means that by simply adding a new inputfield in the form, a new variable can be stored. 表单将看见所有的流程变量，而 formService.getStartFormData(String processDefinitionId).getFormProperties() 将为空。 Properties are derived from process variables, but they don't have to be stored as process variables. For example, a process variable could be a JPA entity of class Address. And a form property StreetName used by the UI technology could be linked with an expression #{address.street} 尽管属性从流程变量继承而来，但是它们不必存储为流程变量。例如，一个流程变量可能是一个类Address的JPA实体。并且，由UI技术使用的表单属性 StreetName 能够和一个表达式#{address.street} 连接。 Analogue, the properties that a user is supposed to submit in a form can be stored as a process variable or as a nested property in one of the process variables with a UEL value expression like e.g. #{address.street} . Analogue the default behavior of properties that are submitted is that they will be stored as process variables unless a formProperty declaration specifies otherwise. Also type conversions can be applied as part of the processing between form properties and process variables. 类型约定能够应用作为表单属性和流程变量之间处理环节的部分。 For example: 例如： Form property room will be mapped to process variable room as a String. 表单属性 room ：将作为一个String映射为流程变量 room。 Form property duration will be mapped to process variable duration as a java.lang.Long 表单属性 duration ：将作为一个java.lang.Long映射为流程变量 duration。 Form property speaker will be mapped to process variable SpeakerName. It will only be available in the TaskFormData. If property speaker is submitted, an ActivitiException will be thrown. Analogue, with attribute readable="false", a property can be excluded from the FormData, but still be processed in the submit. 表单属性会将 speaker 映射为流程变量 SpeakerName。他只能在TaskFormData获得。如果提交属性speaker，那么将会抛出ActivitiException。模拟地，带有属性 readable="false"，尽管一个属性将会从 FormData排除在外，但是在提交里面仍将处理。 Form property street will be mapped to Java bean property street in process variable address as a String. And required="true" will throw an exception during the submit if the property is not provided. 表单属性 street在流程变量里面将会作为String映射为Java bean 属性 street 。如果没有提供这个属性，在提交期间， required="true" 将抛出一个异常。 It's also possible to provide type meta data as part of the FormData that is returned from methods StartFormData FormService.getStartFormData(String processDefinitionId) andTaskFormdata FormService.getTaskFormData(String taskId) 提供类型元数据作为从StartFormData FormService.getStartFormData(String processDefinitionId) 和 TaskFormdata FormService.getTaskFormData(String taskId)返回的FormData 的部分也是有可能的。 We support following form property types: 我们支持下列表单属性类型： string (org.activiti.engine.impl.form.StringFormType) long (org.activiti.engine.impl.form.LongFormType) enum (org.activiti.engine.impl.form.EnumFormType) date (org.activiti.engine.impl.form.DateFormType) For each form property declared, the following FormProperty information will be made available through List formService.getStartFormData(String processDefinitionId).getFormProperties() and List formService.getTaskFormData(String taskId).getFormProperties() 对于每个声明的表单属性，通过 List formService.getStartFormData(String processDefinitionId).getFormProperties() 和and List formService.getTaskFormData(String taskId).getFormProperties() 产生如下的 FormProperty信息。 public interface FormProperty { /** the key used to submit the property in {@link FormService#submitStartFormData(String, java.util.Map)} * or {@link FormService#submitTaskFormData(String, java.util.Map)} */ String getId(); /** the display label */ String getName(); /** one of the types defined in this interface like e.g. {@link #TYPE_STRING} */ FormType getType(); /** optional value that should be used to display in this property */ String getValue(); /** is this property read to be displayed in the form and made accessible with the methods * {@link FormService#getStartFormData(String)} and {@link FormService#getTaskFormData(String)}. */ boolean isReadable(); /** is this property expected when a user submits the form? */ boolean isWritable(); /** is this property a required input field */ boolean isRequired(); } For example: 例如： All that information is accessible through the API. The type names can be obtained with formProperty.getType().getName(). And even the date pattern is available withformProperty.getType().getInformation("datePattern") and the enumeration values are accessible with formProperty.getType().getInformation("values") 通过API来访问那个信息。通过formProperty.getType().getName() 获取类型名；通过formProperty.getType().getInformation("datePattern")获取时间模式；通过formProperty.getType().getInformation("values") 获取枚举值。网路冷眼@BlogJava 2010-11-28 19:49 发表评论



Activiti User Guide（Activiti用户指南)-Chapter 09. JPA
网路冷眼@BlogJava — Sun, 28 Nov 2010 11:39:00 GMT
Chapter 09. JPA
Table of Contents 
 Requirements（需求）  
Configuration（配置） 
  JPA using ProcessEngineBuilder（使用ProcessEngineBuilder的JPA）  
JPA using Spring（使用Sping的JPA）
 
Usage（用法） 
  Simple Example（简单示例）  
Query JPA process variables（查询流程变量）  
Advanced example using Spring beans and JPA（使用Spring beans和JPA的高级示例）
You can use JPA-Entities as process variables, allowing you to: 
你能使用作为流程变量的JPA-实体，允许: 

    
    Updating existing JPA-entities based on process variables, that can be filled in on a form in a userTask or generated in a serviceTask. 
    更新存在基于流程变量的JPA-实体，它被填充在userTask的表单里面，或者在serviceTask里面产生。
    
    
    Reusing existing domain model without having to write explicit services to fetch the entities and update the values 
    复用已存在的领域模型，不必编写显式获取这些实体和更新这些数值。
    
    
    Make decisions (gateways) based on properties of existing entities. 
    基于存在实体属性作决定（网关）
    
    
    ...
    

Requirements（需求）
Only entities that comply to the following are supported: 
只支持遵从下面标准的实体： 

    
    Entities should be configured using JPA-annotations, we support both field and property-access. Mapped super classes can also be used. 
    应当使用JPA-标注配置实体，我们支持字段和属性方法。也能够使用已映射的超类。
    
    
    Entity should have a primary key annotated with @Id, compound primary keys are not supported (@EmbeddedId and @IdClass). The Id field/property can be of any type supported in the JPA-spec: Primitive types and their wrappers (excluding boolean), String, BigInteger, BigDecimal, java.util.Date and java.sql.Date. 
    实体应当具有标注为@Id的主键，不支持组合主键 (@EmbeddedId and @IdClass)。Id 字段/属性能够是JPA规范里任何支持的类型:原子类型和它们的包装类（wrapper)（排除boolean），, String, BigInteger, BigDecimal, java.util.Date and java.sql.Date。
    

Configuration（配置）
To be able to use JPA-entities, the engine must have a reference to an EntityManagerFactory. When JPA is enabled on the engine, JPA-entities used as variables will be detected automatically and will be handled accordingly. 
为了能够使用JPA-实体，引擎必须具有一个到EntityManagerFactory的引用。当在引擎上启用了JPA，作为变量的JPA-实体将被自动检测并作相应的处理。 
JPA using ProcessEngineBuilder（使用ProcessEngineBuilder的JPA）
When creating the ProcessEngine using the ProcessEngineBuilder, the method enableJPA should be called. 
当使用 ProcessEngineBuilder建立 ProcessEngine 时，必须调用方法enableJPA 。
ProcessEngine engine = new ProcessEngineBuilder()
.configureFromPropertiesResource("activiti.properties")
.enableJPA(entityManagerFactory, true, true)
.buildProcessEngine();

This method accepts the following parameters:

这个方法接受下列参数：


    
    entityManagerFactory: An instance of javax.persistence.EntityManagerFactory that will be used to load the Entities and flushing the updates.
    
    entityManagerFactory: 一个javax.persistence.EntityManagerFactory的实例，用作载入实体并刷新更新。
    
    
    handleTransaction: Flag indicating that the engine should begin and commit/rollback the transaction on the used EntityManager instances. Set to false when Java Transaction API (JTA) is used.
    
    handleTransaction: 指示引擎应当开始和提交/回滚所使用 EntityManager的实例的事务标志。当使用时设置Java Transaction API (JTA) 为false。
    
    
    closeEntityManager: Flag indicating that the engine should close the EntityManager instance that was obtained from the EntityManagerFactory. Set to false when the EntityManageris container-managed (e.g. when using an Extended Persistence Context which isn't scoped to a single transaction').
    
    closeEntityManager: 指示引擎应当关闭从 EntityManagerFactory获得的实例 EntityManager 的标志。当EntityManager是容器托管的设置为false（例如，当使用不是作用到单个事物的扩展持久化上下文）
    

JPA using Spring（使用Sping的JPA）
The EntityManagerFactory should be set using the ProcessEngineFactoryBean, which is described in the section called “Configuration（配置）” As an example, we use OpenJPA as persistence-provider using a H2 datasource. The example below is only an extract from a spring configuration-file and only contains relevant beans.

应当使用 ProcessEngineFactoryBean设置EntityManagerFactory ，在the section called “Configuration（配置）”描述。作为示例，我们使用OpenJPA作为使用H2数据源的持久化提供者。如下的示例只从一个Spring配置文件提取出来，并包含了相关的bean.





















    
    jpaEntityManagerFactory: An reference to a bean implementing javax.persistence.EntityManagerFactory that will be used to load the Entities and flushing the updates.
    
    jpaEntityManagerFactory: 一个指向实现javax.persistence.EntityManagerFactory的bean的引用，用来载入和刷新更新。
    
    
    jpaHandleTransaction: Flag indicating that the engine should begin and commit/rollback the transaction on the used EntityManager instances. Set to false when Java Transaction API (JTA) is used.
    
    jpaHandleTransaction: 指示引擎应当开始和提交/回滚所使用 EntityManager的实例的事务标志。当使用时设置Java Transaction API (JTA) 为false。
    
    
    jpaCloseEntityManager: Flag indicating that the engine should close the EntityManager instance that was obtained from the jpaCloseEntityManager. Set to false when theEntityManager is container-managed (e.g. when using an Extended Persistence Context which isn't scoped to a single transaction').
    
    jpaCloseEntityManager:
    
    closeEntityManager: 指示引擎应当关闭从 EntityManagerFactory获得的实例 EntityManager 的标志。当EntityManager是容器托管的设置为false（例如，当使用不是作用到单个事物的扩展持久化上下文）。
    

Usage（用法）
Simple Example（简单示例）
Examples for using JPA variables can be found in JPAVariableTest. We'll explain JPAVariableTest.testUpdateJPAEntityValues step by step.

在 JPAVariableTest里能找到使用JPA变量的示例。将一步一步解释JPAVariableTest.testUpdateJPAEntityValues 。

First of all, we create a EntityManagerFactory for our persistence-unit, which is based on META-INF/persistence.xml. This contains classes which should be included in the persistence unit and some vendor-specific configuration.

首先，我们为我们的持久化单元建立 EntityManagerFactory ，这基于META-INF/persistence.xml。这包含了了持久化单元所需的类和一些数据库供应商相关的配置。

The EntityManagagerFactory is set on the engine to enable JPA support. Please note that this is done using a shortcut for testing purposes, and should actually be set properly using one of the methods described in the section called “Configuration（配置）”.

引擎设置 EntityManagagerFactory来支持JPA。请注意：基于测试目的，通过快捷方式来完成，实际上，通过使用在the section called “Configuration（配置）”描述的方法之一来合理设置。

We are using a simple entity in the test, having an id and String value property, which is also persisted. Before running the test, we create an entity and save this.

在测试里面，我们正使用一个简单实体。这个实体具有一个id和String 值属性。实体也要被持久化。在运行测试之前，我们建立一个实体并保存它。
@Entity(name = "JPA_ENTITY_FIELD")
public class FieldAccessJPAEntity {
@Id
@Column(name = "ID_")
private Long id;
private String value;
public FieldAccessJPAEntity() {
// Empty constructor needed for JPA
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
}

We start a new process instance, adding the entity as a variable. As with other variables, they are stored in the persistent storage of the engine. When the variable is requested the next time, it will be loaded from the EntityManager based on the class and Id stored.

我们启动一个新的流程实例，增加实体作为一个变量。和其它变量一样，它们保存在引擎的持久化存储区。当下次请求这个变量时，将从基于类和保存的Id的EntityManager载入。
Map variables = new HashMap();
variables.put("entityToUpdate", entityToUpdate);
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("UpdateJPAValuesProcess", variables);

The first node in our process definition contains a serviceTask that will invoke the method setValue on entityToUpdate, which resolves to the JPA variable we set earlier when starting the process instance and will be loaded from the EntityManager associated with the current engine's context'.

我们流程定义的第一个节点包含一个serviceTask。它将调用在 entityToUpdate之上的方法setValue 。 当启动这个流程实例时，它将解析我们先前设置的JPA变量。JPA变量从当前流程上下文关联的EntityManager 载入。


When the service-task is finished, the process instance waits in a userTask defined in the process definition, which allows us to inspect the process instance. At this point, theEntityManager has been flushed and the changes to the entity have been pushed to the database. When we get the value of the variable entityToUpdate, it's loaded again and we get the entity with it's value property set to updatedValue.

当服务任务完成时，流程实例在流程定义里定义的userTask。userTask允许我们检查这个流程实例。在这时，EntityManager 已经被刷新并且实体变更已经被推送到数据库。当我们获取变量entityToUpdate的值时，它再次载入。我们取得的 updatedValue的value 属性。
// Servicetask in process 'UpdateJPAValuesProcess' should have set value on entityToUpdate.
Object updatedEntity = runtimeService.getVariable(processInstance.getId(), "entityToUpdate");
assertTrue(updatedEntity instanceof FieldAccessJPAEntity);
assertEquals("updatedValue", ((FieldAccessJPAEntity)updatedEntity).getValue());

Query JPA process variables（查询流程变量）
You can query for ProcessInstances and Executions that have a certain JPA-entity as variable value. Note that only variableValueEquals(name, entity) is supported for JPA-Entities on ProcessInstanceQuery and ExecutionQuery. Methods variableValueNotEquals, variableValueGreaterThan, variableValueGreaterThanOrEqual, variableValueLessThan and variableValueLessThanOrEqual are unsupported and will throw an ActivitiException when an JPA-Entity is passed as value.

你能够查询 ProcessInstances 和 Execution具有某个作为变量值的JPA-bean。注意：对于在 ProcessInstanceQuery 和 ExecutionQuery上的JPA实体只支持 variableValueEquals(name, entity)。当JPA实体作为值传送时，不支持方法variableValueNotEquals, variableValueGreaterThan, variableValueGreaterThanOrEqual, variableValueLessThan和 and variableValueLessThanOrEqual 将抛出一个 ActivitiException异常。
 ProcessInstance result = runtimeService.createProcessInstanceQuery().variableValueEquals("entityToQuery", entityToQuery).singleResult();

Advanced example using Spring beans and JPA（使用Spring beans和JPA的高级示例）
A more advanced example, JPASpringTest, can be found in activiti-spring-examples. It describes the following simple use case:

一个更加高级的示例，JPASpringTest ，能够在activiti-spring-examples 找到。它描述了下列简单的用例:


    
    An existing Spring-bean which uses JPA entities already exists which allows for Loan Requests to be stored.
    
    使用已存在JPA实体的已存在的Spring-bean允许保存Loan Request.
    
    
    Using Activiti, we can use the existing entities, obtained through the existing bean, and use them as variable in our process.
    
    使用Activiti，我们能够使用存在的实体，通过存在的bean来获取这个实体，并在我们的流程里面以变量方式使用它们。
    
    Process is defined in the following steps:
    
    流程在下列步骤定义：
    
    
        
        Service task that creates a new LoanRequest, using the existing LoanRequestBean using variables received when starting the process (e.g. could come from a start form). The created entity is stored as a variable, using activiti:resultVariableName which stores the expression result as a variable.
        
        建立一个新的的服务任务，通过
        
        
        UserTask that allows a manager to review the request and approve/disapprove, which is stored as a boolean variable approvedByManager
        
        允许经理审阅请求并且批准/否决的UserTask，它作为一个布尔值approvedByManager保存。
        
        
        ServiceTask that updates the loan request entity so the entity is in sync with the process.
        
        因为ServiceTask更新贷款请求实体，所以这个实体和流程同步。
        
        
        Depending on the value of the entity property approved, an exclusive gateway is used to make a decision about what path to take next: When the request is approved, process ends, otherwise, an extra task will become available (Send rejection letter), so the customer can be notified manually by a rejection letter.
        
        依赖实体属性 approved的值，所使用的一个总开关下一步作出决策：当请求被批准，流程结束，否则，另外的任务将成为可能（发送拒绝函），这样通过拒绝函手动通知客户。
        
    
    

Please note that the process doesn't contain any forms, since it is only used in a unit test.

请注意这个流程不包括任何表单，因为它只是作为单元测试使用。















${loanRequest.approved}


${!loanRequest.approved}








Although the example above is quite simple, it shows the power of using JPA combined with Spring and parametrized method-expressions. The process requires no custom java-code at all (except for the Spring-bean off course) and speeds up development drastically.

尽管上例相当简单，但是它展示了组合Spring和参数化方法表达式JPA的威力。流程不需要任何Java代码（当然Spring是例外），并及大地加速了开发。


网路冷眼@BlogJava 2010-11-28 19:39 发表评论


Activiti User Guide（Activiti用户指南)-Chapter 10. History(历史)
网路冷眼@BlogJava — Sun, 28 Nov 2010 11:32:00 GMT
Chapter 10. History(历史)
Table of Contents 
 History configuration（历史配置）  
History for audit purposes(审计目的的历史)
History is the component that captures what happened during process execution and stores it permanently. In contrast to the runtime data, the history data will remain present in the DB also after process instances have completed. 
历史是在流程执行过程中抓取的事件以及把事件永久存储的部件。与运行时数据相比较，历史数据既将当前的数据也将流程已经完成的数据保留在数据库中。 
There are 3 history entities: HistoricProcessInstances containing information about current and past process instances, HistoricActivityInstances containing information about a single execution of an activity and HistoricDetail containing various kinds of information related to either a historic process instances or an activity instance. 
存在3种历史实体：HistoricProcessInstance包含与当前和过去流程示例相关的信息；HistoricActivityInstance包含与一个活动的当个执行相关的信息；HistoricActivityInstance包含与历史流程实例或者一个活动示例相关的不同的信息。 
In the API, the HistoryService exposes this information by offering methods createHistoricProcessInstanceQuery, createHistoricActivityInstanceQuery and createHistoricDetailQuery. 
在API里，历史服务（HistoryService）通过提供createHistoricProcessInstanceQuery, createHistoricActivityInstanceQuery and createHistoricDetailQuery方法暴露这个信息。 
Since the DB contains historic entities for past as well as ongoing instances, you might want to consider querying these tables in order to minimize access to the runtime process instance data and that way keeping the runtime execution performant. 
因为DB包含过去的，正运行示例的历史实体，所以为了最小化访问运行流程实例的数据，你也许考虑查询这些库表。这种方式保留了运行期执行的效率。 
Later on, this information will be exposed in Activiti Explorer and Activiti Probe. Also, it will be the information from which the reports will be generated. 
最后，这个信息将会在 Activiti Explorer和 and Activiti Probe里面暴露。这将是报告将会产生信息的来源。 
History configuration（历史配置）
In the activiti.cfg.xml configuration file, you can configure the level of history archiving that needs to happen: 
在activiti.cfg.xml配置文件，你能配置需要的历史归档的级别：


...


Or if you're using the spring style of configuration:

或者如果你正使用Spring风格的配置方式：


...

Following history levels can be configured:

可以配置如下的历史级别：


    
    none: skips all history archiving. This is the most performant for runtime process execution, but no historical information will be available.
    
    忽略所有的历史归档。尽管对于运行期流程执行来说这是性能最高的，但是没有历史信息保留。
    
    
    activity: archives all process instances and activity instances. No details will be archived
    
    归档所有流程实例和活动实例。不归档细节。
    
    
    audit: This is the default. It archives all process instances, activity instances and all form properties that are submitted so that all user interaction through forms is traceable and can be audited.
    
    这是缺省级别。它归档所有流程实例，活动实例和提交的表单属性。以至于通过表单的所有用户交互都是可跟踪并可以被审计。
    
    
    full: This is the highest level of history archiving and hence the slowest. This level stores all information as in the audit level plus all other possible details like process variable updates.
    
    这是历史归档的最高级别。所以是最慢的。这个水平保存audit级别的所有信息加上像流程变量的所有其它可能的细节。
    

History for audit purposes(审计目的的历史)
When configuring at least audit level for configuration. Then all properties submitted through methods FormService.submitStartFormData(String processDefinitionId, Map properties) and FormService.submitTaskFormData(String taskId, Map properties) are recorded.

当配置configuring 至少为audit级别时，那么通过FormService.submitStartFormData(String processDefinitionId, Map properties) 和 FormService.submitTaskFormData(String taskId, Map properties) 方法提交的所有属性将会被记录。

[KNOWN LIMITATION] Currently the forms as worked out in Activiti Explorer do not yet use the submitStartFormData and submitTaskFormData. So the form properties are not yet archived when using the forms in Activity Explorer. @see ACT-294

[KNOWN LIMITATION] 当前在工作的表单 还没有使用 submitStartFormData 和 submitTaskFormData。所以当在使用表单时，表单属性还未被归档。@参见 ACT-294

Form properties can be retrieved with the query API like this:

表单特性能够像下面以查询API方式检索：
historyService
.createHistoricDetailQuery()
.onlyFormProperties()
...
.list();
In that case only historic details of type HistoricFormProperty are returned.

在那种情况下，只返回 HistoricFormProperty类型的历史细节。

If you've set the authenticated user before calling the submit methods with IdentityService.setAuthenticatedUserId(String) then that authenticated user who submitted the form will be accessible in the history as well with HistoricProcessInstance.getStartFormUserId() for start forms and HistoricActivityInstance.getAssignee() for task forms.

如果在调用带有IdentityService.setAuthenticatedUserId(String) 提交方法之前，你已经设置认证用户，那么提交这个表单的那个认证用户将会在历史里可访问。带有HistoricProcessInstance.getStartFormUserId() 访问启动表单，带有HistoricActivityInstance.getAssignee() 访问任务表单。


网路冷眼@BlogJava 2010-11-28 19:32 发表评论


Activiti User Guide（Activiti用户指南)-Chapter 11. Eclipse Designer(Eclipse 设计器)（根据5.0Release修订）
网路冷眼@BlogJava — Sun, 28 Nov 2010 11:26:00 GMT
Chapter 11. Eclipse Designer(Eclipse 设计器)
 Table of Contents
  Installation  
Activiti Designer editor features（特性）  
Activiti Designer BPMN features（Activiti设计器BPMN特性）  
Extending Activiti Designer（扩展Activiti设计器） 
  Customizing the palette（定制面板）  
Exporting to custom output formats（输出定制的格式）
 Activiti comes with an Eclipse plugin, the Activiti Eclipse Designer, that can be used to graphically model, test and deploy BPMN 2.0 processes Eclipse. The Activiti Eclipse Designer is started and maintained by Tijs Rademakers, Tiese Barrell, Ron van Liempd and Yvo Swillens. 
Activiti携带了能够在Eclipse里面用来对BPMN 2.0流程进行图形化建模的Eclipse插件。Activiti Eclipse Designer由Tijs Rademakers, Tiese Barrell, Ron van Liempd 和 Yvo Swillens发起并维护。 
Installation
 The following installation instructions are verified on Eclipse Classic Helios. 
下列安装指令在 classic Eclipse Helios 环境里面得到验证。 
Go to Help -> Install New Software. In the following panel, click on Add button and fill in the following fields: 
到 Help -> Install New Software.在下面面板里面，点击 Add 按钮并填充下面的字段： 
  Name: Activiti BPMN 2.0 designer
 
 Location: http://activiti.org/designer/update/
  
Make sure the "Contact all updates sites.." checkbox is not checked, because all the necessary plugins can be downloaded from the Activiti update site. 
确保选择 "Contact all updates sites.."复选框，这是因为所有必要的插件从Activiti的更新站点下载。  
Activiti Designer editor features（特性）
   Create Activiti projects and diagrams. 
建立Activiti项目和流程图。 
 
 The Activiti project is generated as a Maven project. To configure the dependencies you need to run mvn eclipse:eclipse and the project dependencies will be configured as expected. 
Activiti项目作为一个Maven项目而产生。为了配置所需的依赖，请运行 mvn eclipse:eclipse，那么项目依赖的配置将如你所愿。 
 
 A BPMN 2.0 XML file and an image of the process are automatically generated after each save of the Activiti diagram (the automatic generation can be switched of in the Eclipse preferences in the Activiti tab). 
在Activiti流程图每次保存时将自动产生BPMN 2.0 XML文件和流程的图像（在Eclipse的preferences的Activiti标签页里可以关闭自动产生的选项）。 
 
 Generate a unit test (right click on a BPMN 2.0 XML file in the package explorer and select generate unit test) A unit test is generated with an Activiti configuration that runs on an embedded H2 database. You can now run the unit test to test your process definition. 
产生单元测试（右击包导航器的BPMN 2.0 XML文件并选择产生单元测试（generate unit test））。Activiti配置产生的单元测试运行在嵌入式H2的数据库之上。现在能够运行单元测试来测试流程定义。 
 
 The BPMN 2.0 XML is opened in a Activiti XML editor which provides content assist. Note that there are 2 main XSDs configured, the BPMN 2.0 spec XSD and the Activiti extensions XSD. These two XSDs are not yet alligned in a good manneer. 
Activiti XML编辑器提供内容辅助功能。可以在Activiti XML编辑器里面打开BPMN 2.0 XML文件。注意存在两种可配置的XSD：符合BPMN 2.0规范的XSD和Activiti扩展的XSD。这两个还没有以良好的方式齐头并进。 
 
 A basic validation is performed after each save of the Activiti diagram and the errors are mentioned in the Eclipse problem view. 
当Activiti流程图每次保存时，完成基本的校验。校验错误显示在Eclipse 问题视图里。 
 
 A basic deployment editor is available when right-clicking on an Activiti diagram in the package explorer. You see a Deployment property at the end of the pop-up items. The deployment editor currently supports saving a BAR file, and will be extended in the next release to also deploy the BAR file to the Activiti engine. 
当右击包导航器的Activiti的流程图时，将显示一个基本的部署编辑器。在弹出项的的最下端将显示一个"Deployment"属性。部署编辑器当前支持保存为一个BAR文件。在下一个版本将扩展为将BAR文件部署到Activiti引擎。 
 Activiti Designer BPMN features（Activiti设计器BPMN特性）
   Support for start event, end event, sequence flow, parallel gateway, exclusive gateway, embedded subprocess, script task, user task, service task, mail task and manual tasks. 
支持启动事件，结束事件，顺序流，并行网关，唯一网关，嵌入式子流程，脚本任务，用户任务，服务任务，邮件任务和手动任务。 
 
 Java class or expression configuration is supported for the Java service task. In addition field extensions can be configured. 
支持对Java服务任务进行Java类或者表达式配置。能够配置另外的字段扩展。 
 
 Support for additional Activiti extensions like the Mail task, the candidate configuration of User tasks and Script task configuration. 
支持像Mail任务的Activiti扩展任务，用户任务的候选人配置和脚本任务配置。
 
 
 
 Support for conditions on sequence flows. 
支持顺序流之上的条件表达式。 
 Extending Activiti Designer（扩展Activiti设计器）
 You can extend the default functionality offered by Activiti Designer. This section documents which extensions are available, how they can be used and provides some usage examples. Extending Activiti Designer is useful in cases where the default functionality doesn't suit your needs, you require additional capabilities or have domain specific requirements when modelling business processes. Extension of Activiti Designer falls into two distinct categories, extending the palette and extending output formats. Each of these extension ways requires a specific approach and different technical expertise. 
你能够扩展由Activiti Designer提供的缺省功能。本章为哪些扩展可用，如何使用这些扩展问题提供一些有用的示例。在缺省功能不适合你的需求，你需要额外的能力，或者当对业务流程建模时具有领域特定的需求的地方，正是扩展Activiti Designer扩展有用武之地。Activiti Designer扩展有两个明显的分类：扩展面板和扩展输入格式。每个扩展方式需要特定的方法和不同的技术技巧。 
Note
 Extending Activiti Designer requires technical knowledge and more specifically, knowledge of programming in Java. Depending on the type of extension you want to create, you might also need to be familiar with Maven, Eclipse, OSGi, Eclipse extensions and SWT. 
注意 
扩展需要技术基础和更特别的Java编程基础。依赖ni ddddd所想建立的扩展类型，你也许需要熟悉Maven，Eclipse，OSGi，Eclipse扩展和SWT。 
Customizing the palette（定制面板）
 You can customize the palette that is offered to users when modelling processes. The palette is the collection of shapes that can be dragged onto the canvas in a process diagram and is displayed to the right hand side of the canvas. As you can see in the default palette, the default shapes are grouped into compartments (these are called "drawers") for Events, Gateways and so on. There are two options built-in to Activiti Designer to customize the drawers and shapes in the palette: 
当建模时，你可以给用户提供一个定制的面板。面板是能够拉至 
  Adding your own shapes / nodes to existing or new drawers 
增加你自己的图形或者节点到已存在或新的抽屉上。
 
 Disabling any or all of the default BPMN 2.0 shapes offered by Activiti Designer, with the exception of the connection and selection tools 
j禁止任何Activiti Designer提供的缺省BPMN 2.0图形，连接和选择
 In order to customize the palette, you create a JAR file that is added to a specific installation of Activiti Designer (more on how to do that later). Such a JAR file is called anextension. By writing classes that are included in your extension, Activiti Designer understands which customizations you wish to make. In order for this to work, your classes should implement certain interfaces. There is an integration library available with those interfaces and base classes to extend which you should add to your project's classpath. 
未来定制调色板，你建立一个可以添加到Activiti Designer（后面将更多介绍how to do that ）里的JAR的文件。这样的JAR文件叫一个扩展（extension） 。 
Note
 You can setup your project in whichever tool you prefer and build the JAR with your build tool of choice. For the instructions below, a setup is assumed with Eclipse Helios, using Maven (3.x) as build tool, but any setup should enable you to create the same results. 
注意 
ni你能够设置你喜欢的工具来设置你的项目。用这个工具来构建这个JAR包。对于下列指令，假定用Eclipse Helios设置，采用Maven（3.x）作为构建工具，但是任何设置建立相同的结果。 
Extension setup (Eclipse/Maven)（扩展设置(Eclipse/Maven))
 Download and extract Eclipse (Galileo or Helios should both work) and a recent version (3.x) of Apache Maven. If you use a 2.x vesion of Maven, you will run into problems when building your project, so make sure your version is up to date. We assume you are familiar with using basic features and the Java editor in Eclipse. It's up to you whether your prefer to use Eclipse's features for Maven or run Maven commands from a command prompt. 
下载并抽取 和最新版本。如果你使用Maven 2.x版本，在构建项目时将带来问题，所以确保它的版本及时更新。我们假定你熟悉Eclipse里面的基本特性和Java编辑器。是否你钟情在Eclipse里面使用Maven或者在命令行提示下使用Maven，完全取决于你。 
Create a new project in Eclipse. This can be a general project type. Create a pom.xml file at the root of the project to contain the Maven project setup. Also create folders for the src/main/java and src/main/resources folders, which are Maven conventions for your Java source files and resources respectively. Open the pom.xml file and add the following lines: 
在Eclipse里面建立一个新项目。这个项目可以是一个一般类型的项目。为了包含Maven项目设置，在项目的根目录下建立一个pom.xml文件夹。也要建立 src/main/java 和 src/main/resources文件夹，这是Maven对Java源代码文件和相关资源文件的约定。打开pom.xml文件并增加下列行：


 4.0.0

 org.acme
 money-tasks
 1.0.0
 jar
 Acme Corporation Money Tasks
...

As you can see, this is just a basic pom.xml file that defines a groupId, artifactId and version for the project. We will create a customization that includes a single custom node for our money business.
正如你所见，这只是定义了项目的 一个基本的pom.xml文件。我们
Add the integration library to your project's dependencies by including this dependency in your pom.xml file:
通过在pom.xml文件里包含项目的依赖库，将集成的库加到项目里面。

 
  org.activiti.designer
  org.activiti.designer.integration
  
  compile
 

Warning
At the moment, the dependency is not available from the Activiti Maven repository. To use it, you should download it from here and place it in your local Maven repository.
此时，还未从Activiti的Maven仓库获得依赖。为了使用它，从这里下载 from here，并把它放到你本地的Maven仓库里。
Finally, in the pom.xml file, add the configuration for the maven-compiler-plugin so the Java source level is at least 1.5 (see snippet below). You will need this in order to use annotations. You can also include instructions for Maven to generate the JAR's MANIFEST.MF file. This is not required, but you can use a specific property in the manifest to provide a name for your extension (this name may be shown at certain places in the designer and is primarily intended for future use if you have several extensions in the designer). If you wish to do so, include the following snippet in pom.xml:
最后，因为

 
        
   maven-compiler-plugin
   
    1.5
    1.5
    true
    true
    true
   
  
  
   org.apache.maven.plugins
   maven-jar-plugin
   2.3.1
   
    
     true
     
      false
      true
     
     
      Acme Money
     
    
   
  
 

The name for the extension is described by the ActivitiDesigner-Extension-Name property. The only thing left to do now is tell Eclipse to setup the project according to the instructions in pom.xml. So open up a command shell and go to the root folder of your project in the Eclipse workspace. Then execute the following Maven command:
扩展名由ActivitiDesigner-Extension-Name 属性描述。唯一剩下的d事实告诉Eclipse根据文件里指令建立这个项目。所以打开一个命令shell并到Eclipse工作区的项目根文件夹。执行下面的Maven命令：
mvn eclipse:eclipse
Wait until the build is successful. Refresh the project (use the project's context menu (right-click) and select Refresh). You should now have the src/main/java and src/main/resourcesfolders as source folders in the Eclipse project.
等到构建成功完成。刷新项目（使用项目的上下文菜单（右击）并选择“刷新”（Refresh））。现在你应当在Eclipse项目里看见文件夹src/main/java 和 src/main/resources作为源代码文件夹。
Note
You can of course also use the m2eclipse plugin and simply enable Maven dependency management from the context menu (right-click) of the project. Then choose Maven > Update project configuration from the project's context menu. That should setup the source folders as well.
你当然也可使用 m2eclipse 插件。简单地从上项目下文菜单（右击）启动Maven依赖管理。然后从项目的上下文菜单选择“ Maven > Update project configuration ”。也要设置设置源代码。
That's it for the setup. Now you're ready to start creating customizations to Activiti Designer!
设置就这样弄好了。建立Activiti Designer的定制的准备工作就绪。
Applying your extension to Activiti Designer（应用对Activiti Designer的扩展）
You might be wondering how you can add your extension to Activiti Designer so your customizations are applied. These are the steps to do just that:
你可能疑惑如何才能把自己的定制加入到Activiti Designer以便让自己的定制起作用呢。那么采取这些步骤可以解决：


Once you've created your extension JAR (for instance, by performing a mvn install in your project to build it with Maven), you need to transfer the extension to the computer where Activiti Designer is installed;
一旦你建立自己的扩展JAR（例如，通过Maven在你的项目里执行一个mvn install 来构建）。你需要将这个扩展放到Activiti Designer安装的地方。

Store the extension somewhere on the hard drive where it will be able to remain and remember the location;
ddd将扩展存储在硬盘的某个地方，在那可以保存扩展。

Start Activiti Designer and from the menu, select Window > Preferences
首先启动Activiti Designer，然后在菜单里选择 Window > Preferences.

In the preferences screen, type user as keyword. You should see an option to access the User Libraries in Eclipse in the Java section.
在preferences 屏幕，键入 user 作为关键字。你应当在Eclipse的Java部分看见访问 User Libraries 的选项。


Select the User Libraries item and a tree view shows up to the right where you can add libraries. You should see the default group where you can add extensions to Activiti Designer (depending on your Eclipse installation, you might see several others as well).
选择 User Libraries 项，在右端将显示一个树形视图，在此可以添加你自己的Java库。你应当能看见扩展加入到Activiti Designer 的缺省组（依赖于你的Eclipse的安装，你可能看到其它的情况）。


Select the Activiti Designer Extensions group and click the Add JARs... button. Navigate to to folder where your extension is stored and select the extension file you want to add. After completing this, your preferences screen should show the extension as part of the Activiti Designer Extensions group, as shown below.
选择组Activiti Designer Extensions组并点击 Add JARs...按钮。导航至你自己扩展所保存的文件夹并选择所要添加的扩展。完成之后，你的 preference屏幕应当显示作为 Activiti Designer Extensions 组的一部分的扩展，如下所示。


Click the OK button to save and close the preferences dialog. The Activiti Designer Extensions group is automatically added to new Activiti projects you create. You can see the user library as entry in the project's tree in the Navigator or Package Explorer. If you already had Activiti projects in the workspace, you should also see the new extensions show up in the group. An example is shown below.
点击OK按钮，保存并关闭preference对话框。组自动添加到你所建的Activiti项目里面。在Navigator或者Package Explorer视图上的项目树书上，用户库作为一个条目显示。如果你在工作区上存在一个Activiti项目，那么你应当看见在组里显示的新的扩展。示例如下所示。

Diagrams you open will now have the shapes from the new extension in their palette (or shapes disabled, depending on the customizations in your extension). If you already had a diagram opened, close and reopen it to see the changes in the palette.
打开的流程图的有一个新的扩展，并能看见图形（依赖于你的定制，这些图形可能被禁止）。如果流程图已经打开，关闭并重新打开，观察面板发生的变化。
Adding shapes to the palette（把图形加到面板）
With your project set up, you can now easily add shapes to the palette. Each shape you wish to add is represented by a class in your JAR. Take note that these classes are not the classes that will be used by the Activiti engine during runtime. In your extension you describe the properties that can be set in Activiti Designer for each shape. From these shapes, your refer to the runtime class that should be used by the engine. This class should implement JavaDelegate as for any ServiceTask in Activiti.
一旦项目设置好，你能轻易把图形添加到面板。你想加入的图形在Jar包里用一个类来表示。注意这些类不是Activiti引擎在运行期间所使用的类。在扩展里，描述了在Activiti Designer里可以设置的属性。通过这些图形，引用应当有引擎所使用的运行期类。这些类应当为Activiti里的ServiceTask实现JavaDelegte接口。
A shape's class is a simple Java class, to which a number of annotations are added. The class should implement the CustomServiceTask interface, but you shouldn't implement this interface yourself. Extend the AbstractCustomServiceTask base class instead (at the moment you MUST extend this class directly, so no abstract classes in between). In the Javadoc for that class you can find instructions on the defaults it provides and when you should override any of the methods it already implements.
图形类是一个简单的Java类，加入了注释。尽管这个类应当实现接口，但是不应当你自己实现这个接口。而应当扩展这个基类作为代替（目前你必须直接扩展这个类，所以没有抽象类）。在那个类的Javadoc里面，可以找它提供的缺省功能的指令。你应当复写它已经实现的任何方法。
/**
 * @author John Doe
 * @version 1
 * @since 1.0.0
 */
public class AcmeMoneyTask extends AbstractCustomServiceTask {
...
}
You will need to implement the getName() method to determine the name the node will have in the palette. You can also put the nodes in their own drawer and provide an icon. Override the appropriate methods from AbstractCustomServiceTask. If you want to provide an icon, make sure it's in the src/main/resources package in your JAR. The path you supply is relative to that folder.
需要实现 getName()方法来决定将在面板中节点的名称。你也能将节点放置到它们的抽屉里并提供一个图标。复写AbstractCustomServiceTask类里合适的方法。如果你想提供一个图标，确定它在JAR包里的src/main/resources包。提供的路径是相对路径。
You can add properties to the shape by adding members to the class and annotating them with the @Property annotation like this:
通过向类加入成员并以如下方式用 @Property 标注标注它们可以给图形增加属性。
@Property(type = PropertyType.TEXT, displayName = "Account Number")
@Help(displayHelpShort = "Provide an account number", displayHelpLong = HELP_ACCOUNT_NUMBER_LONG)
private String accountNumber;
At the moment, there are just two PropertyType values you can use, TEXT and MULTILINE_TEXT. Future releases will allow you to use other types. You can make a field required by setting the required attribute to true. A message and red background will appear if the user doesn't fill out the field.
当前，只存在两种可以使用的PropertyType 值： TEXT和MULTILINE_TEXT。未来版本将允许你使用其它的类型。通过设置必选的属性为true让字段必选。如果用户没有填充字段，将出现一个消息，背景为红色。
As you can see, there's also an @Help annotation that's used to provide the user some guidance when filling out the field. You can also use the @Help annotation on the class itself - this information is shown at the top of the property sheet presented to the user.
如你所见，当填充字段时，也有一个标注用来提供给用户一些指南的的 @Help标注。也可在类自身使用 @Help 标注--这个信息在属性表上提供给用户信息。
Below is the listing for a further elaboration of the MoneyTask. A comment field has been added and you can see an icon is included for the node.
为了获得MoneyTask的详情，以下是列表。已经加入注释字段，并且在节点能看见图标。
/**
 * @author John Doe
 * @version 1
 * @since 1.0.0
 */
@Runtime(delegationClass = "org.acme.runtime.AcmeMoneyJavaDelegation")
@Help(displayHelpShort = "Creates a new account", displayHelpLong = "Creates a new account using the account number specified")
public class AcmeMoneyTask extends AbstractCustomServiceTask {

 private static final String HELP_ACCOUNT_NUMBER_LONG = "Provide a number that is suitable as an account number.";

 @Property(type = PropertyType.TEXT, displayName = "Account Number", required = true)
 @Help(displayHelpShort = "Provide an account number", displayHelpLong = HELP_ACCOUNT_NUMBER_LONG)
 private String accountNumber;

 @Property(type = PropertyType.MULTILINE_TEXT, displayName = "Comments")
 @Help(displayHelpShort = "Provide comments", displayHelpLong = "You can add comments to the node to provide a brief description.")
 private String comments;

 /*
  * (non-Javadoc)
  * 
  * @see org.activiti.designer.integration.servicetask.AbstractCustomServiceTask #contributeToPaletteDrawer()
  */
 @Override
 public String contributeToPaletteDrawer() {
  return "Acme Corporation";
 }

 @Override
 public String getName() {
  return "Money node";
 }

 /*
  * (non-Javadoc)
  * 
  * @see org.activiti.designer.integration.servicetask.AbstractCustomServiceTask #getSmallIconPath()
  */
 @Override
 public String getSmallIconPath() {
  return "icons/coins.png";
 }
}
If you extend Activiti Designer with this shape, The palette and corresponding node will look like this:
如果用这个图形扩展Activiti Designer，面板及其相关节点如下所示：

The properties screen for the money task is shown below. Note the required message for the accountNumber field.
money任务的属性屏幕如下所示。注意 accountNumber字段的必填的消息。

The help for fields is offered by the buttons to the right of each property. Clicking on the button shows a popup as displayed below.
在每个属性的右侧的按钮提供字段的帮助信息。点击按钮将显示如下弹出的信息。

The final step for your shape is to indicate the class that is instantiated by the Activiti engine when it reaches your node when executing a process instance. To do this, you use the @Runtime annotation. The delegationClass attribute you return should contain the canonical name of the runtime class. Note that the runtime class shouldn't be in your extension JAR, as it's dependent on the Activiti libraries.
当执行一个流程实例时，Activiti引擎到达你的节点。图形的最终步骤指明被Activiti引擎实例化的那个类。可以 @Runtime 标注来完成这个功能。返回属性应当包含运行时期的正规名称。注意运行时期类不应当在扩展JAR包里，因为它依赖于Activiti类库。
@Runtime(delegationClass = "org.acme.runtime.AcmeMoneyJavaDelegation")
Disabling default shapes in the palette（禁止面板里的缺省图形）
This customization requires you to include a class in your extension that implements the DefaultPaletteCustomizer interface. You should not implement this interface directly, but subclass the AbstractDefaultPaletteCustomizer base class. Currently, this class provides no functionality, but future versions of the DefaultPaletteCustomizer interface will offer more capabilities for which this base class will provide some sensible defaults so it's best to subclass so your extension will be compatible with future releases.
这个定制需要你在扩展里包含实现接口的类。你不应当直接实现这个接口，而是子类化AbstractDefaultPaletteCustomizer 基类。当前，接口的未来版本将提供为那些基类通过更多功能，所以最好子类化，这样，你的扩展将会和未来的版本。
Extending the AbstractDefaultPaletteCustomizer class requires you to implement one method, disablePaletteEntries(), from which you must return a list of PaletteEntry values. For each of the default shapes, you can disable it by adding its corresponding PaletteEntry value to your list. Note that if you remove shapes from the default set and there are no remaining shapes in a particular drawer, that drawer will be removed from the palette in its entirety. If you wish to disable all of the default shapes, you only need to addPaletteEntry.ALL to your result. As an example, the code below disables the Manual task and Script task shapes in the palette.
扩展 AbstractDefaultPaletteCustomizer类需要你实现一个disablePaletteEntries()方法，你必须返回一个 PaletteEntry值列表。对于每个缺省图形，通过增加相关的 PaletteEntry值到你的列表，你能禁止它。注意如果从缺省集合里删除图形，特别的抽屉里没有任何图形，那么这个抽屉也将从面板中删除。如果你想禁止所有缺省的图形，你只需要把加入PaletteEntry.ALL 到结果。作为一个示例，下列代码禁止了面板中的手动任务和脚本任务。
public class MyPaletteCustomizer extends AbstractDefaultPaletteCustomizer {

 /*
  * (non-Javadoc)
  *
  * @see org.activiti.designer.integration.palette.DefaultPaletteCustomizer#disablePaletteEntries()
  */
 @Override
 public List disablePaletteEntries() {
  List result = new ArrayList();
  result.add(PaletteEntry.MANUAL_TASK);
  result.add(PaletteEntry.SCRIPT_TASK);
  return result;
 }

}
The result of applying this extension is shown in the picture below. As you can see, the manual task and script task shapes are no longer available in the Tasks drawer.
这个扩展的应用效果如下图所示。如你所见，手动任务和脚本任务的图形不在Task抽屉上获取。

To disable all of the default shapes, you could use something similar to the code below.
为了禁止所有的缺省图形，你可以应当使用和下列相似的代码。
public class MyPaletteCustomizer extends AbstractDefaultPaletteCustomizer {

 /*
  * (non-Javadoc)
  *
  * @see org.activiti.designer.integration.palette.DefaultPaletteCustomizer#disablePaletteEntries()
  */
 @Override
 public List disablePaletteEntries() {
  List result = new ArrayList();
  result.add(PaletteEntry.ALL);
  return result;
 }

}
The result will look like this (notice that the drawers the default shapes were in are no longer in the palette):
结果将如下相似（注意缺省图形原来所在的抽屉也不在面板里面了）。

Exporting to custom output formats（输出定制的格式）
You can extend Activiti Designer to publish to additional formats when saving diagrams. These extensions are called Export Marshallers and are invoked automatically by Activiti Designer on each save action by the user. This behavior can be enabled or disabled by setting a preference in Eclipse's preferences dialog for each format to be saved.
当你保存流程图时，你能够扩展Activiti Designer 发表另外的格式。这些扩展被称为。当用户每次采取保存的行为时，由Activiti Designer自动调用。
You can compare these extensions to the BPMN 2.0 export and process image saving that's performed during save actions by default in Activiti Designer. In fact, these functions use exactly the same extension features you can use to save to your own formats.
你能将这些功能和BPMN 2.0输出和流程图像进行比较。缺省地，后者在Activiti Designer里在保存动作期间完成。 
事实上，这些功能完全使用你能使用的相同的扩展特性。它通常保存为你自己的格式。
To create an Export Marshaller, you need to create a different kind of extension than for extending the palette. The reason for this is simple: from your code you will need access to more APIs than are offered by the integration library. In particular, you will need classes that are available in Eclipse itself. The way to implement an Export Marshalleris therefore to create an Eclipse plugin (which you can do by using Eclipse's PDE support) and package it in a custom Eclipse product. It's beyond the scope of this user guide to explain all the details involved in developing Eclipse plugins, so the instructions below are limited to the functionality for extending Activiti Designer.
为了建立一个输出解组（ Export Marshaller)，你需要建立不同种类的扩展，而不是扩展面板。这个原因是简单的：从代码观点来看，你将需要比访问比集成库需要更多的API。特别地，你将需要Eclipse里能够获取的类。实现一个Export Marshaller 方法是建立一个Eclipse的插件（通过Eclipse的PDE支持），并且在一个定制的Eclipse产品里将它打包。解释所有关于开发Eclipse 插件的细节超过了本用户指南的范围，所以下列指令被限制为扩展Activiti Designer的功能。
Your bundle should be dependent on the following libraries:
你的bundle应当依赖下列库：

Create an extension to the org.activiti.designer.eclipse.extension.export.ExportMarshaller extension point. For this extension point, you are required to subclass the AbstractExportMarshallerclass. This abstract base class provides you with a number of useful methods when marshalling to your own format, such as adding markers to Eclipse's problems view and saving resources to the workspace.
建立一个org.activiti.designer.eclipse.extension.export.ExportMarshaller 扩展点的扩展。对于这个扩展点，需要子类化 AbstractExportMarshaller这个类。当自己的格式时这个抽象基类提供了大量的有用的方法，诸如在Eclipse Problem视图添加标记，并把资源保存到工作区里面。
You are required to implement some methods, such as getMarshallerName() and getFormatName(). These methods are used to display options to the user and to show information in progress dialogs, so make sure the descriptions you return reflect the functionality you are implementing.
需要实现诸如这样getMarshallerName() 和 getFormatName()的方法。这些方法用来显示用户的选项和显示进度对话框的信息，这样确保返回的描述反应了所实现的功能。
The bulk of your work is performed in the marshallDiagram(Diagram diagram, IProgressMonitor monitor) method. You are provided with the diagram object, which contains all of the information about the objects in the diagram (BPMN constructs) and the graphical representation. If you want to access the diagram through its resource in Eclipse or you want to transform the diagram using XSLT, there are methods to get to Resources and InputStreams for the diagram in the AbstractExportMarshaller class.
工作的大部分在 marshallDiagram(Diagram diagram, IProgressMonitor monitor)方法里面执行。提供了流程图对象，它包含关于流程图(BPMN构件）对象和图形表示的所有信息。如果你想通过Eclipse里的一样访问流程图，或者你想采用XSLT来转换流程图，在AbstractExportMarshaller 类里有为流程图获取Resources 和的 InputStreams方法。
It's probably a good idea to invoke clearProblems() as one of the first things you do; this will clear any previous markers for your marshaller. You should also use the progress monitor provided to report your progress back to the user. If you need examples on how to do this, take a look at the code of Activiti Designer itself.
首先调用 clearProblems() 方法可能是个好主意；这将清除 marshaller先前的标记。你也应当所提供的进度监视器，向用户报告进展情况。如果需要如何完成这样功能的示例，请参考Activiti Designer 自身的代码。




网路冷眼@BlogJava 2010-11-28 19:26 发表评论


Activiti User Guide（Activiti用户指南)-Chapter 12. Activiti Modeler(Activiti建模器)
网路冷眼@BlogJava — Sun, 28 Nov 2010 11:16:00 GMT
Chapter 12. Activiti Modeler(Activiti建模器)
Table of Contents 
 Changing the location of the process model repository(变更流程模型仓库的位置)  
Changing the host of the Modeler(变更建模器的主机)
The Activiti Modeler is a web based process editor that can be used to author BPMN 2.0 process graphically using nothing more then a browser. The process files are stored by the server on a the file system, such that they are easily accessible and can be imported without hassles into any Java IDE. 
Activiti建模器(Activiti Modeler)是一个用来仅在浏览器里面以图形化编辑BPMN 2.0流程的，基于Web的流程编辑器。通过服务器流程文件存在文件系统，所以很容易对它们进行访问，并无忧输入到任何JavaIDE里面。 
Bugs and issues can be reported on the Signavio core components issue tracker. 
可以将缺陷和问题报告到Signavio core components issue tracker. 
The Activiti Modeler is automatically installed during the demo setup. 
在demo setup过程中自动安装Activiti Modeler。 
 
Changing the location of the process model repository(变更流程模型仓库的位置)
After running the demo setup, process XML files are stored in the apps/activiti-model-repository folder. The location of the file-based repository can be switched by changing the fileSystemRootDirectory property in the (exploded)activiti-modeler.war/WEB-INF/classes/configuration.properties file. 
在运行演示创建的过程之后，流程XML文件将会保存在apps/activiti-model-repository文件夹。通过变更在(exploded)activiti-modeler.war/WEB-INF/classes/configuration.properties文件里的 fileSystemRootDirectory 属性，来切换基于文件的仓库位置。 
Changing the host of the Modeler(变更建模器的主机)
After running the demo setup, the Activiti Modeler will accessible only on the localhost address. When you want to change the host of the Modeler, e.g. to run it centrally on a server, change the host property in the (exploded)activiti-modeler.war/WEB-INF/classes/configuration.properties file. 
在运行演示创建之后，将只能从localhost地址访问Activiti Modeler。当你想变更Modeler的主机，例如，在一个服务器上集中运行。那么，请你变更在(exploded)activiti-modeler.war/WEB-INF/classes/configuration.properties 文件的host属性。
> cat configuration.properties
host = http://192.168.1.101:8080
fileSystemRootDirectory = /Users/jbarrez/Development/model-repo


网路冷眼@BlogJava 2010-11-28 19:16 发表评论