< Indietro | Avanti >

Lezione 3: Creazione e perfezionamento della dichiarazione di associazione classe-a-classe

Questa lezione spiega come creare una dichiarazione di associazione che specifica una classe UML sia come oggetto di input che di output. Questa dichiarazione di associazione classe-a-classe contiene regole di associazione che, quando si esegue la trasformazione generata, creano una copia della classe e delle rispettive operazioni nel modello di origine e la posizionano nel modello di destinazione. È anche possibile creare una dichiarazione di associazione operazione-a-operazione, che viene richiamata dall'associazione secondaria nella dichiarazione di associazione classe-a-classe.
Una dichiarazione di associazione, chiamata anche associazione, specifica come creare o aggiornare un oggetto di output per un determinato oggetto di input. Quando si creano le trasformazioni, è possibile utilizzare una dichiarazione di associazione per specificare come gli attributi di un oggetto di input corrispondano agli attributi di un oggetto di output. Ciascuna dichiarazione di associazione specifica un tipo di input e un tipo di output, selezionati dai metamodelli aggiunti al modello di associazione.

Per ciascuna dichiarazione di associazione nel modello di associazione, il framework di creazione trasformazioni genera un file di origine Java con nome nTransform.java, dove n rappresenta il nome della dichiarazione di associazione. Tutti insieme, questi file Java costituiscono il codice della trasformazione. Oltre alla generazione del codice di implementazione per la trasformazione, il framework di creazione della trasformazione genera anche il codice per registrare la trasformazione con il servizio di trasformazione. Dopo aver creato una dichiarazione di associazione, è possibile aggiungere regole di associazione in modo incrementale e generare il codice di origine, o le implementazioni, per le regole di associazione. Non è necessario dover definire tutte le regole di associazione prima della generazione del codice sorgente.

Generalmente la convenzione di denominazione delle dichiarazioni di associazione è x2y, dove x rappresenta il tipo di oggetto di input e y rappresenta il tipo di oggetto di output. Ad esempio, la dichiarazione di associazione Package2EPackage specifica una dichiarazione di associazione che ha Package come oggetto di input e EPackage come oggetto di output.

Un'associazione tra elementi stabilisce la corrispondenza tra i rispettivi attributi, che permette lo scambio dei dati tra loro. Quasi tutte le associazioni consentono di manipolare ulteriormente i dati tra l'origine e la destinazione. Ad esempio, è possibile scegliere di specificare calcoli o apportare altre modifiche ai dati creando codice personalizzato, che consente di assegnare valori alla destinazione.

Per creare una dichiarazione di associazione classe-a-classe nel modello di associazione:

  1. Nella cartella model, nella vista Esplora pacchetti, fare doppio clic sul file .mapping se non è già aperta.
  2. Nell'editor di associazione trasformazioni, nella sezione Root di associazione, fare clic con il tasto destro del mouse su Generalizza_Classi; quindi fare clic su Crea associazione.
  3. Nella finestra Nuova associazione, nel campo Nome associazione, immettere Class2Class; quindi fare clic su OK. L'associazione viene visualizzata nella vista Struttura e viene aperta nell'area editor nella sezione Root di associazione.

Aggiunta di oggetti di input e di output alla dichiarazione di associazione classe-a-classe

Dopo aver creato la dichiarazione di associazione, è necessario aggiungervi un oggetto di input e un oggetto di output. In questa lezione, viene specificata una classe UML come oggetto di input e di output.
Nota: Quando si creano le trasformazioni modello-a-modello, per aggiungere un tipo di oggetto che non è disponibile nel metamodello di input o di output utilizzato dall'associazione, è possibile aggiungere i profili UML appropriati o i metamodelli Ecore all'ambito dell'associazione. Nella finestra Aggiunta input, fare clic su Aggiungi modello e specificare il modello appropriato.

Per aggiungere un oggetto di input e un oggetto di output alla dichiarazione di associazione classe-a-classe:

  1. Fare clic sull'icona Aggiungi un oggetto di input, l'icona più a sinistra nella barra degli strumenti relativa all'associazione che si sta modificando:
    Questa immagine mostra l'icona Aggiungi oggetto di input ubicata sulla barra degli strumenti relativa all'associazione che si sta modificando.
  2. Nella finestra Aggiunta input, nel riquadro Elemento, selezionare un'oggetto metamodello. Il riquadro Elemento visualizza gli elementi nel metamodello o nei metamodelli specificati come origine o destinazione per il modello di associazione. Per questa esercitazione, nel riquadro Elemento, espandere uml, fare clic su Classe, quindi su OK.
  3. Fare clic sull'icona Aggiungi oggetto di output, la seconda icona da sinistra sulla barra degli strumenti relativa all'associazione che si sta modificando:
    Questa immagine mostra l'icona Aggiungi oggetto di output, la seconda icona da sinistra sulla barra degli strumenti relativa all'associazione che si sta modificando.
  4. Nella finestra Aggiunta output, nel riquadro Elemento, espandere uml, fare clic su Classe, quindi su OK.
  5. Fare clic su File > Salva.
È adesso possibile definire le regole di associazione tra gli attributi degli oggetti di input e di output della classe.

Definizione delle regole di associazione tra gli attributi degli oggetti di input e di output della classe

Dopo aver aggiunto gli oggetti di input e di output alla dichiarazione di associazione, sarà possibile definire le regole di associazione tra gli attributi. Le regole di associazione, chiamate anche associazioni, specificano come assegnare un valore ad un attributo di un oggetto di output, in base ai valori degli attributo di un oggetto di input.

Nella dichiarazione di associazione classe-a-classe, procedere come segue:
  • Creare una regola di associazione di spostamento che crea una classe nel modello di destinazione

    La regola di associazione deve essere creata tra l'attributo name degli oggetti di input e di output. La classe di destinazione ha lo stesso nome della classe nel modello di input; questa procedura è simile alla creazione di una copia della classe. In una lezione successiva, verranno aggiunte le operazioni di associazione alla regola di associazione.

  • Creare una regola di associazione secondaria che, per ciascuna operazione nella classe, crei un'operazione corrispondente nella classe nel modello di destinazione.

    Creare una regola di associazione secondaria tra l'attributo ownedOperation degli oggetti di input e di output. Per ciascuna operazione nella raccolta ownedOperation, l'operazione generata nel modello di destinazione avrà lo stesso nome e visibilità dell'operazione nel modello di input.

Le regole di associazione, chiamate anche associazioni, specificano come assegnare un valore ad un attributo di un oggetto di output, in base ai valori degli attributo di un oggetto di input. È possibile creare più regole di associazione tra gli oggetti di input e di output e, come dimostra una lezione successiva in questa esercitazione, è anche possibile creare più regole di associazione tra un attributo di input e un oggetto di output. È possibile creare i seguenti tipi di regole di associazione:
Spostamento
Lo spostamento, una regola di associazione semplice, è il tipo di regola di associazione più basico. Gli attributi di input e di output devono essere tipi di dati compatibili. Entrambi gli attributi di input e di output o nessuno dei due possono avere valori multipli. Ad esempio, selezionare questa opzione se un attributo dell'oggetto di output è String e un attributo dell'oggetto di input può essere convertito in String senza codice personalizzato. Questo tipo di regola di associazione supporta un'associazione tra un elemento o attributo di origine e un elemento o attributo di destinazione.Il codice sorgente della trasformazione generato da una regola di associazione spostamento, implementa una regola che copia il valore di un attributo di input in un attributo di output.
Associazione secondaria

Un'associazione secondaria è una chiamata a una associazione dall'interno di un'altra associazione. L'associazione secondaria da richiamare può, ma non è obbligatorio, essere definita nello stesso file di associazione dell'associazione che la richiama. Un'associazione secondaria consente di associare un tipo complesso nel modello di input a un tipo complesso nel modello di output. L'associazione secondaria creata può richiamare un'associazione che esiste in qualsiasi file di associazione. La definizione delle associazioni secondarie nei file di associazione separati favorisce il riutilizzo delle associazioni; tuttavia la creazione di più file di associazione potrebbe aumentare le operazioni di gestione del progetto. Le associazioni secondarie possono includere anche altre associazioni secondarie, che risultano in una struttura gerarchica.

Le regole di associazione secondaria supportano i seguenti tipi di associazione:
  • Associazioni 1-a-1 tra gli oggetti di input e gli oggetti di output o tra gli attributi degli oggetti di input e di output
  • Associazioni 1-a-m o m-a-1 tra gli attributi degli oggetti di input e di output
  • Associazioni m-a-n tra gli attributi degli oggetti di input e di output
Se la regola di associazione secondaria specifica l'associazione 1-a-m, il trasformatore generato aggiunge un oggetto di un attributo singleton ad un elenco; per un'associazione m-a-1 mapping, il trasformatore estrae un oggetto da un elenco e lo inserisce in un attributo singleton.

È anche possibile creare regole di associazione secondaria tra gli oggetti di input e gli oggetti di output in una dichiarazione di associazione.

Per ciascuna associazione secondaria in una dichiarazione di associazione, viene generato un estrattore chiamato getfunzioneInputTofunzioneOutput_UsingAssociazione_Extractor nel trasformatore di contenuto, dove funzioneInput rappresenta il nome dell'attributo di input, funzioneOutput rappresenta il nome dell'attributo di output e Associazione rappresenta il nome della dichiarazione di associazione.

Personalizzato
Questo tipo di regola di associazione consente di specificare codice personalizzato che calcola il valore di una proprietà di output. Ad esempio, selezionare questo tipo di associazione per impostare il valore di una proprietà nell'oggetto di output come uguale alla concatenazione di più proprietà dell'oggetto di input.

È possibile specificare perfezionamenti semantici utilizzando l'API OCL (Object Constraint Language) fornita da Eclipse.

Le regole di associazione personalizzata supportano i seguenti tipi di associazione:
  • Associazioni 1-a-n tra oggetti di input e di output o tra attributi degli oggetti di input e di output
  • Associazioni m-a-n tra oggetti di input e di output o tra attributi degli oggetti di input e di output
  • Associazioni m-a-1, dove m-a-1 rappresenta una delle seguenti associazioni:
    • Un'associazione da un singolo attributo di input, la cui molteplicità è impostata su m, a un singolo attributo di output, la cui molteplicità è impostata su 1
    • Un'associazione tra più attributi di input a un singolo attributo di output
    • Un'associazione tra più oggetti di input a un singolo oggetto di output
Associazioni ereditate
È possibile creare questa regola di associazione solo tra un oggetti di input e un oggetto di output.
Una dichiarazione di associazione che eredita, eredita le regole di associazione definite nella dichiarazione di associazione ereditata. È possibile sovrascrivere le regole di associazione ereditate definendo una regola di associazione che abbia le seguenti qualità:
  • La proprietà dell'oggetto di input e la proprietà dell'oggetto di output sono le stesse della regola di associazione ereditata.
  • Le regole di associazione ereditate e di sostituzione sono associazioni secondarie con estrattori corrispondenti oppure le regole di associazione ereditate e di sostituzione sono entrambe associazioni di spostamento o personalizzate.
Se si crea una regola di associazione associazioni ereditate, sarà necessario specificare la dichiarazione di associazione che contiene le regole di associazione che si desidera ereditare. Non è possibile specificare più di un'associazione ereditata in una dichiarazione di associazione.

Una regola di associazione ereditata e la regola o l'estrattore generati da tale associazione, conservano la stessa posizione relativa nell'ordine di elaborazione della regola di associazione sovrascritta e i rispettivi estrattore o regola generati.

Per ciascuna regola associazione di spostamento o personalizzata, viene aggiunta una regola al codice sorgente della trasformazione generata. Per ciascuna regola di associazione secondaria, nel codice sorgente della trasformazione viene generato un estrattore di contenuto. Quando si crea una regola di associazione, il tipo viene determinato dagli attributi di input e di output selezionati. Ad esempio, se gli attributi di input e di output sono tipi primitivi compatibili, ad esempio string o integer, viene specificata una regola di associazione di spostamento. Se gli attributi di input e di output sono tipi complessi, viene specificata una regola di associazione secondaria. Se né il tipo regola di associazione spostamento né associazione secondaria sono appropriati, viene specificata una regola di associazione personalizzata.

Per definire le regole di associazione nella dichiarazione di associazione Class2Class:

  1. Creare una regola di associazione di spostamento tra l'attributo name dell'oggetto di input e di output:
    1. Nell'area editor, nell'oggetto di input della classe, fare clic sull'attributo name.
    2. Trascinare la maniglia dell'attributo name sull'attributo name nell'oggetto di output della classe.
  2. Creare una regola di associazione secondaria tra l'attributo ownedOperation dell'oggetto di input e output.
    1. Nell'area editor, nell'oggetto di input della classe, fare clic sull'attributo ownedOperation.
    2. Trascinare la maniglia dell'attributo ownedOperation sull'attributo ownedOperation nell'oggetto di output della classe. Poiché l'attributo ownedOperation è una raccolta, per impostazione predefinita viene creata una regola di associazione secondaria.
  3. Fare clic su File > Salva.
È adesso possibile creare la dichiarazione di associazione operazione-a-operazione.

Creazione di una dichiarazione di associazione operazione-a-operazione

A questo punto della lezione, nell'area editor, all'associazione secondaria è associato un simbolo che raffigura una X in un cerchio rosso, che indica un errore. Posizionare il puntatore del mouse su questo simbolo per visualizzare il messaggio di errore. Il messaggio di errore riporta che è necessario selezionare una dichiarazione di associazione che la regola di associazione secondaria dovrà richiamare. Per risolvere questo errore, creare una dichiarazione di associazione operazione-a-operazione.

Per creare dichiarazione di associazione operazione-a-operazione:

  1. Se la vista Proprietà non è aperta, nell'area editor, fare clic con il tasto destro del mouse sull'elemento associazione secondaria creato durante lo svolgimento della sezione precedente, al punto 2, e fare clic su Mostra in proprietà.
  2. Nella vista Proprietà, nella scheda Dettagli, accanto al campo Associazione, fare clic su Nuovo.
  3. Nella finestra Nuova associazione, nel campo Nome associazione, immettere Operation2Operation.
  4. Se il campo Input non contiene un valore di Operation, fare clic su Sfoglia e, nella finestra Aggiunta input, nel riquadro Elemento, fare clic su Operazione.
  5. Se il campo Output non contiene un valore di Operation, fare clic su Sfoglia e, nella finestra Aggiunta output, nel riquadro Elemento, fare clic su Operazione.
  6. Fare clic su OK. Il simbolo di errore viene rimosso e la dichiarazione di associazione operazione-a-operazione viene visualizzata nella vista Struttura. In una lezione successiva, verranno create le regole di associazione in questa dichiarazione di associazione.
  7. Fare clic su File > Salva.
Nella lezione successiva, verrà definita una dichiarazione di associazione classe-a-interfaccia.
< Indietro | Avanti >

Feedback