Home Page Icon
Home Page
Table of Contents for
jBPM6 Developer Guide
Close
jBPM6 Developer Guide
by Esteban Aliverti, Mauricio Salatino, Mariano Nicolas De Maio
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
Search in book...
Toggle Font Controls
Playlists
Add To
Create new playlist
Name your new playlist
Playlist description (optional)
Cancel
Create playlist
Sign In
Email address
Password
Forgot Password?
Create account
Login
or
Continue with Facebook
Continue with Google
Sign Up
Full Name
Email address
Confirm Email Address
Password
Login
Create account
or
Continue with Facebook
Continue with Google
Prev
Previous Chapter
Table of Contents
Next
Next Chapter
jBPM6 Developer Guide
jBPM6 Developer Guide
Add Highlight
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click
here
login for view all page.
Day Mode
Cloud Mode
Night Mode
Reset