Activiti工作流引擎实战

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

"Activiti in Action 是一本详细介绍 Activiti 工作流引擎的书籍，该书在Manning出版社的Early Access Program (MEAP) 版本中发布。这本书旨在帮助开发者理解BPMN2.0标准，并掌握如何使用Activiti框架实现业务流程管理。" 在深入探讨Activiti之前，我们先来了解一下什么是BPMN2.0。Business Process Modeling Notation（BPMN）2.0 是一种图形化表示业务流程的国际标准，它提供了一种通用的语言，使得业务人员和技术人员可以更好地理解和沟通流程的设计。BPMN2.0引入了丰富的符号和元素，如泳道、任务、网关、事件等，用于描述复杂的业务流程逻辑。 "Activiti in Action"的第一部分"Introducing BPMN2.0 and Activiti"，主要介绍了Activiti框架及其与BPMN2.0的关系。作者会详细解释Activiti是如何作为jbpm3和jbpm4的继承者，提供更加高效、灵活的工作流开发环境。此外，这部分还会讲述Activiti工具栈，包括其核心的流程引擎以及与之配合的各类工具。第二部分"Implementing BPMN2.0 processes with Activiti"深入到实际的流程开发中，通过实例展示如何使用Activiti实现BPMN2.0过程。这包括基础的BPMN2.0过程实现，高级的BPMN2.0特性和扩展的使用，以及如何处理错误和异常，以及引擎的部署和配置。第三部分"Enhancing BPMN2.0 processes"进一步提升流程的复杂性和实用性，如实施高级工作流策略，将服务集成到BPMN2.0过程中，利用Activiti内置的业务规则引擎进行决策管理，以及文档管理的使用等。这部分内容旨在帮助读者将Activiti应用到实际的企业级业务场景中，实现更高效、智能化的业务流程自动化。 "Activiti in Action"这本书全面覆盖了Activiti的各个方面，无论你是初学者还是有经验的开发者，都能从中受益，提升在业务流程管理领域的专业技能。通过阅读本书，你将能够熟练运用Activiti工作流引擎，实现符合BPMN2.0标准的高效业务流程。

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页未读，继续阅读

kingsun521

粉丝: 0
资源: 6

Activiti工作流引擎实战

activiti in action

activiti in action最全代码

Activiti in Action(Activiti实践)英文版(官方)

Activiti in action

Activiti in Action 源码

Activiti in action 英文

Activiti in Action.2012

Activiti in Action英文版

activiti in action meap版 全本

activiti in action meap版 pdf

最新资源

activiti in action meap版全本