| Puede encontrar la versión original de este artÃculo en Inglés en: |
|---|
Prerequisitos
Para empezar a utilizar UML2 (y seguir el ejemplo de este artÃculo), debe tener instalados Eclipse 3.1, EMF 2.1, y UML2 1.1.
Introducción
Este artÃculo le llevará por los pasos básicos para crear modelos utilizando UML2. Utilizando un sencillo modelo (el modelo ExtendedPO2, sigilosamente 'tomado prestado' del libro EMF 'bible') como ejemplo, veremos todo lo nocesario para crear algunos de los elementos más comunes que componen un modelo. Por cada tipo de elemento, primero veremos su proceso de creación utilizando el editor UML y luego exploraremos como conseguir lo mismo utilizando código Java. Abajo puede ver el modelo ExtendedPO2:
 Figura 1: Aspecto del Modelo ExtendedPO2 |
Empezando
Antes de empezar, necesitará crear un sencillo proyecto en su espacio de trabajo. Este proyecto servirá como contenedor para el modelo que vamos a crear utilizando el editor UML2. Sigua estos pasos para crear el proyecto para este artÃculo:
- Seleccione en el menú Window > Open Perspective > Other...
- Seleccione el botón de la perspectiva Resource y pulse el botón OK.
- Seleccione en el menú File > New > Project...
- Seleccione el asistente Project dentro de la categoria Simple y pulse el botón Next >.
- Introduzca un nombre de proyecto (por ejemplo "Getting Started with UML2") y pulse elbotón Finish.
En este punto su espacio de trabajo se deberÃa paracer a esto:
 Figura 2: Aspecto del espacio de trabajo tras crear el proyecto |
Bien, esto deberÃa ser suficiente para permitirnos empezar con el editor UML2. Ahora, para seguir con la aproximación programática de la creación de modelos, asumamos, que usted ha creado una clase (llamada, digamos GettingStartedWithUML2) en la que usted puede escribir algún código para construir nuestro modelo de ejemplo. Los fragmentos de código que mostraremos asumen que usted ha definido los siguientes métodos de utilidad para ofrecer al usuario información sobre el programa:
public static boolean DEBUG = true; protected static void out(String output) { if (DEBUG) {
System.out.println(output); } } protected static void err(String error) {
System.err.println(error); }
Se puede utilizar una bandera de depuración estática para activar o desactivar la salida de información por el stream de salida del sistema . Los errores siempre se imprimirán por el stream de error estándar del sistema .
Todo bien hasta ahora! En cada una de las siguientes secciones veremos como crear un tipo diferente de elemento UML2, empezando con los modelos.
Crear Modelos
En la raÃz de todo modelo UML2 hay un elemento model. Contiene un conjunto (jerarquico) de elementos que juntos describen el sistema fÃsico que está siendo modelado. Para crear un modelo utilizando el editor UML2, sigua estos pasos:
- Seleccione un proyecto en la vista del navegador (por ejemplo Getting Started with UML2) y seleccione el menú File > New > Other....
- Seleccione el asistente UML2 Model dentro de la categorÃa Example EMF Model Creation Wizards y pulse el botón Next >.
- Inntroduzca un nombre de fichero (por ejemplo ExtendedPO2.uml2 y pulse el botón Next >.
- Seleccione Model para el objeto modelo y pulse el botón Finish.
- Seleccione en el menú Window > Show View > Properties.
- Seleccione el elemento Model en el editor UML2.
- Introduzca un valor (por ejemplo epo2 para la propiedad Name en la vista Properties.
En este punto su espacio de trabajo se deberÃa parecer a esto:
 Figura 3: Aspecto del espacio de trabajo tras crear el modelo |
Ahora veamos como realizar la misma tarea utilizando código Java. El siguiente fragmento de código muestra un método que programáticamente crea y devuelve un modelo con el nombre especificado.
protected static Model createModel(String name) {
Model model = UML2Factory.eINSTANCE.createModel();
model.setName(name);
out("Model '" + model.getQualifiedName() + "' created.");
return model;
}
Primero, le pedimos a la factorÃa de objetos UML2 que cree un modelo , y seleccionamos su nombre . Luego, sacamos la información para que el usuario sepa que el modelo se ha creado satisfactoriamente. Finalmente, devolvemos el modelo . Observará, si no lo ha echo ya, que todos los fragmentos de código de este artÃculo siguen este patrón: crear el elemento (y seleccionar algunas de sus propiedades), informar al usuario y retornar.
Todos los elementos con nombre (un modelo es un tipo de elemento con nombre) tienen un nombre "simple" y un nombre cualificado. El nombre cualificado es el nombre "simple" precedido con los nombres "simples" de todos los espacios de nombre de los contenidos en el elemento. Observe que el nombre cualificado de un elemento sólo está definido si todos los espacios de nombres que contiene tienen nombres "simples" que no están vacÃos.
Bien, veamos este método en acción. Por ejemplo, podrÃamos crear un modello llamado epo2 de esta forma:
Model epo2Model = createModel("epo2");
Crear Paquetes
Un paquete es un espacio de nombres para sus miembros (elementos packageable), y podrÃa contener otros paquetes. Un paquete puede importar miembros individuales de otros paquetes, o todos los miembros de otros paquetes. Para crear un paquete utilizando el editor UML2, siga estos pasos:
- Seleccione un paquete (por ejemplo Package foo) en el editor UML2.
- Pulse con el botón derecho y seleccione la opción New Child > Owned Member Package en el menú contextual.
- Introduzca un valor (por ejemplo "bar") para la propiedad Name en la vista Properties.
Realmente no necesitamos crear un paquete porque nuestro modelo de ejemplo no contiene ninguno, excepto por supuesto, el paquete raÃz (es decir, el modelo). Esto es: 'un modelo es un tipo de paquete'.
Veamos como realizar la misma tarea utilizando código Java. El siguiente fragmento de código muestra un método que programáticamente crea y devuelve un paquete con el nombre especificado en un paquete anidado especificado:
protected static org.eclipse.uml2.Package createPackage(org.eclipse.uml2.Package nestingPackage, String name) {
org.eclipse.uml2.Package package_ = nestingPackage.createNestedPackage(name);
out("Package '" + package_.getQualifiedName() + "' created.");
return package_;
}
AquÃ, en vez de pedirle a la factorÃa que cree un paquete por nosotros, hemos utilizado uno de los métodos del API UML2 .
En UML2, existe un método factorÃa de la forma create<feature name>(EClass) o create<feature name>() por cada caracterÃstica que pueda contener otros elementos (es decir cada caracterÃstica contenedora). Además, existen métodos de factorÃa más convenientes para los tipos que se crean más comunmente (como los paquetes). En este caso, el paquete tiene una caracterÃstica (ownedMember) que puede contener elementos 'empaquetables', por eso podrÃamos obtener la clase Ecore del tipo del elemento 'empaquetable' que queremos crear (es decir, Package) desde el paquete Ecore de UML2. y pasarlo al método factorÃa createOwnedMember(EClass). En su lugar, utilizamos el método de factorÃa más conveniente createNestedPackage(String) que implÃcitamente crea un paquete y acepta el nombre de paquete deseado como argumento. Detrás de la escena, el paquete creará un paquete anidado, seleccionará su nombre, lanzará una notificación (con un tipo de evento igual a 0), y añadirá el paquete a la lista de miembros propietarios.
Bien, veamos este método en acción. Por ejemplo, podrÃamos crear un parquete llamado bar dentro del paquete foo de esta forma:
org.eclipse.uml2.Package barPackage = createPackage(fooPackage, "bar");
Crear Tipos Primitivos
Un tipo primitivo define un tipo de datos, sin ninguna subestructura importante. Los tipos primitivos usados en UML incluyen Boolean, Integer, UnlimitedNatural, y String. Para crear un tipo primitivo usando el editor UML2, siga estos pasos:
- Seleccione un paquete (por ejemplo Model epo2) en el editor the UML2.
- Pulse con el botón derecho y seleccione New Child > Owned Member Primitive Type en el menú contextual.
- Introduzca un valor (por ejemplo int en la propiedad Name en la vista Properties.
Cree el resto de tipos primitivos del modelo ExtendedPO2 utilizando el editor UML2.
En este punto, su espacio de trabajo se deberÃa parecer a esto:
 Figura 4: Aspecto del espacio de trabajo tras crear los tipos primitivos |
Veamos cómo realizar la misma tarea utilizando código Java. El siguiente fragmento de código muestra un método que crea y devuelve programáticamente un tipo primitivo con el nombre especificado en el paquete especificado.
protected static PrimitiveType createPrimitiveType( org.eclipse.uml2.Package package_, String name) {
PrimitiveType primitiveType = (PrimitiveType) package_.createOwnedPrimitiveType(name);
out("Primitive type '" + primitiveType.getQualifiedName() + "' created.");
return primitiveType;
}
Aquà hemos llamado al método factorÃa de conveniencia createOwnedPrimitiveType(String) para pedirle al paquete que cree un tipo primitivo con el nombre especificado como uno de su miembros.
Bien, veamos este método en acción. Por ejemplo, podrÃamos crear un tipo primitivo llamado int en el modelo epo2 de esta forma:
PrimitiveType intPrimitiveType = createPrimitiveType(epo2Model, "int");
Escriba el código para crear programáticamente el resto de los tipos primitivos del modelo ExtendedPO2.
Crear Enumeraciones
Una enumeración es tipo de datos cuyos ejemplares podrÃan ser de cualquiera de las enumeraciones literales definidas por el usuario. Para crear una enumeración utilizando el editor UML2, siga estos pasos:
- Seleccione un paquete (por ejemplo Model epo2) en el editor UML2.
- Pulse con el botón derecho y seleccione la opción New Child > Owned Member Enumeration en el menú contextual.
- Introduzca un valor (por ejemplo OrderStatus en la propiedad Name en la vista Properties.
En este punto, su espacio de trabajo se deberÃa parecer a esto:
 Figura 5: Aspecto del espacio de trabajo tras crear la enumeración |
Veamos cómo realizar la misma tarea utilizando código Java. El siguiente fragmento de código muestra un método que crea y devuelve programáticamente una enumeración con el nombre especificado en el paquete especificado:
protected static Enumeration createEnumeration(org.eclipse.uml2.Package package_, String name) {
Enumeration enumeration = (Enumeration) package_.createOwnedEnumeraton(name);
out("Enumeration '" + enumeration.getQualifiedName() + "' created.");
return enumeration;
}
Aquà hemos llamado al método factorÃa de conveniencia createOwnedEnumeration(String) para pedirle al paquete que cree una enumeración con el nombre especificado como uno de sus miembros.
Bien, veamos este método en acción. Por ejemplo, podrÃamos crear una enumeración llamada OrderStatus en el modelo eop2 de esta forma:
Enumeration orderStatusEnumeration = createEnumeration(epo2Model,"OrderStatus");
Crear Literales de Enumeraciones
Un literal de enumeración es un valor de dato definido por el usuario para una enumeración. Para crear un literal de enumeración utilizando el editor UML2, siga estos pasos:
- Seleccione una enumeración (por ejemplo Enumeration OrderStatus) en el editor UML2.
- Pulse con el botón derecho y seleccione la opción New Child > Enumeration Literal en el menú contextual.
- Introduzca un valor (por ejemplo Pending) para la propiedad Name en la vista Properties.
Cree el resto de literales de enumeración del modelo ExtendedPO2 utilizando el editor UML2.
En este punto, su espacio de trabajo se deberÃa parecer a esto:
 Figura 6: Aspecto del espacio de trabajo tras crear los literales de enumeración |
Veamos cómo realizar la misma tarea utilizando código Java. El siguiente fragmento de código muestra un método que crea y devuelve programáticamente un literal de enumeración con el nombre especificado en el paquete especificado:
protected static EnumerationLiteral createEnumerationLiteral(Enumeration enumeration, String name) {
EnumerationLiteral enumerationLiteral = enumeration.createOwnedLiteral(name);
out("Enumeration literal '" + enumerationLiteral.getQualifiedName() + "' created.");
return enumerationLiteral;
}
Aquà hemos llamado al método factorÃa de conveniencia createOwnedLiteral(String) para pedirle a la enumeración que cree un literal de enumeración con el nombre especificado como uno de sus literales.
Bien, veamos este método en acción. Por ejemplo podrÃamos crear un literal de enumeración llamado Pending en la enumeración OrderStatus, de esta forma:
createEnumerationLiteral(orderStatusEnumeration, "Pending");
Escriba el código para crear programáticamente el resto de literales de enumeración del modelo ExtendedPO2.
Crear Clases
Una clase ese un tipo de clasificador cuyas caracterÃsticas son atributos (algunos de los cuales podrÃan representar los finales navegables de asociaciones) y operaciones. Para crear una clase utilizando el editor UML2, siga estos pasos:
- Seleccione un paquete (por ejemplo Model epo2) en el editor UML2.
- Pulse con el botón derecho y seleccione la opción New Child > Owned Member Class en el menú contextual.
- Introduzca un valor (por ejemplo Supplier para la propiedad Name en la vista Properties.
Cree el resto de clases del modelo ExtendedPO2 utilizando el editor UML2.
En este punto, su espacio de trabajo se deberÃa parecer a esto:
 Figura 7: Aspecto del espacio de trabajo tras crear las clases |
Veamos cómo realizar la misma tarea utilizando código Java. El siguiente fragmento de código muestra un método que crea y devuelve programáticamente una clase con el nombre especificado en el paquete especificado:
protected static org.eclipse.uml2.Class createClass(org.eclipse.uml2.Package package_, String name, boolean isAbstract) {
org.eclipse.uml2.Class class_ = package_.createOwnedClass(name, isAbstract);
out("Class '" + class_.getQualifiedName() + "' created.");
return class_;
}
Aquà hemos llamado al método de factorÃa de conveniencia createOwnedClass(String, boolean) para pedirle al paquete que cree una clase con el nombre especificado como uno de sus miembros, y seleccione el atributo isAbstract de la clase basándose en el argumento boolean especificado.
PodrÃa habrer observado que hemos puesto referencias completamente cualificadas para los interfaces de Package y Class. Esto es recomendable para que estos tipos no se confundan con java.lang.Class y java.lang.Package, que son importados explÃcitamente en Java.
Bien, veamos este método en acción. Por ejemplo podrÃamos crear una clase no-abstracta llamada Supplier en el modelo epo2 de esta forma:
org.eclipse.uml2.Class supplierClass = createClass(epo2Model,"Supplier", false);
Escriba el código para crear programáticamente el resto de las clases del modelo ExtendedPO2.
Crear Generalizaciones
Una generalización es una relación taxonómica entre una clasificador especifico y un clasificador más general donde cada ejemplar del clasificador especifico también es un ejemplar indirecto, y hereda las caracterÃsticas, del clasificador general. Para crear una generalización utilizando el editor UML2, siga estos pasos:
- Seleccione un clasificador (por ejemplo Class USAddress) en el editor UML2).
- Pulse con el botón derecho y seleccione la opción New Child > Generalization en el menú contextual.
- Seleccione un valor (por ejemplo epo2::Address) para la propiedad General en la vista Properties.
Cree el resto de generalizaciones del modelo ExtendedPO2 utilizando el editor UML2.
En este punto, su espacio de trabajo se deberÃa parecer a esto:
 Figura 8: Aspecto del espacio de trabajo tras crear las generalizaciones |
Veamos cómo realizar la misma tarea utilizando código Java. El siguiente fragmento de código muestra un método que crea y devuelve programáticamente una generalización con el nombre especificado en el paquete especificado:
protected static Generalization createGeneralization(Classifier specificClassifier, Classifier generalClassifier) {
Generalization generalization = specificClassifier.createGeneralization(generalClassifier);
out("Generalization " + specificClassifier.getQualifiedName() + " ->> "
+ generalClassifier.getQualifiedName() + " created.");
return generalization;
}
Aquà hemos llamado a un método de factorÃa de conveniencia sobre el clasificador especÃfico que crea una generalización como uno de sus hijos y selecciona el clasificador general con el argumento especificado.
Bien, veamos este método en acción. Por ejemplo, podrÃamos crear una generalización entre la clase especÃfica USAddress y la clase general Address de esta forma:
createGeneralization(usAddressClass, addressClass);
Escriba el código para crear programáticamente el resto de las generalizaciones del modelo ExtendedPO2.
Crear Atributos
Cuando una propiedad pertenece a un clasificador representa un atributo; en este caso relaciona un ejemplar de un clasificador con un valor o conjunto de valores del tipo del atributo.
Entre los tipos de Classifier que pueden tener atributos en UML2 se incluyen Artifact, DataType, Interface, Signal, y StructuredClassifier (y sus subtipos).
Para crear un atributo utilizando el editor UML2, siga estos pasos:
- Seleccione un clasificador (por ejemplo, Class Supplier) en el editor UML2.
- Pulse con el botón derecho y seleccione la opción New Child > Owned Attribute Property en el menú contextual.
- Introduzca un valor (por ejemplo name para la propiedad Name en la vista Properties.
- Seleccione un valor (por ejemplo epo2::String) para la propiedad Type.
- Seleccione la propiedad (por ejemplo Property name) en el editor UML2.
- Pulse con el botón derecho y seleccione la opción New Child > Lower Value Literal Integer en el menú contextual.
Los valores inferior y superior para elementos múltiples (como las propiedades) están representados como valores de especificación (objetos de primera-clase) en UML 2.0. El valor por defecto para los lÃmites inferior y superior es 1, a menos que exista un valor de especificación hijo, en cuyo caso se utiliza su valor. Observe que para ser tratado como un lÃmite, el valor inferior debe ser un entero literal y el valor superior debe ser un natural ilimitado literal.
Cree el resto de atributos que faltan en el modelo ExtendedPO2 utilizando el editor EML2.
En este punto su espacio de trabajo se deberÃa parecer a esto:
 Figura 9: Aspecto del espacio de trabajo tras crear los atributos |
Veamos como realizar la misma tarea utilizando código Java. El siguiente fragmento de código muestra un método que crea programáticamente en la clase especÃficada un atributo y lo devuelve con el lÃmite superior, el lÃmite inferior, el tipo y el nombre especificados:
protected static Property createAttribute(org.eclipse.uml2.Class class_,
String name, Type type, int lowerBound, int upperBound) {
Property attribute = class_.createOwnedAttribute(name, type,
lowerBound, upperBound);
StringBuffer sb = new StringBuffer();
sb.append("Attribute '");
sb.append(attribute.getQualifiedName());
sb.append("' : ");
sb.append(type.getQualifiedName());
sb.append(" [");
sb.append(lowerBound);
sb.append("..");
sb.append(MultiplicityElement.UNLIMITED_UPPER_BOUND == upperBound
? "*" : String.valueOf(upperBound));
sb.append("]");
sb.append(" created.");
out(sb.toString());
return attribute;
}
Aquà hemos llamado al método de factorÃa de conveniencia createOwnedAttribute(String, Type, int, int) para pedirle a la clase que cree una propiedad como uno de sus propios atributos, seleccione el tipo del atributo al tipo especificado, y seleccione los lÃmites inferior y superior del atributo (el método factorÃa crea un entero literal y un natural ilimitado literal, respectivamente, y selecciona sus valores con el valor entero especificado).
La constante MultiplicityElement.UNLIMITED_UPPER_BOUND representa el valor ilimitado para el lÃmite superior (-1), y está en EMF.
Bien, veamos este método en acción. Por ejemplo, podrÃamos crear un atributo con multiplicidad 0...1 del tipo String llamado name en la clase Supplier de esta forma:
createAttribute(supplierClass, "name", stringPrimitiveType, 0, 1);
Escriba código para crear programáticamente el resto de atributos de las clases del modelo ExtendedPO2.
Crear Asociaciones
Una asociación especifica una relación semántica que puede ocurrir entre dos o más ejemplares con tipo; sus finales están representados por propiedades, cada una de las cuales está conectada al tipo del final. Cuando una propiedad pertenece a una asociación representa un final no-navegable de la asociación, en cuyo caso el tipo de la propiedad es el tipo de la asociación final.
La noción de navegabilidad de la asociación final se ha separado de la propiedad en la (prontamente) finalizada especificación UML 2.0, para que una propiedad que pertence a una asociación no sea necesariamente no-navegable como ocurre en UML2 2.0.
Para crear una asociación utilizando el editor UML2, siga estos pasos:
- Seleccione un paquete (por ejemplo Model epo2) en el editor UML2.
- Pulse con el botón derecho y seleccione la opción New Child > Owned Member Association en el menú contextual.
- Introduzca un valor (por ejemplo Supplier_orders para la propiedad Name en la vista Properties.
- Seleccione la asociación recién creada (Association Supplier_orders) en el editor UML2.
- Pulse con el botón derecho y seleccione la opción New Child > Property en el menú contextual.
- Seleccione un valor (por ejemplo epo2::Supplier) para la propiedad Type en la vista Properties.
- Seleccione una clase (por ejemplo Class Supplier) en el editor UML2.
- Pulse con el botón derecho y seleccione la opción New Child > Owned Attribute Property en el menú contextual.
- Seleccione un valor (por ejemplo, Composite) para la propiedad Aggregation en el vista Properties.
- Seleccione un valor (por ejemplo, epo2::Supplier_orders) para la propiedad Association.
- Introduzca un valor (por ejemplo orders) para la propiedad Name.
- Seleccione un valor (por ejemplo, epo2::PurchaseOrder) para la propiedad Type.
- Seleccione la propiedad (navegable) (por ejemplo Property orders) en el editor UML2.
- Pulse con el botón derecho y seleccione la opción New Child > Lower Value Literal Integer en el menú contextual.
- Seleccione la propiedad (navegable) (por ejemplo, Property orders) en el editor UML2.
- Pulse con el botón derecho y seleccione la opción New Child > Upper Value Literal Unlimited Natural en el menú contextual.
- Introduzca un valor (por ejemplo -1 para la propiedad Value en la vista Properties.
Cree el resto de asociaciones del modelo ExtendedPO2 utilizando el editor UML2.
En este punto su espacio de trabajo se deberÃa parecer a esto:
 Figura 10: Aspecto del espacio de trabajo tras crear las asociaciones |
Veamos como realizar la misma tarea utilizando código Java. El siguiente fragmento de código muestra un método que crea programáticamente una asociación en la clase especÃficada y la devuelve con el lÃmite superior, el lÃmite inferior, los nombres de roles, los tipos de agregaciones, y las navegabilidades.
protected static Association createAssociation(Type type1,
boolean end1IsNavigable, AggregationKind end1Aggregation,
String end1Name, int end1LowerBound, int end1UpperBound,
Type type2, boolean end2IsNavigable,
AggregationKind end2Aggregation, String end2Name,
int end2LowerBound, int end2UpperBound) {
Association association = type1.createAssociation(end1IsNavigable,
end1Aggregation, end1Name, end1LowerBound, end1UpperBound, type2,
end2IsNavigable, end2Aggregation, end2Name, end2LowerBound,
end2UpperBound);
StringBuffer sb = new StringBuffer();
sb.append("Association ");
if (null == end1Name || 0 == end1Name.length()) {
sb.append('{');
sb.append(type1.getQualifiedName());
sb.append('}');
} else {
sb.append("'");
sb.append(type1.getQualifiedName());
sb.append(NamedElement.SEPARATOR);
sb.append(end1Name);
sb.append("'");
}
sb.append(" [");
sb.append(end1LowerBound);
sb.append("..");
sb.append(MultiplicityElement.UNLIMITED_UPPER_BOUND == end1UpperBound
? "*" : String.valueOf(end1UpperBound));
sb.append("] ");
sb.append(end2IsNavigable ? '<' : '-');
sb.append('-');
sb.append(end1IsNavigable ? '>' : '-');
sb.append(' ');
if (null == end2Name || 0 == end2Name.length()) {
sb.append('{');
sb.append(type2.getQualifiedName());
sb.append('}');
} else {
sb.append("'");
sb.append(type2.getQualifiedName());
sb.append(NamedElement.SEPARATOR);
sb.append(end2Name);
sb.append("'");
}
sb.append(" [");
sb.append(end2LowerBound);
sb.append("..");
sb.append(MultiplicityElement.UNLIMITED_UPPER_BOUND == end2UpperBound
? "*" : String.valueOf(end2UpperBound));
sb.append("]");
sb.append(" created.");
out(sb.toString());
return association;
}
Aquà hemos llamado a un método de factorÃa de conveniencia sobre el primer tipo final que crea una asociación (y su final) entre él y otro tipo como uno de sus hermanos (es decir, como un hijo de su paquete) y con los lÃmites inferior y superior, los nombres de roles, los tipos de agregaciones, y la navegabilidad especificados. Los propietarios de los finales de la asociación (propiedades) están basados en las navegabilidades especificadas (los finales navegables pertenecen a los tipos finales y los finales no navegables pertenecen a la asociación (hasta UML2 2.0).
La constante NamedElement.SEPARATOR representa el separador estándar (::) utilizado en los nombres cualificados.
Bien, veamos este método en acción. Por ejemplo, podrÃamos crear una composición unidireccional (composite association) entre las clases Supplier y PurchaseOrder del modelo epo2 de esta forma:
createAssociation(supplierClass, true, AggregationKind.COMPOSITE_LITERAL,
"orders", 0, MultiplicityElement.UNLIMITED_UPPER_BOUND, purchaseOrderClass,
false, AggregationKind.NONE_LITERAL, "", 1, 1);
Escriba el código para crear programáticamente el resto de asociaciones del modelo ExtendedPO2.
Grabar el Modelo
Ahora que hemos empleado todo este tiempo en crear un modelo, será mejor que grabemos nuestro trabajo. Cuando se crea un modelo utilizando el asistente de modelo UML2, se crea un recurso por lo que lo único que tenemos que hacer es serializar los contenidos del modelo como un XML a nuestro fichero en disco (es decir a ExtendedPO2.uml2). Para grabar el modelo utilizando el editor UML2, siga estos pasos:
- Seleccione el menú File > Save.
Es asà de simple. Programáticamente, tenemos que hacer un poco más de trabajo porque hasta ahora hemos ido creando nuestro modelo en el vacÃo, es decir sin ningún recurso contenedor. El siguiente fragmento de código muestra un método que graba un paquete especÃfico a un recurso con una URI especificada.
protected static void save(org.eclipse.uml2.Package package_, URI uri) {
Resource resource = new ResourceSetImpl().createResource(uri);
resource.getContents().add(package_);
try {
resource.save(null);
out("Done.");
} catch (IOException ioe) {
err(ioe.getMessage());
}
}
Aquà hemos creado un conjunto de recursos y un recurso con la URI especificada, hemos añadido el paquete al contenido del recurso y hemos pedido al recurso que se grabe él mismo utilizando las opciones por defecto. Si ocurre una excepción, se lo notificamos al usuario mediante un método de utilidad.
Bien, veamos este método en acción. Por ejemplo, podrÃamos grabar el modelo epo2 a un recurso con la URI ExtendedPO2.uml2 (relativo a una URI pasada como argumento) de esta forma:
save(epo2Model, URI.createURI(args[0]).appendSegment("ExtendedPO2").
appendFileExtension(UML2Resource.FILE_EXTENSION));
La constante UML2Resource.FILE_EXTENSION representa la extensÃón de fichero para los recursos UML2 (.uml2). Observe que el interface UML2Resource contiene varias constantes que podrÃa encontrar muy útiles cuando trabaje con recursos UML2.
Conclusión
¡Felicidades! Si ha llegado hasta aquà habrá crea un sencillo modelo programáticamente y/o utilizando el editor UML2. Se podrÃa haber dicho mucho más, pero el propósito de este artÃculo era sólo introducirle en el trabajo con UML2.
Para obtener más información sobre UML2, visite su home page o únase a los newsgroup.
Código Fuente
Para ejecutar el ejemplo o ver el código fuente de este artÃculo, descomprima el fichero 
uml2.articles_200508041102.zip en su directorio home de Eclipse e importe el plug-in com.ibm.uml2.articles en su espacio de trabajo como un proyecto binario con contenido enlazado (File > Import… > External Plug-ins and Fragments). Puede ejecutar la clase GettingStartedWithUML2 como una aplicación Java con un URI de fichero (por ejemplo "file:/home/juan/java/Getting Started with UML2") como un argumento de programa.