午夜久久av,成人网欧美在线视频,亚洲精品一线

�|��\��L(f��ng)��@BlogJava — Tue, 08 Mar 2011 13:40:00 GMT

Extend the migration logic

扩展�q�移逻辑

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

�q�移逻辑可以�~�写�Q�以便轻村֜�满��你的需求。源代码在所下蝲zip文�g里src子文件夹里作一个Maven 2��目来��用。�ؓ(f��)了构��Z��个新的zip文�g�Q�在已经改变或者扩展逻辑之后�Q�简单执行下面指�?/p>

mvn clean install

to produce a new zip file in the target folder.

在target文�g下��生一个新的zip文�g�?

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

下图提供了在�q�移逻辑里类的高层次概貌�?

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 �q�两个类都有在迁�U�zip的根目录下的ant构徏脚本里调用的main�Ҏ(gu��)��?
These classes construct a ServiceFactory based on the two properties files, using a static factory method
通过使用静态的工厂�Ҏ(gu��)��Q�基于两个properties文�g�q�些�c�L��Z��?strong>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())构徏�q�些服务�Q�这些服务被用来执行�q�移逻辑�Q?/li>

 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 是一个包含流�E��{换和数据��(g��)索的��程定义借口。它使用�?Jbpm3Dao.的实现。这个类的缺省实��C��用了Hibernate�?strong>SessionFactory从jBPM 3的数据库表里��(g��)索所有的数据�?

ActivitiService 提供需要从Activiti数据库表�q�移数据的操作。例如，部��v转换之后的流�E�定义就是如此的操作�?

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都是接口�Q��ƈ能由你自己实现。采用正常的JavaBean讄��器，能将它们注入到ServiceFactory。当没有讄��q�些实现�Q�ServiceFactory��后退一步，建立�~�省的实玎ͼ�(x��)

    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 }

�|��\��L(f��ng)��@BlogJava 2011-03-08 21:40 发表评论

�|��\��L(f��ng)��@BlogJava — Mon, 07 Mar 2011 15:23:00 GMT

Chapter 18. JBPM Migration�Q�JBPM �q�移�Q?/strong>

Table of Contents

目录�?

Database migration

数据�q�移

Process conversion

��程转换

Extend the migration logic

扩展�q�移逻辑

The jBPM migration is considered [EXPERIMENTAL].

jBPM�q�移仅作[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�q�移到Activiti是有可能的。迁�U�d��括流�E�定义�{换（例如从JPDL3到BPMN 2.0�Q�和数据�q�移�?

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.

�q�移工具目前只作�?#8216;预览’之用�Q?/strong>当前�q�移不能覆盖��C�品的��程定义和数据。也要注意迁�U�L��‘最大的努力’�Q�这意味着你可以需�?#8216;扩展�q�移逻辑’来控制你所有的用例�?

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:

�q�移工具�?a >activiti.org下蝲站点以zip文�g方式分开下蝲。一旦加压这个文�Ӟ��文�g和文件夹如下所�C�：(x��)

build.xml: This ant buildfile contains the targets to execute the process definition conversion and database migration.

build.xml: �q�个ant构徏文�g包含了执行流�E�定义�{换和数据库迁�Uȝ��目标�?

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:�q�个�Ҏ(gu��)��文件包含了jBPM和Activiti数据库的数据库连接参数。当执行数据库迁�U�L��Q�必��L��变这些特性文件�?

processes: when running a process definition conversion, the jBPM 3 process definition files must be placed in this folder.

processes:当运�?a href="file:///G:/index.html#processConversion">��程定义转换�Ӟ��jBPM3��程定义文�g必须攄��到这个文件夹�?

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:�q�个文�g包含�q�移工具的源代码。如果希望裁剪或者扩展迁�U�M��码满��你自己的需求，请阅�?a href="file:///G:/index.html#extendMigration">扩展部分�?

lib: this folder contains all jars required to execute the migration logic.

lib:�q�个文�g夹包含执行迁�U�逻辑的全部jar包�?/li>

Database migration

数据库迁�U?/strong>

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数据库表�q�移到Activiti数据库schema是有可能的。�ؓ(f��)了完成这个�Q务，必须改变下面的properties文�g�Q�指向正��的数据库：(x��)

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: 包含了迁�U�d��要写入数据库的连接参数。这个可能是和jBPM相同数据库schema�Q�例如，在jBPM和Activiti数据库表名，索引名，外键名等�{�没有冲�H�）.

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

数据�q�移��用jBPM3数据库表的数据来做：(x��)

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对应物。这意味着转换之后的流�E�定义将作�ؓ(f��)�q�移的一部分被部�|�到Activiti的数据库表。作为副作用�Q�它也��生BPMN 2.0 XML文�g�Q�这和当执行��程转换时所发生的事�怼��?

Migrate runtime and history data of the processes to the Activiti tables. In this release, this is not yet implemented!

�q�移��程的运行时和历史数据到Activiti数据库表�?strong>本次发布�Q�这没有实现�Q?/strong>

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

使用Hibernate查询和jBPM自��n的Hibernate�?

��，可以从jBPM 3数据库表里检索到�q�些数据�?

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的流�E�定义xml转换��在Activiti引擎执行的BPMN 2.0是有可能的。�ؓ(f��)了完成这个�Q务，请将jBPM 3攄��到process 文�g夏V��可以有��M��数量�Q�内�|�）子文件夹�Q�工具将扫描process每个�Q�子�Q�文件夹�Q�来发现processdefinition.xml文�g�Q�文件名必须是processfinition.xml!�Q��?

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.

被发现的��程��被解析�q��|�到一个内存数据库�Q�以便对包含在数据库�q�移的jBPM部��v数据库表的流�E�定义进行反向工�E�，以�ؓ(f��)解析和部�|�之用�?

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文�g夹，那么执行在解压之后的�q�移工具文�g�Ҏ(gu��)��目录下的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:

在�{换过�E�中�Q�通过描述��程转换执行是何地和何时转换的方式，可以观察到大量的日志。在转换的末��，��观察到下列日志出现�Q?

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.

正如日志所�C�，BPMN 2.0��程的结果可以在converted-process-xxxx文�g多w��扑ֈ��Q�这里xxxx是�{换的旉��戟�?

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

在本�ơ发布里�Q�只实现了对开始，�l�束�Q�等待和��d��节点的有限支持。在��来�Q�这个覆盖范围将要扩充�?

�|��\��L(f��ng)��@BlogJava 2011-03-07 23:23 发表评论

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

�|��\��L(f��ng)��@BlogJava — Mon, 10 Jan 2011 12:58:00 GMT

Chapter 17. Activiti KickStart

Table of Contents

Overview�Q�概�q�ͼ�

Changing the database�Q�变更数据库�Q?

Overview�Q�概�q�ͼ�

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的工��P��用Activiti引擎可用的构�Ӟ��constructs�Q�的子集提供�l�快速创�?#8220;卛_��Q�adhoc�Q?#8221;的业务流�E�。Kickstart提供了不必学�?f��n)BPMN或者�Q何徏模环境的��单UI�Q�因为它�?w��i)立了每个业务用户都熟�(zh��n)�的概��c(di��n)��但是，通过KickStart创徏的的��程�Q�是和BPMN 2.0兼容�Q��ƈ可作为更为复杂BPM努力的�v炏V�?

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创徏的流�E�在Activiti Explorer立即可用�Q��ƈ在Probe里面可见�?

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

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

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.

��单的业务��程�Q�一些流�E�天然简单，�q�且每个公司都有。考虑��C��Ҏ(gu��)��E�，请假��程�Q�雇佣流�E�，�{�等…�q�些��程用书面或者e-mail的方式已�l�完成。Kickstart�q�行快速对�q�些��程建模�Q�每当需要时改变它们。因此，Kickstart真正地降低了门槛�Q��ƈ让这些业务流�E�自动化�?

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.

原型�Q�在�ȝ��复杂的BPMN 2.0建模和考虑��程的偏例之前，它往往是明智的�Q�让所有参与的人��^�{�，制定一个原型来展示所要完成的愿景。KickStart的允许恰恰如此：(x��)创徏一个业务流�E�的原型�Q�让大家看到你的��x��?

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.

卛_��工作�Q�在一些情况，在一个公叔R��Q�不同的人员或组之间的协作是必要的。�?zh��n)�知道正常时如何运作的�Q�在�q�里发送邮�Ӟ��在那里打�?sh��)�?#8230;�q�经常终止于没有人知道需要完成什么或者何时完成这��L(f��ng)��焦��a(b��)坑。但是，诸如Activiti�q�样的业务流�E�管理��^台是解决分发和后�l�事情的卓越解决之道�Q�因为它的目的是准确跟踪�q�些事情。Kickstart允许�(zh��n)�在数分钟之内创建即席工作的��程�Q��ƈ在�h们之间分发和协调��d��?/li>

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的能力。下图作为示例。它展示如何在几分钟之内创徏一个付�Ҏ(gu��)��E��?

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

在点�?#8220;保存”按钮之后�Q�这个流�E�立卛_��Activiti Explorer可用�?

KickStart also allows to define forms for every task:

KickStart也允��ؓ(f��)每个��d��定义表单�Q?

Which are obviously directly usable in Activiti Explorer:

�q�些明显直接在Activiti Explorer可用�Q?

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

在流�E�徏立的��L��旉��Q�它可以查看相应的BPMN2.0业务��程图�?

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

每当它是必需�Q�与KickStart的定义的��程可被打开和修改：(x��)

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�Q�这意味着该流�E�可以由��M��兼容的BPMN2.0�~�辑器输入：(x��)

Changing the database�Q�变更数据库�Q?/strong>

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当前�q�没有��用REST API�Q�而是通过包括了Activiti引擎作�ؓ(f��)�c�d��使用服务API。虽然Explorer�Q�Probe和Cycle使用相同的机制改变数据（参见�q�里�Q�，但这不适于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.

��Z��改变演示安装里KickStart使用的数据库�Q��生一个新的activiti.cfg.jar,�q�将它放�|�到apps/apache-tomcat-6.x/webapps/activiti-kickstart/WEB-INF/lib文�g夏V�?

�|��\��L(f��ng)��@BlogJava 2011-01-10 20:58 发表评论

�|��\��L(f��ng)��@BlogJava — Sat, 08 Jan 2011 03:49:00 GMT
     摘要: 随着�W�合BPMN 2.0标准的BPMS��程引擎Activiti 5.0正式版推出，由Tijs Rademakers �?Ron Van Liempd�~�写的‘实战Activiti’书�c�昨天在“Manning Early Access Program”现�w�。目前第一章释出，可以先睹为快。呵呵，真棒�Q�本��是�W�一章之�Q?1�Q?nbsp; 阅读全文

�|��\��L(f��ng)��@BlogJava 2011-01-08 11:49 发表评论

�|��\��L(f��ng)��@BlogJava — Thu, 06 Jan 2011 13:26:00 GMT
     摘要: 随着�W�合BPMN 2.0标准的BPMS��程引擎Activiti 5.0正式版推出，由Tijs Rademakers �?Ron Van Liempd�~�写的‘实战Activiti’书�c�昨天在“Manning Early Access Program”现�w�。目前第一章释出，可以先睹为快。呵呵，真棒�Q�本��是�W�一章之�Q?0�Q?nbsp; 阅读全文

�|��\��L(f��ng)��@BlogJava 2011-01-06 21:26 发表评论

�|��\��L(f��ng)��@BlogJava — Wed, 05 Jan 2011 13:01:00 GMT
     摘要: 随着�W�合BPMN 2.0标准的BPMS��程引擎Activiti 5.0正式版推出，由Tijs Rademakers �?Ron Van Liempd�~�写的‘实战Activiti’书�c�昨天在“Manning Early Access Program”现�w�。目前第一章释出，可以先睹为快。呵呵，真棒�Q�本��是�W�一章之�Q?�Q?nbsp; 阅读全文

�|��\��L(f��ng)��@BlogJava 2011-01-05 21:01 发表评论

�|��\��L(f��ng)��@BlogJava — Tue, 04 Jan 2011 15:12:00 GMT
     摘要: 随着�W�合BPMN 2.0标准的BPMS��程引擎Activiti 5.0正式版推出，由Tijs Rademakers �?Ron Van Liempd�~�写的‘实战Activiti’书�c�昨天在“Manning Early Access Program”现�w�。目前第一章释出，可以先睹为快。呵呵，真棒�Q�本��是�W�一章之�Q?�Q?nbsp; 阅读全文

�|��\��L(f��ng)��@BlogJava 2011-01-04 23:12 发表评论

�|��\��L(f��ng)��@BlogJava — Tue, 04 Jan 2011 12:43:00 GMT
     摘要: 随着�W�合BPMN 2.0标准的BPMS��程引擎Activiti 5.0正式版推出，由Tijs Rademakers �?Ron Van Liempd�~�写的‘实战Activiti’书�c�昨天在“Manning Early Access Program”现�w�。目前第一章释出，可以先睹为快。呵呵，真棒�Q�本��是�W�一章之�Q?�Q?nbsp; 阅读全文

�|��\��L(f��ng)��@BlogJava 2011-01-04 20:43 发表评论

�|��\��L(f��ng)��@BlogJava — Mon, 03 Jan 2011 09:59:00 GMT
     摘要: 随着�W�合BPMN 2.0标准的BPMS��程引擎Activiti 5.0正式版推出，由Tijs Rademakers �?Ron Van Liempd�~�写的‘实战Activiti’书�c�昨天在“Manning Early Access Program”现�w�。目前第一章释出，可以先睹为快。呵呵，真棒�Q�本��是�W�一章之�Q?�Q?nbsp; 阅读全文

�|��\��L(f��ng)��@BlogJava 2011-01-03 17:59 发表评论

�|��\��L(f��ng)��@BlogJava — Mon, 03 Jan 2011 08:06:00 GMT
     摘要: 随着�W�合BPMN 2.0标准的BPMS��程引擎Activiti 5.0正式版推出，由Tijs Rademakers �?Ron Van Liempd�~�写的‘实战Activiti’书�c�昨天在“Manning Early Access Program”现�w�。目前第一章释出，可以先睹为快。呵呵，真棒�Q�本��是�W�一章之�Q?�Q?nbsp; 阅读全文

�|��\��L(f��ng)��@BlogJava 2011-01-03 16:06 发表评论

�|��\��L(f��ng)��@BlogJava — Sun, 02 Jan 2011 14:39:00 GMT
     摘要: 随着�W�合BPMN 2.0标准的BPMS��程引擎Activiti 5.0正式版推出，由Tijs Rademakers �?Ron Van Liempd�~�写的‘实战Activiti’书�c�昨天在“Manning Early Access Program”现�w�。目前第一章释出，可以先睹为快。呵呵，真棒�Q�本��是�W�一章之�Q?�Q?nbsp; 阅读全文

�|��\��L(f��ng)��@BlogJava 2011-01-02 22:39 发表评论

�|��\��L(f��ng)��@BlogJava — Sat, 01 Jan 2011 14:52:00 GMT
     摘要: 随着�W�合BPMN 2.0标准的BPMS��程引擎Activiti 5.0正式版推出，由Tijs Rademakers �?Ron Van Liempd�~�写的‘实战Activiti’书�c�昨天在“Manning Early Access Program”现�w�。目前第一章释出，可以先睹为快。呵呵，真棒�Q�本��是�W�一章之�Q?�Q?nbsp; 阅读全文

�|��\��L(f��ng)��@BlogJava 2011-01-01 22:52 发表评论

�|��\��L(f��ng)��@BlogJava — Sat, 01 Jan 2011 07:40:00 GMT
     摘要: 随着�W�合BPMN 2.0标准的BPMS��程引擎Activiti 5.0正式版推出，由Tijs Rademakers �?Ron Van Liempd�~�写的‘实战Activiti’书�c�昨天在“Manning Early Access Program”现�w�。目前第一章释出，可以先睹为快。呵呵，真棒�Q�本��是�W�一章之�Q?�Q?nbsp; 阅读全文

�|��\��L(f��ng)��@BlogJava 2011-01-01 15:40 发表评论

�|��\��L(f��ng)��@BlogJava — Sat, 18 Dec 2010 13:54:00 GMT
     摘要: 随着�W�合BPMN 2.0标准的BPMS��程引擎Activiti 5.0正式版推出，由Tijs Rademakers �?Ron Van Liempd�~�写的‘实战Activiti’书�c�昨天在“Manning Early Access Program”现�w�。目前第一章释出，可以先睹为快。呵呵，真棒�Q�本��是�W�一章之�Q?�Q?nbsp; 阅读全文

�|��\��L(f��ng)��@BlogJava 2010-12-18 21:54 发表评论

Activiti in Action�Q�实战Activiti�Q?目录

�|��\��L(f��ng)��@BlogJava — Thu, 16 Dec 2010 14:33:00 GMT
     摘要: 随着�W�合BPMN 2.0标准的BPMS��程引擎Activiti 5.0正式版推出，由Tijs Rademakers �?Ron Van Liempd�~�写的‘实战Activiti’书�c�昨天在“Manning Early Access Program”现�w�。目前第一章释出，可以先睹为快。呵呵，真棒�Q�本文是该书的目录�?nbsp; 阅读全文

�|��\��L(f��ng)��@BlogJava 2010-12-16 22:33 发表评论

�|��\��L(f��ng)��@BlogJava — Tue, 14 Dec 2010 12:56:00 GMT
     摘要: Activiti是一个轻量��的工作流和业务流�E�管理（BPM�Q�Business Process Management�Q��^台。其��目�ȝ��?qi��ng)首席架构师为Tom Baeyens�Q�原jBPM的创始�h�Q�Activiti为Tom另一力作。Activiti��Z��务�h员提供Activiti Cycle工具�Q��ؓ(f��)开发�h员提供Activiti 引擎�Q��ؓ(f��)�pȝ��理员提供Activiti Probe�Q�Activiti 探针�Q�一个系�l��^台治理工��P��。它的核心是一个针对Java�q�_��Z��BPMN 2的原生流�E�引擎，快若闪电(sh��)�Q�坚若磐矟뀂它是开源��Y�Ӟ��采用Apache许可分发。Activiti可运行在��M��Java应用�E�序�Q�在服务器，在集��，甚至在云计算环境均可�q�行。它可和Spring完美集成�Q�体型轻盈（lightweight�Q�，概念��z�。本文是对它所包含�l��g的介�l��?nbsp; 阅读全文

�|��\��L(f��ng)��@BlogJava 2010-12-14 20:56 发表评论

�|��\��L(f��ng)��@BlogJava — Mon, 13 Dec 2010 13:40:00 GMT
     摘要: Activiti是一个轻量��的工作流和业务流�E�管理（BPM�Q�Business Process Management�Q��^台。其��目�ȝ��为Tom Baeyens�Q�原jBPM的创始�h�Q�Activiti为Tom另一力作。Activiti��Z��务�h员提供Activiti Cycle工具�Q��ؓ(f��)开发�h员提供Activiti 引擎�Q��ؓ(f��)�pȝ��理员提供Activiti Probe�Q�Activiti 探针�Q�一个系�l��^台治理工��P��。它的核心是一个针对Java�q�_��Z��BPMN 2的原生流�E�引擎，快若闪电(sh��)�Q�坚若磐矟뀂它是开源��Y�Ӟ��采用Apache许可分发。Activiti可运行在��M��Java应用�E�序�Q�在服务器，在集��，甚至在云计算环境均可�q�行。它可和Spring完美集成�Q�体型轻盈（lightweight�Q�，概念��z�。本文是Activiti�|�站上一��文章“The Process Cycle Layer”的��译�?nbsp; 阅读全文

�|��\��L(f��ng)��@BlogJava 2010-12-13 21:40 发表评论

�|��\��L(f��ng)��@BlogJava — Sat, 11 Dec 2010 12:40:00 GMT
     摘要: 摘要: Activiti是一个轻量��的工作流和业务流�E�管理（BPM�Q�Business Process Management�Q��^台。其��目�ȝ��为Tom Baeyens�Q�原jBPM的创始�h�Q�Activiti为Tom另一力作。Activiti��Z��务�h员提供Activiti Cycle工具�Q��ؓ(f��)开发�h员提供Activiti 引擎�Q��ؓ(f��)�pȝ��理员提供Activiti Probe�Q�Activiti 探针�Q�一个系�l��^台治理工��P��。它的核心是一个针对Java�q�_��Z��BPMN 2的原生流�E�引擎，快若闪电(sh��)�Q�坚若磐矟뀂它是开源��Y�Ӟ��采用Apache许可分发。Activiti可运行在��M��Java应用�E�序�Q�在服务器，在集��，甚至在云计算环境均可�q�行。它可和Spring完美集成�Q�体型轻盈（lightweight�Q�，概念��z�。本文是Activiti�|�站上FAQ的翻译�?  阅读全文

�|��\��L(f��ng)��@BlogJava 2010-12-11 20:40 发表评论

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

�|��\��L(f��ng)��@BlogJava — Sat, 04 Dec 2010 17:37:00 GMT

Chapter 1. Introduction�Q�简介）

Table of Contents

License�Q�授权）
Download�Q�下载）
Sources�Q�源代码�Q?/a>
Required software�Q�依赖的软�g�Q?/a>
Reporting problems�Q�报告问题）
Experimental features�Q�实验性特性）

License�Q�授权）

Activiti is distributed under the Apache V2 license.

Download�Q�下载）

http://activiti.org/download.html

Sources�Q�源代码�Q?/h4>
The distribution contains most of the sources as jar files. To find and build the full source codebase, please read the

Required software�Q�依赖的软�g�Q?/h4>

JVM 5+

Ant 1.7.1+

Reporting problems�Q�报告问题）

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

每个自重的开发�h与应当阅�?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

�?a >the Users forum上完成粘贴问题和意见之后�Q�在our JIRA issue tracker 上徏立问题（issues).

Experimental features�Q�实验性特性）

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

�Q�标��Cؓ(f��) [EXPERIMENTAL] 的小节应当视��Z��E�_��的�?/p>

�|��\��L(f��ng)��@BlogJava 2010-12-05 01:37 发表评论

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

�|��\��L(f��ng)��@BlogJava — Sat, 04 Dec 2010 17:35:00 GMT

Chapter 2. Getting Started�Q�入门指南）

Table of Contents

Demo setup�Q�安装演�C�）
Example projects in the workspace�Q�工作区里的�C�Z��目�Q?/a>
Library dependencies�Q�库依赖�Q?/a>
Eclipse setup�Q�Eclipse下的安装�Q?/a>
Inspecting the database�Q�检查数据库�Q?/a>

Demo setup�Q�安装演�C�）

Setup is an ant script located in directory setup that helps you get up and running with Activiti quickly.
安装是一个放�|�在目录里的脚本。它帮助用户快速徏立�ƈ�q�行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.
��Z��q�行脚本�Q�需要一个可以工作的安装。也要确�?em>JAVA_HOME �?ANT_HOME�pȝ��变量讄��正确。虽然具体的讄��方式�Ҏ(gu��)��操作�pȝ��不同而相异，但是为如何完成这些设�|�提供了描述。演�C�安装脚本在下测试通过�?
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.
��Z��针对你的环境配置安装�Q�请更新属性文�?code>build.properties �?build.{your-database}.properties。�ؓ(f��)了获取更多可配置属性和潜在的值的信息�Q�请仔细��(g��)查这些文件�?
The easiest target to get started is open a command prompt in de setup folder and type:
入门最�Ҏ(gu��)��的目标是在setup文�g�Ҏ(gu��)��开一个命令提�C��ƈ键入�Q?pre>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:
�q�个目标��启动Tomcat。如果正在��用H2数据库，它也��启动H2数据库。若是第一�ơ执行安装，它也��执行下列安装：(x��)

(*) 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目录里�?/p>

(*) 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是缺省的数据库�?/p>

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数据库时�Q�才完成�q�一步。如果采用不同的数据库，那么假定数据库已�l�启动�ƈ�q�行了�?/p>

(*) Create the Activiti tables in the database
(*) 在数据库里徏立Activiti库表

(*) Insert the demo users and groups in the Activiti identity tables (see below)
(*) ��示例用户和�l�插入到 Activiti identity表（见下�Q��?/p>

(*) Deploy the example processes to the Activiti Engine DB
(*) ��示例流�E�部�|�至Activiti Engine DB�?/p>

(*) Download Tomcat if not available in the ${downloads.dir}
(*) 如果在目录里面没有Tomcat�Q�就下蝲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�?/p>

(*) Deploy the REST interface webapp into tomcat
(*)部��vREST接口webapp值Tomcat

(*) Download the Activiti Modeler webapp to ${activiti.home}/webapps
(*) ��Activiti Modeler webapp下蝲�?{activiti.home}/webapps目录�?/p>

(*) Deploy the Probe, Explorer and Modeler webapps into tomcat.
(*) ��Probe, Explorer and Modeler webapps部��v至Tomcat�?/p>

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之后�Q�Tomcat��在后台�q�行。�ؓ(f��)了停止这些进�E�，误��?ant demo.stop。在构徏脚本里的其它目标也能够单个调用。它们将考虑考虑可配�|�属性。详情可以运�?code>ant -p 得到�?
These are the demo users:
�q�些事示例用��P��(x��)

Table 1.1. The demo users�Q�示例用��P��
UserId
Password
Security roles
kermit
kermit
admin
gonzo
gonzo
manager
fozzie
fozzie
user
Now you can access following web applications:
现在�Q�你能访问下列web 应用�E�序:

Table 1.2. The webapp tools�Q�webapp工具�Q?/b>
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�C�Z��安装时�ؓ(f��)了尽快，��容易展现Activiti功能和能力的一�U�方式。但是这�q�不意味着�q�是采用Activiti的唯一方式。Activiti只是一个jar包，它可以嵌入到��M��Java环境�Q�Swing或者Tomcat�Q�JBoss,WebSphere�{�等。或者你能选择��Activiti作�ؓ(f��)一个典型的�Q�独立的BPM服务器。Java若在�Q�Activiti��在�Q?
Example projects in the workspace�Q�工作区里的�C�Z��目�Q?/h4>
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: 把这一�p�d��C�Z��展示了Activiti的通用用法�Q�保存在DB里的BPMN��程定义和流�E�执行。还有持久化API使用的示例�?
�q�个��目包含了eclipse的项目文�Ӟ��一个ant构徏文�g和一个maven pom文�g。ant 构徏文�g和maven pom文�g�怺�独立。作��Z��的构建部分，��Z��构徏和部�|�流�E�，两者展�C�Z��能够使用ant和maven�q�行构徏�?/p>

activiti-spring-examples: These examples show how you can use the Activiti Engine in a Spring environment.
activiti-spring-examples: �q�些�C�Z��展示在Spring环境下如何��用Activiti引擎�?/p>

activiti-groovy-examples: These examples show the library dependencies for groovy and an example process with groovy scripting.
activiti-groovy-examples: dd�q�些�C�Z��展示了groovy的依赖库和用groovy脚本处理的示例流�E��?/p>

activiti-jpa-examples: These examples show library dependencies and how you can work with JPA in Activiti.
activiti-jpa-examples: �q�些�C�Z��展示了JPA的依赖库�Q�以�?qi��ng)在Activiti里采用JPA是如何工作的�?/p>

activiti-cycle-examples: This is a project containing an demo example project for Activiti Cycle
activiti-cycle-examples: �q�是一个包含针对Activiti Cycle的示例项目�?/p>

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: �q�是一个在�C�Z��安装里配�|�Activiti Modeler所需的基于模型的仓库�?/p>

the section called “Eclipse setup�Q�Eclipse下的安装�Q��?/a> shows how you can set up your eclipse environment to play with these example projects.
the section called “Eclipse setup�Q�Eclipse下的安装�Q��?/a> 展示了如何安装eclipse环境来熟�(zh��n)�这些示例项目�?
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:
作�ؓ(f��) demo.start的部分，��展开�q�些事例�?�q�意味着所有的库和配置文�g��安�|�就位。如果不�q�行demo.start而将�C�Z��和库展开到合适的位置�Q�运行安装目录下的这个命令：(x��)
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.
一旦完�Q�将包含 activiti-engine-examples �?code>activiti-spring-examples目录。这些目录相应地包含而来�q�行时所依赖的jar包和��试时依赖的jar包�?
Library dependencies�Q�库依赖�Q?/h4>
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.
吧�ؓ(f��)了防止由于库包含多次而��发布文�g变得太大�Q�所有的库被分组到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文�g里面的ant 脚本能够展开�C�Z�� (target inflate.examples) �?qi��ng)其库。当构徏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 �Q��ƈ且在setup/files/dependencies 目录里下列文件描�q�C��库依赖：(x��)

libs.engine.runtime.txt: The library runtime dependencies to run the Activiti Engine.
libs.engine.runtime.txt: �q�行Activiti引擎的运行时依赖库�?/p>

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: ��Z��q�行��试�Q�需要加入到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: ��Z��使用groovy脚本能力�Q�需要加入到libs.engine.runtime.txt 的库�?/p>

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: ��Z��使用JPA变量引用能力�Q�需要加入到libs.engine.runtime.txt 的库�?/p>

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引擎的运行期依赖库。（�q�个列表包含�?code>libs.engine.runtime.txt�Q?/p>

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环境下，��Z��试�Q�需要加入到libs.spring.runtime.txt 下的库�?/p>

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: 相关�l��gcycle�Q�rest webapp和像Activiti Explorer, Activiti Probe �?Activiti Cycle之类的UI Webapp所需依赖库的全部列表�?

Eclipse setup�Q�Eclipse下的安装�Q?/h4>
To run and play with the examples in your eclipse, follow these simple instructions:
��Z��在eclipse里运行示例，遵从�q�些��单的指��o(h��)�Q?
File --> Import...
File --> Import...

Select General --> Existing Projects into Workspace and click Next
选择 General --> Existing Projects into Workspace�q�点�?code>Next

Click 'Browse...', select the directory ${activiti.home}/workspace and you'll see the example projects being automatically selected.
点击 'Browse...'�Q�选择目录 ${activiti.home}/workspace �Q�那么将自动选择�C�Z��目�?
Then you can click Finish in the Import dialog and you're all set.
吧然后你在输出对话框能点�?y��n)L��钮，所有都讄��好了�?
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.
��Z��更加方便赯��Q�打开ant视图�Q�Window --> Show View --> Ant�Q��ƈ��文件拽至ant�H�口。通过在它们上面双击，现在你能�Ȁ�z�L��建目标�?
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.
如果你想当输入时�Q�BPMN 2.0 XML自动完成和校验，可以��BPMN 2.0 XML Schema 加入到XML分类里面。导航至Preferences --> XML --> XML Catalog --> Add�Q�从文�g�pȝ��里的文�g多w��?code>docs/xsd/BPMN20.xsd选择XML Schema�?

Inspecting the database�Q�检查数据库�Q?/h4>
To check out the database while trying out the demo setup, run the following Ant target in the setup folder:
当尝试示例安装时�Q��ؓ(f��)了检查数据库�Q�运行在文�g夹下的Ant目标�Q?pre>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:
�q�将引导H2 Web控制台。注意Ant 目标�q�不�q�回�Q�所以�ؓ(f��)了关闭控制台�Q�需要键�?em>'CTRL + C'。在 JDBC URL字段里填入URL�Q��ƈ点击“connect”：(x��)
jdbc:h2:tcp://localhost/activiti

You are now able to browse the Activiti database schema and check the content of the tables.
现在你能��览Activiti数据库结构�ƈ��(g��)查数据库表里面的内容�?
To change the database, see ???
��Z��改变数据库，参见 ???�?img src ="http://www.aygfsteel.com/lewhwa/aggbug/339824.html" width = "1" height = "1" />

�|��\��L(f��ng)��@BlogJava 2010-12-05 01:35 发表评论

Activiti User Guide�Q�Activiti用户指南)-Chapter 3. Configuration�Q�配�|�）

�|��\��L(f��ng)��@BlogJava — Sat, 04 Dec 2010 17:32:00 GMT

Chapter 3. Configuration�Q�配�|�）

Table of Contents

Creating a ProcessEngine�Q�徏立一个流�E�引擎）
ProcessEngineConfiguration bean
Database configuration�Q�数据库配置�Q?/a>
Job executor activation�Q�作业执行器�Ȁ�z�）
Mail server configuration�Q�邮件服务器配置�Q?/a>
History configuration�Q�历史配�|�）
Supported databases�Q�支持的数据库）
Changing the database�Q�改变数据库�Q?/a>
Downloading the Oracle driver�Q�下载Oracle�Q?/a>

Creating a ProcessEngine�Q�徏立一个流�E�引擎）

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文�g来配�|�。注意你采用构徏��程引擎的Spring风格的方�?a href="file:///G:/作品/userguide/src/Zh_CN.html/#">the Spring style of building a process engine�Q�这�U�方式�ƈ不适合

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

获取ProcessEngine最�Ҏ(gu��)��的方式是使用org.activiti.engine.ProcessEngines�c�：(x��)

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.

�q�将在classpath上寻�?activiti.cfg.xml文�g�Q��ƈ在那个文件的配置之上构徏一个引擎。下列片�D�|��C�Z��一个示例配�|�。下面部分将�l�出详细的配�|�特性的��M��概观�?/p>

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.

注意配置文�g事实上是一个Spring配置�?strong>�q��ƈ不意味着Activiti只能在Spring环境下��? ��Z��构徏引擎�Q�我们在内部��单地�q��了解析和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).

通过使用配置文�g�Q�也能通过�~�程方式建立ProcessEngineConfiguration对象。��用一个不同的bean id也是可能的。（例如�Q�见�W?行）�?/p>
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).

不��用配�|�文件也是可能的�Q�基于缺省徏立一个配�|�（详情参见不同支持的类�Q?a href="file:///G:/作品/userguide/src/Zh_CN.html/#configurationClasses">the different supported classes�Q�）

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()的方法返回一个能�q�一步配�|�的ProcessEngineConfiguration 。在调用操作之后�Q�徏立一�?code>ProcessEngine �?/p>
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 必须包括��h��id 'processEngineConfiguration'的bean�?/p>

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):

得到�q�个bean然后用来构徏e ProcessEngine。可以定�?code>processEngineConfiguration的类有多个。这些类表示不同的环境，响应地设�|��ؓ(f��)�~�省。�ؓ(f��)了减��需要配�|�引擎的属性数量，选择的类以匹配环境是最�?j��ng)_��c(di��n)��当前可获得的类如下�Q�将来的版本��推出新的类�Q?

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��考虑事务。缺省地�Q�只有在引擎引导时检查数据库�Q�如果没有Activiti schema或者schema版本不正��，��抛出异常）�?/p>

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: �q�是一个针对单元测试目的的便捷�c�R��Activiti��考虑事务。缺省��用H2内存数据库。当引擎引导�q�关闭时�Q�数据库��被建立和删除。当使用�Ӟ��可能需要额外的配置�Q�当使用作业执行器或者邮件能力的�C�Z��除外�Q?/p>

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环境下��用流�E�引擎时使用。详情参见Spring集成部分the Spring integration section�?/p>

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事务的单独模式运行时使用�?/p>

Database configuration�Q�数据库配置�Q?/h4>
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:

有两�U�方式类配置引擎��用的数据库。第一个选项是定义数据库的jdbc属性：(x��)

jdbcUrl: jdbc url of the database.

jdbcUrl: 数据库的jdbc url�?/p>

jdbcDriver: implementation of the driver for the specific database type.

jdbcDriver: 特定数据库驱动的实现�?/p>

jdbcUsername: username to connect to the database.

jdbcUsername: �q�接到数据的用户名�?/p>

jdbcPassword: password to connect to the database.

jdbcPassword: �q�接到数据库的密码�?/p>

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):

��Z��所提供的jdbc属性所构徏的数据源��有的连接池讄��?

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

jdbcMaxActiveConnections: 在�Q何时刻连接池最大能够包含的可以�Ȁ�zȝ��q�接数。缺省�ؓ(f��)10.

jdbcMaxIdleConnections: The number of idle connections that the connection pool at maximum at any time can contain.

jdbcMaxIdleConnections:在�Q何时刻连接池最大能够包含的�I�闲的连接数

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: 在连接强制返回之前，能够从连接池��(g��)��Z��个连接所需的以毫秒计算的时间倹{�?/p>

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: �q�是一个底层的讄��Q�给�q�接池一个打印日志状态�ƈ重试�q�接获取的机�?x��)。在�q�种情况下通常占用很长旉��Q�以避免如果�q�接池位�|�不好导致导致�?zh��n)�无声息地��p�|�Q�，�~�省�?0000�Q?0�U�）�?/p>

Example database configuration:

�C�Z��数据库配�|�：(x��)

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

可选，可以使用 javax.sql.DataSource的实玎ͼ�例如Apache Commons的DBCP�Q�：(x��)

...

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�q�不包含允许定义如此数据源的Java库。所以，��保�q�些�Q�例如，从DBCP而来�Q�在你的classpath里面�?

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

不管采用jdbc�q�是数据源方法，可以讄��下列属性：(x��)

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 需要。这个设�|�将军_��要使用哪个建立/删除脚本。要了解支持哪些�c�d��的概要，请参�?a href="file:///G:/作品/userguide/src/Zh_CN.html/#supporteddatabases">the 'supported databases' section �?/p>

databaseSchemaUpdate: allows to set the strategy to handle the database schema on process engine boot and shutdown.

databaseSchemaUpdate�Q�允许当��程引擎引导和关闭时�Q�设�|�处理数据库�l�构采取的策略�?

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 �Q�缺省）�Q�当��程引擎建立�Ӟ��(g��)查DB和库的版本。如果版本不匚w��Q�将抛出异常�?/p>

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:一旦流�E�引擎构建完成，执行一个检查。如果有必要�Q�更新数据库的结构。如果结构不存在�Q�就创徏它�?/p>

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�Q�在��程引擎创徏时创建结构；当流�E�引擎时到达删除�l�构�?/p>

Job executor activation�Q�作业执行器�Ȁ�z�）

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.

作业执行器是一个管理点火定时器一对线�E�的�l��g�Q�之后也叫异步消息）。对于单元测试场景，和多个线�E�一道工作是�ȝ��(ch��)的。所以API允许通过API查询 (ManagementService.createJobQuery) �q�执行作�?(ManagementService.executeJob) 以便从一个单元测试里控制作业执行。�ؓ(f��)了避免作业干扎ͼ�可以��x��它�?

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

�~�省圎ͼ�当流�E�引擎引导时�Ȁ�z�JobExecutor。指�?/p>

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

当流�E�引擎引导时�Q��ƈ不想�Ȁ�z?JobExecutor�?

Mail server configuration�Q�邮件服务器配置�Q?/h4>
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 支持在业务流�E�里发送电(sh��)子邮件。事实上�Q��ؓ(f��)了发送邮�Ӟ��需要配�|�一个有效的SMTP邮�g服务器配�|�。这个配�|�可选项参见e-mail task �?

History configuration�Q�历史配�|�）

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

可选项。允许媄(ji��ng)响引擎的历史能力history capabilities的设�|�。详情参�?a href="file:///G:/作品/userguide/src/Zh_CN.html/#">history configuration �?/p>

Supported databases�Q�支持的数据库）

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

下表是Activiti所使用的数据库表类型（大小写敏感的�Q��?

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�Q�改变数据库�Q?/h4>
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:

在某些点你可能想做的其中一件事是配�|�来使用不同的数据库。�ؓ(f��)了配�|�演�C�安装或者�ؓ(f��)不同数据库��生一个配�|�文�Ӟ��遵从�q�些步骤�Q?

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

�~�辑 setup/build.properties �q�将db参数变�ؓ(f��)你的数据库的�c�d�� {oracle | mysql | postgresql | h2}�?/p>

Edit setup/build.${db}.properties and change the JDBC connection parameters to those of your database installation.

�~�辑setup/build.${db}.properties�q�将JDBC�q�接参数变�ؓ(f��)你所安装数据库的那些参数�?/p>

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

��Z��建立一个基于你所指定build.*.properties 文�g的属性的配置文�g。请�q�行

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

�?code>setup 文�g夏V��生的配置文�g�?code>setup/build/activiti-cfg里能够找到�?��Z��方便赯��Q�一个叫activiti-cfg.jar的jar包包含了能够�?code>setup/build 里找到的配置文�g�?

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

如果你想在另一个数据库上运行演�C�安装，首先用下面的命��o(h��)停止�C�Z��安装

ant demo.stop demo.clean demo.start

Then clean and re-start the demo setup with

然后清除�q��新启动演�C�安装：(x��)

ant demo.clean demo.start

Downloading the Oracle driver�Q�下载Oracle�Q?/h4>
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作�ؓ(f��)数据源来�q�行演示安装�Q�在调用ant目标 demo.start�?strong>�?/strong>�Q�必��要有额外的步骤�Q?

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).

因�ؓ(f��)�׃��Oracle JDBC Driver的授权原因，我们不能重新分发它，所以你应当手动下蝲�Q?a >http://www.oracle.com/technetwork/database/enterprise-edition/jdbc-112010-090769.html。确保下载的是ojdbc5.jar�Q�）

Copy the downloaded ojdbc5.jar to setup/files/dependencies/libs/ This filename is

拯��下蝲的ojdbc5.jar至setup/files/dependencies/libs/�?/p>

�|��\��L(f��ng)��@BlogJava 2010-12-05 01:32 发表评论

�|��\��L(f��ng)��@BlogJava — Sat, 04 Dec 2010 17:30:00 GMT

Chapter 4. Spring integration�Q�Spring集成�Q?/h4>
Table of Contents

ProcessEngineFactoryBean
Transactions�Q�事务）
Expressions�Q�表辑ּ��Q?/a>
Automatic resource deployment�Q�自动资源部�|Ԍ��
Unit testing�Q�单元测试）

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

��管你肯定能够不用��用Spring而��用Activiti�Q�但是本章将解释一些优�U�的Spring集成�Ҏ(gu��)��?

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能够配置��Z��个普通的Spring bean。集成的开始点是类org.activiti.spring.ProcessEngineFactoryBean。那个bean提取一个流�E��ƈ建立��程引擎。这意味着�Ҏ(gu��)��和所有在配置部分的归��的配置属性，完全和Spring相同�Q?/p>
...

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

一定要注意�Q�processEngineConfiguration bean现在使用org.activiti.spring.SpringProcessEngineConfiguration �c�R�?

Transactions�Q�事务）

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�C�Z��?code>SpringTransactionIntegrationTest 。这里是�q�个�C�Z��里所使用的配�|�文�?位置在SpringTransactionIntegrationTest-context.xml�Q�。引号部分包含了数据源，事务��理器，��程引擎和Activiti引擎服务�?/p>
...

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

Spring配置文�g的其余部分包含了bean和在�q�个�C�Z��所使用的配�|�：(x��)

...

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:

首先�Q�用��M��Spring方式建立应用�E�序上下文。在本例�Q�能够��用一个classpath XML 资源来配�|�我们的Spring应用�E�序上下文：(x��)

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

or since it is a test:

或者它是一个测试：(x��)

@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�q�调用它们之上的�Ҏ(gu��)��。将对一个应用繁�D�的�Q�在Activiti服务�Ҏ(gu��)��之上必要的事务语义服务增加一个额外的拦截器。所以我们能够像下面来部�|�一个流�E�来使用 repositoryService�Q?/p>
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.

其它�Ҏ(gu��)��也可工作。在�q�种情况下， Spring事务��包围在�Ҏ(gu��)��附近。Activiti服务�Ҏ(gu��)��调用��加入同一事务�?/p>
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看�v来如此。记得吗�Q�在上面的Spring bean配置里，已将repositoryService注入到userBean�?/p>
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�Q�表辑ּ��Q?/h4>
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�Ҏ(gu��)��表达式调�?在Spring bean上一个方法�?/p>
activiti:expression="#{printer.printMessage()}" />

Where Printer looks like this:

�q�里 Printer 看�v来如下：(x��)

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

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

Spring bean配置�Q�如上所�C�）看�v来如下：(x��)

...

Automatic resource deployment�Q�自动资源部�|Ԍ��

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集成也�ؓ(f��)部��v资源提供一个特�D�的�Ҏ(gu��)��。在��程引擎配置里，你能指定一�p�d��资源。当建立资源引擎�Ӟ��扫描�ƈ部��v所有这些资源。存在一个防止复刉��|�的�q��o(h��)器。只有当资源实际上已�l�发生变化时�Q�才��新的部�|�才部��v到Activiti 数据库里。这个需要Spring容器需要经帔R��新引��|��比如��试�Q�的地方才有意义�?

Here's an example

�q�里有个�C�Z��

...

Unit testing�Q�单元测试）

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集成�Ӟ��采用标准的测试设�?a href="file:///G:/作品/userguide/src/Zh_CN.html/#">Activiti testing facilities让业务流�E�的��试轻而易举。下例展�C�在一个典型基于Spring的单元测试里面一个业务流�E�是如何��试的�?/p>
@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).

注意�Q��ؓ(f��)了让�q�个能够工作�Q�需要在Spring配置里面定义一�?em>org.activiti.engine.test.ActivitiRule bean�Q�在上例里通过auto-wiring 注入�Q��?/p>

�|��\��L(f��ng)��@BlogJava 2010-12-05 01:30 发表评论

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

�|��\��L(f��ng)��@BlogJava — Sat, 04 Dec 2010 17:27:00 GMT

Chapter 5. API

Table of Contents

Engine API�Q�引擎API �Q?/a>
Exception strategy�Q�异常处理策略）
Unit testing�Q�单元测试）
The process engine in a webapplication�Q�在Web应用里的��程引擎�Q?/a>
Process Virtual Machine API�Q�流�E�虚拟机API�Q?/a>
Expressions�Q�表辑ּ��Q?/a>

Engine API�Q�引擎API �Q?/h4>
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章节里描�q�的那样�Q�它可以用几�U�方法徏立。从 ProcessEngine 里能够获得包括工作流/BPM�Ҏ(gu��)��的各�U�各��L(f��ng)��服务�?因�ؓ(f��)ProcessEngine和服务对象是�U�程安全的，所以能够�ؓ(f��)整个服务器范围保留这些服务的引用�?�?

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.

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

Exception strategy�Q�异常处理策略）

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都可抛出�q�个异常�Q�但�?某些�Ҏ(gu��)��产生'expected'异常。在 the javadocs里面对这�U�异常进行了文��化。例如，下面是一个从 TaskService 抽取一�D�代码：(x��)

/** * 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.

在上例，当传递一个不存在的�Q务的id�Q�将�?x��)抛��Z��个异常。当�?d��ng)��javadoc 明明白白说明taskId不能为null�Q�当传递null�Ӟ��抛�?ActivitiException �?

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

��管我们竭力避免一个庞大的异常层次体系�Q�但�q�是在特�D�情况下增加了如下的子类�?

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

ActivitiWrongDbException: 当Activiti引擎发现数据库结构版本和引擎版本之间不匹配时�Q�将抛出�q�个异常�?/p>

ActivitiOptimisticLockingException: Thrown when an optimistic locking occurs in the datastore caused by concurrent access of the same data entry.

ActivitiOptimisticLockingException: 当数据库里由对相同的数据��ƈ发访问导致乐观锁定时发生�?/p>

Unit testing�Q�单元测试）

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.

业务��程是��Y仉��目的一个集成部分，那么应当采用正常应用逻辑��试 �Q�采用单元测试。因为Activiti是一个嵌入式Java引擎�Q�所以编写业务流�E�的单元��试像编写正常的单元��试一��L(f��ng)��单�?

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�?风格。在Junit 3风格里，必须扩展org.activiti.engine.test.ActivitiTestCase。这��得通过保护成员字段获得��程引擎和服务。在��试的setup()里，�~�省地流�E�引擎将通过classpath上的 activiti.cfg.xml 资源初始化流�E�引擎。�ؓ(f��)了指定不同的配置文�g�Q�覆�?getConfigurationResource() �Ҏ(gu��)��。当配置资源是相同时�Q�流�E�引擎静态地�~�存多个单元��试�?

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 �Q�你能用org.activiti.engine.test.Deployment标注��试�Ҏ(gu��)��。在�q�行��试以前�Q�将同一包里部��v�?testClassName.testMethod.bpmn20.xml作�ؓ(f��)��试�c�R��在��试�l�束�Q�将删除包括所有相关的��程实例�Q��Q务等�{�部�|�Ӏ?em>Deployment 标注也支持显式设�|�资源的位置。详情参�?the Javadocs�?

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

��上面所有的情况考虑�q�去�Q�Junit 3风格的测试方式如下所�C��?/p>
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风格�~�写单元��试�Ӟ��Z��获得相同的功能，必须使用 org.activiti.engine.test.ActivitiRule 规则。采用这个规则，通过getter获得��程引擎和服务。采�?ActivitiTestCase�Q�如上）�Q�包括��?org.activiti.engine.test.Deployment �Q�它的��用和配置如上�Q�标注的�q�个规则�Q�它?y��u)��在classpath上寻扄��省的配置。当使用相同配置资源�Ӟ��程引擎静态地�~�存多个单元��试�?

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

下面代码片段展示了采用的Junit 4风格的测试和 ActivitiRule用法的示例�?/p>
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�Q�在Web应用里的��程引擎�Q?/h4>
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 是一个线�E�安全的�c�dƈ能在多个�U�程里面��L��׃�n。在一个Web应用里面�Q�这意味着当容器引导和关闭引擎�Ӟ��可能建立�q�个��程引擎�?

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

下列代码通过使用 ServletContextListener�Q�展�C�Z��在一个普通的 Servlet 环境下如何完成这个工作的�?/p>
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委托�l?ProcessEngines.init()。它?y��u)��在classpath上寻�?activiti.cfg.xml 资源文�g�Q��ƈ且�ؓ(f��)�l�定的配�|�徏�?ProcessEngines。如果在classpath上具有多个如此的资源文�g�Q�确保它们都��h��不同的名字。当需要流�E�引擎时�Q�它?y��u)��采用下面的��?gu��)��来取�?/p>
ProcessEngines.getDefaultProcessEngine()

or

�?/p>
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.

当然�Q�采用徏立流�E�引擎的变体也是可能的。如 configuration section所�C��?

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

context-listener 的contextDestroyed 委托�l?code>ProcessEngines.destroy()

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

Process Virtual Machine API�Q�流�E�虚拟机API�Q?/h4>
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 �Q�API暴露��程虚拟机的POJO核心。�ؓ(f��)了理解Activiti的内部工作机制的教育目的�Q�阅��dƈ把玩API是有��的�?�q�且POJO API也能用来构徏新的��程语言�?

For example:

例如�Q?/p>
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�Q�表辑ּ��Q?/h4>
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�q�行表达式解析。UEL代表�l�一表达式（Unified Expression Language �Q�，它是JAVA EE 6规范�Q?the EE6 specification �Q�的一部分。�ؓ(f��)了在所有环境支持最新的UEL规范�Q�我们采用了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.

表达式能够在下列�C�Z��中��用：(x��) Java Service tasks, Execution Listeners, Task Listeners �?Conditional sequence flows。尽��存在两�U�表辑ּ��Q��D��辑ּ�和方法表辑ּ�。但是，Activiti�Ҏ(gu��)��q�行了抽象，在需要表辑ּ�的地方两者均可��用�?

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:

��D��辑ּ��Q�Value expression�Q?/strong>: 解析��Z��个倹{��缺省地�Q�所有的��程均可使用。表辑ּ�里也可��用所有的spring bean�Q�如果��用Spring�Q��?strong>在此之上�Q�在表达式上下文里也可获得DelegateExecution。因为，执行暴露�?code>execution�Q�带有名�U?code>execution的所有变量和spring-beans��被隐藏�Q��ƈ且不能在表达式里使用。例如：(x��)

${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:

�Ҏ(gu��)��表达式：(x��)调用一个方法，带不带参数均可。当调用没有参数的方法，��保在方法名之后加入�I�括受��这些传入的参数可以字面值或者被解析解释的表辑ּ�。例如：(x��)

Method expression:

�Ҏ(gu��)��表达式：(x��)

${printer.print()} ${myBean.addNewOrder('orderName')} ${myBean.doSomething(myVar, execution)}

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

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

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

��Z��更多的具体的用法和示例，��h��?Expressions in Spring�Q?a href="file:///G:/作品/userguide/src/Zh_CN.html/#">Java Service tasks�Q?a href="file:///G:/作品/userguide/src/Zh_CN.html/#">Execution Listeners�Q?Task Listeners 或�?a href="file:///G:/作品/userguide/src/Zh_CN.html/#">Conditional sequence flows�?

�|��\��L(f��ng)��@BlogJava 2010-12-05 01:27 发表评论

Activiti User Guide�Q�Activiti用户指南)-Chapter 6. Deployment�Q�部�|Ԍ��

�|��\��L(f��ng)��@BlogJava — Sat, 04 Dec 2010 17:23:00 GMT

Chapter 6. Deployment�Q�部�|Ԍ��

Table of Contents

Business archives�Q�业务��案）
Java classes�Q�Java�c�）
Deploying programmatically�Q�编�E�式部��v�Q?/a>
Deploying with ant�Q�以ant方式部��v�Q?/a>
Deploying with Activiti Probe�Q�以Activiti Probe部��v)
Versioning of process definitions�Q�流�E�定义的版本��理�Q?/a>

Business archives�Q�业务档案）

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.

��Z��部��v��程�Q�必��d��程打包为流�E��案。一个流�E�档案是Activiti引擎的部�|�单元。基本来��_(d��)��一个流�E��案等价于一个zip文�g。它包含了BPMN 2.0��程�Q��Q务表单，规则和其它文件类型。通常�Q�流�E��案包含一个命名资源的集合�?

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.

当部�|�业务档案时�Q�以.bpmn20.xml 扩展名�ؓ(f��)的BPMN文�g方式扫描来扫描它。每个BMPN文�g被扫描，它包含多个流�E�定义�?

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�c?strong>��不�?x��)加入到classpath。�ؓ(f��)了运行流�E�，业务��案里面的流�E�定义的所有定制类�Q�例如Java服务�c�L��者事件监听器实现�Q�应当包含在Activiti引擎的classpath里面�?

Java classes�Q�Java�c�）

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.

当启动一个流�E�实例（例如serviceTask或者event-listener�Q�TaskListener�Q�时�Q�定义在��程里面的所有定制类应当包含在引擎的classpath上面。当把流�E�定义部�|�到引擎�Ӟ��不必��哪些类攑ֈ�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�q�要加入你自��q��定制�c�L��Q�你应当��包含这些类的jar包添加至activiti-rest webapp lib里面。也不要忘记包含定制�cȝ��依赖包（如果有的话）�Q�这个和activiti-engine.jar位置相同。在发行版本中的如下位置扑ֈ��q�个文�g夹：(x��)

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

Deploying programmatically�Q�编�E�式部��v�Q?/h4>
Deploying a business archive from a zip file can be done like this:

以如下方式完成从zip文�g来部�|�流�E�档案：(x��)

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�Q�以ant方式部��v�Q?/h4>
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:

��Z��以ant方式来部�|�业务档案，首先需要定�?deploy-bar ��d��。确保配�|�jar包，Activiti jar�?qi��ng)其所有的依赖都在classpath路径里面�?/p>

Deploying with Activiti Probe�Q�以Activiti Probe部��v)

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

通过Probe也可以部�|�流�E�定义，�q�在Activiti Probe - Deployments里面描述�?

Versioning of process definitions�Q�流�E�定义的版本��理�Q?/h4>
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没有版本��理的概��c(di��n)��这是好事，因�ؓ(f��)可执行的BPMN��程文�g��作为开发项目的一部分�ȝ��在一个SVN的仓库里�Q�所以在部��v�Ӟ��才徏立流�E�定义的版本。在部��v期间�Q�在ProcessDefinition 保存到Activiti DB之前�Q�Activiti��ؓ(f��)它分布一个版本号�?

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

对于业务档案里的每个��程定义�Q�执行下列步骤初始化 key, version, name �?id �q�些属性：(x��)

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

��程id 属�?用作为流�E�定义的key�Ҏ(gu��)�?/p>

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 属�?用作为流�E�定义的�Ҏ(gu��)�?name 。如果没有指定name属性，那么id属性作为名�U�C��用�?/p>

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.

当一个带有特�D�key的流�E�第一�ơ部�|�时�Q�版本分配�ؓ(f��)1。对带有相同key的流�E�定义，在后�l�部�|�时�Q�每部��v一�ơ，在当前最大部�|�版本号上加1。key�Ҏ(gu��)��用来区分流�E�定义�?/p>

The id property is set to {processDefinitionKey}:{processDefinitionVersion}

id�Ҏ(gu��)��设�|��ؓ(f��){processDefinitionKey}:{processDefinitionVersion}

�|��\��L(f��ng)��@BlogJava 2010-12-05 01:23 发表评论

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

�|��\��L(f��ng)��@BlogJava — Sat, 04 Dec 2010 17:19:00 GMT
     摘要: Chapter 7. BPMN Table of Contents What is BPMN?�Q�何为BPMN�Q? Examples�Q�示例） Defining a process�Q�定义一个流�E�） Getting started: 10 minute tutorial�Q�开始：(x��)10分钟教程�Q? Use case�Q�用例） Process diagram�Q�流�E�图�Q? XML representat...  阅读全文

�|��\��L(f��ng)��@BlogJava 2010-12-05 01:19 发表评论

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

�|��\��L(f��ng)��@BlogJava — Sun, 28 Nov 2010 11:49:00 GMT

Chapter 08. Forms�Q�表单）

Table of Contents

Build-in form rendering�Q�内�|�表单渲染）
External form rendering�Q�外部表单渲染）
Form properties�Q�表单属性）

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��Z��的业务流�E�的手动步骤提供了一个方便和灉|��的增加表单的�Ҏ(gu��)��。我们�ؓ(f��)表单的工作支持两�U�策略：(x��)内置渲染和外部渲染�?

Build-in form rendering�Q�内�|�表单渲染）

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:

作�ؓ(f��)通过Activiti Explorer使用��d��表单的一个示例，demo setup脚本安装了业务流�E�。请��(g��)查示例的完整的源代码。业务流�E�图如下所�C�：(x��)

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

��Z��使用内置的渲染，在部�|�中必须包括表单文�g。通过如下的编�E�方式来完成�Q?/p>
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:

或者，首先通过构徏一个包含如上所�C�的��程和表单的业务��案zip文�g�Q�然后，如下部��v�q�个文�g。这些通过一个ant��d��来完成�?/p>

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 规范�q�没有指明�Q务或者�Q务表单应当如何渲染，使用Activiti特定的构造型来定义如此的表单。在�?startEvents�?userTask之上能够制定�q�个属�?userTask�?/p>
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).

当你采用自己的渲染时�Q�属性能够包含你所用来表明你的表单的�Q何文本倹{��但是内�|�的表单渲染器猜�?code>activiti:formKey 引用到同一业务��案�Q?部��v�Q�的一个资源�?

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。所以它把资源文件解析�ؓ(f��)a Juel expression 。解析结�?HTML String 被发送到客户。未来，我们希望加入表单引擎�Q�但是它需要更多的库依赖，所以我们优选把Juel作�ؓ(f��)�~�省的表单引擎�?

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.

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

And here is the contents of that form file:

�q�里是那个表单文件的内容�Q?/p>
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 客户应用�E�序的额外信息。这��h��览器��用这些隐藏字�D��ƈ加强相应输入字段。例如，制定某一文本字段是date�Q�Activiti Explorer ��加入一个日期选取器是可能的�?

Variable names must be camel-cased.

变量名必��L��骆驼方式的�?/p>

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):

保存的流�E�变量的�~�省值是 string。��用一个输入变量后面跟�?em>'_type' 的隐藏字�D�|��定义�c�d��Q�这样将HTML的输入约定�ؓ(f��)�q�个变量�Q�：(x��)

Currently supported are String, Integer, Boolean, Date.

当前支持的类型�ؓ(f��)�Q?em>String, Integer, Boolean, Date�?/p>

Input variables can be made required by adding a hidden field with the input variable name followed by '_required':

通过使用一个输入变量后面跟�?em>'_type' 的隐藏字�D�|��产生必须的输入变量�?/p>

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�c�d��用ISO 8601 (YYYY-MM-DD)来验证。这个字�D�也��用浏览器里的��M��本地日期拑֏�器（使用HTML5�?em>input type="date"�Q�。通过YUI calendar widget�q�回一个弹出日期拾取器。当�?d��ng)��也可能手动输入你自己的日期，�׃��输入的验证方法�?/p>

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表单字段也已�l�被加强产生HTML 5 input type=number。尽��Activiti-Explorer 提供客户端验证，但是在可支持HTML5的浏览器也提供内�|�验证和定制输入字段�?/p>

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.

可以预料�Q?Activiti Explorer 在未来将�?x��)��?FormService.getStartFormData来代替这些隐藏字�D�值来加强表单输入字段。那是�ؓ(f��)什么隐藏字�D�被标记为实验性的原因�?

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

通过API�Q��?FormService.getRenderedStartForm 来获取渲染表单字�W�串�?/p>
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:

以一个用户�ؓ(f��)表单输入的属性，采用 FormService.submitStartFormData来启动一个新的流�E�实例�?/p>
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�Q�表单属性）”

��Z��了解�?ProcessInstance RuntimeService.startProcessInstanceById(String processDefinitionId)比较�Q�以�q�个 FormService �Ҏ(gu��)��启动一个新的流�E�实例之间的差异�Q�请参见 read the section called “Form properties�Q�表单属性）” �?

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

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

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.

相关的用户�Q务具有和它绑定的��d��表单。。这些作��辑ּ�引用�Q�在�q�行期解析�ؓ(f��)它们的文本表�C��?/p>
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.

通过在表单里面选择合适的输入�Q�经理将在表单里面指�C�Z��假请求是否批注�?

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

�l�果作�ؓ(f��)一个流�E�变量保存，在表单提交之后在�ȝ��关里使用�?/p>
${!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.

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

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.

雇员现在能够选择重发休假��h��。这栯��l�理的用��h��E�重新执行。或者雇员可以抛弃这个请求，�l�止�q�个��程�?/p>
Adjust vacation Request

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

Number of days:

External form rendering�Q�外部表单渲染）

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.

上面我们展示了内�|�的��d��表单渲染。但是API也允�怽��?Activiti Engine之外执行你自��q��d��表单渲染器。这些步骤解释了你能使用的渲染你的�Q务表单的钩子�?

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).

必要的，渲染一个表单所需的所有数据被�l�装在这�q�个服务�Ҏ(gu��)��的其中之一�Q?code>StartFormData FormService.getStartFormData(String processDefinitionId) �?code>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)�Ҏ(gu��)��能够完成提交表单的属性�?

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

��Z��学习(f��n)表单属性如何映��到��程变量�Q�参�?a href="file:///G:/作品/userguide/src/Zh_CN.html/#formProperties">the section called “Form properties�Q�表单属性）” �?

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.

随便�Q��ؓ(f��)了其它�Q何目的，你能使用出除了�Q务表单之外访问部�|�资源的能力�?

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技术渲染不同的表单�Q�这可能方便。例如，一个表单用来在正常屏幕大小的Web应用使用�Q�一个表单在手机��屏�q��用，甚至是IM表单或者email表单的一个模�ѝ�? Form properties�Q�表单属性） 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. 与业务流�E�相关的所有信息既可包含流�E�变量自己，也可通过��程变量包括它们的引用。Activiti支持��复杂的Java对象保存为像 Serializable 对象�Q�JPA实体或者作为String 的整个XML文��的流�E�变量�? 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. 启动一个流�E�和完成��d��是�h们介入到��程的地斏V��和人通信需要采用一些UI技术来渲染表单。�ؓ(f��)了让多个UI技术和�q�_��处，��程定义能够包含转化逻辑�Q�将��程变量里面的复杂对象传化�ؓ(f��)一个属性的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. 然后��M��UI技术能在这些属性之上构��Z��个表单。这些属性能在这些流�E�变量之上提供一个专有（有更多限�Ӟ��视图。显�C�Z��个表单所需的属性在�q�回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: �~�省圎ͼ�内置的表单引擎，��?#8216;看见‘属性，正如看见��程变量一栗��所以，如果��d��表单属性和��程变量�?-1的匹配关�p�，没有必要对它声明�?/p> 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. 表单��看见所有的��程变量�Q��?formService.getStartFormData(String processDefinitionId).getFormProperties() ��ؓ(f��)�I��? 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} ��管属性从��程变量�l�承而来�Q�但是它们不必存储�ؓ(f��)��程变量。例如，一个流�E�变量可能是一个类Address的JPA实体。�ƈ且，由UI技术��用的表单属�?StreetName 能够和一个表辑ּ�#{address.street} �q�接�? 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. �c�d��U�定能够应用作�ؓ(f��)表单属性和��程变量之间处理环节的部分�? For example: 例如�Q?/p> Form property room will be mapped to process variable room as a String. 表单属�?room �Q�将作�ؓ(f��)一个String映射为流�E�变�?room�?/p> Form property duration will be mapped to process variable duration as a java.lang.Long 表单属�?duration �Q�将作�ؓ(f��)一个java.lang.Long映射为流�E�变�?duration�?/p> 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. 表单属性会(x��)��?speaker 映射为流�E�变�?SpeakerName。他只能在TaskFormData获得。如果提交属性speaker�Q�那么将�?x��)抛出ActivitiException。模拟地�Q�带有属�?readable="false"�Q�尽��一个属性将�?x��)�?FormData排除在外�Q�但是在提交里面仍将处理�?/p> 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在流�E�变量里面将�?x��)作为String映射为Java bean 属�?street 。如果没有提供这个属性，在提交期��_(d��)�� required="true" ��抛��Z��个异常�?/p> 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) 提供�c�d��元数据作��Z��StartFormData FormService.getStartFormData(String processDefinitionId) �?TaskFormdata FormService.getTaskFormData(String taskId)�q�回的FormData 的部分也是有可能的�? We support following form property types: 我们支持下列表单属性类型：(x��) 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信息�?/p> 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: 例如�Q?/p> 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() 获取�c�d��名；通过formProperty.getType().getInformation("datePattern")获取旉��模式�Q�通过formProperty.getType().getInformation("values") 获取枚�D倹{�? �|��\��L(f��ng)��@BlogJava 2010-11-28 19:49 发表评论
Activiti User Guide�Q�Activiti用户指南)-Chapter 09. JPA �|��\��L(f��ng)��@BlogJava — Sun, 28 Nov 2010 11:39:00 GMT Chapter 09. JPA Table of Contents Requirements�Q�需求） Configuration�Q�配�|�） JPA using ProcessEngineBuilder�Q��用ProcessEngineBuilder的JPA�Q?/a> JPA using Spring�Q��用Sping的JPA�Q?/a> Usage�Q�用法） Simple Example�Q�简单示例） Query JPA process variables�Q�查询流�E�变量） Advanced example using Spring beans and JPA�Q��用Spring beans和JPA的高�U�示例） You can use JPA-Entities as process variables, allowing you to: 你能使用作�ؓ(f��)��程变量的JPA-实体�Q�允�? Updating existing JPA-entities based on process variables, that can be filled in on a form in a userTask or generated in a serviceTask. 更新存在��Z��程变量的JPA-实体�Q�它被填充在userTask的表单里面，或者在serviceTask里面产生�?/p> Reusing existing domain model without having to write explicit services to fetch the entities and update the values 复用已存在的领域模型�Q�不必编写显式获取这些实体和更新�q�些数倹{�?/p> Make decisions (gateways) based on properties of existing entities. ��Z��存在实体属性作军_��Q�网养I�� ... Requirements�Q�需求） Only entities that comply to the following are supported: 只支持遵从下面标准的实体�Q? Entities should be configured using JPA-annotations, we support both field and property-access. Mapped super classes can also be used. 应当使用JPA-标注配置实体�Q�我们支持字�D�和属性方法。也能够使用已映��的��类�?/p> 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. 实体应当��h��标注为@Id的主键，不支持组合主�?(@EmbeddedId and @IdClass)。Id 字段/属性能够是JPA规范里�Q何支持的�c�d��:原子�c�d��和它们的包装�c�（wrapper)�Q�排除boolean�Q�，, String, BigInteger, BigDecimal, java.util.Date and java.sql.Date�?/p> Configuration�Q�配�|�） 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. ��Z��能够使用JPA-实体�Q�引擎必��d��有一个到EntityManagerFactory的引用。当在引擎上启用了JPA�Q�作为变量的JPA-实体��被自动��(g��)��ƈ作相应的处理�?
JPA using ProcessEngineBuilder�Q��用ProcessEngineBuilder的JPA�Q?/h5> When creating the ProcessEngine using the ProcessEngineBuilder, the method enableJPA should be called. 当��?ProcessEngineBuilder建立 ProcessEngine �Ӟ��必须调用�Ҏ(gu��)��enableJPA �?/p> ProcessEngine engine = new ProcessEngineBuilder() .configureFromPropertiesResource("activiti.properties") .enableJPA(entityManagerFactory, true, true) .buildProcessEngine(); This method accepts the following parameters: �q�个�Ҏ(gu��)��接受下列参数�Q?
entityManagerFactory: An instance of javax.persistence.EntityManagerFactory that will be used to load the Entities and flushing the updates.
entityManagerFactory: 一�?code>javax.persistence.EntityManagerFactory的实例，用作载入实体�q�刷新更新�?/p>

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的实例的事务标志。当使用时设�|?code>Java Transaction API (JTA) 为false�?/p>

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�Q�例如，当��用不是作用到单个事物的扩展持久化上下文）

JPA using Spring�Q��用Sping的JPA�Q?/h5>
The EntityManagerFactory should be set using the ProcessEngineFactoryBean, which is described in the section called “Configuration�Q�配�|�）” 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 �Q�在the section called “Configuration�Q�配�|�）”描述。作为示例，我们使用OpenJPA作�ؓ(f��)使用H2数据源的持久化提供者。如下的�C�Z��只从一个Spring配置文�g提取出来�Q��ƈ包含了相关的bean.

jpaEntityManagerFactory: An reference to a bean implementing javax.persistence.EntityManagerFactory that will be used to load the Entities and flushing the updates.

jpaEntityManagerFactory: 一个指向实�?code>javax.persistence.EntityManagerFactory的bean的引用，用来载入和刷新更新�?/p>

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的实例的事务标志。当使用时设�|?code>Java Transaction API (JTA) 为false�?/p>

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�Q�例如，当��用不是作用到单个事物的扩展持久化上下文）�?/p>

Usage�Q�用法）

Simple Example�Q�简单示例）

Examples for using JPA variables can be found in JPAVariableTest. We'll explain JPAVariableTest.testUpdateJPAEntityValues step by step.

�?JPAVariableTest里能扑ֈ�使用JPA变量的示例。将一步一步解�?code>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.

首先�Q�我们�ؓ(f��)我们的持久化单元建立 EntityManagerFactory �Q�这��Z��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�Q�配�|�）”.

引擎讄�� EntityManagagerFactory来支持JPA。请注意�Q�基于测试目的，通过快捷方式来完成，实际上，通过使用�?a href="file:///G:/作品/userguide/src/Zh_CN.html/#jpaconfiguration">the section called “Configuration�Q�配�|�）”描述的方法之一来合理设�|��?

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�?code>String 值属性。实体也要被持久化。在�q�行��试之前�Q�我们徏立一个实体�ƈ保存它�?/p>
@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.

我们启动一个新的流�E�实例，增加实体作�ؓ(f��)一个变量。和其它变量一��P��它们保存在引擎的持久化存储区。当下次��h��q�个变量�Ӟ��从��Z��c�d��保存的Id的EntityManager载入�?/p>
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'.

我们��程定义的第一个节点包含一�?code>serviceTask。它?y��u)��调用�?entityToUpdate之上的方�?code>setValue �?当启动这个流�E�实例时�Q�它?y��u)��解析我们先前设�|�的JPA变量。JPA变量从当前流�E�上下文兌��?code>EntityManager 载入�?/p>

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.

当服务�Q务完成时�Q�流�E�实例在��程定义里定义的userTask。userTask允许我们��(g��)查这个流�E�实例。在�q�时�Q?code>EntityManager 已经被刷新�ƈ且实体变更已�l�被推送到数据库。当我们获取变量entityToUpdate的值时�Q�它再次载入。我们取得的 updatedValue�?code>value 属性�?/p>
// 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�Q�查询流�E�变量）

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��h��某个作�ؓ(f��)变量值的JPA-bean。注意：(x��)对于�?ProcessInstanceQuery �?ExecutionQuery上的JPA实体只支�?variableValueEquals(name, entity)。当JPA实体作�ؓ(f��)��g��送时�Q�不支持�Ҏ(gu��)��variableValueNotEquals, variableValueGreaterThan, variableValueGreaterThanOrEqual, variableValueLessThan�?and variableValueLessThanOrEqual ��抛��Z��?ActivitiException异常�?/p>
ProcessInstance result = runtimeService.createProcessInstanceQuery().variableValueEquals("entityToQuery", entityToQuery).singleResult();

Advanced example using Spring beans and JPA�Q��用Spring beans和JPA的高�U�示例）

A more advanced example, JPASpringTest, can be found in activiti-spring-examples. It describes the following simple use case:

一个更加高�U�的�C�Z��Q�JPASpringTest �Q�能够在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�Q�我们能够��用存在的实体�Q�通过存在的bean来获取这个实体，�q�在我们的流�E�里面以变量方式使用它们�?

Process is defined in the following steps:

��程在下列步骤定义：(x��)

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.

建立一个新的的服务��d��Q�通过

UserTask that allows a manager to review the request and approve/disapprove, which is stored as a boolean variable approvedByManager

允许�l�理审阅��h��q�且批准/否决的UserTask�Q�它作�ؓ(f��)一个布?y��u)��(d��ng)�?code>approvedByManager保存�?/p>

ServiceTask that updates the loan request entity so the entity is in sync with the process.

因�ؓ(f��)ServiceTask更新��h��h��实体�Q�所以这个实体和��程同步�?/p>

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的��|��所使用的一个��d��关下一步作出决�{�：(x��)当请求被批准�Q�流�E�结束，否则�Q�另外的��d��成为可能（发送拒�l�函�Q�，�q�样通过拒绝函手动通知客户�?/p>

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

��h��意这个流�E�不包括��M��表单�Q�因为它只是作�ؓ(f��)单元��试使用�?

${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.

��管上例相当��单，但是它展�C�Z��l�合Spring和参数化�Ҏ(gu��)��表达式JPA的威力。流�E�不需要�Q何Java代码�Q�当然Spring是例外）�Q��ƈ�?qi��ng)大地加速了开发�?

�|��\��L(f��ng)��@BlogJava 2010-11-28 19:39 发表评论

Activiti User Guide�Q�Activiti用户指南)-Chapter 10. History(历史)

�|��\��L(f��ng)��@BlogJava — Sun, 28 Nov 2010 11:32:00 GMT

Chapter 10. History(历史)

Table of Contents

History configuration�Q�历史配�|�）
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.

历史是在��程执行�q�程中抓取的事�g以及(qi��ng)把事件永久存储的部�g。与�q�行时数据相比较�Q�历史数据既��当前的数据也将��程已经完成的数据保留在数据库中�?

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�U�历史实体：(x��)HistoricProcessInstance包含与当前和�q�去��程�C�Z��相关的信息；HistoricActivityInstance包含与一个活动的当个执行相关的信息；HistoricActivityInstance包含与历史流�E�实例或者一个活动示例相关的不同的信息�?

In the API, the HistoryService exposes this information by offering methods createHistoricProcessInstanceQuery, createHistoricActivityInstanceQuery and createHistoricDetailQuery.

在API里，历史服务�Q�HistoryService�Q�通过提供createHistoricProcessInstanceQuery, createHistoricActivityInstanceQuery and createHistoricDetailQuery�Ҏ(gu��)��暴露�q�个信息�?

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.

因�ؓ(f��)DB包含�q�去的，正运行示例的历史实体�Q�所以�ؓ(f��)了最��化讉K��q�行��程实例的数据，你也许考虑查询�q�些库表。这�U�方式保留了�q�行期执行的效率�?

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.

最后，�q�个信息��会(x��)�?Activiti Explorer�?and Activiti Probe里面暴露。这��是报告��会(x��)产生信息的来源�?

History configuration�Q�历史配�|�）

In the activiti.cfg.xml configuration file, you can configure the level of history archiving that needs to happen:

在activiti.cfg.xml配置文�g�Q�你能配�|�需要的历史归档的��别：(x��)

...

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

或者如果你正��用Spring风格的配�|�方式：(x��)

...

Following history levels can be configured:

可以配置如下的历史��别：(x��)

none: skips all history archiving. This is the most performant for runtime process execution, but no historical information will be available.

忽略所有的历史归档。尽��对于运行期��程执行来说�q�是性能最高的�Q�但是没有历史信息保留�?/p>

activity: archives all process instances and activity instances. No details will be archived

归��所有流�E�实例和�z�d��实例。不归档�l�节�?/p>

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.

�q�是�~�省�U�别。它归��所有流�E�实例，�z�d��实例和提交的表单属性。以至于通过表单的所有用户交互都是可跟踪�q�可以被审计�?/p>

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.

�q�是历史归档的最高��别。所以是最慢的。这个水�q�保存audit�U�别的所有信息加上像��程变量的所有其它可能的�l�节�?/p>

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.

当配�|?a href="file:///G:/作品/userguide/src/Zh_CN.html/#">configuring 臛_��为audit�U�别�Ӟ��那么通过FormService.submitStartFormData(String processDefinitionId, Map properties) �?FormService.submitTaskFormData(String taskId, Map properties) �Ҏ(gu��)��提交的所有属性将�?x��)被记录�?

[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] 当前在工作的表单 �q�没有��?submitStartFormData �?submitTaskFormData。所以当在��用表单时�Q�表单属性还未被归��。@参见 ACT-294

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

表单�Ҏ(gu��)��能够像下面以查询API方式��(g��)索：(x��)

historyService .createHistoricDetailQuery() .onlyFormProperties() ... .list();

In that case only historic details of type HistoricFormProperty are returned.

在��U�情况下�Q�只�q�回 HistoricFormProperty�c�d��的历史细节�?

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.

如果在调用带�?code>IdentityService.setAuthenticatedUserId(String) 提交�Ҏ(gu��)��之前�Q�你已经讄��认证用户�Q�那么提交这个表单的那个认证用户��会(x��)在历史里可访问。带�?code>HistoricProcessInstance.getStartFormUserId() 讉K��启动表单�Q�带�?code>HistoricActivityInstance.getAssignee() 讉K��d��表单�?/p>

�|��\��L(f��ng)��@BlogJava 2010-11-28 19:32 发表评论

�|��\��L(f��ng)��@BlogJava — Sun, 28 Nov 2010 11:26:00 GMT

Chapter 11. Eclipse Designer(Eclipse 设计�?

Table of Contents

Installation
Activiti Designer editor features�Q�特性）
Activiti Designer BPMN features�Q�Activiti设计器BPMN�Ҏ(gu��)��）
Extending Activiti Designer�Q�扩展Activiti设计器）

Customizing the palette�Q�定刉��板）
Exporting to custom output formats�Q�输出定制的格式�Q?/a>

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��程�q�行囑�Ş化徏模的Eclipse插�g。Activiti Eclipse Designer由Tijs Rademakers, Tiese Barrell, Ron van Liempd �?Yvo Swillens发�v�q�维护�?
Installation

The following installation instructions are verified on Eclipse Classic Helios.
下列安装指��o(h��)�?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.在下面面杉K��面，点击 Add 按钮�q�填充下面的字段�Q?

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.."复选框�Q�这是因为所有必要的插�g从Activiti的更新站点下载�?
Activiti Designer editor features�Q�特性）

Create Activiti projects and diagrams.
建立Activiti��目和流�E�图�?

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��目作�ؓ(f��)一个Maven��目而��生。�ؓ(f��)了配�|�所需的依赖，误��?mvn eclipse:eclipse�Q�那么项目依赖的配置��如你所�ѝ�?

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文�g和流�E�的囑փ��Q�在Eclipse的preferences的Activiti标签��里可以关闭自动产生的选项�Q��?

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.
产生单元��试�Q�右��d��D��器的BPMN 2.0 XML文�g�q��择产生单元��试�Q?em>generate unit test�Q�）。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文�g。注意存在两�U�可配置的XSD�Q�符合BPMN 2.0规范的XSD和Activiti扩展的XSD。这两个�q�没有以良好的方式齐头�ƈ�q��?

A basic validation is performed after each save of the Activiti diagram and the errors are mentioned in the Eclipse problem view.
当Activiti��程图每�ơ保存时�Q�完成基本的校验。校验错误显�C�在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.
当右��d��D��器的Activiti的流�E�图�Ӟ��显�C�Z��个基本的部��v�~�辑器。在弹出��的的最下端��显�C�Z��?Deployment"属性。部�|�编辑器当前支持保存��Z��个BAR文�g。在下一个版本将扩展为将BAR文�g部��v到Activiti引擎�?

Activiti Designer BPMN features�Q�Activiti设计器BPMN�Ҏ(gu��)��）

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.
支持启动事�g�Q�结束事�Ӟ��序��，�q�行�|�关�Q�唯一�|�关�Q�嵌入式子流�E�，脚本��d��Q�用户�Q务，服务��d��Q�邮件�Q务和手动��d��?

Java class or expression configuration is supported for the Java service task. In addition field extensions can be configured.
支持对Java服务��d��q�行Java�c�L��者表辑ּ�配置。能够配�|�另外的字段扩展�?

Support for additional Activiti extensions like the Mail task, the candidate configuration of User tasks and Script task configuration.
支持像Mail��d��的Activiti扩展��d��Q�用户�Q务的候选�h配置和脚本�Q务配�|��?/p>

Support for conditions on sequence flows.
支持��序��之上的条�g表达式�?

Extending Activiti Designer�Q�扩展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提供的缺省功能。本章�ؓ(f��)哪些扩展可用�Q�如何��用这些扩展问题提供一些有用的�C�Z��。在�~�省功能不适合你的需求，你需要额外的能力�Q�或者当对业务流�E�徏模时��h��领域特定的需求的地方�Q�正是扩展Activiti Designer扩展有用武之地。Activiti Designer扩展有两个明昄��分类�Q�扩展面板和扩展输入格式。每个扩展方式需要特定的�Ҏ(gu��)��和不同的技术技巧�?
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所惛_��立的扩展�c�d��Q�你也许需要熟�(zh��n)�Maven�Q�Eclipse�Q�OSGi�Q�Eclipse扩展和SWT�?
Customizing the palette�Q�定刉��板）

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:
当徏模时�Q�你可以�l�用��h��供一个定制的面板。面板是能够拉至

Adding your own shapes / nodes to existing or new drawers
增加你自��q��囑�Ş或者节点到已存在或新的抽屉上�?/p>

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��止��M��Activiti Designer提供的缺省BPMN 2.0囑�Ş�Q�连接和选择

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�Q�后面将更多介绍how to do that �Q�里的JAR的文件。这��L(f��ng)��JAR文�g叫一个扩展（extension�Q?�?
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你能够设�|�你喜欢的工��h��讄��你的��目。用�q�个工具来构��个JAR包。对于下列指令，假定用Eclipse Helios讄��Q�采用Maven�Q?.x�Q�作为构建工��P��但是��M��讄��建立相同的结果�?
Extension setup (Eclipse/Maven)�Q�扩展设�|?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.
下蝲�q�抽�?和最新版本。如果你使用Maven 2.x版本�Q�在构徏��目时将带来问题�Q�所以确保它的版本及(qi��ng)时更新。我们假定你熟�?zh��n)�Eclipse里面的基本特性和Java�~�辑器。是否你钟情在Eclipse里面使用Maven或者在命��o(h��)行提�C�Z��使用Maven�Q�完全取决于你�?
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里面建立一个新��目。这个项目可以是一个一般类型的��目。�ؓ(f��)了包含Maven��目讄��Q�在��目的根目录下徏立一个pom.xml文�g夏V��也要徏�?src/main/java �?src/main/resources文�g夹，�q�是Maven对Java源代码文件和相关资源文�g的约定。打开pom.xml文�g�q�增加下列行�Q?pre> 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.
正如你所见，�q�只是定义了��目�?一个基本的pom.xml文�g。我�?
Add the integration library to your project's dependencies by including this dependency in your pom.xml file:
通过在pom.xml文�g里包含项目的依赖库，��集成的库加到项目里面�?pre> 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.
此时�Q�还未从Activiti的Maven仓库获得依赖。�ؓ(f��)了��用它�Q�从�q�里下蝲 from here�Q��ƈ把它攑ֈ�你本地的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:
最后，因�ؓ(f��)
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 属性描�q�。唯一剩下的d事实告诉Eclipse�Ҏ(gu��)��文�g里指令徏立这个项目。所以打开一个命令shell�q�到Eclipse工作区的��目�Ҏ(gu��)��件夹。执行下面的Maven命��o(h��)�Q?pre>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.
�{�到构徏成功完成。刷新项目（使用��目的上下文菜单�Q�右击）�q��择“刷新”（Refresh�Q�）。现在你应当在Eclipse��目里看见文件夹src/main/java �?src/main/resources作�ؓ(f��)源代码文件夹�?
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 插�g。简单地从上��目下文菜单�Q�右击）启动Maven依赖��理。然后从��目的上下文菜单选择�?Maven > Update project configuration ”。也要设�|�设�|�源代码�?
That's it for the setup. Now you're ready to start creating customizations to Activiti Designer!
讄��p��样弄好了。徏立Activiti Designer的定制的准备工作��q�A�?
Applying your extension to Activiti Designer�Q�应用对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以便让自��q��定制起作用呢。那么采取这些步骤可以解冻I��(x��)

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�Q�例如，通过Maven在你的项目里执行一个mvn install 来构建）。你需要将�q�个扩展攑ֈ�Activiti Designer安装的地斏V�?/p>

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

Start Activiti Designer and from the menu, select Window > Preferences
首先启动Activiti Designer�Q�然后在菜单里选择 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 屏幕�Q�键�?user 作�ؓ(f��)关键字。你应当在Eclipse的Java部分看见讉K�� 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 ��，在右端将昄��一个树(w��i)形视图，在此可以��d��你自��q��Java库。你应当能看见扩展加入到Activiti Designer 的缺省组�Q�依赖于你的Eclipse的安装，你可能看到其它的情况�Q��?

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.
选择�l?code>Activiti Designer Extensions�l��ƈ点击 Add JARs...按钮。导航至你自己扩展所保存的文件夹�q��择所要添加的扩展。完成之后，你的 preference屏幕应当昄��作�ؓ(f��) Activiti Designer Extensions �l�的一部分的扩展，如下所�C��?

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按钮�Q�保存�ƈ关闭preference对话框。组自动��d��C��所建的Activiti��目里面。在Navigator或者Package Explorer视图上的��目�?w��i)书上，用户库作��Z��个条目显�C�。如果你在工作区上存在一个Activiti��目�Q�那么你应当看见在组里显�C�的新的扩展。示例如下所�C��?

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.
打开的流�E�图的有一个新的扩展，�q�能看见囑�Ş�Q�依赖于你的定制�Q�这些图形可能被��止�Q�。如果流�E�图已经打开�Q�关闭�ƈ重新打开�Q�观察面板发生的变化�?
Adding shapes to the palette�Q�把囑�Ş加到面板�Q?/h6>
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.
一旦项目设�|�好�Q�你能轻易把囑�Ş��d��到面�ѝ��你惛_��入的囑�Ş在Jar包里用一个类来表�C�。注意这些类不是Activiti引擎在运行期间所使用的类。在扩展里，描述了在Activiti Designer里可以设�|�的属性。通过�q�些囑�Ş�Q�引用应当有引擎所使用的运行期�c�R��这些类应当为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.
囑�Ş�c�L��一个简单的Java�c�，加入了注释。尽��这个类应当实现接口�Q�但是不应当你自己实现这个接口。而应当扩展这个基�c�M��Z��替（目前你必��ȝ��接扩展这个类�Q�所以没有抽象类�Q�。在那个�cȝ��Javadoc里面�Q�可以找它提供的�~�省功能的指令。你应当复写它已�l�实现的��M��Ҏ(gu��)��?pre>/** * @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()�Ҏ(gu��)��来决定将在面板中节点的名�U�。你也能��节�Ҏ(gu��)��|�到它们的抽屉里�q�提供一个图标。复写AbstractCustomServiceTask�c�里合适的�Ҏ(gu��)��。如果你��x��供一个图标，��定它在JAR包里�?code>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:
通过向类加入成员�q�以如下方式�?@Property 标注标注它们可以�l�图形增加属性�?pre>@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.
当前�Q�只存在两种可以使用�?code>PropertyType ��|��(x��) TEXT�?code>MULTILINE_TEXT。未来版本将允许你��用其它的�c�d��。通过讄��必选的属性�ؓ(f��)true让字�D�必选。如果用��h��有填充字�D�，��出��C��个消息，背景为红艌Ӏ?
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.
如你所见，当填充字�D�|��Q�也有一个标注用来提供给用户一些指南的�?@Help标注。也可在�c�自�w��?@Help 标注--�q�个信息在属性表上提供给用户信息�?
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.
��Z��获得MoneyTask的详情，以下是列表。已�l�加入注释字�D�，�q�且在节点能看见图标�?pre>/** * @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�Q�面板及(qi��ng)其相兌��点如下所�C�：(x��)

The properties screen for the money task is shown below. Note the required message for the accountNumber field.
money��d��的属性屏�q�如下所�C�。注�?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.
在每个属性的右侧的按钮提供字�D늚�帮助信息。点�?y��n)L��钮将昄��如下弹出的信息�?

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.
当执行一个流�E�实例时�Q�Activiti引擎到达你的节点。图形的最�l�步骤指明被Activiti引擎实例化的那个�c�R��可�?@Runtime 标注来完成这个功能。返回属性应当包含运行时期的正规名称。注意运行时期类不应当在扩展JAR包里�Q�因为它依赖于Activiti�c�d��?pre>@Runtime(delegationClass = "org.acme.runtime.AcmeMoneyJavaDelegation")
Disabling default shapes in the palette�Q�禁止面杉K��的缺省图形）

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.
�q�个定制需要你在扩展里包含实现接口的类。你不应当直接实现这个接口，而是子类�?code>AbstractDefaultPaletteCustomizer 基类。当前，接口的未来版本将提供为那些基�c�通过更多功能�Q�所以最好子�c�d��Q�这��P��你的扩展��会(x��)和未来的版本�?
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�c�需要你实现一�?code>disablePaletteEntries()�Ҏ(gu��)��Q�你必须�q�回一�?PaletteEntry值列表。对于每个缺省图形，通过增加相关�?PaletteEntry值到你的列表�Q�你能禁止它。注意如果从�~�省集合里删除图形，特别的抽屉里没有��M��囑�Ş�Q�那么这个抽屉也��从面板中删除。如果你想禁止所有缺省的囑�Ş�Q�你只需要把加入PaletteEntry.ALL 到结果。作��Z��个示例，下列代码��止了面板中的手动�Q务和脚本��d��?pre>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.
�q�个扩展的应用效果如下图所�C�。如你所见，手动��d��和脚本�Q务的囑�Ş不在Task抽屉上获取�?

To disable all of the default shapes, you could use something similar to the code below.
��Z��止所有的�~�省囑�Ş�Q�你可以应当使用和下列相似的代码�?pre>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):
�l�果��如下相��|��注意�~�省囑�Ş原来所在的抽屉也不在面杉K��面了�Q��?

Exporting to custom output formats�Q�输出定制的格式�Q?/h5>
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.
当你保存?g��u)��程图时�Q�你能够扩展Activiti Designer 发表另外的格式。这些扩展被�U�Cؓ(f��)。当用户每次采取保存的行为时�Q�由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输出和流�E�图像进行比较。缺省地�Q�后者在Activiti Designer里在保存动作期间完成�?
事实上，�q�些功能完全使用你能使用的相同的扩展�Ҏ(gu��)��。它通常保存��Z��自己的格式�?
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.
��Z��建立一个输��l�（ Export Marshaller)�Q�你需要徏立不同种�cȝ��扩展�Q�而不是扩展面�ѝ��这个原因是��单的�Q�从代码观点来看�Q�你��需要比讉K��比集成库需要更多的API。特别地�Q�你��需要Eclipse里能够获取的�c�R��实��C��?code>Export Marshaller �Ҏ(gu��)��是徏立一个Eclipse的插�Ӟ��通过Eclipse的PDE支持�Q�，�q�且在一个定制的Eclipse产品里将它打包。解释所有关于开发Eclipse 插�g的细节超�q�了本用��h��南的范围�Q�所以下列指令被限制为扩展Activiti Designer的功能�?
Your bundle should be dependent on the following libraries:
你的bundle应当依赖下列库：(x��)

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.
建立一�?code>org.activiti.designer.eclipse.extension.export.ExportMarshaller 扩展点的扩展。对于这个扩展点�Q�需要子�c�d�� AbstractExportMarshaller�q�个�c�R��当自己的格式时�q�个抽象基类提供了大量的有用的方法，诸如在Eclipse Problem视图��d��标记�Q��ƈ把资源保存到工作区里面�?
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.
需要实现诸如这�?code>getMarshallerName() �?getFormatName()的方法。这些方法用来显�C�用��L(f��ng)��选项和显�C��度对话框的信息，�q�样��保�q�回的描�q�反应了所实现的功能�?
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)�Ҏ(gu��)��里面执行。提供了��程囑֯�象，它包含关于流�E�图(BPMN构�g�Q�对象和囑�Ş表示的所有信息。如果你想通过Eclipse里的一栯��问流�E�图�Q�或者你想采用XSLT来�{换流�E�图�Q�在AbstractExportMarshaller �c�里有�ؓ(f��)��程图获�?code>Resources 和的 InputStreams�Ҏ(gu��)��?
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() �Ҏ(gu��)��可能是个好主意；�q�将清除 marshaller先前的标记。你也应当所提供的进度监视器�Q�向用户报告�q�展情况。如果需要如何完成这样功能的�C�Z��Q�请参考Activiti Designer 自��n的代码�?

�|��\��L(f��ng)��@BlogJava 2010-11-28 19:26 发表评论

Activiti User Guide�Q�Activiti用户指南)-Chapter 12. Activiti Modeler(Activiti建模�?

�|��\��L(f��ng)��@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(变更建模器的��L��)

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)是一个用来仅在浏览器里面以图形化�~�辑B(t��i)PMN 2.0��程的，��Z��Web的流�E�编辑器。通过服务器流�E�文件存在文件系�l�，所以很�Ҏ(gu��)��对它们进行访问，�q�无忧输入到��M��JavaIDE里面�?

Bugs and issues can be reported on the Signavio core components issue tracker.

可以��缺陷和问题报告�?a >Signavio core components issue tracker.

The Activiti Modeler is automatically installed during the demo setup.

�?a href="file:///G:/作品/userguide/src/Zh_CN.html/#">demo setup�q�程中自动安装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.

在运行演�C�创建的�q�程之后�Q�流�E�XML文�g��会(x��)保存在apps/activiti-model-repository文�g夏V��通过变更�?strong>(exploded)activiti-modeler.war/WEB-INF/classes/configuration.properties文�g里的 fileSystemRootDirectory 属性，来切换基于文件的仓库位置�?

Changing the host of the Modeler(变更建模器的��L��)

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.

在运行演�C�创��Z��后，��只能从localhost地址讉K��Activiti Modeler。当你想变更Modeler的主机，例如�Q�在一个服务器上集中运行。那么，请你变更�?strong>(exploded)activiti-modeler.war/WEB-INF/classes/configuration.properties 文�g�?strong>host属性�?/p>
> cat configuration.properties host = http://192.168.1.101:8080 fileSystemRootDirectory = /Users/jbarrez/Development/model-repo

�|��\��L(f��ng)��@BlogJava 2010-11-28 19:16 发表评论

午夜久久av,成人网欧美在线视频,亚洲精品一线

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

Activiti in Action�Q�实战Activiti�Q?目录

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

Chapter 1. Introduction�Q�简介）

License�Q�授权）

Download�Q�下载）

Required software�Q�依赖的软�g�Q?/h4> JVM 5+ Ant 1.7.1+

Reporting problems�Q�报告问题）

Experimental features�Q�实验性特性）

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

Chapter 2. Getting Started�Q�入门指南）

Demo setup�Q�安装演�C�）

Activiti User Guide�Q�Activiti用户指南)-Chapter 3. Configuration�Q�配�|�）

Chapter 3. Configuration�Q�配�|�）

Creating a ProcessEngine�Q�徏立一个流�E�引擎）

ProcessEngineConfiguration bean

Job executor activation�Q�作业执行器�Ȁ�z�）

History configuration�Q�历史配�|�）

Supported databases�Q�支持的数据库）

ProcessEngineFactoryBean

Transactions�Q�事务）

Automatic resource deployment�Q�自动资源部�|Ԍ��

Unit testing�Q�单元测试）

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

Chapter 5. API

Exception strategy�Q�异常处理策略）

Unit testing�Q�单元测试）

Activiti User Guide�Q�Activiti用户指南)-Chapter 6. Deployment�Q�部�|Ԍ��

Chapter 6. Deployment�Q�部�|Ԍ��

Business archives�Q�业务档案）

Java classes�Q�Java�c�）

Deploying with Activiti Probe�Q�以Activiti Probe部��v)

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

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

Chapter 08. Forms�Q�表单）

Build-in form rendering�Q�内�|�表单渲染）

Vacation Request

Vacation Approval

Adjust vacation Request

External form rendering�Q�外部表单渲染）

Form properties�Q�表单属性）

Activiti User Guide�Q�Activiti用户指南)-Chapter 09. JPA

Chapter 09. JPA

Requirements�Q�需求）

Configuration�Q�配�|�）

Usage�Q�用法）

Simple Example�Q�简单示例）

Query JPA process variables�Q�查询流�E�变量）

Advanced example using Spring beans and JPA�Q���用Spring beans和JPA的高�U�示例）

Activiti User Guide�Q�Activiti用户指南)-Chapter 10. History(历史)

Chapter 10. History(历史)

History configuration�Q�历史配�|�）

History for audit purposes(审计目的的历�?

Chapter 11. Eclipse Designer(Eclipse 设计�?

Table of Contents

Installation

Activiti Designer editor features�Q�特性）

Activiti Designer BPMN features�Q�Activiti设计器BPMN�Ҏ(gu��)��）

Extending Activiti Designer�Q�扩展Activiti设计器）

Note

Customizing the palette�Q�定刉���板）

Note

Extension setup (Eclipse/Maven)�Q�扩展设�|?Eclipse/Maven))

Warning

Note

Applying your extension to Activiti Designer�Q�应用对Activiti Designer的扩展）

Disabling default shapes in the palette�Q�禁止面杉K��的缺省图形）

Activiti User Guide�Q�Activiti用户指南)-Chapter 12. Activiti Modeler(Activiti建模�?

Chapter 12. Activiti Modeler(Activiti建模�?

Changing the location of the process model repository(变更���程模型仓库的位�|?

Changing the host of the Modeler(变更建模器的��L��)

Required software�Q�依赖的软�g�Q?/h4>

JVM 5+

Ant 1.7.1+

Advanced example using Spring beans and JPA�Q��用Spring beans和JPA的高�U�示例）

Customizing the palette�Q�定刉��板）

Changing the location of the process model repository(变更��程模型仓库的位�|?