Question

当我首先停止考虑数据库时（开始使用Uuid而不是考虑auto_incremented id），DDD确实开始变得有意义。今天，我意识到您可以persist value objects，而不仅仅是实体。 DDD, value objects and ORM

我的问题与人格实体有关。我需要保留MealTime的3种表示形式（一种用于早餐，午餐，晚餐，它们各自的类别分别为1、2和3），但最重要的是，我要封装的行为是MealPeriod中的CreateWeek，它使用MealTime值返回每周的结构化数组。

MealPeriod是否必要，还是我应该只拥有一个MealPeriods（或MealTimes）来保存MealTime集合？
如果我们要保留MealPeriod集合，我应该在类本身还是在存储库中添加一个$_personality_id引用，我应该使用$personality->id()作为personality_id db列名（在表中）我们将MealTime集合保存在哪里？

MealPlan（聚集根）

final class MealPlan extends AggragateRoot {

    private PlanId $_id;
    private UserId $_user_id;
    private $_personality;

    public function __construct(PlanId $id, UserId $userId){
        $this->_id = $id;
        $this->_user_id = $userId;
    }

    public static function create(string $id, string $userId){
        return new self(new PlanId($id), new UserId($userId));
    }

    public function id(): PlanId {
        return $this->_id;
    }

    // setter/getter for personality
}

final class Personality {

    private PersonalityId $_id;
    private PlanId $_plan_id;
    private Allergen $_allergen;
    private MealPeriods $_meal_periods;

    public function __construct(PersonalityId $id, PlanId $plan_id, Allergen $allergen, MealPeriod $meal_period){
        $this->_id = $id;
        $this->_plan_id = $plan_id;
        $this->_allergen = $allergen;
        $this->_meal_period = $meal_period;
    }

    public static function create(string $id, string $plan_id, int $allergen, array $meal_period){
        return new self(
            new PersonalityId($id),
            new PlanId($plan_id),
            new Allergen($allergen),
            new MealPeriod($meal_period)
        );
    }
}

class MealPeriod {

    private array $_collection;

    public function __construct(array $times){
        foreach($times as $data){
            array_push($this->_collection, $data);
        }
    }

    public function get(int $category){
        return array_filter($this->_collection, function($value) use ($category){
            return $value->category() === $category;
        });
    }

    public function breakfast(): MealTime {
        return $this->get(1);
    }

    public function lunch(): MealTime {
        return $this->get(2);
    }

    public function dinner(): MealTime {
        return $this->get(3);
    }

    public function createWeek(){
        // uses breakfast, lunch and dinner MealTime values to generate some data.
    }
    
}

class MealTime {

    private int $_meal_category;
    private int $_skip;
    private int $_unique;
    private int $_leftover;
    private int $_variety;
    private int $_time;

    public function __construct(int $category, int $skip, int $unique, int $leftover, int $variety){
        $this->_meal_category = $category;
        $this->_skip = $skip;
        $this->_unique = $unique;
        $this->_leftover = $leftover;
        $this->_variety = $variety;
    }

    public function category(): int {
        return $this->_meal_category;
    }

    public function skip(): int {
        return $this->_skip;
    }

    public function unique(): int {
        return $this->_unique;
    }

    public function leftover(): int {
        return $this->_leftover;
    }

    public function variety(): int {
        return $this->_variety;
    }
}

Answer 1

使用DDD的最关键部分是普适语言（UL）。我将提出一个简化的UL，从那里我们将能够回答您的所有问题。简化的练习应该有助于为您澄清概念，并且也可以显示我的误解。

我的问题与人格实体有关。我需要保持MealTime的3种表示形式（早餐，午餐，晚餐各一种，它们各自的类别分别是1、2和3），但最重要的是，我要封装的行为是MealPeriod中的CreateWeek，它使用了MealTime值以返回每周的结构化数组。

根据此声明，您的UL可能是（一个sme定义了UL，它通常包含很多细节）：用户创建每周进餐时间表。每天三餐早餐午餐和晚餐。每顿饭仅在一天的指定时间内有效。 请注意，UL中的所有细节均以客户为中心。忘记数据，ID或任何技术信息。

在此UL中，我们可以说：

CreateWeek 不属于MealPeriod。没有办法说“进餐时间创造一周的进餐时间”。不符合UL。
需要有一个初始的“名词”（实体）来创建时间表。 UL将该实体称为“用户”。
该名词创建每周计划，因此将包含Createweek方法。 createweek方法是实体内部的工厂方法。现在，“用户”有资格被称为聚合根，因为它负责管理其他实体的生命周期。
每日/每周的用餐时间是一个整体。日程安排实体将包含三餐。
每顿饭有效时，每顿饭将包含1个期间的值对象。

关于序列化： DDD与序列化无关。 DDD所需要的是一种持久化实体和模型，并在以后恢复持久化的实体和模型到其完整状态的方法。此功能通常在域外处理，但作为接口注入域中。

说了这么多：您不需要在进餐期间使用“ Id”。 UL将餐期类别描述为一种值类型（在“餐”的上下文之外没有意义）。值类型没有任何标识ID，因为它们完全由实体封装。

持有/坚持收集价值对象

1 个答案: