Activiti实战：深入探索BPMN2.0与Activiti框架

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

"activiti in action" 本书《Activiti in Action》是关于Business Process Management Notation 2.0（BPMN 2.0）和Activiti框架的专业指南。Activiti是一个开源的工作流引擎，它实现了BPMN 2.0标准，为企业流程管理提供了强大的工具。这本书主要分为三个部分，详细介绍了如何使用Activiti实现和优化BPMN 2.0流程。第一部分“介绍BPMN 2.0和Activiti”包括以下章节： 1. 介绍Activiti框架：这部分内容将帮助读者理解Activiti的核心概念、设计哲学以及在企业中的应用。它涵盖了Activiti的基本架构，如何开始使用这个框架，并提供了一些简单的示例。 2. BPMN 2.0：对开发者意味着什么？本章深入解析了BPMN 2.0标准，阐述了其对开发人员的意义，包括各种图形符号、活动类型和流程控制结构，使开发者能理解并设计出符合标准的流程图。 3. 介绍Activiti工具栈：这里会介绍与Activiti相关的工具和库，如模型器、API和持久化机制，以便开发者能够有效地进行流程建模和实施。 4. 使用Activiti流程引擎：详细讨论了如何与Activiti引擎交互，包括启动、管理和监控流程实例，以及配置和扩展引擎的能力。第二部分“用Activiti实现BPMN 2.0流程”涵盖： 5. 实现一个BPMN 2.0流程：通过实际案例，演示如何从头开始创建和执行一个BPMN 2.0流程，包括任务、事件、网关等元素的使用。 6. 应用高级BPMN 2.0和扩展：讲解如何利用BPMN 2.0的高级特性和Activiti特定的扩展，如多实例、子流程和事件处理，以实现更复杂的业务逻辑。 7. 处理错误处理：讨论错误和异常的处理机制，包括错误事件、补偿任务和错误边界事件，以确保流程的健壮性。 8. 部署和配置Activiti引擎：详细阐述如何在不同的环境中部署Activiti，以及如何根据需求调整引擎配置。 9. 探索额外的Activiti模块：介绍如表单、用户任务和身份管理等功能，以增强流程的用户体验和安全性。第三部分“增强BPMN 2.0流程”包含： 10. 实现高级工作流：讲解如何实现更复杂的工作流程，如并发、优先级和动态任务分配，以满足企业的高级需求。 11. 与BPMN 2.0流程集成服务：介绍如何将外部服务集成到流程中，如Web服务调用、数据库查询等，以实现流程间的协作。 12. 统治业务规则引擎：讨论如何使用Activiti集成业务规则引擎，如Drools，以实现灵活的业务决策。 13. 使用文档管理：介绍如何在流程中集成文档管理功能，以支持文件的创建、存储和共享。《Activiti in Action》旨在帮助读者从基础到高级，全面掌握BPMN 2.0和Activiti框架，以便在实际项目中构建和优化高效的企业流程。通过本书，开发者可以深入了解BPMN 2.0标准，学习如何利用Activiti实现自动化和管理业务流程，提升企业的运营效率。

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

剩余455页未读，继续阅读

*道童*

粉丝: 28
资源: 22

Activiti实战：深入探索BPMN2.0与Activiti框架

Activiti in Action：开源BPM引擎实战

深入探索Java BPM：Activiti in Action实战指南

Activiti工作流引擎实战：高清英文PDF

Activiti in action

Activiti in Action

Activiti in Action 源码

Activiti in action 英文

Activiti in Action.2012

Activiti in Action英文版

activiti in action meap版 pdf

最新资源