【免费】activiti6.0官方英文文档，需要自取免费！免费！免费！_activiti6文档,activiti6官方文档

需积分: 0 200 浏览量更新于2024-01-17 评论收藏 8.1MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

Activiti是一个开源的业务流程管理(BPM)框架，被广泛用于设计、执行和管理复杂的业务流程。它提供了一套在企业中构建和管理工作流程并自动化业务过程的工具和功能。为了更好地了解和使用Activiti框架，官方提供了详尽的英文文档和用户手册。这些文档可以帮助开发人员快速入门，并提供了关于Activiti的详细信息、技术概念和最佳实践。而且，好消息是这些文档是免费提供的，用户可以自行获取并进行使用。如果你无法访问Activiti的官方网站，不要灰心，因为这份官方文档可以为你提供所需的安全感。你可以在这些文档中找到Activiti的各个版本的用户指南、开发指南以及架构概述等内容。官方的用户手册是开发者入门和了解Activiti框架的好资源。其中包含了Activiti框架的基本概念、架构和核心功能的详细介绍。它提供了清晰而全面的指导，帮助用户了解Activiti的工作原理，并学习如何使用它来管理和执行工作流程。用户手册还介绍了Activiti的核心组件，例如流程引擎、任务管理、表单引擎和事件处理等。它还提供了丰富的示例代码和操作指南，指导用户在实际项目中如何应用Activiti。此外，用户手册还涵盖了Activiti的进阶主题，如流程设计、流程部署、流程执行和监控等。它还介绍了Activiti与其他流程管理工具和系统的集成方法，以及在企业中推广和应用Activiti的最佳实践。如果你正在使用Activiti进行开发或将其应用于你的业务流程管理中，这份官方文档将成为你不可或缺的参考资料。无论是初学者还是经验丰富的开发人员，都可以通过阅读这些文档来更好地理解和应用Activiti框架。总之，Activiti的官方英文文档和用户手册是开发者学习和使用Activiti框架的宝贵资源。它们提供了清晰而全面的指导，帮助用户快速入门，并深入了解Activiti框架的各个方面。无论你是初学者还是有经验的开发人员，这些文档都将为你的工作提供重要的支持和指导。不要错过这份免费的资源，快去获取并开始学习吧！

资源详情

资源评论

资源推荐

2021/1/4 Activiti User Guide

https://www.activiti.org/userguide/#_getting_started 16/281

Activiti database type Example JDBC URL Notes

db2 jdbc:db2://localhost:50000/activiti

mssql jdbc:sqlserver://localhost:1433;databaseName=activiti

(jdbc.driver=com.microsoft.sqlserver.jdbc.SQLServerDriver)

OR jdbc:jtds:sqlserver://localhost:1433/activiti

(jdbc.driver=net.sourceforge.jtds.jdbc.Driver)

Tested using Microsoft JDBC

Driver 4.0 (sqljdbc4.jar) and

JTDS Driver

3.6. Creating the database tables

The easiest way to create the database tables for your database is to:

Add the activiti-engine jars to your classpath

Add a suitable database driver

Add an Activiti configuration file (activiti.cfg.xml) to your classpath, pointing to your database (see database configuration section)

Execute the main method of the DbSchemaCreate class

However, often only database administrators can execute DDL statements on a database. On a production system, this is also the

wisest of choices. The SQL DDL statements can be found on the Activiti downloads page or inside the Activiti distribution folder, in the

database subdirectory. The scripts are also in the engine jar (activiti-engine-x.jar), in the package org/activiti/db/create (the drop

folder contains the drop statements). The SQL files are of the form

Where db is any of the supported databases and type is

engine: the tables needed for engine execution. Required.

identity: the tables containing users, groups and memberships of users to groups. These tables are optional and should be used

when using the default identity management as shipped with the engine.

history: the tables that contain the history and audit information. Optional: not needed when history level is set to none. Note that

this will also disable some features (such as commenting on tasks) which store the data in the history database.

Note for MySQL users: MySQL version lower than 5.6.4 has no support for timestamps or dates with millisecond precision. To make

things even worse, some version will throw an exception when trying to create such a column but other versions don’t. When doing

auto-creation/upgrade, the engine will change the DDL when executing it. When using the DDL file approach, both a regular version

and a special file with mysql55 in it are available (this applies on anything lower than 5.6.4). This latter file will have column types with

no millisecond precision in it.

Concretely, the following applies for MySQL version

<5.6: No millisecond precision available. DDL files available (look for files containing mysql55). Auto creation/update will work out

of the box.

5.6.0 - 5.6.3: No millisecond precision available. Auto creation/update will NOT work. It is advised to upgrade to a newer database

version anyway. DDL files for mysql 5.5 could be used if really needed.

5.6.4+: Millisecond precision available. DDL files available (default file containing mysql). Auto creation/update works out of the

box.

Do note that in the case of upgrading the MySQL database later on and the Activiti tables are already created/upgraded, the column

type change will have to be done manually!

3.7. Database table names explained

The database names of Activiti all start with ACT_. The second part is a two-character identification of the use case of the table. This

use case will also roughly match the service API.

ACT_RE_*: RE stands for repository . Tables with this prefix contain static information such as process definitions and process

resources (images, rules, etc.).

ACT_RU_*: RU stands for runtime . These are the runtime tables that contain the runtime data of process instances, user tasks,

variables, jobs, etc. Activiti only stores the runtime data during process instance execution, and removes the records when a

process instance ends. This keeps the runtime tables small and fast.

ACT_ID_*: ID stands for identity . These tables contain identity information, such as users, groups, etc.

ACT_HI_*: HI stands for history . These are the tables that contain historic data, such as past process instances, variables,

tasks, etc.

ACT_GE_*: general data, which is used in various use cases.

activiti.{db}.{create|drop}.{type}.sql

2021/1/4 Activiti User Guide

https://www.activiti.org/userguide/#_getting_started 17/281

3.8. Database upgrade

Make sure you make a backup of your database (using your database backup capabilities) before you run an upgrade.

By default, a version check will be performed each time a process engine is created. This typically happens once at boot time of your

application or of the Activiti webapps. If the Activiti library notices a difference between the library version and the version of the Activiti

database tables, then an exception is thrown.

To upgrade, you have to start with putting the following configuration property in your activiti.cfg.xml configuration file:

Also, include a suitable database driver for your database to the classpath. Upgrade the Activiti libraries in your application. Or

start up a new version of Activiti and point it to a database that contains an older version. With databaseSchemaUpdate set to true ,

Activiti will automatically upgrade the DB schema to the newer version the first time when it notices that libraries and DB schema are

out of sync.

As an alternative you can also run the upgrade DDL statements. It’s also possible to run the upgrade database scripts, available

on the Activiti downloads page.

3.9. Job Executor (since version 6.0.0)

The async executor of Activiti 5 is the only available job executor in Activiti 6 as it is a more performant and more database friendly

way of executing asynchronous jobs in the Activiti Engine. The old job executor of Activiti 5 is removed. More information can be found

in the advanced section of the user guide.

Moreover, if running under Java EE 7, JSR-236 compliant ManagedAsyncJobExecutor can be used for letting the container manage

the threads. In order to enable them, the thread factory should be passed in the configuration as follows:

The managed implementation fall back to their default counterparts if the thread factory is not specified.

3.10. Job executor activation

The AsyncExecutor is a component that manages a thread pool to fire timers and other asynchronous tasks. Other implementations

are possible (for example using a message queue, see the advanced section of the user guide).

By default, the AsyncExecutor is not activated and not started. With the following configuration the async executor can be started

together with the Activiti Engine.

The property asyncExecutorActivate instructs the Activiti Engine to startup the Async executor at startup.

3.11. Mail server configuration

Configuring a mail server is 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.

3.12. History configuration

Customizing the configuration of history storage is optional. This allows you to tweak settings that influence the history capabilities of

the engine. See history configuration for more details.

</bean>

</beans>

</bean>

</bean>

1 <property name="asyncExecutorActivate" value="true" />

1 <property name="history" value="audit" />

2021/1/4 Activiti User Guide

https://www.activiti.org/userguide/#_getting_started 18/281

3.13. Exposing configuration beans in expressions and scripts

By default, all beans that you specify in the activiti.cfg.xml configuration or in your own Spring configuration file are available to

expressions and in the scripts. If you want to limit the visibility of beans in your configuration file, you can configure a property called

beans in your process engine configuration. The beans property in ProcessEngineConfiguration is a map. When you specify that

property, only beans specified in that map will be visible to expressions and scripts. The exposed beans will be exposed with the

names as you specify in that map.

3.14. Deployment cache configuration

All process definition are cached (after they’re parsed) to avoid hitting the database every time a process definition is needed and

because process definition data doesn’t change. By default, there is no limit on this cache. To limit the process definition cache, add

following property

Setting this property will swap the default hashmap cache with a LRU cache that has the provided hard limit. Of course, the best value

of this property depends on the total amount of process definitions stored and the number of process definitions actually used at

runtime by all the runtime process instances.

You can also inject your own cache implementation. This must be a bean that implements the

org.activiti.engine.impl.persistence.deploy.DeploymentCache interface:

There is a similar property called knowledgeBaseCacheLimit and knowledgeBaseCache for configuring the rules cache. This is only

needed when you use the rules task in your processes.

3.15. Logging

All logging (activiti, spring, mybatis, … ) is routed through SLF4J and allows for selecting the logging-implementation of your choice.

By default no SFL4J-binding jar is present in the activiti-engine dependencies, this should be added in your project in order

to use the logging framework of your choice. If no implementation jar is added, SLF4J will use a NOP-logger, not logging anything

at all, other than a warning that nothing will be logged. For more info on these bindings

http://www.slf4j.org/codes.html#StaticLoggerBinder.

With Maven, add for example a dependency like this (here using log4j), note that you still need to add a version:

The activiti-ui and activiti-rest webapps are configured to use Log4j-binding. Log4j is also used when running the tests for all the

activiti-* modules.

Important note when using a container with commons-logging in the classpath: In order to route the spring-logging through

SLF4J, a bridge is used (see http://www.slf4j.org/legacy.html#jclOverSLF4J). If your container provides a commons-logging

implementation, please follow directions on this page: http://www.slf4j.org/codes.html#release to ensure stability.

Example when using Maven (version omitted):

3.16. Mapped Diagnostic Contexts

Activiti supports Mapped Diagnostic Contexts feature of SLF4j. These basic information are passed to the underlying logger along with

what is going to be logged:

processDefinition Id as mdcProcessDefinitionID

processInstance Id as mdcProcessInstanceID

execution Id as mdcExecutionId

1 <property name="processDefinitionCacheLimit" value="10" />

</property>

</dependency>

</dependency>

2021/1/4 Activiti User Guide

https://www.activiti.org/userguide/#_getting_started 19/281

None of these information are logged by default. The logger can be configured to show them in desired format, extra to the usual

logged messages. For example in Log4j the following sample layout definition causes the logger to show the above mentioned

information:

This is useful when the logs contain information that needs to checked in real time, by means of a log analyzer for example.

3.17. Event handlers

The event mechanism in the Activiti engine allows you to get notified when various events occur within the engine. Take a look at all

supported event types for an overview of the events available.

It’s possible to register a listener for certain types of events as opposed to getting notified when any type of event is dispatched. You

can either add engine-wide event listeners through the configuration, add engine-wide event listeners at runtime using the API or add

event-listeners to specific process definitions in the BPMN XML.

All events dispatched are a subtype of org.activiti.engine.delegate.event.ActivitiEvent . The event exposes (if available)

the type , executionId , processInstanceId and processDefinitionId . Certain events contain additional context related to the

event that occurred, additional information about additional payload can be found in the list of all supported event types.

3.17.1. Event listener implementation

The only requirement an event-listener has, is to implement org.activiti.engine.delegate.event.ActivitiEventListener .

Below is an example implementation of a listener, which outputs all events received to the standard-out, with exception of events

related to job-execution:

The isFailOnException() method determines the behaviour in case the onEvent(..) method throws an exception when an event

is dispatched. In case false is returned, the exception is ignored. When true is returned, the exception is not ignored and bubbles

up, effectively failing the current ongoing command. In case the event was part of an API-call (or any other transactional operation,

e.g. job-execution), the transaction will be rolled back. In case the behaviour in the event-listener is not business-critical, it’s

recommended to return false .

There are a few base implementations provided by Activiti to facilitate common use cases of event-listeners. These can be used as

base-class or as an example listener implementation:

org.activiti.engine.delegate.event.BaseEntityEventListener: An event-listener base-class that can be used to listen for entity-

related events for a specific type of entity or for all entities. It hides away the type-checking and offers 4 methods that should be

overridden: onCreate(..) , onUpdate(..) and onDelete(..) when an entity is created, updated or deleted. For all other

entity-related events, the onEntityEvent(..) is called.

3.17.2. Configuration and setup

If an event-listener is configured in the process engine configuration, it will be active when the process engine starts and will remain

active after subsequent reboots of the engine.

log4j.appender.consoleAppender.layout.ConversionPattern=ProcessDefinitionId=%X{mdcProcessDefinitionID}

executionId=%X{mdcExecutionId} mdcProcessInstanceID=%X{mdcProcessInstanceID} mdcBusinessKey=%X{mdcBusinessKey} %m%n

public class MyEventListener implements ActivitiEventListener {

@Override

public void onEvent(ActivitiEvent event) {

switch (event.getType()) {

case JOB_EXECUTION_SUCCESS:

System.out.println("A job well done!");

break;

case JOB_EXECUTION_FAILURE:

System.out.println("A job has failed...");

break;

default:

System.out.println("Event received: " + event.getType());

}

@Override

public boolean isFailOnException() {

// The logic in the onEvent method of this listener is not critical, exceptions

// can be ignored if logging fails...

return false;

}

2021/1/4 Activiti User Guide

https://www.activiti.org/userguide/#_getting_started 20/281

The property eventListeners expects a list of org.activiti.engine.delegate.event.ActivitiEventListener instances. As

usual, you can either declare an inline bean definition or use a ref to an existing bean instead. The snippet below adds an event-

listener to the configuration that is notified when any event is dispatched, regardless of its type:

To get notified when certain types of events get dispatched, use the typedEventListeners property, which expects a map. The key

of a map-entry is a comma-separated list of event-names (or a single event-name). The value of a map-entry is a list of

org.activiti.engine.delegate.event.ActivitiEventListener instances. The snippet below adds an event-listener to the

configuration, that is notified when a job execution was successful or failed:

The order of dispatching events is determined on the order the listeners were added. First, all normal event-listeners are called

( eventListeners property) in the order they are defined in the list . After that, all typed event listeners ( typedEventListeners

properties) are called, if an event of the right type is dispatched.

3.17.3. Adding listeners at runtime

It’s possible to add and remove additional event-listeners to the engine by using the API ( RuntimeService ):

Please note that the listeners added at runtime are not retained when the engine is rebooted.

3.17.4. Adding listeners to process definitions

It’s possible to add listeners to a specific process-definition. The listeners will only be called for events related to the process definition

and to all events related to process instances that are started with that specific process definition. The listener implementations can be

defined using a fully qualified classname, an expression that resolves to a bean that implements the listener interface or can be

configured to throw a message/signal/error BPMN event.

Listeners executing user-defined logic

The snippet below adds 2 listeners to a process-definition. The first listener will receive events of any type, with a listener

implementation based on a fully-qualified class name. The second listener is only notified when a job is successfully executed or when

it failed, using a listener that has been defined in the beans property of the process engine configuration.

...

<list>

</list>

</property>

</bean>

...

<map>

<list>

</list>

</entry>

</map>

</property>

</bean>

/**

* Adds an event-listener which will be notified of ALL events by the dispatcher.

* @param listenerToAdd the listener to add

void addEventListener(ActivitiEventListener listenerToAdd);

/**

* Adds an event-listener which will only be notified when an event occurs, which type is in the given types.

* @param listenerToAdd the listener to add

* @param types types of events the listener should be notified for

void addEventListener(ActivitiEventListener listenerToAdd, ActivitiEventType... types);

/**

* Removes the given listener from this dispatcher. The listener will no longer be notified,

* regardless of the type(s) it was registered for in the first place.

* @param listenerToRemove listener to remove

void removeEventListener(ActivitiEventListener listenerToRemove);

1 <process id="testEventListeners">

剩余280页未读，继续阅读

Mr.敦的私房菜

粉丝: 6321
资源: 4

会员权益专享

"免费获取活动6.0官方英文用户手册，解决无法访问官网问题2021/1/4"

评论0

会员权益专享

最新资源

"免费获取活动6.0官方英文用户手册，解决无法访问官网问题2021/1/4"

评论0

Activiti6.0教程例子下载

activiti6的手册pdf版和html版

activiti6.0 中文api

activiti6.0 汉化

activiti6.0 act_ru_execution表字段

activiti流程引擎官方文档

activiti7官方文档

activiti7中文文档

activiti bpmn visualizer教程

springboot+activiti7官网

activiti-image-generator

activiti撤回任务

Activiti6 适配达梦数据库

activiti-5.22.0.zip 下载

通过processInstanceId查询bpmn

activiti7部署流程

activiti7代码

若以集成activiti7

activiti图形化界面

org.activiti.compatibility.DefaultActiviti5CompatibilityHandler. Activiti 5 backwards compatibility disabled.

会员权益专享

最新资源