嵌套VS聚合?

时间:2013-06-20 13:27:03

标签: mongodb uml

表示MongoDB文件的最佳方式是什么?我将Product作为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.

嵌套图示例:

Nesting

enter image description here

1 个答案:

答案 0 :(得分:1)

从编程角度(例如Java):

参考:http://docs.oracle.com/javase/tutorial/java/javaOO/nested.html

嵌套类分为两类:静态和非静态。声明为static的嵌套类简称为静态嵌套类。非静态嵌套类称为内部类。

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

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

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

从UML角度来看:

  1. 从命名空间

    进行类推广

    分类 - |> EncapsulatedClassifier-- |> StructuredClassifier-- |> Classifier-- |>命名空间

  2. 命名空间有“member”和“ownedMember”。

    / member:NamedElement [0 .. *]

    / ownedMember:NamedElement [0 .. *]

    “member”表示“StaticNestedClass + InnerClass”;“ownedMember”仅表示“InnerClass”

  3. 一般建议:

    1. 我不会使用“嵌套”连接器;它会导致“StaticNestedClass”和“InnerClass”之间的混淆。
    2. 我不会使用“聚合”连接器(白色钻石);因为它是由遗留原因引入的;
    3. 始终使用“Association”和“Composition”。
    4. 如何制作图表?

      1. 如果要对“StaticNestedClass”元素进行建模,请将“OuterClass :: StaticNestedClass”作为类名称。没有涉及连接器。
      2. 如果要建模“InnerClass”(在UML规范中,它被称为“nestedClassifier”), (1)在图上创建两个类元素,分别给出名称“OuterClass”和“OuterClass :: InnerClass”。 (2)从“OuterClass”到“OuterClass :: InnerClass”绘制一个“Composition”连接器。
      3. 协会或作文

        这实际上取决于你的要求。

        大多数人喜欢用“破坏”过程描述“构图”; “整体”被摧毁,然后“部分”也被摧毁了。

        然而,从“构造”过程描述总是有效的;在这个过程中你“全新”,你“新成了部分”。 优良作法是使“构造”和“破坏”它们保持一致。

        E.g。汽车和轮子;

        如果有人写了下面的疯狂代码,哇..

        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!
        

        所以这不是一个真正的“组合”,因为构造和破坏是不一致的。 如果从析构函数中删除“删除w1;删除w2”,则Car和Wheel之间的关系为“关联”。

        代码的组合版本将如下所示:

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