Skip to main content

By clicking Submit, you agree to the developerWorks terms of use.

The first time you sign into developerWorks, a profile is created for you. Select information in your profile (name, country/region, and company) is displayed to the public and will accompany any content you post. You may update your IBM account at any time.

All information submitted is secure.

  • Close [x]

The first time you sign in to developerWorks, a profile is created for you, so you need to choose a display name. Your display name accompanies the content you post on developerworks.

Please choose a display name between 3-31 characters. Your display name must be unique in the developerWorks community and should not be your email address for privacy reasons.

By clicking Submit, you agree to the developerWorks terms of use.

All information submitted is secure.

  • Close [x]

developerWorks Community:

  • Close [x]

Generating UML models programmatically by using IBM Rational Software Architect

An introduction to the Rational Modeling Platform API

Ahmed Makady, Application and Integration Middleware Specialist , Gulf Business Machines
Ahmed works for Gulf Business Machines, IBM's General Marketing and Services Representative in the Arabian gulf region, where he delivers Rational software services to customers. He has been working with IBM products for more than seven years, including products from Rational, Lotus, WebSphere, and information management. He has extensive software design and development experience, especially using Java, J2EE, and Lotus Domino. Ahmed is certified for IBM Rational Unified Process and several other IBM products and technologies.

Summary:  This article shows you how to generate Unified Modeling Language (UML) models from structured text by using the IBM® Rational® Software Delivery Platform API, in particular the architecture management piece of the Rational Software Delivery Platform (Rational Modeling Platform, for short). This can save you time if you already have structured information that you would like to use for building UML models. The article gives an overview of the modeling architecture and the programming model. It also provides a detailed code example, along with a code walkthrough and an outline of the steps required to run this sample code.

Date:  26 Aug 2008
Level:  Intermediate PDF:  A4 and Letter (51KB | 13 pages)Get Adobe® Reader®
Also available in:   Chinese

Activity:  7973 views
Comments:  

Why you may need to generate UML models programmatically

The Unified Modeling Language (UML) has become a very widely adopted communication standard for software development projects around the world. In software projects, UML models are currently used to describe and communicate about software artifacts, starting from requirements through application architecture, analysis, and design, to development, deployment and maintenance.

However, in many situations, a project has information assets described in text format, and those assets need to be represented in UML to comply with best practices and to communicate with the rest of the project team.

For example, business process analysts may have business process descriptions in text that need to be converted to UML activity diagrams before delivery to the application architecture and design team to use while designing the application. UML activity diagrams are much clearer and easier for architects and designers. It may take a long time and significant effort for business analysts to go through the business process descriptions and create activity diagrams for each business process. Having a tool that automates generation of the models from text descriptions is of great help. The Rational Modeling Platform API provides the capability to create such a tool through simple Java™ code.


Introduction to the Rational Modeling Platform architecture and programming model

The Rational Modeling Platform is the foundation upon which Rational modeling solutions are based. Its most visible feature consists of a UML modeler with modeling editors, views, and tools that are built by using the various services offered by the platform. This platform is based on Eclipse technology, which is an open source tool integration platform. Rational modeling solutions include Eclipse.

Rational Modeling Platform architecture

The Rational Modeling Platform covers a wide set of technologies that can be divided into two groups: the Rational modeling components and the Eclipse components. What follows is a brief overview of each component that plays a role in this programming model.


Figure 1. Rational Modeling Platform architecture diagram
Rational components top, Eclipse components bottom

Eclipse components

  • Eclipse platform. Central to the Eclipse technology is the Eclipse platform. This component includes frameworks to build user interfaces, manage resources, coordinate builders, integrate debuggers, and much more. The Eclipse platform is responsible for all of the basic frameworks required by an integrated development environment. IBM Rational modeling solutions make great use of the extensibility offered by this platform.
  • Eclipse Modeling Framework (EMF). EMF is a model integration technology that serves as the backbone to IBM Rational modeling solutions.
  • UML 2. UML 2 is an EMF-based implementation of the UML 2.1 Superstructure specification. UML is a specification that defines a graphical language for visualizing, specifying, constructing, and documenting the artifacts of distributed object systems. The Rational Modeling Platform uses this implementation for its UML 2.1 functionality.
  • EMFT Transactions. EMFT stands for Eclipse Modeling Framework Technology. This framework contains of several technologies that complement the manipulation of EMF-based models. The EMFT Transactions component provides a framework for model management (accessing and modifying models). The Rational Modeling Platform uses EMFT Transactions for all model management.
  • EMFT OCL. EMFT OCL is an EMF-based implementation of the OCL 2.0 specification. Object Constraint Language (OCL) is a formal language used to describe rules that apply to UML models. The Rational Modeling Platform uses EMFT OCL to evaluate OCL expressions for the models that it manages, as well as to validate user input during code completion.
  • EMFT Validation. EMFT Validation is an extensible validation framework for EMF instance models. The Rational Modeling Platform uses EMFT Validation to constrain the models that it manages. In particular, it uses the framework to constrain UML 2 models according to the official specification.
  • EMFT Query. EMFT Query is a framework to help traversal of EMF model instances. It provides an SQL-inspired set of classes to formulate queries, as well as a rich condition class hierarchy. OCL expressions are supported to act as filters during model traversal. The Rational Modeling Platform uses EMFT Query to perform searches within the models that it manages.
  • Graphical Editing Framework (GEF). GEF provides the basis for the creation of graphical editors. It includes a model-view-controller (MVC)-based framework, as well as a rendering subsystem. The Rational Modeling Platform uses GEF indirectly for its diagram implementation through the GMF (Graphical Modeling Framework) component.
  • Graphical Modeling Framework (GMF). GMF is a framework to create graphical modeling editors. It consists of two main parts: a runtime component and a tooling component. The runtime part provides the infrastructure required to support extensible and feature-rich modeling diagram editors based on GEF and EMF. The tooling component enables the generation of such editors from various input models. The Rational Modeling Platform uses the GMF runtime element extensively.

Rational Modeling Platform components

Rational Modeling Platform components span three layers: UML Modeler, UML Modeling layer, and Domain Modeling layer.

  • UML Modeler. The UML Modeler layer includes the classes and interfaces required to manage the platform's UML modeling environment. The UMLModeler class is the entry point to control the lifecycle of the modeler's UML models and profiles. In addition, the class provides access to various classes required to interact with UML models.
  • UML Modeling layer. The UML Modeling layer includes helper components to work with UML models and diagrams. For example, it includes helpers to find UML objects in models, helpers to use UML element types (for example, activity nodes, control nodes, annotations), and helpers to find, create, customize, or analyze diagrams.
  • Domain Modeling layer. The Domain Modeling layer includes various services useful for the production of arbitrary EMF-based modeling editors.

Rational Modeling Platform API terms and concepts

To get started using the Rational Modeling Platform API, it is important to understand how to manage models and diagrams. The following list includes important terms and concepts that you need to know.

  • Rational Modeling Platform models. Models managed by the Rational Modeling Platform are instances of EMF models. As an example, every UML model in the Rational Modeling Platform is an instance of an EMF-based UML metamodel available in UML 2's org.eclipse.uml2.uml plug-in. This plug-in is an implementation of the official UML 2.0 specification. UML models are read and modified by using the Java interfaces. Model management is done mainly through the UMLModeler Java class. This is a utility class that exposes model and profile lifecycle operations and provides access to the modeling platform.
  • Rational Modeling Platform editing domains. EMF introduced the concept of an editing domain to control the lifecycle of models. An editing domain manages a self-contained set of interrelated EMF models and the commands that modify them. The editing domain used by the UML modeler for the Rational Modeling Platform is accessed through the UMLModeler.getEditingDomain() method.
  • Commands. A command is responsible for the modification of a model. A command is represented by the Command Java interface.
  • Command stacks. A command stack is a feature associated with an editing domain. The command stack contains commands that are executed to modify the models controlled by the editing domain. A command stack is represented by the CommandStack Java interface.
  • Rational Modeling Platform diagrams. Rational Modeling Platform diagrams are based on GMF notation models. A GMF notation model provides the basic objects to describe diagrams. It defines nodes, edges, styles, and other graphical information that is required by the framework to serialize diagrams. In the Rational Modeling Platform, diagrams are added as annotations to UML model elements and are persisted in UML modeler files (.emx fiiles). The IUMLDiagramHelper Java interface is used for manipulating Rational Modeling Platform diagrams.

Sample code objective and walkthrough

The sample Java code that follows demonstrates use of the Rational Modeling Platform API. The code is presented through a Java pluglet in IBM® Rational® Software Architect. Pluglets are small Java applications that are used to make minor extensions to the workbench in a simple and straight-forward way. Pluglets are written in Java and reside in a pluglet project. The pluglet can be tested in the same instance of the workbench, just like any other Java application. Pluglet authors can use the Java development environment, and they have access to the Rational Modeling Platform application programming interfaces (APIs).

The sample code reads business process steps from a text file and creates a UML activity diagram skeleton (one activity node for each process step) for this process in Rational Software Architect. To create this diagram, the code uses the Rational Modeling Platform API for manipulating Rational Modeling Platform models, diagrams, and model elements.

Sample code walkthrough

For better insight into the code, it is advisable that you take a look at the UML sequence diagram for the pluglet code. This diagram is available as a JPG image as part of the article material attached in the Download section.

The pluglet execution entry point is the method plugletmain() of the pluglet class: GenerateActivityDiagram. The code starts by retrieving the Rational Modeling Platform UML Modeler editing domain. As mentioned previously, the editing domains are used for manipulating Rational Modeling Platform models. The line of code in Listing 1 retrieves the modeler editing domain:


Listing 1. Retrieve UML Modeler editing domain
TransactionalEditingDomain editDomain = UMLModeler.getEditingDomain();
			

The next step is model manipulation. According to the Rational Modeling Platform programming model, this is done through defining and running commands on the command stack associated with the editing domain. The simplest way to create a command is to extend the RecordingCommand class and implement the doExecute() abstract method to perform the required model changes. The code fragment in Listing 2 creates a new RecordingCommand, implements the doExecute() method, and actually executes the command by calling the execute() method on the command stack associated with the UML Modeler editing domain.


Listing 2. Retrieve a specific UML model and modify it
editDomain.getCommandStack().execute(new RecordingCommand(editDomain, undoLabel) {

    protected void doExecute() {

        Collection models = UMLModeler.getOpenedModels();
        for (Iterator iter = models.iterator(); iter.hasNext();) {

            Model model = (Model) iter.next();
            out.println(model.getName());

            if (model == null )
                out.println("Could not open model");
            else{

                //Start operating on models having the name  "*Test*"
                if (model.getName().indexOf("Test") != -1){
                    createProcessActivityDiagram(model);
                }
            }
        }

    }
});
			

The doExecute() method in the previous code retrieves all of the models currently open in the Rational Modeling Platform environment (Rational Software Architect). Next, it iterates on these models and, for each model that contains the string "Test" as part of the name, it executes the createProcessActivityDiagram() method, passing the model instance to be manipulated as a parameter. This method reads sample business process steps from an external text file and adds a new activity diagram to the model that was passed as a parameter. The newly created activity diagram contains one node for each business process step read from the text file. Following is a detailed explanation for the createProcessActivityDiagram() method.

The createProcessActivityDiagram() method does all of the model manipulation work. First, it adds a new UML package, package1, to the model being processed. Next, it adds a new UML activity, Activity1, to the newly created package, and then it creates a new UML activity diagram, ActivityDiagram1, and adds it to the UML activity. Then, process steps are read from the text file and, for each step, an action node is added to Activity1. At the end, the nodes created for the actions on the diagram are adjusted for display by using the IUMLDiagramHelper interface method layoutNodes(). See the code fragment in Listing 3.


Listing 3. Modifying the UML model in Rational Software Architect to add a package, an activity, a diagram, and action nodes
//Create a package to hold the activity diagram
Package aPackage = addPackage(model, "package1");

//Add an activity "Activity1" to the package
Activity activity1 = addActivity(aPackage, "Activity1");

//Add an activity diagram to the activity
Diagram diagram = addActivityDiagram(activity1, "ActivityDiagram1");
...

//Read process steps from a file...
in = new BufferedReader(new FileReader("..."));

...

while((actionName = in.readLine())!=null){

    //Add an action to the activity
    addAction(activity1, actionName);
}
...

//Adjust diagram layout
UMLModeler.getUMLDiagramHelper().layoutNodes(diagram.getChildren(), "DEFAULT");
...
			

For more details on the methods addPackage(), addActivity(), addActivityDiagram(), and addAction(), read the Rational Modeling Platform API documentation (see Resources). The full code is available here (see Downloads).


Running the sample code

Prerequisites

This code has been developed and tested with Rational Software Architect V7.0.0. Make sure that the following extensibility features are installed with Rational Software Architect before you run the code:

  • Pluglets
  • Plug-in Development Environment
  • Eclipse Technology Extensibility
  • Modeling Extensibility

To run the sample code, follow these steps:

  1. Switch to the Modeling perspective in Rational Software Architect.
  2. Import the ModelGenProj project into Rational Software Architect:
    1. Select File > Import.
    2. In the Import dialog box, select Other > Project Interchange and then click Next.
    3. In the Import Project Interchange Contents dialog box, point to the file ModelGenProj.zip, check the ModelGenProj entry, and click Finish.
  3. Open the GenerateActivityDiagram.java file, which is located in the com.gbm.rational.support package. Make sure that the path to the process steps file defined in the pluglet code, steps.txt, points to the right location. This location is defined in the line of code shown in Listing 4. You can either modify the file location in the code or create a folder structure on your file system that complies with the path referenced in the code.

Listing 4. Specifying the input file path
in = new BufferedReader(new FileReader("..."));
			

  1. Open the model named Test by double-clicking it in the Rational Software Architect Project Explorer under ModelGenProj > Models > Test. Make sure that this is the only model that is open in Rational Software Architect, because the pluglet code operates on any open model with the string "Test" as part of the name.
  2. In the Project Explorer, right-click the GenerateActivityDiagram.java file, and select Run As > Pluglet.
  3. After the code runs, examine your UML model. You'll find a new package created, together with a UML activity diagram created that represents the process steps defined in the steps.txt file. This file contains a list of the process steps to be modeled, each in a separate line. To view the UML diagram created, from Project Explorer, navigate to ModelGenProj > Diagrams > Test and double-click the UML diagram package1: Activity1: ActivityDiagram1.

Acknowledgement

The author thanks Amr Yassin for reviewing this article.



Download

DescriptionNameSizeDownload method
Sample code and UML sequence diagramModel-gen-proj.zip47KB HTTP

Information about download methods


Resources

Learn

  • Using Pluglets in IBM Rational Software Architect, by Dave Kelsey, introduces the pluglet facilities contained within IBM Rational Software Architect (IBM® developerWorks®, November 2006).

  • Getting Started with UML2, on the Eclipse.org Web site, describes how to get started with the UML2 plug-ins for Eclipse. In particular, it gives an overview of how to create models (and their contents) both programmatically and by using the sample UML editor.

  • Check Eclipse UML2 Project for updates on the open source Eclipse UML2 project.

  • In Rational Software Architect 7.0 Help: From the Help menu, select Help Contents > Extending Rational Software Architect Functionality > Rational Modeling Platform Developer's Guide.

  • The Rational Software Architect page on developerWorks includes technical documentation, how-to articles, downloads, and other useful information.

  • UML Resource Page: Find resources, tutorials, specifications and information about the Unified Modeling Language.

Get products and technologies

Discuss

About the author

Ahmed works for Gulf Business Machines, IBM's General Marketing and Services Representative in the Arabian gulf region, where he delivers Rational software services to customers. He has been working with IBM products for more than seven years, including products from Rational, Lotus, WebSphere, and information management. He has extensive software design and development experience, especially using Java, J2EE, and Lotus Domino. Ahmed is certified for IBM Rational Unified Process and several other IBM products and technologies.

Report abuse help

Report abuse

Thank you. This entry has been flagged for moderator attention.


Report abuse help

Report abuse

Report abuse submission failed. Please try again later.


developerWorks: Sign in


Need an IBM ID?
Forgot your IBM ID?


Forgot your password?
Change your password

By clicking Submit, you agree to the developerWorks terms of use.

 


The first time you sign into developerWorks, a profile is created for you. Select information in your profile (name, country/region, and company) is displayed to the public and will accompany any content you post. You may update your IBM account at any time.

Choose your display name

The first time you sign in to developerWorks, a profile is created for you, so you need to choose a display name. Your display name accompanies the content you post on developerWorks.

Please choose a display name between 3-31 characters. Your display name must be unique in the developerWorks community and should not be your email address for privacy reasons.

(Must be between 3 – 31 characters.)

By clicking Submit, you agree to the developerWorks terms of use.

 


Rate this article

Comments

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=1
Zone=Rational
ArticleID=332551
ArticleTitle=Generating UML models programmatically by using IBM Rational Software Architect
publish-date=08262008
author1-email=amakady@ae.gbm.ihost.com
author1-email-cc=clarkega@us.ibm.com