jBPM6 Developer Guide电子书

jBPM6 Developer Guide

Table of Contents

jBPM6 Developer Guide

Credits

About the Author

Acknowledgments

About the Author

About the Author

About the Reviewers

www.PacktPub.com

Support files, eBooks, discount offers, and more

Why subscribe?

Free access for Packt account holders

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

1. Why Do We Need Business Process Management?

Theoretical background

Introduction, analysis, and explanations of standard specifications

Technical details and common practices of jBPM6

The conceptual background of BPM

Business processes

Sequence of business activities

Naming our activities

Business users and business applications

Humans and systems behave differently

Humans and systems – classification strategies

Achieving a business goal

The BPM discipline

BPM stage 1 – discovering your business processes

BPM stage 2 – formalizing your new processes

BPM stage 3 – implementing your technical assets

The business entity model

Coordination and orchestration of activities

BPM stage 4 – runtime

BPM stage 5 – monitoring

BPM stage 6 – improvements

BPM applications in the real world

The BPMS check list

BPM APIs and common practices

BPM – adoption of standards

Summary

2. BPM Systems' Structure

Components of a BPMS

The execution node

The semantic module

The process engine

Process definition structures

Process instance structures

Node instance structures

Components inside jBPM6

Transactions and persistence

Audit/History logs

Real-time dashboards

Data mining and data analysis tools

The KIE APIs

KIE services

The KIE module

The KIE container

The KIE base

The KIE session

External interactions

The Human task component

Human tasks – life cycle

Human tasks – APIs

The User/Group callback

The BPMS ecosystem

BPM and service-oriented architecture

Service orchestration

Enterprise Service Bus

Rule engines

Classic BPM system and rule engine integration

Event-driven architecture and complex event processing

Predictive analytics and decision management

Summary

3. Using BPMN 2.0 to Model Business Scenarios

Introduction to BPMN 2.0

Process modeling compliance

BPMN 2.0 elements

Flow elements

Connecting elements

Data elements

Swimlanes

Artifacts

Task types in jBPM6

Subprocess types in jBPM6

Event subtypes

Boundary events

BPMN 2.0

Modeling business scenarios with BPMN 2.0

Technical perspective

Sprint management technical overview

Adding simple process data

Summary

4. Understanding the KIE Workbench

What you need to start a jBPM6 environment

Running the KIE Workbench installer

What you will need to create the jBPM6 business processes

Workbench utilities

Process designer

Other knowledge asset editors

What you will need to run the jBPM6 business processes

Process runtime

Process UI

Task lists

Task forms

Summary

5. Creating a Process Project in the KIE Workbench

An IDE to our knowledge

A variety of process designers

The BPMN 2.0 Eclipse editor

The Web Process Designer

The jBPM Eclipse plugin

Interacting with the Web Process Designer

Creating new processes

Implementing our first process

The Web Process Designer sections

The toolbar

The Shape Repository panel

The editing canvas

The Properties panel

Sprint management process design

Configuring the process properties

Configuring the event nodes

Configuring the task nodes

The Service tasks

Configuring gateway nodes

Configuring sequence flow elements

Accessing existing processes

Modifying and deleting existing processes

Testing the process definitions

Process simulations

Unit testing the process definition

Process modeling summary

The Web Process Designer advanced topics

Importing process definitions

Service tasks

Work Item definition editor

Using Work Item definitions in the process designer

Providing a runtime for our process

The project editor

Build and deploy

Configuring the deployment unit

Summary

6. Human Interactions

Understanding human interactions

Human interactions inside our processes

WS-HT standard specification

Human tasks' life cycle

jBPM6 Human task component's overview

Human task component APIs

The task service

Adding a users and groups data source origin

Starting your task service

Connecting to the KIE session

Task-oriented user interfaces

Task lists

Task forms

Building your own extensions to Human tasks

Task life cycle event listeners

Task service interceptors

When to use task event listeners or interceptors

Task model provider

Summary

7. Defining Your Environment with the Runtime Manager

Understanding the role of the runtime manager

Understanding the runtime environment

Registerable items factory

Defining our runtime environment

Runtime lifecycle management

The different implementations available

Singleton Runtime Manager

The CDI injection

Per Request Runtime Manager

The CDI injection

Per Process Instance Runtime Manager

The CDI injection

The UI configuration of runtime managers

Configuring a KIE session for a KIE module

Configuring a runtime manager type

Creating your own runtime manager

Per Process Definition Runtime Manager

Summary

8. Implementing Persistence and Transactions

Why do we need persistence and transactions?

Persisting long running processes

The server failover and distribution mechanism

Persistence in jBPM6

KieStoreServices – creating and loading KIE sessions

How does persistence work?

Persistence and transaction configuration for jBPM6

History logs – extending the basic functionality

Object marshalling strategies

Other persistence mechanisms

Infinispan persistence

Summary

9. Integration with Other Knowledge Definitions

What is a rule?

Old-fashioned integration

The Drools rule engine

What Drools needs to work

Applying rules to our processes

Gateway conditions

Business Rule tasks

Ad hoc process instance evaluations

Runtime configurations to activate rules

Temporal reasoning and processes

Events and complex events

CEP

EDA

Drools Fusion functionalities

Event declarations

Temporal operators

Sliding windows

Drools Fusion in action

Summary

10. Integrating KIE Workbench with External Systems

Defining your architecture

Scalability considerations

Extending the KIE Workbench architecture

Web service addition

Work item handler default configurations

Executor service commands

KIE Session Sharing Considerations

Remote engine invocations

REST interface

JMS interface

Deploying the KIE Workbench in the cloud

Summary

A. The UberFire Framework

UberFire

Integrating components

The existing components and services

Extending and reusing the UberFire UI components

Model View Presenter

The workbench components

Workbench screens

Workbench pop ups

Workbench editors

Workbench perspectives

The lifecycle annotations

Creating a screen and a pop up

Creating a perspective

Integrating components with the existing workbenches

Summary

Index