The dedicated SoaML diagrams are created with commands shown when right- clicking on SoaML Package element in the model browser.
Diagram Creation Commands
Capability diagram: Creates Class Diagram with SoaML.CapabilityDiagram stereotype
Service Interface diagram: Creates Class Diagram with SoaML.ServiceInterfaceDiagram stereotype
Service Contract diagram: Creates Class Diagram with SoaML.ServiceContractDiagram stereotype
Message diagram: Creates Class Diagram with SoaML.MessageDiagram stereotype
Participants diagram: Creates Class Diagram with SoaML.ParticipantDiagram stereotype
Service Architecture diagram: Creates Class Diagram with SoaML.ServiceArchitectureDiagram stereotype
Figure 7 Diagram 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:
SoaML Package: Creates Package with SoaML.Package stereotype
Capability:: Creates Class with SoaML.Capability stereotype
Participant: Creates Class with SoaML.Participant stereotype
ServiceInterface: Creates Class with SoaML.ServiceInterface stereotype
Consumer: Creates Interface with SoaML.Consumer stereotype
Provider: Creates Interface with SoaML.Provider stereotype
MessageType: Creates Class with SoaML.MessageType stereotype
ServiceContract: Creates Collaboration with SoaML.ServiceContract stereotype
ServiceArchitecture: Creates Collaboration with SoaML.ServiceArchitecture stereotype
Figure 4 Commands on SoaML Package
Commands shown when right-clicking on a MessageType element:
id: Creates Attribute with SoaML.id stereotype
Attachment: Creates Attribute with SoaML.Attachment stereotype
Commands shown when right-clicking on a Participant element:
BPMN Implementation: Creates BPMN activity and opens BPMN diagram
This command is required for specifying a participant behavior with BPMN models
Request: Creates Port with SoaML.Request stereotype
Service: Creates Port with SoaML.Service stereotype
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.
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.
Capability Diagram Palette
Capability: Creates Class with SoaML.Capability stereotype
Stereotype representation: “text”
Restrictions: Capabilities inside of capabilities should not be created
Operation: Creates an Operation
“Use” link: Creates Dependency with “use” stereotype
Stereotype representation: “text”
Traceability link: Creates a traceability between two model elements
Note: Creates a Note for a model element
Figure 8 Capability Diagram Example
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.
Message Diagram Palette
MessageType: Creates a Class with SoaML.ServiceInterface stereotype
Stereotype representation: “text”
Restrictions: ServiceInterfaces inside of ServiceInterface should not be created
ID: Creates an Attribute with SoaML.id stereotype
Stereotype representation: “text”
Attachment: Creates an Attribute with SoaML.Attachment stereotype
Stereotype representation: “text”
Class: Creates a Class
DataType: Creates a corresponding Data Type
Enumeration
Enumeration Literal
“Generalization” link: Creates a “Generalization” link
Association: Creates a “Association” link
Aggregation:
Composition links:
Traceability link: Creates a traceability between two model elements
Note: Creates a Note for a model element
Figure 21 Message Diagram Example
This is the major use case extracted from the SoaML specification and implemented in the SoaML Modelio module:
Figure 22 MessageType Modeling Use Case
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.
Table 9 Participant Diagram Palette
Command | Description |
---|---|
![]() |
Creates a Class with SoaML.Participant stereotype Stereotype representation: “text” SmartAction:
![]() ![]() ![]() |
![]() |
Creates a port with SoaML.Service stereotype on Participant or Part Stereotype representation: “text” |
![]() |
Creates a port with SoaML.Request stereotype on Participant or Part Stereotype representation: “text” |
![]() |
Creates a part inside of Participant Restriction:
|
![]() |
Creates a Collaboration Use inside of Participant Restriction:
|
![]() |
Creates a “generalization” link between two Participants. |
![]() |
Creates a “Provide Interface” link on a Port. |
![]() |
Creates a “Required Interface” link on a Port. |
![]() |
Creates a “Connector” between two Ports. |
![]() |
Creates a “Delegate” link between external port and a port belonging to a Part. |
![]() |
Creates a “Binding” link between Collaboration Uses representing Service Architectures and Parts representing Participants |
![]() |
Creates a traceability between two model elements |
![]() |
Creates a Note for a model element |
Figure 23 Participant Diagram Example
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
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.
Table 10 Service Architecture Diagram Palette
![]() |
Creates a Collaboration with SoaML.ServiceArchitecture stereotype Stereotype representation: “text” Restrictions: only Participants and Service Contract typed instances are possible to create inside. |
---|---|
![]() |
Creates a Role (Instance) inside of a Service Architecture. Restrictions:
|
![]() |
Creates a CollaborationUse inside of a Service Architecture. Restrictions:
|
![]() |
Creates a binding link between a Role and a Collaboration Use. Restrictions:
|
![]() |
Creates a traceability between two model elements |
![]() |
Creates a Note for a model element |
Figure 26 Service Architecture Diagram Example
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
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.
ServiceContract: Creates Collaboration with SoaML.ServiceContract stereotype Stereotype representation: “text”
SmartAction:
Instance: Creates an anonymous role inside of service contract
Context: Simple Service Contract
Restriction: It is impossible to model instance outside of a service contract.
ServiceChannel link: Creates a Connector with SoaML.ServiceChannel stereotype
Binding link: Creates a binding between service contract collaboration use and role.
Context: Compound Service Contract
Traceability link: Creates a traceability between two model elements
Note: Creates a Note for a model element
Figure 15 Service Contract Diagram Example
These are the major use cases extracted from the SoaML specification and implemented in the SoaML Modelio module.
Figure 16 Binary Service Contract Use Case
Figure 17 Simple Service Contract Use Case
Figure 18 Multi-Party Service Contract Use Case
Figure 19 Compound Service Contract Use Case
Figure 20 Compound Service Interfaces Modeling – Modelio Approach
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.
Table 6 Service Interface Diagram Palette
Command | Description |
---|---|
![]() |
Creates a Class with SoaML.ServiceInterface stereotype Stereotype representation: “text” Restrictions: ServiceInterfaces inside of ServiceInterface should not be created. |
![]() |
Creates a Interface with SoaML.Provider stereotype Stereotype representation: “text” SmartAction:
![]() |
![]() |
Creates a Interface with SoaML.Consumer stereotype Stereotype representation: “text” SmartAction:
![]() |
![]() | Creates an Operation inside a Service Interface, Provider or COnsumer |
![]() |
SmartAction:
|
![]() | Creates Dependency with “use” stereotype Stereotype representation: “text” |
![]() | Creates Connector between 2 internal parts, e.g. two roles representing Provider or Consumer interfaces. Stereotype representation: “text” |
![]() | Creates an dependency with SoaML.Expose stereotype between ServiceInterface and a Capability Stereotype representation: “text” Restriction: Link between a ServiceInterface and a Capability only |
![]() | Creates a traceability between two model elements |
![]() | Creates a Note for a model element |
Figure 10 Service Interface Diagram Example
The advanced features are available when right-clicking on a relevant element in the model explorer.
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
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
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
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.
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.
The document is dedicated to software engineers who intend to create SoaML models.
SoaML: SoaML specification 1.0 beta 2 version from 09.12.09 http://www.omg.org/spec/SoaML/
Modelio: Modelio CASE Tool, http://modeliosoft.com
SOFTEAM R&D Team web-site: http://rd.softeam.com
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
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.
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:
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
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