Compose your own business process using a combination of the building blocks listed in this topic.
These are the external users or services that interact with the process.
There are two kinds of partners:
The interface partner is a direct link to the interface where the partner is configured. An interface partner is the process interface and exposes operations that can be called by external partners
The reference is not an interface, but instead tells the process where to find operations that it can invoke. More to the point, it specifies the interface that is used in the invocation of another component.
Variables store the messages that are exchanged between the partners in a process and the data that is used in its business logic.
A variable belongs to the scope in which it is declared. If it is created in the global process scope then it is a global variable, and thus visible to the process as a whole. Those that are created within nested scopes can only be seen by objects within that scope.
There are two choices available:
This variable can be either a business object or a simple type.
This variable uses either an input or output parameter as defined within an interface.
Correlation sets are used in runtime environments where there are multiple instances of the same process running. The sets allow two partners to initialize a business process transaction, temporarily suspend activity, and then recognize each other again when that transaction resumes.
When you work on the canvas, you will be working with a combination of the three following types of objects:
Activities are the individual business tasks that operate in conjunction with each other to implement the larger business goal that is represented by the process that contains them.
Elements are the objects that are used to support or configure activities.
Handlers appear as inline interactive boxes that you populate with activities. They are associated with an activity on the canvas and, when certain conditions are met within this parent activity, they represent a specific course of action.
The following graphic shows a fault handler (with a catch element) that is associated with an invoke activity.
What follows is a description of all the activities, elements, and handlers that are available in the palette to the left of the canvas, the submenus that are nested behind the dark grey arrows in the palette, and the action bars that appear when you hover over an activity on the canvas.
First submenu
![]() |
|
Second submenu
![]() |
|
Third submenu
![]() |
|
Information service activity
The information service activity is an optional feature for WebSphere Integration Developer that enables you to discover and invoke operations on an IBM Information Server, as well as offering direct access to relational database management systems through full SQL support.
If the icon for this activity ( ) appears on the first submenu
of the palette, then the Information service activity for business
processes feature has been installed, and instructions on how to
use it can be found under the Adding an information service activity to
a business process heading within the process editor documentation. If
the icon does not appear, then the feature is not installed, and the documentation
will not appear in the navigation.
To install the information service activity, use the Rational Product Updater, and look for IBM Information Server Plug-In for WebSphere Integration Developer in the optional feature tab. For general information about optional feature installation, refer to Finding and installing product updates.
Action bar
The elements and handlers that appear in the action bar will vary according to what activity is currently selected. Here is a list, in alphabetical order, of the elements that you might see.
Element | Icon | Description |
---|---|---|
Case element | ![]() |
Used within a choice activity, this element is used to create a control path and define the conditions that will cause this path to be executed. During execution, the process will evaluate the conditions in each of the case elements, and follow the first one that evaluates to true. |
Catch element | ![]() |
Use this element within a fault handler to intercept, and deal with a specific kind of fault. The catch element is always the first element on a fault handler's control path, and the activities that follow it are executed should the fault conditions you specify occur. You can catch a built-in fault type, or define one yourself. On the canvas, each catch shows the name of the fault type that it will catch, and each is associated with a variable. |
Catch all element | ![]() |
Use this element within a fault handler to intercept, and deal with any fault that is not already defined in an existing catch element. The catch all element is the first object on a control path, and the activities the follow it are executed should the fault conditions you specify occur. |
Compensation handler | ![]() |
Use the compensation handler on either an invoke or a scope activity, and within a long-running process to define logic that will execute when a fault is thrown after the parent activity has already been committed. Compensation is used when the activity cannot simply be reversed or undone, but another operation must be executed in order to return the failed process to a balanced state. |
Link | ![]() |
Use the link within a parallel activity to connect nested activities and form individual control paths. The link is used to express a synchronization dependency. In other words, it is execution under constraint because the link creates a dependency of one activity and the variables it uses on another activity. You can specify a transition condition on the link in the properties area of the process editor. |
Event handler | ![]() |
Use the event handler to associate either a process of a scope activity with an external stimulus. They can respond to events that happen at any time during an application's lifetime, or as many times as those events repeat. There can be several paths within the handler, and they determine how the process should proceed based on the nature of the data received. Each path is preceded by either an OnEvent or a Timeout element. |
OnEvent element | ![]() |
Use this element within an event handler to create a control path and specify the operation that will cause this path to be executed. |
Fault handler | ![]() |
A fault handler is a collection of specific activities that will run when a fault is thrown on the activity with which the handler is associated. Fault handlers can be used on both invoke and scope activities, and will run either when a fault is thrown by the invoke activity, or by an activity inside the scope activity. You can place activities on paths within the handler to either deal with anticipated faults, or attempt to find another way to complete the operation. Each path within the fault handler is preceded by either a catch, or a catch all element. |
Otherwise element | ![]() |
Use this element within a choice activity to to create a control path that will execute when none of the other cases evaluate to true. Use this element on only one of the paths within a choice activity. During execution, the process will evaluate the conditions in each of the case elements, and should none of them evaluate to true, it will execute the activities in this path. |
Receive element | ![]() |
Use this element within a receive choice activity to create a control path and specify the operation that will execute it. There is at least one receive element path nested within a receive choice activity. During execution, the process halts at the receive choice activity and listens for a message from its operations. The first message that comes in determines which path is executed. |
Add compensation handler | ![]() |
Use this element with a compensate activity to call a compensation handler on nested scopes. |
Timeout element | ![]() |
Use this element within either a receive choice activity or an event handler to create a control path that is executed when a specified time has either been reached or has elapsed. This element is used on a single path, and is configured to specify either a specific date, or period of time. During execution, this path is chosen when no input is received within this time period, or by the specified date. |