Index by title

Diagram Creation Commands

The dedicated SoaML diagrams are created with commands shown when right- clicking on SoaML Package element in the model browser.

Diagram Creation Commands


Figure 7 Diagram Creation Commands


Element Creation Commands

The following commands are shown when right-clicking on a model element in the model browser.

Commands shown when right-clicking on a SoaML Package element:

Commands on SoaML Package


Figure 4 Commands on SoaML Package

Commands shown when right-clicking on a MessageType element:

Commands on MessageType

Commands shown when right-clicking on a Participant element:

Commands on Participant

Date index


 Deployment

After the Modelio Enterprise Edition installation, start the modeller and create a simple UML model.


Figure 1 Creating Default UML Model with Modelio

Go to the MDA menu and choose Install a module (Figure 2).


Figure 2 Module Deployment

You will be led to mdastore folder. Proceed to the location of the SoaML module (Figure 3).


Figure 3 “shape” Module Folder

You need to choose SoaML_x.yy.zz.jmdac and click Open.


Capability diagram

The Capability diagram is used for designing capabilities (functions) and relations between them (use links). Capabilities can be placed in packages to separate domains.

The diagram is dedicated to capabilities only. The other required elements, such as Classes, Interfaces and MessageTypes to type parameters are modeled elsewhere. They are dragged and dropped to the diagram from the model browser.

Palette

Capability Diagram Palette


Figure 8 Capability Diagram Example


Message diagram

Message Diagram is dedicated to model SoaML Message Types as well as their internals using links to classes representing the data model. The diagram covers basic cases of MessageType composition modeling. The data models should be modeled with UML class diagrams.

Palette

Message Diagram Palette


Figure 21 Message Diagram Example

Use Cases

This is the major use case extracted from the SoaML specification and implemented in the SoaML Modelio module:


Figure 22 MessageType Modeling Use Case


Participant Diagram

This diagram is dedicated to a Participant modeling including its internal structure and relationships to Service Architectures.

The elements required for modeling the internal structure of the Participant should be dragged and dropped from the model browser. This includes dragging and dropping of other Participants and ServiceArchitectures. This operation will create parts for Participant including ports and required collaboration use for ServiceArchitectures. Parts have to be typed with Participants, Ports with ServiceInterfaces, CollaborationUse with ServiceArchitecture.

Palette

Table 9 Participant Diagram Palette

Command Description
Participant Creates a Class with SoaML.Participant stereotype
Stereotype representation: “text” SmartAction:
  1. If clicked inside of exiting Participant, a new Part is created typed by a newly created additional Participant, including ports.
  2. If Participant A is dragged and dropped inside of an existing participant, a part is created typed by Participant A
  3. If Service Architecture A is dragged and dropped inside of an existing participant, a Collaboration Use is created typed by Service Architecture A
Restrictions: only Participants and Service Architecture typed instances are possible to create inside.
Service Creates a port with SoaML.Service stereotype on Participant or Part
Stereotype representation: “text”
Request Creates a port with SoaML.Request stereotype on Participant or Part
Stereotype representation: “text”
Instance Creates a part inside of Participant
Restriction:
  1. It is impossible to model instance outside of a Participant.
  2. Instance should be typed with a Participant
CollaborationUse Creates a Collaboration Use inside of Participant
Restriction:
  1. It is impossible to a Collaboration Use outside of a Participant.
  2. Collaboration Use should be typed with Service Architecture
“Generalization” link Creates a “generalization” link between two Participants.
“Provided Interface” link Creates a “Provide Interface” link on a Port.
“Required Interface” link Creates a “Required Interface” link on a Port.
“Connector” link Creates a “Connector” between two Ports.
“Delegate” link Creates a “Delegate” link between external port and a port belonging to a Part.
“Binding” link Creates a “Binding” link between Collaboration Uses representing Service Architectures and Parts representing Participants
Traceability link Creates a traceability between two model elements
Note Creates a Note for a model element


Figure 23 Participant Diagram Example

Use Cases

This is the major use case extracted from the SoaML specification and implemented in the SoaML Modelio module:


Figure 24 Participant Modeling Use Case

In the above Use Case a Service Architecture is dragged and dropped into the Participant.


Figure 25 Conjugate Service Interface Modeling Use Case


Service Architecture Diagram

This diagram is dedicated to the Service Architecture collaboration modeling including its internals. Participants and Service Contracts should be modeled with the relevant diagrams and then dragged and dropped from the model browser to the Service Architecture diagram. It is also possible to create simple roles and collaboration use inside of the Service Architecture and later to type them with Participants and Service Contracts respectively.

Palette

Table 10 Service Architecture Diagram Palette

Service Architecture Creates a Collaboration with SoaML.ServiceArchitecture stereotype Stereotype representation: “text”
Restrictions: only Participants and Service Contract typed instances are possible to create inside.
Role (Instance) Creates a Role (Instance) inside of a Service Architecture.
Restrictions:
  1. It should be impossible to create Instances outside of Service Architecture.
  2. Role should be typed by a Participant
CollaborationUse Creates a CollaborationUse inside of a Service Architecture.
Restrictions:
  1. It should be impossible to create Instances outside of Service Architecture.
  2. CollaborationUse should be typed by a Service Contract
“Binding” link Creates a binding link between a Role and a Collaboration Use.
Restrictions:
  1. Role should be typed by a Participant
  2. CollaborationUse should be typed by a Service Contract
Traceability link Creates a traceability between two model elements
Note Creates a Note for a model element


Figure 26 Service Architecture Diagram Example

Use Cases

This is the major use case extracted from the SoaML specification and implemented in the SoaML Modelio module:


Figure 27 Service Architecture Modeling Use Case


Service Contract Diagram

The Service Contract diagram is dedicated to service contract modeling.

The following use cases are covered by this diagram:

The Service Contract diagram is strictly dedicated to modeling Service Contract collaboration internals. The other elements (“Providers” and “Consumers”) are dragged and dropped from the model browser. These elements are modeled elsewhere.

Palette

Service Contract Diagram Palette


Figure 15 Service Contract Diagram Example

Use Cases

These are the major use cases extracted from the SoaML specification and implemented in the SoaML Modelio module.

Binary Service Contract


Figure 16 Binary Service Contract Use Case

Simple Service Contract


Figure 17 Simple Service Contract Use Case

Multi-Party Service Contract


Figure 18 Multi-Party Service Contract Use Case

Compound Service Contract


Figure 19 Compound Service Contract Use Case


Figure 20 Compound Service Interfaces Modeling – Modelio Approach


Service Interface Diagram

The ServiceInterface diagram is dedicated to model ServiceInterfaces, Providers, Consumers and their relationships. The Capabilities can be dragged and dropped to show “expose” relationships between Service Interfaces and Capabilities.

4.2.1 Palette

Table 6 Service Interface Diagram Palette

Command Description
ServiceInterface Creates a Class with SoaML.ServiceInterface stereotype
Stereotype representation: “text”
Restrictions: ServiceInterfaces inside of ServiceInterface should not be created.
Provider Creates a Interface with SoaML.Provider stereotype
Stereotype representation: “text”
SmartAction:
    1. If clicked inside of exiting ServiceInterface, a new part is created typed by newly created additional “Provider”
Consumer Creates a Interface with SoaML.Consumer stereotype
Stereotype representation: “text”
SmartAction:
  • If clicked inside of exiting ServiceInterface, a new part is created typed by newly created additional “Consumer”
Operation Creates an Operation inside a Service Interface, Provider or COnsumer
Smart “Realize” link SmartAction:
  1. If target element is a Class, creates “Generalization” link
  2. If target element is an Interface, creates “Realization” link
"Use" link Creates Dependency with “use” stereotype
Stereotype representation: “text”
"Connector" link Creates Connector between 2 internal parts, e.g. two roles representing
Provider or Consumer interfaces.
Stereotype representation: “text”
“Expose” link Creates an dependency with SoaML.Expose stereotype between ServiceInterface and a Capability
Stereotype representation: “text”
Restriction: Link between a ServiceInterface and a Capability only
Traceability link Creates a traceability between two model elements
Note Creates a Note for a model element


Figure 10 Service Interface Diagram Example

Advanced Features

The advanced features are available when right-clicking on a relevant element in the model explorer.

“derive ServiceInterface” command

Applicable to: “Provider” interface.

Action: Creates a “ServiceInterface” class with all operations of the “realized” interface.

Smart action: This command is applicable to a multiple selection of “Provider” interfaces


Figure 11 Derive Service Interface Command

“conjugate ServiceInterface” command

Applicable to: “ServiceInerface” class

Action: Creates a “ServiceInterface” class, with the following properties

Smart action: This command is applicable to a multiple selection of “ServiceInerface” classes


Figure 12 Conjugate ServiceInterface Command

Use Cases

This is the major use case extracted from the SoaML specification and implemented in the SoaML Modelio module, including conjugate Service Interface definition:


Figure 13 Service Interface Modeling Use Case

“Expose” use case:


Figure 14 Exposing Capability Use Case


Sample SoaML Model

The Sample SoaML model presents examples of diagrams proposed by the Modelio SoaML module. These diagrams are outlined below.


Figure 33 capability diagram

The Capability Diagram specifies sample capabilities for the Purchase Order example from the SoaML specification. OrderProcessing capability uses Shipping capability in order to fulfill its functionalities.


Figure 34 services interface diagram

The Service Interface diagram is illustrated by a Place Order Service which involves a provider and consumer interfaces: Order Taker and Order Placer respectively. The conjugate service concept is illustrated with the ~Place Order Service.


Figure 35 service contract diagram

The Service Contract diagram describes the Place Order service contract, which involves the Order Placer consumer interface and the Order Taker provider interface.


Figure 36 message diagram

The Message diagram is used to specify the Purchase Order Message Type (POMessage). The POMessage includes a Form attachment as well as customer and po fields typed by Customer class and Purchase Order data type respectively.


Figure 37 participant diagram

The Participant diagram depicts a Dealer participant requesting a Place Order Service, which in its turn provide Order Taker interface and requires Order Placer interface.


Figure 38 service architecture diagram

Finally, the Service Architecture diagram shows that a Dialer and a Manufacturer collaborate over the Place Order service contract specified above.


Travel Agency Sample Example

The Travel Agency example provides a sample illustration of the BPEL and Java skeleton generation for implementation of SOA architecture with Web Services.


Figure 39 Assembly View

The Travel Agency system consists in three sub-subsystems:

The components are integrated with corresponding Service Interfaces over Provider interfaces


Figure 40 FlightSearchResult Message Type

The messages are specified with message diagrams.


Figure 41 FlightBooking


Figure 42 services interface diagram

The components and their interfaces are specified in details.


Figure 43 Travel Agency Front Desk

The Travel Agency Front Desk behavior is specified with a business process, which is refined with operation invocations.


Figure 44 services interface diagram

This component involves several conjugate Service Interfaces that are important to allow BPMN refinement with operation invocations.


Figure 45 Travel Front Desk behavior in BPMN notation.


Figure 46 Refining BPMN with operation invocations

The SoaML Engine module allows generation of XSD, WSDL, BPEL and annotated Java skeletons for Web Service implementation.


SoaML Designer

Introduction

Commands

Diagrams

SoaML Models Creation in an Expert Mode

Web Service Generation

Examples


Intended Audience

The document is dedicated to software engineers who intend to create SoaML models.


References


Scope

SoaML is an OMG standard, defined as an extension of the UML language for modeling SOA architectures. The current document describes how to use Modelio with this SoaML extension.

For further information on how to use Modelio, the main Modelio user guide should be consulted.

The Modelio SoaML Designer module is based on the analysis of the SoaML specification version 1.0 beta 2 from 09.12.09


SoaML Models Creation in an Expert Mode

The above section presented the Modelio approach for SoaML modelling using dedicated diagrams. These diagrams allow to clearly separate concerns and concentrate on major use-case for SoaML modelling. For the sake of clearness and user-friendliness, this is achieved by reducing the usage of the SoaML.

The SoaML module fully covers the whole collection of stereotypes defined in the specification. In order to benefit from this, one may use Modelio in an expert mode. In this mode, a user should create UML models and then annotate them with SoaML stereotypes.

The following example gives instructions on annotations of UML elements with SoaML stereotypes.

Create any UML element. Go to “MDA annotations” window and choose the stereotype button (Figure 28).


Figure 28 Creating UML Class

Only applicable SoaML stereotypes are shown in the dialogue window (Figure 29).


Figure 29 SoaML Stereotypes.

This mechanism is applicable for all stereotypes described in the SoaML specification.


Web Service Generation

The Web Service generation features are provided by the SoaMLEngine module, which have to be deployed to enable features described below.

The SoaMLEngine module also requires the following modules installed:


Specifying Participants Behavior with BPMN

It is possible to specify behavior of SoaML Participants with BPMN. This feature is used by transformations to BPEL implementations.

In order to create a BPMN process representing the participant implementation in BPMN, right-click on the Participant element in the model browser and activate BPMN Implementation command.


Figure 30 Creating BPMN Implementation for SoaML Participant.

A BPMN activity is created and a BPMN diagram is opened.

The SoaML Engine module (when deployed) allows refining the BPMN models with operation invocations.

If the Participant contains the ports typed with service interfaces, it is possible for each activity to select a relevant operation from the port (see Figure 31).

This information is used later for BPEL model transformation.


Figure 31 Refining BPMN model with operation invocation


Transformation to Web Services

Thanks to the SoaMLEngine module, a SoaML model can be transformed into a Web Service PSM model. For this, model-to-model transformation the following actions are performed:

This functionality is implemented in SoaMLEngine module which has to be deployed as well as its dependency modules i.e. XSD, WSDL, BPEL, BPMN and SOA Architecture. Figure 32 depicts the transform GUI command which can only be launched on the SoaML package element.


Figure 32 SoaMLEngine Transform Command