Bounded Context: границы предметных областей

Bounded Context: границы предметных областей

Представь: в команде фронтендер говорит "курс" и имеет в виду страницу с уроками. Маркетолог говорит "курс" и подразумевает лендинг с ценой и отзывами. Бухгалтер слышит "курс" и думает о валютном курсе. Одно слово - три разных значения.

Когда все три смысла попадают в одну структуру Course, получается монстр с полями Price, ExchangeRate, Lessons, LandingURL, VATPercent. Любое изменение в биллинге ломает обучение. Любой рефакторинг обучения задевает маркетинг.

Bounded Context решает эту проблему: каждый контекст - это граница применимости одной модели. Внутри неё модель согласована сама с собой, а термины единого языка имеют ровно один смысл.

Язык - самый заметный признак границы, но не вся она. Внутри контекста согласованы три вещи:

  • модель - какие сущности есть и как они связаны. «Заказ» в биллинге и «заказ» на складе - разные модели, а не разные названия одного;
  • язык - термины и их значения, одинаковые для разработчиков и предметных экспертов;
  • правила - какие инварианты действуют. То, что в одном контексте обязательно, в другом может быть неважно.

Поэтому «переименовать и договориться о словах» контекст не создаёт: если две команды используют один термин одинаково, но нуждаются в разных инвариантах, границы всё равно две.

По сути это область действия единого языка: пока не составлен словарь и не сказано, что «курс» значит вот это и только это, границу проводить не по чему. Как такой словарь собирается и поддерживается - в уроке Ubiquitous Language.

Что такое Bounded Context

Bounded Context (ограниченный контекст) - это явная граница, внутри которой доменная модель непротиворечива. Один и тот же термин в разных контекстах означает разные вещи и представлен разными структурами.

// Контекст Learning - курс как набор уроков
package learning

type Course struct {
    ID          CourseID
    Title       string
    Slug        CourseSlug
    Lessons     []Lesson
    Description string
}

// Контекст Billing - курс как продукт с ценой
package billing

type Course struct {
    ID        CourseID
    Name      string
    PriceRub  int
    IsActive  bool
    TrialDays int
}
<?php
declare(strict_types=1);

// Контекст Learning - курс как набор уроков
namespace App\Learning\Domain;

final class Course
{
    /** @param Lesson[] $lessons */
    public function __construct(
        public readonly CourseId $id,
        public readonly string $title,
        public readonly CourseSlug $slug,
        public readonly array $lessons,
        public readonly string $description,
    ) {}
}

// Контекст Billing - курс как продукт с ценой
namespace App\Billing\Domain;

final class Course
{
    public function __construct(
        public readonly CourseId $id,
        public readonly string $name,
        public readonly int $priceRub,
        public readonly bool $isActive,
        public readonly int $trialDays,
    ) {}
}
# Контекст Learning - курс как набор уроков
# app/learning/domain.py
from dataclasses import dataclass


@dataclass(frozen=True)
class Course:
    course_id: CourseId
    title: str
    slug: CourseSlug
    lessons: list[Lesson]
    description: str


# Контекст Billing - курс как продукт с ценой
# app/billing/domain.py
from dataclasses import dataclass


@dataclass(frozen=True)
class Course:
    course_id: CourseId
    name: str
    price_rub: int
    is_active: bool
    trial_days: int

Обрати внимание: оба контекста используют слово "Course", но внутри у них совершенно разные поля и поведение. Это не дублирование - это намеренное разделение ответственности.

Контексты BackendStart

На платформе BackendStart можно выделить четыре основных контекста:

КонтекстКлючевые понятияЗа что отвечает
LearningCourse, Lesson, Progress, QuizПрохождение уроков, оценка знаний
IdentityUser, Session, OAuthProviderРегистрация, аутентификация
ContentTrack, Markdown, Slug, TagХранение и валидация контента
AnalyticsEvent, PageView, MetricСбор статистики использования

В контексте Learning слово User - это "ученик с прогрессом". В контексте Identity тот же User - "учётная запись с email и OAuth-токенами". Разные модели, разные правила, разные пакеты.

Карта контекстов BackendStart: Learning, Identity, Content, Analytics. ACL между Learning и Identity, события связывают Content и Analytics

Примеры урока используют ещё один контекст - Billing (курс как продукт: цена, пробный период, оплата). На карте выше показаны только четыре основных; Billing подключается к соседям так же, через события или ACL, и в структуре пакетов ниже он лежит рядом с ними.

Структура пакетов в Go

Каждый Bounded Context живёт в своём пакете. Внутри пакета - слои по гексагональной архитектуре:

internal/
  learning/
    domain/       # Entity, VO, Aggregate, Repository interface
    app/          # Use-cases (Application Services)
    infra/        # GORM-репозиторий, HTTP-адаптеры
  identity/
    domain/
    app/
    infra/
  content/
    domain/
    app/
    infra/
  analytics/
    domain/
    app/
    infra/
  billing/
    domain/
    app/
    infra/

⚠️ Не смешивай контексты в одном пакете

Если learning/domain/ импортирует billing/domain/, граница нарушена. Контексты общаются только через явные интеграционные механизмы: события, API или ACL-адаптеры.

Context Map: отношения между контекстами

Контексты не существуют изолированно. Между ними есть отношения, и тип отношений определяет, как они интегрируются. Два слова, которые встречаются в описании любой пары: upstream («выше по течению») - контекст, который отдаёт данные или модель, и downstream («ниже по течению») - контекст, который их потребляет и зависит от изменений upstream.

Customer-Supplier (Заказчик-Поставщик)

Downstream (заказчик) зависит от upstream (поставщика), и поставщик учитывает потребности заказчика: согласует изменения API и не ломает контракт без предупреждения. Пример: Content (поставщик) предоставляет уроки для Learning (заказчик). Команда Content планирует API с учётом того, что нужно Learning.

Conformist (Конформист)

Downstream принимает модель upstream "как есть", без трансляции в свои термины и без влияния на неё. Пример: интеграция с внешним OAuth-провайдером - GitHub диктует формат токенов, и Identity подстраивается.

Separate Ways (Каждый сам по себе)

Контексты не интегрируются вовсе. Пример: Content и Identity - контенту не важно, кто пользователь, а учётным записям не важно, какие есть уроки.

Anti-Corruption Layer (Антикоррупционный слой)

Защитный адаптер, который переводит внешнюю модель в термины своего контекста. Это самый важный паттерн для защиты границ.

Anti-Corruption Layer на практике

Когда контекст Learning получает данные из Content, он не должен работать с чужими структурами напрямую. ACL переводит внешнюю модель во внутреннюю:

ACL переводит RawLesson из контекста Content в LessonMaterial контекста Learning - чужая модель не протекает внутрь

package learning

import (
    "context"
)

// Внутренняя модель контекста Learning
type LessonMaterial struct {
    LessonID    LessonID
    Title       string
    ContentHTML string
    HasQuiz     bool
}

// Порт: что нужно контексту Learning от внешнего мира
type ContentProvider interface {
    GetLessonMaterial(ctx context.Context, slug string) (LessonMaterial, error)
}
<?php
declare(strict_types=1);

namespace App\Learning\Domain;

// Внутренняя модель контекста Learning
final readonly class LessonMaterial
{
    public function __construct(
        public LessonId $lessonId,
        public string $title,
        public string $contentHtml,
        public bool $hasQuiz,
    ) {}
}

// Порт: что нужно контексту Learning от внешнего мира.
// final НЕ ставится - это интерфейс.
interface ContentProvider
{
    public function getLessonMaterial(string $slug): LessonMaterial;
}
# app/learning/domain.py
from dataclasses import dataclass
from typing import Protocol


# Внутренняя модель контекста Learning
@dataclass(frozen=True)
class LessonMaterial:
    lesson_id: LessonId
    title: str
    content_html: str
    has_quiz: bool


# Порт: что нужно контексту Learning от внешнего мира
class ContentProvider(Protocol):
    def get_lesson_material(self, slug: str) -> LessonMaterial: ...
package infra

import (
    "context"
    "fmt"

    "myapp/internal/content/contentclient"
    "myapp/internal/learning"
)

// ACL-адаптер: переводит модель Content → модель Learning
type ContentACLAdapter struct {
    contentAPI contentclient.Client
}

func (a *ContentACLAdapter) GetLessonMaterial(
    ctx context.Context, slug string,
) (learning.LessonMaterial, error) {
    // Получаем данные в формате контекста Content
    raw, err := a.contentAPI.FetchLesson(ctx, slug)
    if err != nil {
        return learning.LessonMaterial{}, fmt.Errorf("content api: %w", err)
    }

    // Переводим в термины контекста Learning
    return learning.LessonMaterial{
        LessonID:    learning.LessonID(raw.ID),
        Title:       raw.Title,
        ContentHTML: raw.RenderedBody,
        HasQuiz:     raw.QuizFileExists,
    }, nil
}
<?php
declare(strict_types=1);

namespace App\Learning\Infrastructure;

use App\Content\Api\ContentClient;
use App\Learning\Domain\ContentProvider;
use App\Learning\Domain\LessonId;
use App\Learning\Domain\LessonMaterial;

// ACL-адаптер: переводит модель Content -> модель Learning
final class ContentAclAdapter implements ContentProvider
{
    public function __construct(
        private readonly ContentClient $contentApi,
    ) {}

    public function getLessonMaterial(string $slug): LessonMaterial
    {
        // Получаем данные в формате контекста Content
        $raw = $this->contentApi->fetchLesson($slug);

        // Переводим в термины контекста Learning
        return new LessonMaterial(
            lessonId: new LessonId($raw->id),
            title: $raw->title,
            contentHtml: $raw->renderedBody,
            hasQuiz: $raw->quizFileExists,
        );
    }
}
# app/learning/infra/content_acl.py
from app.content.contentclient import ContentClient, ContentApiError
from app.learning.domain import LessonId, LessonMaterial


class ContentUnavailableError(Exception):
    """Ошибка контекста Learning: чужое исключение наружу не протекает."""


# ACL-адаптер: переводит модель Content -> модель Learning
class ContentACLAdapter:
    def __init__(self, content_api: ContentClient) -> None:
        self._content_api = content_api

    def get_lesson_material(self, slug: str) -> LessonMaterial:
        # Получаем данные в формате контекста Content
        try:
            raw = self._content_api.fetch_lesson(slug)
        except ContentApiError as e:
            raise ContentUnavailableError(f"content api: {e}") from e

        # Переводим в термины контекста Learning
        return LessonMaterial(
            lesson_id=LessonId(raw.id),
            title=raw.title,
            content_html=raw.rendered_body,
            has_quiz=raw.quiz_file_exists,
        )

Если формат данных в Content изменится, правки затронут только ACL-адаптер. Домен Learning останется нетронутым.

Интеграция между контекстами

Два основных способа связать контексты, не нарушая границ:

Через доменные события

Предпочтительный способ для асинхронных сценариев - через event-driven архитектуру. Learning публикует событие - Analytics его обрабатывает. Важная деталь: Analytics не импортирует доменный тип Learning. Событие описано в отдельном пакете контрактов - это «опубликованный язык», о котором договорились оба контекста:

// internal/contracts/events.go (пакет contracts) - опубликованный язык событий.
// Не домен Learning: это договор, который знают оба контекста.
type LessonCompletedV1 struct {
    UserID   int64
    LessonID string
    At       time.Time
}

// Learning переводит свой доменный факт в контракт и публикует
event := contracts.LessonCompletedV1{
    UserID:   userID,
    LessonID: lessonID,
    At:       time.Now(),
}
publisher.Publish(ctx, event)

// Analytics подписан на контракт, а не на learning.LessonCompleted,
// и переводит его в свою модель
func (h *AnalyticsHandler) OnLessonCompleted(e contracts.LessonCompletedV1) {
    h.metrics.RecordProgress(e.UserID, e.LessonID, e.At)
}
// App\Contracts\Events\LessonCompletedV1 - опубликованный язык событий.
// Не домен Learning: это договор, который знают оба контекста.
final readonly class LessonCompletedV1
{
    public function __construct(
        public int $userId,
        public string $lessonId,
        public DateTimeImmutable $at,
    ) {}
}

// Learning переводит свой доменный факт в контракт и публикует
$event = new LessonCompletedV1(
    userId: $userId,
    lessonId: $lessonId,
    at: new DateTimeImmutable(),
);
$publisher->publish($event);

// Analytics подписан на контракт, а не на доменный класс Learning,
// и переводит его в свою модель
final class AnalyticsHandler
{
    public function __construct(
        private readonly MetricsRecorder $metrics,
    ) {}

    public function onLessonCompleted(LessonCompletedV1 $e): void
    {
        $this->metrics->recordProgress($e->userId, $e->lessonId, $e->at);
    }
}
from dataclasses import dataclass
from datetime import datetime


# app/contracts/events.py - опубликованный язык событий.
# Не домен Learning: это договор, который знают оба контекста.
@dataclass(frozen=True)
class LessonCompletedV1:
    user_id: int
    lesson_id: str
    at: datetime


# Learning переводит свой доменный факт в контракт и публикует
event = LessonCompletedV1(
    user_id=user_id,
    lesson_id=lesson_id,
    at=datetime.now(),
)
publisher.publish(event)


# Analytics подписан на контракт, а не на доменный класс Learning,
# и переводит его в свою модель
class AnalyticsHandler:
    def __init__(self, metrics: MetricsRecorder) -> None:
        self._metrics = metrics

    def on_lesson_completed(self, e: LessonCompletedV1) -> None:
        self._metrics.record_progress(e.user_id, e.lesson_id, e.at)

Через синхронный API

Когда нужен немедленный ответ. Learning запрашивает данные у Identity через интерфейс:

// Интерфейс в контексте Learning
type UserInfoProvider interface {
    GetDisplayName(ctx context.Context, userID int64) (string, error)
}

// Реализация вызывает Identity-контекст
type IdentityAdapter struct {
    identitySvc identity.UserService
}

func (a *IdentityAdapter) GetDisplayName(
    ctx context.Context, userID int64,
) (string, error) {
    user, err := a.identitySvc.FindByID(ctx, userID)
    if err != nil {
        return "", err
    }
    return user.DisplayName, nil
}
<?php
declare(strict_types=1);

// Интерфейс в контексте Learning
namespace App\Learning\Domain;

interface UserInfoProvider
{
    public function getDisplayName(int $userId): string;
}

// Реализация вызывает Identity-контекст
namespace App\Learning\Infrastructure;

use App\Identity\Domain\UserService;
use App\Learning\Domain\UserInfoProvider;

final class IdentityAdapter implements UserInfoProvider
{
    public function __construct(
        private readonly UserService $identitySvc,
    ) {}

    public function getDisplayName(int $userId): string
    {
        $user = $this->identitySvc->findById($userId);
        return $user->displayName;
    }
}
# Интерфейс в контексте Learning
# app/learning/domain.py
from typing import Protocol


class UserInfoProvider(Protocol):
    def get_display_name(self, user_id: int) -> str: ...


# Реализация вызывает Identity-контекст
# app/learning/infra/identity_adapter.py
from app.identity.domain import UserService


class IdentityAdapter:
    def __init__(self, identity_svc: UserService) -> None:
        self._identity_svc = identity_svc

    def get_display_name(self, user_id: int) -> str:
        # Ошибку Identity (пользователь не найден) пробрасываем как есть -
        # как и в Go-версии, где err возвращается без обёртки
        user = self._identity_svc.find_by_id(user_id)
        return user.display_name

Монолит и Shared Kernel

Не каждый проект требует микросервисов. В монолите контексты живут в одном бинарнике, но в разных пакетах. Это даёт разделение без сетевых издержек. Компилятор защищает только неэкспортированные имена: internal/ не мешает пакету learning импортировать billing, ведь оба лежат в одном internal/. Поэтому запрет импорта между контекстами закрепляют линтером зависимостей (например, depguard в golangci-lint) или отдельными Go-модулями.

Shared Kernel - небольшой набор общих типов, которые используют несколько контекстов. Обычно это базовые Value Objects:

package shared

// time.Time уже общий тип стандартной библиотеки,
// оборачивать его в Shared Kernel незачем.
type UserID int64

ℹ️ Shared Kernel должен быть минимальным

Если в shared-пакете больше 5-10 типов - вероятно, контексты недостаточно разделены. Shared Kernel - это компромисс, а не архитектурная цель.

Для BackendStart монолит с пакетным разделением - оптимальный выбор. Один сервер, четыре контекста в разных пакетах, Shared Kernel с UserID. Микросервисы здесь не нужны - команда маленькая, трафик умеренный.

Как один такой контекст выглядит изнутри - со своим словарём, объектами-значениями, агрегатом, репозиториями и ACL-адаптером к соседнему контексту Identity - собрано в мини-проекте трека.

Мини-задание

  • Выдели 3-4 Bounded Context в своём проекте и запиши ключевые сущности каждого
  • Найди слово, которое означает разное в двух контекстах (аналог "Course")
  • Определи тип отношений между контекстами (Customer-Supplier, Conformist и т.д.)
  • Напиши интерфейс Anti-Corruption Layer для одной интеграции между контекстами

Зарегистрируйтесь бесплатно, чтобы пройти квиз, вести прогресс.