Activiti 实践：BPMN2.0与Activiti框架详解

5星 · 超过95%的资源需积分: 10 180 浏览量更新于2024-07-28 收藏 10.77MB PDF 举报

"activiti in action meap版全本" 《Activiti in Action MEAP版》是一本关于 Activiti 框架的详尽指南，它深入介绍了Business Process Model and Notation (BPMN) 2.0 标准以及如何使用 Activiti 实现这一标准。这本书特别适用于开发者和对业务流程管理感兴趣的读者。 Part 1：介绍 BPMN 2.0 和 Activiti 1. 介绍 Activiti 框架：这部分向读者展示了 Activiti 的核心概念、设计目标和其在业务流程自动化中的角色。它涵盖了框架的基本架构，包括流程定义、执行和服务API。 2. BPMN 2.0：对开发者意味着什么？这部分详细解释了 BPMN 2.0 标准的主要元素，如活动（Activity）、网关（Gateway）和事件（Event），以及它们如何协同工作来表示复杂的业务流程。同时，探讨了BPMN如何帮助开发者实现更直观、可维护的流程模型。 3. 介绍 Activiti 工具栈：这部分介绍了 Activiti 提供的各种工具，如流程设计器、命令行接口（CLI）和REST API，这些工具简化了流程的开发、部署和监控。 4. 使用 Activiti 过程引擎：详细讲解了如何与Activiti 过程引擎交互，包括创建、启动、查询和管理流程实例，以及如何处理流程变量和信号。 Part 2：实现 BPMN 2.0 过程 5. 实现一个 BPMN 2.0 流程：通过一个实际的示例，演示如何使用 BPMN 2.0 符号构建流程图，并在Activiti中部署和执行。 6. 应用高级 BPMN 2.0 和扩展：深入讨论了流程中的并发、事件子流程、多实例任务等复杂特性，以及如何利用Activiti支持的自定义扩展。 7. 错误处理：讲解了如何在流程中处理异常和错误，包括错误边界事件、事件子流程和补偿活动。 8. 部署和配置 Activiti Engine：涵盖了Activiti引擎的部署选项、配置参数以及如何进行性能优化。 9. 探索额外的 Activiti 模块：介绍了Activiti之外的一些附加功能，如表单处理、身份管理和监控工具。 Part 3：增强 BPMN 2.0 过程 10. 实现高级工作流：讨论了如何构建更复杂的工作流，包括动态任务分配、流程版本控制和流程变更管理。 11. 与 BPMN 2.0 流程集成服务：讲解如何将外部服务和系统集成到流程中，使用调用活动、消息事件和事件子流程等技术。 12. 利用业务规则引擎：介绍如何结合使用Activiti与业务规则引擎，如Drools，以实现动态决策和规则驱动的流程。 13. 文档管理：探讨了如何在业务流程中整合文档管理功能，支持文档的创建、存储和版本控制。该书通过丰富的示例和实践指导，不仅帮助读者理解 BPMN 2.0 标准，还教授如何利用 Activiti 在实际项目中有效地实施和管理业务流程。对于希望提升业务流程自动化能力的开发者或IT专业人员来说，这是一份宝贵的资源。

©Manning Publications Co. Please post comments or corrections to the Author Online forum:

http://www.manning-sandbox.com/forum.jspa?forumID=722

processes that are deployed on the Activiti Engine. Working with demo processes is fun, but

it’s even better to try out your own developed business process.

1.4 Implementing your first process in Activiti

Let’s try and implement a simplified version of a book order process. We could use the

Activiti Modeler to first model the process, and the Activiti Designer to implement and deploy

the process, but it’s better to start off with a BPMN 2.0 XML document for learning purposes.

So no drag and drop development, but get ready for some XML hacking.

1.4.1 Say hello to Activiti

We’ll keep things simple and if you don’t understand every construct already, don’t be

worried we’ll discuss the BPMN 2.0 elements in more detail in chapter 2. In code listing 1.1 a

starter for the BPMN 2.0 XML definition of the book order process is shown with only a start

event, an end event and a sequence flow to connect the two.

Listing 1.1 bookorder.simple.bpmn20.xml document with only a start and end event

<?xml version="1.0" encoding="UTF-8"?>

<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" #1

targetNamespace="http://www.bpmnwithactiviti.org"> #2

<sequenceFlow id="sequenceflow1" #A

sourceRef="startevent1" targetRef="endevent1"/>

</process>

</definitions>

#1 Root element of BPMN 2.0 XML

#2 The process namespace

#A Connecting the start and end event

A BPMN 2.0 XML definition always starts with a

definitions

element #1 with a

namespace of the OMG BPMN specification. Each process definition must also define a

namespace, we have defined here a

targetNamespace

#2 with the book’s website as its

attribute value. Activiti also provides a namespace, which enables us to use Activiti

extensions to the BPMN 2.0 specification, as we will see in chapter 4. We can now run this

very simple process to test if we have correctly defined the process definition and the

environment set-up in the right manner.

To test this process, you have to create a Java project in your favorite editor. In this book

we’ll use Eclipse for the example description, because the Eclipse Designer is only available

as an Eclipse plug-in. But it’s easier to download the source code from the book’s website at

Manning and import the examples from there.

When you import the

bpmn-examples

project (that’s the project used in this chapter),

the Activiti libraries have to be added to the Java build path. The source code of the book

uses Maven to retrieve all the necessary dependencies. The project structure of the example

code is explained in detail in chapter 4 and appendix A. But starting from Eclipse Indigo

Chapter author name: Rademakers

©Manning Publications Co. Please post comments or corrections to the Author Online forum:

http://www.manning-sandbox.com/forum.jspa?forumID=722

(version 3.7.x) there’s good built-in Maven support so it’s really easy to get it working. Just

activate the Maven project capabilities by choosing for the Configure – Convert to Maven

Project option in the project menu when you right-click on the

bpmn-examples

project in

Eclipse. Eclipse will download all the necessary dependencies and configure the classpath for

you.

With the dependencies in place you can add look for the

SimpleProcessTest

unit test

in the

org.bpmnwithactiviti.chapter1

package of the

bpmn-examples

project. The

SimpleProcessTest

class contains one test method, which is shown in code listing 1.2.

Listing 1.2 First example of a JUnit test for a Activiti process deployment

public class SimpleProcessTest {

@Test

public void startBookOrder() {

ProcessEngine processEngine = ProcessEngineConfiguration #1

.createStandaloneInMemProcessEngineConfiguration() #1

.buildProcessEngine(); #1

RuntimeService runtimeService =

processEngine.getRuntimeService();

RepositoryService repositoryService =

processEngine.getRepositoryService();

repositoryService.createDeployment() #2

.addClasspathResource("bookorder.simple.bpmn20.xml") #2

.deploy(); #2

ProcessInstance processInstance = #3

runtimeService.startProcessInstanceByKey( #3

"simplebookorder"); #3

assertNotNull(processInstance.getId());

System.out.println("id " + processInstance.getId() + " " +

processInstance.getProcessDefinitionId());

}

#1 Create the Activiti engine

#2 Deploy the simplebookorder process definition

#3 Start the bookorder process instance

In just a few lines of code we are able to start-up the Activiti process engine, deploy the

book order process XML file from code listing 1.1 to it, and start a process instance for the

deployed process definition.

The process engine can be created with the

ProcessEngineConfiguration

#1, which

can be used to start the Activiti engine and the H2 database. In this case the process engine

is started with an in-memory H2 database. There are different ways to start-up an Activiti

engine and we’ll explain the options in detail in chapter 4. By the way, Activiti can also run

on other database platforms than H2, like Oracle or PostgreSQL.

The next important step in code listing 1.2 is the deployment of the

bookorder.simple.bpmn20.xml

file we showed in code listing 1.1. To deploy a process

©Manning Publications Co. Please post comments or corrections to the Author Online forum:

http://www.manning-sandbox.com/forum.jspa?forumID=722

from Java code we need to access the

RepositoryService

from the

ProcessEngine

instance. Via the

RepositoryService

instance we can add the book order XML file to the

list of classpath resources to deploy it to the process engine #2. The process engine will

validate the book order process file and create a new process definition in the H2 database.

Now it’s easy to start a process instance based on the newly deployed process definition

by invoking the

startProcessInstanceByKey

method #3 on the

RuntimeService

instance, which is also retrieved from the

ProcessEngine

instance. The key

bookorder

which is passed as process key parameter, should be equal to the process

attribute from

the book order process of code listing 1.1. A process instance is stored to the H2 database

and a process instance id is created that can be used to as a reference to this specific

process instance. So this identifier is very important.

You can now run the unit test and the result should be green. In the console you should

see a message like:

id 4 simplebookorder:1:3

This message means that the process instance id is 4 and the process definition that was

used to create the instance was the

simplebookorder

definition with version 1 and the

process definition database id is 3. Now we have the basics covered, let’s implement a bit

more of the book order process, so we can use the Activiti Explorer to claim and finish a user

task for our process.

1.4.2 Implementing a simple book order process

It would be a bit of a shame to stop chapter 1 with an example that contains just a start and

an end event. So let’s enhance our simple book order process with a script task and a user

task, so we can see a bit of action on the Activiti engine. First the script task will print an

ISBN number that will be been given as input to the book order process when started. Then

a user task will be used to handle the book ordering manually.

Activiti provides the possibility to use the scripting language you want, but Groovy is

supported by default. So we’ll use a line of Groovy to print the ISBN process variable. In

code listing 1.3 a revised version of the book order process is shown.

Listing 1.3 A book order process with a script and user task

<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"

targetNamespace="http://www.bpmnwithactiviti.org">

<sequenceFlow id="sequenceflow1" name="Validate order"

sourceRef="startevent1" targetRef="scripttask1"/>

<scriptTask id="scripttask1" #A

name="Validate order"

scriptFormat="groovy">

out:println "validating order for isbn " + isbn; #1

</script>

</scriptTask>

Chapter author name: Rademakers

©Manning Publications Co. Please post comments or corrections to the Author Online forum:

http://www.manning-sandbox.com/forum.jspa?forumID=722

<sequenceFlow id="sequenceflow2" name="Sending to sales"

sourceRef="scripttask1" targetRef="usertask1"/>

<userTask id="usertask1" name="Work on order"> #2

<documentation>book order user task</documentation>

<formalExpression>sales</formalExpression> #B

</resourceAssignmentExpression>

</potentialOwner>

</userTask>

<sequenceFlow id="sequenceflow3" name="Ending process"

sourceRef="usertask1" targetRef="endevent1"/>

</process>

</definitions>

#A Definition of a script task

#B Assign task to sales group

#1 Print the isbn

#2 Definition of a user task

With the two additional tasks added to the process definition, the number of lines of the

XML file grows quite a bit. In the chapter 3 we’ll show the Activiti designer, which abstract

you from implementing XML file and provides a drag and drop type of process development.

The script task contains a

out:println

variable #1, which is a Groovy reserved word

within the Activiti script task for printing text to the system console. Also notice that the

isbn

variable can be used directly in the script code without any additional programming.

The user task #2 contains a potential owner definition, which means that the task can be

claimed and completed by users that are part of the group sales. When we run this process

in a minute, we can see in the Activiti Explorer that this user task is available in the task list

for the user

kermit

, who is part of the

sales

group.

Now that we added more logic to the process, we also need to change our unit test. One

thing we need to add is a process variable

isbn

when starting the process. And to test if the

user task is created, we need to query the Activiti engine database for user tasks that can be

claimed by the user

kermit

. Let’s take a look at the changed unit test in code listing 1.4.

You can again find this unit test class in the

bpmn-examples

project in the

org.bpmnwithactiviti.chapter1

package.

Listing 1.4 A unit test with a process variable and user task query

public class BookOrderTest {

@Test

public void startBookOrder() {

ProcessEngine processEngine = ProcessEngineConfiguration

.createStandaloneProcessEngineConfiguration()

.buildProcessEngine();

RepositoryService repositoryService =

processEngine.getRepositoryService();

RuntimeService runtimeService =

http://www.manning-sandbox.com/forum.jspa?forumID=722

processEngine.getRuntimeService();

IdentityService identityService =

processEngine.getIdentityService();

TaskService taskService = processEngine.getTaskService(); #1

repositoryService.createDeployment()

.addClasspathResource("bookorder.bpmn20.xml")

.deploy();

Map<String, Object> variableMap =

new HashMap<String, Object>();

variableMap.put("isbn", "123456");

identityService.setAuthenticatedUserId("kermit"); #A

ProcessInstance processInstance = #2

runtimeService.startProcessInstanceByKey( #2

"bookorder", variableMap); #2

assertNotNull(processInstance.getId());

List<Task> taskList = taskService.createTaskQuery() #B

.taskCandidateUser("kermit") #B

.list() #B

assertEquals(1, taskList.size());

System.out.println("found task " +

taskList.get(0).getName());

taskService.complete(taskList.get(0).getId());

}

#1 Get a TaskService instance

#2 Start a process with a variable

#A Set authenticated user to kermit

#B Find tasks available for kermit

The

BookOrderTest

unit test starts a process instance with a

Map

of variables #2 that

contains one variable with a name of

isbn

and a value of

123456

. In addition, when the

process instance has been started, a

TaskService

instance #1 is used to retrieve the tasks

available to claim by the user

kermit

. Because there is only one process instance running

with one user task we test that the number of tasks retrieved is 1.

Also note that we are not using the in-memory database anymore, but switched

(

createStandaloneProcessEngineConfiguration

) to the default standalone H2

database that’s installed as part of the Activiti installation procedure. So before running the

unit test the H2 database should be running (

ant h2.start

ant demo.start

). Now

we can run the unit test to see if our changes work. In the console you should see a similar

output to:

validating order for isbn 123456

found task Work on order

The first line is printed by the Groovy script task in the running process instance. The last

line confirms that one user task is available for claim for the user

kermit

. Because a user

task is created we should be able to see this task in the Activiti Explorer. Confirm that

Tomcat has been started (

ant tomcat.start

ant demo.start

Now point your browser to

http://localhost:8080/activiti-explorer

and login with the user

kermit and the same password. When you click on the link Queued you should see one

剩余456页未读，继续阅读

xsgkaka

粉丝: 4
资源: 2

Activiti 实践：BPMN2.0与Activiti框架详解

activiti权威指南

activiti in action meap版 pdf

Activiti-in-Action.pdf

activiti.in.action

activiti工作流的参考文献有哪些

org.activiti.engine.activitiexception: no activiti tables in db

activiti-modeler哪个版本好

activiti5 和activiti6

Activiti7 和 SpringBoot 的版本关系

activiti7 activiti API

最新资源