UML-to-Java transformations description
If the transformation configuration implements the Reconciled Modeling design contract management protocol (DCMP), you must specify source and target elements that are valid for the UML-to-Java and Java-to-UML transformations.
Valid transformation sources
- UML models
- Packages and their contents
- Non-nested classes and their contents
- Non-nested interfaces and their contents
- Non-nested enumerations
The transformation transforms the contents of UML models, packages, classes, and interfaces. For example, when the transformation transforms a class, the transformation also transforms the operations and properties of the class.
If you select a model or model elements in the Project Explorer view instead of using the Transformation Configuration editor, the model or elements that you select override the source model or elements that you specify in the transformation configuration. The transformation configuration is not affected and the source that you specify on the Source and Target page of the transformation configuration editor or in the New Transformation Configuration wizard does not change.
Valid transformation targets
You can specify a Java project, or a source folder in a Java project, as the destination for the output of the UML-to-Java transformation.
Alternate names for generated output
You can create a mapping model to specify alternate names for the elements that the transformation generates, without modifying the source model. You might specify alternate names if you want to include Java-specific details, such as naming restrictions in platform-independent models, or if the logical organization of the source model is not appropriate as target packaging.
You can specify a qualified name such as com.ibm.NewName or an unqualified name such as NewName. Specifying alternate names for packages affects all classifiers in that package, unless the classifier specifies a fully qualified name. You can also specify alternate locations in the same project for elements that the transformation generates.
Support for custom enumerations
You can enable the generation of Java enumerations that preserve the name and values of the enumeration literals as retrievable strings. To enable this feature, select the UML to Java Custom Enumeration Extension when you configure a UML-to-Java transformation.
Transformation of passive class state machines
You can enable the generation of Java code for passive class state machines. To enable this feature, select the corresponding extension when you configure a UML-to-Java transformation. After the transformation runs, you can run the generated state machine code as a Java application.
Transformation of XSD data types
If you apply the XSD Types model library to a UML model, when you run the UML-to-Java transformation, the XSD data types are transformed into corresponding Java qualified names. For detailed mapping information, see the reference topic below.
Parameterized types that the UML-to-Java transformation supports
- AbstractCollection
- AbstractList
- AbstractMap
- AbstractSequentialList
- AbstractSet
- ArrayList
- BitSet
- Collection
- HashMap
- HashSet
- Hashtable
- LinkedList
- List
- Map
- Set
- SortedMap
- SortedSet
- Stack
- TreeMap
- TreeSet
- WeekHashMap
- Vector
The transformation does not generate parameterized type information for other Java collections.
UML collection types and Java varargs
- In the Properties view, on the General page, the Ordered and Unique properties specify the UML collection type.
- In the Properties view, on the Advanced page, the Is Ordered and Is Unique properties specify the UML collection type.
- Select the corresponding transformation extension in the transformation configuration. See the related task topic below for information about configuring a UML-to-Java transformation.
- Apply the «JavaCollection» stereotype to the corresponding UML parameter or property, and set the collectionType property of the stereotype.
To create a Java vararg, you can apply the vararg keyword to the parameter, or you can let the transformation transform the last parameter in a list into a vararg by default.
Annotation of Java source code with UML collection information
If you do not configure the transformation to generate code that is compatible with J2SE 5.0, the UML-to-Java transformation adds comments about UML collection types to the Java collection types that it generates. These comments enable the visual development tools to create accurate visual representations of the Java collection types.
If you specify a multiplicity of * on a UML attribute and you do not change the Java collection information in the transformation configuration, by default, the UML-to-Java transformation generates a Java set.
UML elements | UML-to-Java transformation output | Visual representation of transformation output |
---|---|---|
![]() |
The transformation generates the following source
code if you clear the Use Java 5 check box
in the transformation configuration:
|
![]() |
The transformation generates the following source
code if you select the Use Java 5 check box
in the transformation configuration:
|
- In Class1, the transformation generates a UML attribute called class2 with the «JavaCollection» stereotype applied; the collectionType property is set to java.util.Collection, and the multiplicity is set to *.
- In Class2, the transformation generates a UML attribute of type Class called class1, with a multiplicity set to 1, and no stereotype applied.
The following image shows the visual representation of the UML class that the Java-to-UML transformation generates:

Generation of Javadoc information
- The contents of the documentation property for a UML
element, which the transformation places between the following tags:
/* * <!-- begin-UML-doc --> * <!-- end-UML-doc --> */
- Annotations that the transformation generates
- Information generated by the JDT comments template for the corresponding Java typeNote: To customize the Javadoc information that a JDT template generates, click ; then expand Comments, select a Java type, and in the Pattern field for that type, customize the Java comment.
Preservation of Javadoc information from previous releases of IBM Rational Software Architect Designer
Documentation of relationships in transformation output
- Associations
- Generalizations
- Implementations
- Realizations
The transformation adds documentation for generalization, implementation, and realization relationships to the UML documentation for the originating class in each relationship. The transformation also adds the documentation for these relationships to the Javadoc information for the generated target class of each relationship.
For associations, the transformation adds the UML documentation to the documentation of each associated property.
Preservation of Java keywords
UML models cannot represent several Java keywords, such as strictfp, native, transient, and volatile. To preserve these keywords when you run the UML-to-Java transformation, you should model these keywords as UML keywords.
Model element identifiers in transformation output
When you run a transformation that is configured to create trace relationships, for each element that supports the @generated tag, the transformation appends a unique identifier to the @generated tag. This identifier specifies the UML model element from which the Java element was generated, as in this example: * @generated "sourceid:platform:/resource/UMLProject/SimpleModel.emx#_83GpoBtIEdyLaOwyRX_ZMQ". If you rename elements in the source UML model, this unique identifier enables the merge functionality to refactor and merge the appropriate elements.
The Java-to-UML, or reverse, transformation can also use the identifiers to match corresponding elements between the Java project and the UML model. If applicable, changes to the Java source code elements are treated as modifications or as code refactoring instead of additions and deletions to the generated code.
Visual representations of generated Java elements
If the transformation cannot transform UML elements, such as nested elements, it moves these elements to the nearest package. If the transformation cannot move a model element to the nearest package, it deletes the element.
To avoid possible problems, you should place your source model under version control.
Trace relationships between source model elements and transformation output
You can use the UML-to-Java transformation to create trace relationships from UML source model elements to the generated Java classes. You can then view the trace relationships in a topic diagram by creating and running model queries.
Creating trace relationships is useful in large projects that might contain multiple models and multiple transformation configurations. You can also create and run traceability queries that display how the transformation output relates to software specifications and model elements.
When you rerun the transformation, if necessary, the transformation uses the identifier in the source code to match corresponding elements and then changes the code to reflect the changes to the model. For example, if you rename a UML operation in the source model and rerun the transformation, the transformation renames the previously generated Java method and preserves the method body, instead of deleting the previously generated method and adding a new method.
The Java-to-UML, or reverse, transformation can also use the identifiers to match corresponding elements between the Java project and the UML model. If applicable, changes to the Java source code elements are treated as modifications or as code refactoring instead of additions and deletions to the generated code.
UML element | Transformation output | Trace relationship in a class diagram |
---|---|---|
![]() |
|
![]() |
The transformation does not alter the source model when you specify that the transformation generate trace relationships.
Integration with team support
The UML-to-Java transformation provides integration functionality with IBM® Rational® Team Concert™, CVS, Rational ClearCase®, and Rational ClearCase LT version control systems, which enables you to automatically check out files or add new files. You must enable team capabilities to work with configuration management systems.