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.
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.
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.
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.
You can enable the generation of Java enumerations that preserve the name and values of the enumeration literals as retrievable strings. To enable this functionality, you select the UML to Java Custom Enumeration Extension when you configure a transformation.
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.
The transformation does not generate parameterized type information for other Java collections.
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:public class Class1 {
/**
* <!-- begin-UML-doc -->
* <!-- end-UML-doc -->
* @uml.annotations for <code>class2</code>
* collection_type="Package1.Class2"
* @generated "UML to Java (com.ibm.xtools.transform.uml2.java5.internal.UML2JavaTransform)"
*/
private Set class2;
}
|
![]() |
The transformation generates the following source
code if you select the Use Java 5 check box
in the transformation configuration:public class Class1 {
/**
* <!-- begin-UML-doc -->
* <!-- end-UML-doc -->
* @generated "UML to Java (com.ibm.xtools.transform.uml2.java5.internal.UML2JavaTransform)"
*/
private Set<Class2> class2;
}
|
The following image shows the visual representation of the UML class that the Java-to-UML transformation generates:

/* * <!-- begin-UML-doc --> * <!-- end-UML-doc --> */
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.
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.
If you want the output of the UML-to-Java transformation to be the primary engineering artifact, you can specify that the transformation implements the design contract management protocol (DCMP) known as Mixed Modeling. By specifying this DCMP, the transformation creates a direct relationship between the source UML objects and the generated Java code. Creating direct relationships deletes the source UML objects and replaces them with visual representations of the source objects.
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.
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 |
|---|---|---|
![]() |
/**
*
*/
package Package1;
import java.util.Collection;
/**
* <!-- begin-UML-doc -->
* <!-- end-UML-doc -->
* @uml.annotations
* derived_abstraction="platform:/resource/UMLProject/Model.emx#_9YlH8CpPEdyn7_VFIWTp4A"
* @generated "sourceid:platform:/resource/UMLProject/Model.emx#_9YlH8CpPEdyn7_VFIWTp4A"
*/
public class Class1 {
/**
* <!-- begin-UML-doc -->
* <!-- end-UML-doc -->
* @generated "sourceid:platform:/resource/UMLProject/Model.emx#__8ptgOSnEdyXH8PWExuX2g"
*/
private Integer attribute1;
/**
* @return the attribute1
* @generated "sourceid:platform:/resource/UMLProject/Model.emx#__8ptgOSnEdyXH8PWExuX2g?GETTER"
*/
public Integer getAttribute1() {
// begin-user-code
return attribute1;
// end-user-code
}
/**
* @param theAttribute1 the attribute1 to set
* @generated "sourceid:platform:/resource/UMLProject/Model.emx#__8ptgOSnEdyXH8PWExuX2g?SETTER"
*/
public void setAttribute1(Integer theAttribute1) {
// begin-user-code
attribute1 = theAttribute1;
// end-user-code
}
/**
* <!-- begin-UML-doc -->
* <!-- end-UML-doc -->
* @generated "sourceid:platform:/resource/UMLProject/Model.emx#_RDsjcOSnEdyXH8PWExuX2g"
*/
public void Operation1() {
// begin-user-code
// TODO Auto-generated method stub
// end-user-code
}
/**
* <!-- begin-UML-doc -->
* <!-- end-UML-doc -->
* @generated "sourceid:platform:/resource/UMLProject/Model.emx#_R04v0OSnEdyXH8PWExuX2g"
*/
public void Operation2() {
// begin-user-code
// TODO Auto-generated method stub
// end-user-code
}
}
|
![]() |
The transformation does not alter the source model when you specify that the transformation generate trace relationships.
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.
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.