Activiti实战指南：BPMN 2.0与Activiti框架解析

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

"实战Activiti" 本书“实战Activiti”深入介绍了Activiti——一个基于Apache许可的开源业务流程管理（BPM）平台。Activiti项目致力于支持新的BPMN 2.0标准，该标准由对象管理组（OMG）制定，旨在提高流程的互操作性和适应云计算架构。书中的内容涵盖了从基础到高级的各个层面，旨在帮助开发者充分利用Activiti的功能。在第一部分“介绍BPMN 2.0和Activiti”中，作者首先引导读者了解Activiti框架，解释其设计目标和核心概念。接着，书中详细阐述了BPMN 2.0对开发者的重要性，解释了BPMN符号、事件、任务和流控制等基本元素。此外，还介绍了Activiti工具栈，包括用于设计、部署和监控流程的组件。这部分还会教导读者如何与Activiti过程引擎进行交互，以实现流程的运行和管理。第二部分“实现BPMN 2.0过程与Activiti”深入探讨了如何用Activiti实现BPMN 2.0流程。通过实例，读者将学习如何创建和执行一个基本的BPMN 2.0流程，并掌握如何应用高级BPMN特性，如事件、网关和子流程。同时，还讨论了错误处理机制，以及如何部署和配置Activiti引擎以满足特定需求。此外，书中还介绍了其他Activiti模块的用途，如表单、任务和用户组管理。第三部分“增强BPMN 2.0流程”进一步提升了流程实现的复杂度。这一部分涵盖了高级工作流实现，如动态流程调整和流程版本管理。还详细讲解了如何将外部服务与BPMN 2.0流程集成，以实现业务逻辑的自动化。另外，书中提到了利用Activiti的业务规则引擎进行决策管理，以及文档管理系统的集成，从而实现更全面的业务流程自动化。 “实战Activiti”是一本全面的指南，适合对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页未读，继续阅读

decarl

粉丝: 6
资源: 25

Activiti实战指南：BPMN 2.0与Activiti框架解析

Activiti项目实例

Activiti官方demo

activiti示例

杨恩雄编著：疯狂Workflow讲义——实战Activiti工作流应用

更新二进制分支变量与功能安全：实战Activiti REST API

ACTIVITI 实战

activiti 实战

activiti 实战 pdf

activiti-5.16

工作流activiti分享实例

最新资源