Imbrication VS Agrégation?

Question

Quelle est la meilleure façon de représenter les documents MongoDB; J'ai mis le Product comme un sous-document du Client.

First, i've put them as Aggregation; if the Client is broken, the Product is broken too. Do i use that model, or do i switch to Nesting.

Exemple de diagramme imbriqué:

Answer 1

Du point de vue de la programmation (par exemple Java):

Référence: http://docs.oracle.com/javase/tutorial/java/javaOO/nested.html

Les classes imbriquées sont divisées en deux catégories: statique et non statique. Les classes imbriquées déclarées statiques sont simplement appelées des classes imbriquées statiques. Les classes imbriquées non statiques sont appelées classes internes.

class OuterClass { 
    ... 
    static class StaticNestedClass { 
     ... 
    } 

    class InnerClass { 
     ... 
    } 
    InnerClass innerObject = new InnerClass(); 
} 

OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();

Du point de vue UML:

1. Classe généraliser Namespace

   Class-- |> EncapsulatedClassifier-- |> StructuredClassifier-- |> Classifier-- |> Espace de noms

2. L'espace de noms a "member" et "ownedMember".

   /membre: NamedElement [0 .. *]

   /ownedMember: NamedElement [0 .. *]

   le "membre" représente "StaticNestedClass + classe interne", le "ownedMember" représente « classe interne "seulement

suggestions générales:

1. Je n'utiliserais pas de connecteur "imbriqué"; Cela provoquera une confusion entre "StaticNestedClass" et "InnerClass".
2. Je n'utiliserais pas de connecteur "d'agrégation" (diamant blanc); parce qu'il a été introduit par raison héritée;
3. Toujours utiliser "Association" et "Composition".

Comment faire un diagramme?

1. Si vous souhaitez modéliser un élément de « StaticNestedClass », donner « OuterClass :: StaticNestedClass » comme nom de classe. Aucun connecteur impliqué.
2. Si vous souhaitez modéliser "InnerClass" (Dans la spécification UML, il s'appelle "nestedClassifier"), (1) Créez deux éléments de classe sur le diagramme, attribuez respectivement les noms "OuterClass" et "OuterClass :: InnerClass". (2) Dessinez un connecteur "Composition" de "OuterClass" vers "OuterClass :: InnerClass".

Association ou composition

Il est vraiment dépend de vos besoins.

La plupart des gens aiment décrire "Composition" du processus "détruire"; Le "tout" détruit, puis les "parties" sont détruites aussi.

Cependant, il est toujours valide de décrire à partir du processus de "construction"; Dans le processus vous "nouveau le tout", vous avez "créé les parties". Il est bon de faire en sorte que «construire» et «détruire» les cohérentes.

E.g. Voiture et roue;

Si quelqu'un a écrit le code suivant fou, WOW ..

class Car{ 
public: 
    Wheel* w1; 
    Wheel* w2; 
    Car(Wheel* w1_, Wheel* w2_) 
    { 
     w1 = w1_; 
     w2 = w2_; 
    } 
    ~Car() 
    { 
     delete w1; 
     delete w2; 
    } 
} 

Wheel* l1 = new Wheel(); 
Wheel* l2 = new Wheel(); 
Car* myCar = new Car(l1, l2); 
delete myCar; 
l1->Operation1(); //Crash! 

Donc, ce n'est pas un véritable « Composition » parce que la construction et détruire n'est pas conforme. Si vous supprimez le "delete w1; delete w2" du destructeur, la relation entre Car et Wheel est "Association".

La version Composition du code sera comme ceci:

class Car{ 
public: 
    Wheel* w1; 
    Wheel* w2; 
    Car() 
    { 
     w1 = new Wheel(); 
     w2 = new Wheel(); 
    } 
    ~Car() 
    { 
     delete w1; 
     delete w2; 
    } 
}