Entity и Value Object: кто есть кто
Entity и Value Object: кто есть кто
Не все данные одинаковы: у одних есть «личность» и история, у других - только значение. Эта разница меняет, как ты пишешь код, тесты и валидацию. См. также структуры в Go.
Проблема: всё - структура с ID
В типичном Go-проекте все данные выглядят одинаково: структура с полями, ID у каждой. Email - строка, деньги - float64, slug - тоже строка. Валидация разбросана по хэндлерам и сервисам. Два email сравниваются через ==, поэтому Admin@Mail.ru и admin@mail.ru считаются разными адресами. Деньги складываются с потерей точности.
// Типичный «плоский» подход: всё - просто поля
type User struct {
ID int
Name string
Email string // просто строка, никакой защиты
Balance float64 // деньги через float - рецепт катастрофы
}
// Валидация - где-то в хэндлере
func CreateUser(name, email string) (*User, error) {
if !strings.Contains(email, "@") { // дублируется в 5 местах
return nil, errors.New("bad email")
}
return &User{Name: name, Email: email}, nil
}
// Типичный «плоский» подход: всё - просто поля
final class User
{
public function __construct(
public int $id,
public string $name,
public string $email, // просто строка, никакой защиты
public float $balance, // деньги через float - рецепт катастрофы
) {}
}
// Валидация - где-то в контроллере
function createUser(string $name, string $email): User
{
if (!str_contains($email, '@')) { // дублируется в 5 местах
throw new InvalidArgumentException('bad email');
}
return new User(0, $name, $email, 0.0);
}
# Типичный «плоский» подход: всё - просто поля
from dataclasses import dataclass
@dataclass
class User:
id: int
name: str
email: str # просто строка, никакой защиты
balance: float # деньги через float - рецепт катастрофы
# Валидация - где-то в хэндлере
def create_user(name: str, email: str) -> User:
if "@" not in email: # дублируется в 5 местах
raise ValueError("bad email")
return User(0, name, email, 0.0)
DDD предлагает разделить данные на два типа: Entity (сущность) и Value Object (объект-значение). Это разделение фундаментально меняет архитектуру.
Entity: объект с идентичностью
Entity - это объект, который уникален благодаря своему идентификатору, а не содержимому.
Два пользователя могут иметь одинаковые имя и email (однофамильцы с почтой на одном домене), но если у них разные ID - это разные пользователи. И наоборот: пользователь может сменить имя, email, аватарку - но он остаётся тем же пользователем, потому что ID не изменился.
Что делает объект сущностью:
- есть собственная идентичность (ID, UUID) - она и отвечает на вопрос «тот же самый объект или другой»;
- сравнивается по идентичности, а не по содержимому;
- имеет жизненный цикл - создаётся, проходит через состояния, может быть удалён.
ℹ️ Изменяемость - не признак сущности
В списках признаков Entity часто пишут «mutable». Формально это неверно: определяющее свойство одно - идентичность, сохраняющаяся во времени. Изменяемость - типичный способ реализации, а не часть определения.
Сущность вполне может быть неизменяемой: новое состояние - новый объект с той же идентичностью.
// Изменяемый вариант: метод меняет поля func (u *User) ChangeEmail(e Email) { u.email = e } // Неизменяемый: метод возвращает новое значение с тем же ID func (u User) WithEmail(e Email) User { u.email = e // u - копия, ID тот же return u }Второй подход обычен в языках с иммутабельностью по умолчанию и в event sourcing, где состояние - результат свёртки событий. Практическая разница: с иммутабельными сущностями сложнее случайно испортить объект из другого места, но нужно аккуратнее следить, что сохраняется именно последняя версия.
Entity в Go: User
package domain
import (
"errors"
"time"
)
// User - Entity. Идентичность определяется полем ID.
type User struct {
id string
email Email // Value Object (см. ниже)
name string
createdAt time.Time
}
// NewUser - конструктор с валидацией
func NewUser(id string, email Email, name string) (*User, error) {
if id == "" {
return nil, errors.New("user id is required")
}
if name == "" {
return nil, errors.New("user name is required")
}
return &User{
id: id,
email: email,
name: name,
createdAt: time.Now(),
}, nil
}
// Rename - изменение поля. Entity мутируется, но ID остаётся.
func (u *User) Rename(newName string) error {
if newName == "" {
return errors.New("name cannot be empty")
}
u.name = newName
return nil
}
// ID - геттер. Поля приватные, доступ через методы.
func (u *User) ID() string { return u.id }
func (u *User) Email() Email { return u.email }
func (u *User) Name() string { return u.name }
// Equals - Entity сравнивается по ID
func (u *User) Equals(other *User) bool {
if other == nil {
return false
}
return u.id == other.id
}
<?php
declare(strict_types=1);
namespace App\Learning\Domain;
use DateTimeImmutable;
use InvalidArgumentException;
// User - Entity. Идентичность определяется полем id.
// НЕ readonly: имя может меняться, но id остаётся.
final class User
{
private function __construct(
private readonly string $id,
private readonly Email $email,
private string $name,
private readonly DateTimeImmutable $createdAt,
) {}
// create - конструктор-фабрика с валидацией
public static function create(string $id, Email $email, string $name): self
{
if ($id === '') {
throw new InvalidArgumentException('user id is required');
}
if ($name === '') {
throw new InvalidArgumentException('user name is required');
}
return new self($id, $email, $name, new DateTimeImmutable());
}
// rename - изменение поля. Entity мутируется, но id остаётся.
public function rename(string $newName): void
{
if ($newName === '') {
throw new InvalidArgumentException('name cannot be empty');
}
$this->name = $newName;
}
public function id(): string { return $this->id; }
public function email(): Email { return $this->email; }
public function name(): string { return $this->name; }
// equals - Entity сравнивается по id
public function equals(self $other): bool
{
return $this->id === $other->id;
}
}
from dataclasses import dataclass, field
from datetime import datetime
@dataclass(eq=False)
class User:
"""Entity. Идентичность определяется полем id.
eq=False: dataclass не должен сравнивать по всем полям - равенство задаём сами, по id.
"""
id: str
email: Email # Value Object (см. ниже)
name: str
created_at: datetime = field(default_factory=datetime.now, init=False)
def __post_init__(self) -> None:
"""Конструктор с валидацией. User с пустым id не создать."""
if not self.id:
raise ValueError("user id is required")
if not self.name:
raise ValueError("user name is required")
def rename(self, new_name: str) -> None:
"""Изменение поля. Entity мутируется, но id остаётся."""
if not new_name:
raise ValueError("name cannot be empty")
self.name = new_name
# Геттеры не нужны: поля dataclass читаются напрямую (user.id, user.email).
# Защита инвариантов - в __post_init__ и методах, а не в приватности полей.
# Entity сравнивается по id
def __eq__(self, other: object) -> bool:
if not isinstance(other, User):
return NotImplemented
return self.id == other.id
def __hash__(self) -> int:
return hash(self.id)
ℹ️ Приватные поля + конструктор = инварианты
В Go нет классов, но есть отличный паттерн: неэкспортированные поля + конструктор
NewXxx. Никто не создастUserс пустым ID - конструктор не позволит. Это и есть защита инвариантов. Когда способов собрать сущность становится несколько - из HTTP-запроса, из строки БД, из импорта CSV - одного конструктора мало, и рождение сущности выносят в Factory.
Value Object: объект без идентичности
Value Object (VO) - это объект, у которого нет собственной идентичности: он определяется своим содержимым. Два VO с одинаковыми значениями - одно и то же.
Пример из жизни: купюра в 100 рублей. Тебе не важен серийный номер - важна сумма. Любые две купюры по 100 рублей для тебя равны.
Определение - две строки, и обе про идентичность:
- нет собственной доменной идентичности - серийный номер купюры нас не интересует;
- равенство по значению - объекты с одинаковыми полями равны.
Всё остальное, что обычно перечисляют рядом, - рекомендации по реализации, а не часть определения. Они хорошие, и в этом курсе мы им следуем:
- неизменяемость - VO не меняют, а заменяют новым. Иначе объект, переданный в два места, изменится в обоих, а по значению он «тот же самый»;
- валидация в конструкторе - невалидный VO не должен существовать вовсе, тогда проверки не расползаются по коду;
- инварианты в типе -
Emailвместоstringне даёт передать в функцию что попало.
Разделение важно, потому что иначе выходит странность: изменяемый объект
с равенством по значению - всё ещё Value Object по определению, просто
плохо сделанный. А string с адресом почты - не VO вовсе, сколько бы
проверок вокруг ни стояло, потому что не даёт ни отдельного типа,
ни гарантий.
Value Object в Go: Email
package domain
import (
"fmt"
"strings"
)
// Email - Value Object. Определяется значением, а не ID.
type Email struct {
value string // приватное поле - извне не изменить
}
// NewEmail - конструктор с валидацией.
// Невалидный Email невозможно создать.
func NewEmail(raw string) (Email, error) {
// Приводим весь адрес к нижнему регистру: это наше доменное правило.
// По RFC 5321 регистр локальной части (до @) формально может быть значимым.
v := strings.TrimSpace(strings.ToLower(raw))
if v == "" {
return Email{}, fmt.Errorf("email cannot be empty")
}
// Простая проверка. В реальном проекте - regexp или net/mail.
parts := strings.Split(v, "@")
if len(parts) != 2 || parts[0] == "" || parts[1] == "" {
return Email{}, fmt.Errorf("invalid email format: %s", raw)
}
if !strings.Contains(parts[1], ".") {
return Email{}, fmt.Errorf("invalid email domain: %s", parts[1])
}
return Email{value: v}, nil
}
// String возвращает email как строку (для сериализации, логов)
func (e Email) String() string { return e.value }
// Equals - VO сравнивается по значению
func (e Email) Equals(other Email) bool {
return e.value == other.value
}
// Domain возвращает домен email
func (e Email) Domain() string {
parts := strings.Split(e.value, "@")
return parts[1]
}
<?php
declare(strict_types=1);
namespace App\Learning\Domain;
use InvalidArgumentException;
// Email - Value Object. Определяется значением, а не ID.
// final readonly - иммутабельность гарантирована.
final readonly class Email
{
private function __construct(
private string $value,
) {}
// fromString - фабрика с валидацией.
// Невалидный Email невозможно создать.
public static function fromString(string $raw): self
{
$v = strtolower(trim($raw));
if ($v === '') {
throw new InvalidArgumentException('email cannot be empty');
}
$parts = explode('@', $v);
if (count($parts) !== 2 || $parts[0] === '' || $parts[1] === '') {
throw new InvalidArgumentException('invalid email format: ' . $raw);
}
if (!str_contains($parts[1], '.')) {
throw new InvalidArgumentException('invalid email domain: ' . $parts[1]);
}
return new self($v);
}
public function value(): string { return $this->value; }
// equals - VO сравнивается по значению
public function equals(self $other): bool
{
return $this->value === $other->value;
}
// domain возвращает домен email
public function domain(): string
{
return explode('@', $this->value)[1];
}
public function __toString(): string { return $this->value; }
}
from dataclasses import dataclass
@dataclass(frozen=True)
class Email:
"""Value Object. Определяется значением, а не id.
frozen=True: после создания поля не присвоить - иммутабельность.
== и hash по значению dataclass генерирует сам - отдельный equals не нужен.
"""
value: str
def __post_init__(self) -> None:
"""Валидация в конструкторе.
Невалидный Email невозможно создать.
"""
v = self.value.strip().lower()
if not v:
raise ValueError("email cannot be empty")
# Простая проверка. В реальном проекте - regexp или email.utils.
parts = v.split("@")
if len(parts) != 2 or not parts[0] or not parts[1]:
raise ValueError(f"invalid email format: {self.value}")
if "." not in parts[1]:
raise ValueError(f"invalid email domain: {parts[1]}")
# frozen запрещает self.value = v, нормализованное значение кладём напрямую
object.__setattr__(self, "value", v)
# str(email) возвращает email как строку (для сериализации, логов)
def __str__(self) -> str:
return self.value
def domain(self) -> str:
"""Возвращает домен email."""
return self.value.split("@")[1]
Ключевой момент: NewEmail(" Admin@Gmail.COM ") и NewEmail("admin@gmail.com") создают одинаковые Value Objects. Нормализация происходит в конструкторе.
Value Object: Money
Деньги - классический Value Object. Никогда не используй float64 для денег.
package domain
import "fmt"
// Money - Value Object. Хранит сумму в минимальных единицах (копейки, центы).
type Money struct {
amount int64 // в копейках: 1050 = 10 руб 50 коп
currency string // "RUB", "USD"
}
// NewMoney создаёт Money из суммы в копейках
func NewMoney(amountMinor int64, currency string) (Money, error) {
if currency == "" {
return Money{}, fmt.Errorf("currency is required")
}
if amountMinor < 0 {
return Money{}, fmt.Errorf("amount cannot be negative")
}
return Money{amount: amountMinor, currency: currency}, nil
}
// Add складывает две суммы. Возвращает НОВЫЙ VO (иммутабельность).
func (m Money) Add(other Money) (Money, error) {
if m.currency != other.currency {
return Money{}, fmt.Errorf(
"cannot add %s and %s", m.currency, other.currency,
)
}
return Money{amount: m.amount + other.amount, currency: m.currency}, nil
}
// Rubles возвращает сумму в рублях (для отображения).
// Упрощение: считаем, что у валюты 2 знака после запятой
// (для RUB и USD это верно, для JPY - нет).
func (m Money) Rubles() float64 {
return float64(m.amount) / 100
}
// Equals - VO сравнивается по всем полям
func (m Money) Equals(other Money) bool {
return m.amount == other.amount && m.currency == other.currency
}
func (m Money) String() string {
return fmt.Sprintf("%.2f %s", m.Rubles(), m.currency)
}
<?php
declare(strict_types=1);
namespace App\Learning\Domain;
use DomainException;
use InvalidArgumentException;
// Money - Value Object. Хранит сумму в минимальных единицах (копейки, центы).
// final readonly - VO иммутабелен по контракту.
final readonly class Money
{
private function __construct(
private int $amount, // в копейках: 1050 = 10 руб 50 коп
private string $currency, // 'RUB', 'USD'
) {}
public static function fromMinorUnits(int $amountMinor, string $currency): self
{
if ($currency === '') {
throw new InvalidArgumentException('currency is required');
}
if ($amountMinor < 0) {
throw new InvalidArgumentException('amount cannot be negative');
}
return new self($amountMinor, $currency);
}
public static function fromRubles(int $rubles): self
{
return self::fromMinorUnits($rubles * 100, 'RUB');
}
// add складывает две суммы. Возвращает НОВЫЙ VO (иммутабельность).
public function add(self $other): self
{
if ($this->currency !== $other->currency) {
throw new DomainException(
sprintf('cannot add %s and %s', $this->currency, $other->currency)
);
}
return new self($this->amount + $other->amount, $this->currency);
}
// Упрощение: считаем, что у валюты 2 знака после запятой
// (для RUB и USD это верно, для JPY - нет).
public function rubles(): float
{
return $this->amount / 100;
}
// equals - VO сравнивается по всем полям
public function equals(self $other): bool
{
return $this->amount === $other->amount
&& $this->currency === $other->currency;
}
public function __toString(): string
{
return sprintf('%.2f %s', $this->rubles(), $this->currency);
}
}
from dataclasses import dataclass
@dataclass(frozen=True)
class Money:
"""Value Object. Хранит сумму в минимальных единицах (копейки, центы).
frozen=True - VO иммутабелен, == и hash по всем полям генерирует dataclass.
"""
amount: int # в копейках: 1050 = 10 руб 50 коп
currency: str # "RUB", "USD"
def __post_init__(self) -> None:
if not self.currency:
raise ValueError("currency is required")
if self.amount < 0:
raise ValueError("amount cannot be negative")
def add(self, other: "Money") -> "Money":
"""Складывает две суммы. Возвращает НОВЫЙ VO (иммутабельность)."""
if self.currency != other.currency:
raise ValueError(f"cannot add {self.currency} and {other.currency}")
return Money(self.amount + other.amount, self.currency)
def rubles(self) -> float:
"""Возвращает сумму в рублях (для отображения).
Упрощение: считаем, что у валюты 2 знака после запятой
(для RUB и USD это верно, для JPY - нет).
"""
return self.amount / 100
def __str__(self) -> str:
return f"{self.rubles():.2f} {self.currency}"
⚠️ float64 для денег - баг на миллион
0.1 + 0.2 = 0.30000000000000004в любом языке с IEEE 754. Храни деньги в целых числах (копейки) - и проблемы не будет. Value Object Money защищает от этого на уровне типа.
Value Object: Slug
package domain
import (
"fmt"
"regexp"
"strings"
)
var slugRegex = regexp.MustCompile(`^[a-z0-9]+(-[a-z0-9]+)*
Entity и Value Object: кто есть кто | BackendStart.ru
)
// Slug - Value Object для URL-friendly идентификаторов.
type Slug struct {
value string
}
func NewSlug(raw string) (Slug, error) {
v := strings.TrimSpace(strings.ToLower(raw))
if v == "" {
return Slug{}, fmt.Errorf("slug cannot be empty")
}
if !slugRegex.MatchString(v) {
return Slug{}, fmt.Errorf("invalid slug format: %q (allowed: a-z, 0-9, hyphens)", raw)
}
return Slug{value: v}, nil
}
func (s Slug) String() string { return s.value }
func (s Slug) Equals(other Slug) bool { return s.value == other.value }
<?php
declare(strict_types=1);
namespace App\Learning\Domain;
use InvalidArgumentException;
// Slug - Value Object для URL-friendly идентификаторов.
final readonly class Slug
{
private const PATTERN = '/^[a-z0-9]+(-[a-z0-9]+)*$/';
private function __construct(
private string $value,
) {}
public static function fromString(string $raw): self
{
$v = strtolower(trim($raw));
if ($v === '') {
throw new InvalidArgumentException('slug cannot be empty');
}
if (preg_match(self::PATTERN, $v) !== 1) {
throw new InvalidArgumentException(
'invalid slug format: ' . $raw . ' (allowed: a-z, 0-9, hyphens)'
);
}
return new self($v);
}
public function value(): string { return $this->value; }
public function equals(self $other): bool { return $this->value === $other->value; }
public function __toString(): string { return $this->value; }
}
import re
from dataclasses import dataclass
_SLUG_PATTERN = re.compile(r"^[a-z0-9]+(-[a-z0-9]+)*quot;)
@dataclass(frozen=True)
class Slug:
"""Value Object для URL-friendly идентификаторов."""
value: str
def __post_init__(self) -> None:
v = self.value.strip().lower()
if not v:
raise ValueError("slug cannot be empty")
if not _SLUG_PATTERN.match(v):
raise ValueError(
f"invalid slug format: {self.value!r} (allowed: a-z, 0-9, hyphens)"
)
object.__setattr__(self, "value", v)
def __str__(self) -> str:
return self.value
Entity vs Value Object: сравнение
| Критерий | Entity | Value Object |
|---|---|---|
| Идентичность | По ID (UUID, int) | По значениям полей |
| Изменяемость | Не признак: бывает и мутируемой, и неизменяемой | Обычно проектируется неизменяемым |
| Жизненный цикл | Создание -> изменение -> удаление | Создание -> использование |
| Сравнение | a.ID() == b.ID() | a.Equals(b) по всем полям |
| Примеры | User, Course, Order | Email, Money, Slug, DateRange |
| В базе | Своя таблица с PK | Поле(я) в таблице Entity |
Из последней строки таблицы вытекает практическое следствие: Value Object разворачивается в колонки при записи и собирается обратно через конструктор при чтении. Делать это должен адаптер базы, а не домен, - иначе Email можно будет создать в обход валидации. Как выглядит такой перевод между строкой таблицы и доменным типом, в уроке DTO и маппинг.
Как решить: Entity или Value Object?
Задай себе три вопроса:
1. Нужно ли отслеживать этот объект по ID?
- Пользователь - да, у него есть аккаунт, история -> Entity
- Email пользователя - нет, важно только значение -> VO
2. Может ли объект измениться, оставаясь «тем же»?
- Курс может обновить описание, но остаться тем же курсом -> Entity
- Slug
ddd-lite- если он изменился, это уже другой slug -> VO
3. Два объекта с одинаковым содержимым - это один объект?
- Два пользователя с одинаковым именем - разные люди -> Entity
- Два email
admin@example.com- один и тот же email -> VO
🚫 Распространённая ошибка: всё - Entity
Новички делают Entity из всего: EmailEntity, MoneyEntity, SlugEntity - с ID, таблицей в базе и полным CRUD. Это создаёт ненужную сложность. Если объект определяется значением - это Value Object, и ему не нужен ID.
Go и Value Objects: особенности языка
В Go нет классов и модификатора readonly. Но есть приёмы для реализации VO:
1. Приватные поля + конструктор
// Поля неэкспортированные - изменить извне нельзя
type Email struct {
value string // маленькая буква = приватное
}
<?php
declare(strict_types=1);
// Поля private + final readonly - изменить извне нельзя
final readonly class Email
{
public function __construct(
private string $value, // private + readonly = иммутабельность
) {}
}
from dataclasses import dataclass
# frozen=True - присвоить поле после создания нельзя
@dataclass(frozen=True)
class Email:
value: str # запись email.value = ... бросит FrozenInstanceError
2. Методы на value receiver (не pointer)
// Value receiver - метод не может изменить структуру
func (e Email) String() string { return e.value }
func (e Email) Domain() string { ... }
// Это НЕ скомпилируется вне пакета domain (поле неэкспортированное).
// Внутри самого пакета защиту держит только дисциплина:
// email.value = "hacked" - ошибка
<?php
declare(strict_types=1);
// readonly-свойство нельзя присвоить вне конструктора - аналог value receiver
final readonly class Email
{
public function __construct(private string $value) {}
public function __toString(): string { return $this->value; }
public function domain(): string { return explode('@', $this->value)[1]; }
}
// Это бросит \Error на рантайме:
// $email->value = 'hacked'; -> Cannot modify readonly property
from dataclasses import dataclass
# Методы frozen-dataclass не могут изменить объект - аналог value receiver
@dataclass(frozen=True)
class Email:
value: str
def __str__(self) -> str:
return self.value
def domain(self) -> str:
return self.value.split("@")[1]
# Это бросит FrozenInstanceError на рантайме:
# email.value = "hacked"
3. Операции возвращают новый VO
// Add не мутирует m - возвращает новый Money
func (m Money) Add(other Money) (Money, error) {
return Money{amount: m.amount + other.amount, currency: m.currency}, nil
}
<?php
declare(strict_types=1);
// add не мутирует $this - возвращает новый Money
final readonly class Money
{
public function __construct(private int $amount, private string $currency) {}
public function add(self $other): self
{
if ($this->currency !== $other->currency) {
throw new DomainException('currency mismatch');
}
return new self($this->amount + $other->amount, $this->currency);
}
}
from dataclasses import dataclass
# add не мутирует self - возвращает новый Money
@dataclass(frozen=True)
class Money:
amount: int
currency: str
def add(self, other: "Money") -> "Money":
return Money(self.amount + other.amount, self.currency)
4. Zero value - невалидный
// Email{} - пустой, невалидный. Это нормально.
// Единственный способ создать валидный Email - через NewEmail().
var e Email // e.value == "" - невалидный
e, err := NewEmail("admin@example.com") // единственный правильный путь
<?php
declare(strict_types=1);
// В PHP «zero value» нет - конструктор обязан получить аргументы.
// Защита: private __construct + статическая фабрика с валидацией.
final readonly class Email
{
private function __construct(private string $value) {}
public static function fromString(string $raw): self
{
$v = strtolower(trim($raw));
if ($v === '' || !str_contains($v, '@')) {
throw new InvalidArgumentException('invalid email');
}
return new self($v);
}
}
// Невалидный Email создать нельзя - конструктор приватный.
$email = Email::fromString('admin@example.com'); // единственный правильный путь
from dataclasses import dataclass
# В Python «zero value» нет - конструктор обязан получить аргументы.
# Защита: валидация в __post_init__, Email("") упадёт при создании.
@dataclass(frozen=True)
class Email:
value: str
def __post_init__(self) -> None:
v = self.value.strip().lower()
if not v or "@" not in v:
raise ValueError("invalid email")
object.__setattr__(self, "value", v)
# Невалидный Email создать нельзя - __post_init__ не позволит.
email = Email("admin@example.com") # единственный правильный путь
Полный пример: Entity + Value Objects вместе
Вот как Entity и Value Objects работают вместе в доменной модели BackendStart:
package domain
import (
"errors"
"time"
)
// Course - Entity. Учебный трек на платформе.
type Course struct {
id string
slug Slug // Value Object
title string
difficulty Difficulty // Value Object (enum)
totalLessons int
createdAt time.Time
}
type Difficulty string
const (
DifficultyBeginner Difficulty = "beginner"
DifficultyIntermediate Difficulty = "intermediate"
DifficultyAdvanced Difficulty = "advanced"
)
// Valid сообщает, входит ли значение в допустимый набор.
// В Go type + const не запрещает Difficulty("hacker"), поэтому проверяем сами.
func (d Difficulty) Valid() bool {
switch d {
case DifficultyBeginner, DifficultyIntermediate, DifficultyAdvanced:
return true
}
return false
}
func NewCourse(id string, slug Slug, title string, difficulty Difficulty) (*Course, error) {
if id == "" {
return nil, errors.New("course id is required")
}
if slug == (Slug{}) {
return nil, errors.New("course slug is required")
}
if title == "" {
return nil, errors.New("course title is required")
}
if !difficulty.Valid() {
return nil, errors.New("unknown difficulty")
}
return &Course{
id: id,
slug: slug,
title: title,
difficulty: difficulty,
createdAt: time.Now(),
}, nil
}
func (c *Course) ID() string { return c.id }
func (c *Course) Slug() Slug { return c.slug }
func (c *Course) Title() string { return c.title }
// AddLesson увеличивает счётчик уроков. Entity мутируется.
func (c *Course) AddLesson() {
c.totalLessons++
}
// Equals - Entity сравнивается по ID
func (c *Course) Equals(other *Course) bool {
if other == nil {
return false
}
return c.id == other.id
}
<?php
declare(strict_types=1);
namespace App\Learning\Domain;
use DateTimeImmutable;
use InvalidArgumentException;
// Difficulty - Value Object (enum) для уровня сложности
enum Difficulty: string
{
case Beginner = 'beginner';
case Intermediate = 'intermediate';
case Advanced = 'advanced';
}
// Course - Entity. Учебный трек на платформе.
// НЕ readonly: totalLessons мутируется через addLesson().
final class Course
{
private function __construct(
private readonly string $id,
private readonly Slug $slug, // Value Object
private readonly string $title,
private readonly Difficulty $difficulty, // Value Object (enum)
private int $totalLessons,
private readonly DateTimeImmutable $createdAt,
) {}
public static function create(
string $id,
Slug $slug,
string $title,
Difficulty $difficulty,
): self {
if ($id === '') {
throw new InvalidArgumentException('course id is required');
}
if ($title === '') {
throw new InvalidArgumentException('course title is required');
}
return new self($id, $slug, $title, $difficulty, 0, new DateTimeImmutable());
}
public function id(): string { return $this->id; }
public function slug(): Slug { return $this->slug; }
public function title(): string { return $this->title; }
// addLesson увеличивает счётчик уроков. Entity мутируется.
public function addLesson(): void
{
$this->totalLessons++;
}
// equals - Entity сравнивается по id
public function equals(self $other): bool
{
return $this->id === $other->id;
}
}
from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum
class Difficulty(str, Enum):
"""Value Object (enum) для уровня сложности."""
BEGINNER = "beginner"
INTERMEDIATE = "intermediate"
ADVANCED = "advanced"
@dataclass(eq=False)
class Course:
"""Entity. Учебный трек на платформе.
eq=False: равенство задаём сами, по id. total_lessons мутируется через add_lesson().
"""
id: str
slug: Slug # Value Object
title: str
difficulty: Difficulty # Value Object (enum)
total_lessons: int = field(default=0, init=False)
created_at: datetime = field(default_factory=datetime.now, init=False)
def __post_init__(self) -> None:
if not self.id:
raise ValueError("course id is required")
if not self.title:
raise ValueError("course title is required")
def add_lesson(self) -> None:
"""Увеличивает счётчик уроков. Entity мутируется."""
self.total_lessons += 1
# Entity сравнивается по id
def __eq__(self, other: object) -> bool:
if not isinstance(other, Course):
return NotImplemented
return self.id == other.id
def __hash__(self) -> int:
return hash(self.id)
Обрати внимание:
Course- Entity (естьid, мутируется черезAddLesson).Slug- Value Object (передаётся в конструктор, не меняется).Difficulty- Value Object (enum черезtype + const).- Все поля приватные, доступ через геттеры.
- Конструктор
NewCourseвалидирует инварианты: в том числе отвергает нулевойSlug{}и чужое значениеDifficulty. В Gotype + constне запрещаетDifficulty("hacker"), поэтому набор значений проверяет конструктор (в PHP это делает самenum).
Пока у сущности одно правило на конструктор, этого достаточно. Как только внутри появляются дочерние объекты (у прогресса курса - прогресс по каждому уроку) и правила, которые должны быть истинны в любой момент, а не только при создании, сущность становится корнем агрегата и получает единственную точку входа для всех изменений. Этому посвящён следующий урок.
Типичные ошибки и как их избежать
1. Примитивная одержимость (Primitive Obsession)
// ПЛОХО: email - просто string
func SendWelcome(email string) error { ... }
// Кто гарантирует, что email валиден? Никто.
// ХОРОШО: email - Value Object
func SendWelcome(email Email) error { ... }
// Email уже провалидирован при создании через NewEmail.
// ПЛОХО: email - просто string
function sendWelcome(string $email): void { /* ... */ }
// Кто гарантирует, что email валиден? Никто.
// ХОРОШО: email - Value Object
function sendWelcome(Email $email): void { /* ... */ }
// Email уже провалидирован при создании через Email::fromString().
# ПЛОХО: email - просто str
def send_welcome(email: str) -> None: ...
# Кто гарантирует, что email валиден? Никто.
# ХОРОШО: email - Value Object
def send_welcome(email: Email) -> None: ...
# Email уже провалидирован при создании через Email(...).
Технически Value Object - это свой тип, который компилятор не даст перепутать с сырой строкой. Но защиту инварианта даёт только структура с неэкспортированным полем, как Email выше. Определяемый тип вида type Email string можно получить конверсией Email("что угодно") в обход конструктора, поэтому он годится для простых меток, но не для значений с правилами.
2. Мутабельный Value Object
// ПЛОХО: VO с сеттером - нарушение иммутабельности
func (e *Email) SetValue(v string) { e.value = v }
// ХОРОШО: нужен новый email - создай новый VO
newEmail, err := NewEmail("new@example.com")
<?php
declare(strict_types=1);
// ПЛОХО: VO без readonly + сеттер - нарушение иммутабельности
final class Email
{
private string $value;
public function setValue(string $v): void { $this->value = $v; }
}
// ХОРОШО: final readonly + фабрика. Нужен новый email - создай новый VO.
$newEmail = Email::fromString('new@example.com');
from dataclasses import dataclass
# ПЛОХО: VO без frozen + сеттер - нарушение иммутабельности
@dataclass
class Email:
value: str
def set_value(self, v: str) -> None:
self.value = v
# ХОРОШО: frozen=True. Нужен новый email - создай новый VO.
new_email = Email("new@example.com")
3. Entity без поведения (Anemic Model)
// ПЛОХО: Entity - просто контейнер данных
type Course struct {
ID string
Title string
Slug string
}
// Вся логика - в сервисе. Course ничего не умеет.
// ХОРОШО: Entity содержит бизнес-логику
type Course struct { ... }
func (c *Course) AddLesson() { ... }
func (c *Course) CanPublish() bool { ... }
func (c *Course) Rename(title string) error { ... }
// ПЛОХО: Entity - просто контейнер данных
final class Course
{
public string $id;
public string $title;
public string $slug;
}
// Вся логика - в сервисе. Course ничего не умеет.
// ХОРОШО: Entity содержит бизнес-логику
final class Course
{
// ...
public function addLesson(): void { /* ... */ }
public function canPublish(): bool { /* ... */ }
public function rename(string $title): void { /* ... */ }
}
from dataclasses import dataclass
# ПЛОХО: Entity - просто контейнер данных
@dataclass
class Course:
id: str
title: str
slug: str
# Вся логика - в сервисе. Course ничего не умеет.
# ХОРОШО: Entity содержит бизнес-логику
@dataclass(eq=False)
class Course:
...
def add_lesson(self) -> None: ...
def can_publish(self) -> bool: ...
def rename(self, title: str) -> None: ...
Мини-задание
- Выбери 2 Value Object в своём проекте (Email, Money, Slug, DateRange, PhoneNumber) и реализуй их с приватными полями и конструктором
- Убедись, что VO неизменяемый - все методы на value receiver, операции возвращают новый VO
- Напиши тест: два VO с одинаковыми значениями должны быть равны через
Equals - Найди в коде место с «примитивной одержимостью» (string вместо типа) и замени на VO
- Проверь свои Entity: есть ли у них поведение или это просто контейнеры данных?