Observer: события и подписчики (внутри приложения)

Когда одно событие должно запустить пять реакций, проще всего написать всё в одну функцию - и пожалеть через месяц. Observer аккуратно разводит источник и подписчиков.

Проблема

Пользователь прошёл урок. Нужно:

  1. Записать прогресс в БД
  2. Отправить email
  3. Обновить ачивки
  4. Отправить событие в аналитику

Если всё это засунуть в один use-case:

func (s *LessonService) Complete(userID, lessonID int64) error {
    s.repo.MarkCompleted(userID, lessonID)
    s.mailer.SendCongrats(userID)
    s.achievements.Check(userID)
    s.analytics.Track("lesson_completed", userID)
    // ...ещё 3 действия через месяц
    return nil
}
<?php
declare(strict_types=1);

final class LessonService
{
    public function __construct(
        private readonly LessonRepository $repo,
        private readonly Mailer $mailer,
        private readonly AchievementsService $achievements,
        private readonly AnalyticsTracker $analytics,
    ) {}

    public function complete(int $userId, int $lessonId): void
    {
        $this->repo->markCompleted($userId, $lessonId);
        $this->mailer->sendCongrats($userId);
        $this->achievements->check($userId);
        $this->analytics->track('lesson_completed', $userId);
        // ...ещё 3 действия через месяц
    }
}
class LessonService:
    def __init__(
        self,
        repo: LessonRepository,
        mailer: Mailer,
        achievements: AchievementsService,
        analytics: AnalyticsTracker,
    ) -> None:
        self._repo = repo
        self._mailer = mailer
        self._achievements = achievements
        self._analytics = analytics

    def complete(self, user_id: int, lesson_id: int) -> None:
        self._repo.mark_completed(user_id, lesson_id)
        self._mailer.send_congrats(user_id)
        self._achievements.check(user_id)
        self._analytics.track("lesson_completed", user_id)
        # ...ещё 3 действия через месяц

Проблемы: use-case знает обо всех зависимостях (нарушение SRP). Добавление нового действия - правка Complete() (нарушение OCP). Тестирование - мок 5 сервисов. Один упавший обработчик валит весь вызов.

Решение: Observer

Observer - подписка на события. Издатель (publisher) публикует событие. Подписчики (subscribers) реагируют на него. Издатель не знает, кто и сколько подписчиков.

sequenceDiagram
    autonumber
    participant P as Publisher<br/>(OrderService)
    participant B as EventBus
    participant S1 as Subscriber 1<br/>(Mailer)
    participant S2 as Subscriber 2<br/>(Analytics)
    participant S3 as Subscriber 3<br/>(Inventory)

    Note over P,S3: подписка происходит при старте приложения
    S1->>B: Subscribe("order.created")
    S2->>B: Subscribe("order.created")
    S3->>B: Subscribe("order.created")

    Note over P,S3: позже, в runtime
    P->>B: Publish("order.created", payload)
    B->>S1: notify(payload)
    B->>S2: notify(payload)
    B->>S3: notify(payload)
    Note right of B: Publisher не знает,<br/>кто и сколько слушает

Шина событий

Шину обычно держат одну на всё приложение, и Subscribe с Publish могут вызываться из разных потоков одновременно. Поэтому список подписчиков защищают замком. В Go это обязательно: одновременная запись в map из разных горутин роняет программу целиком. sync.RWMutex пускает много публикаций параллельно (RLock), а подписку - по одной (Lock); подробнее о мьютексах - в уроке Пакет sync.

type Event any

type Handler func(Event)

type EventBus struct {
    subs map[string][]Handler
    mu   sync.RWMutex
}

func NewEventBus() *EventBus {
    return &EventBus{subs: map[string][]Handler{}}
}

func (b *EventBus) Subscribe(event string, h Handler) {
    b.mu.Lock()
    defer b.mu.Unlock()
    b.subs[event] = append(b.subs[event], h)
}

func (b *EventBus) Publish(event string, data Event) {
    // Копируем список под замком, а обработчики вызываем уже без него:
    // иначе обработчик, который подписывается или публикует, повесит шину
    b.mu.RLock()
    handlers := append([]Handler(nil), b.subs[event]...)
    b.mu.RUnlock()
    for _, h := range handlers {
        h(data)
    }
}

Теперь use-case публикует событие, а не вызывает всех руками:

type LessonCompleted struct {
    UserID   int64
    LessonID int64
}

func (s *LessonService) Complete(userID, lessonID int64) error {
    if err := s.repo.MarkCompleted(userID, lessonID); err != nil {
        return err
    }
    s.bus.Publish("lesson.completed", LessonCompleted{
        UserID: userID, LessonID: lessonID,
    })
    return nil
}

Подписчики регистрируются при старте приложения:

bus.Subscribe("lesson.completed", func(e Event) {
    evt := e.(LessonCompleted)
    mailer.SendCongrats(evt.UserID)
})

bus.Subscribe("lesson.completed", func(e Event) {
    evt := e.(LessonCompleted)
    achievements.Check(evt.UserID)
})
final class EventBus
{
    /** @var array<string, list<callable>> */
    private array $subs = [];

    public function subscribe(string $event, callable $handler): void
    {
        $this->subs[$event][] = $handler;
    }

    public function publish(string $event, mixed $data): void
    {
        foreach ($this->subs[$event] ?? [] as $handler) {
            $handler($data);
        }
    }
}

Use-case публикует событие, а не вызывает всех руками:

final class LessonCompleted
{
    public function __construct(
        public readonly int $userId,
        public readonly int $lessonId,
    ) {}
}

final class LessonService
{
    public function __construct(
        private readonly LessonRepository $repo,
        private readonly EventBus $bus,
    ) {}

    public function complete(int $userId, int $lessonId): void
    {
        $this->repo->markCompleted($userId, $lessonId);
        $this->bus->publish('lesson.completed', new LessonCompleted($userId, $lessonId));
    }
}

Подписчики регистрируются при старте приложения:

$bus->subscribe('lesson.completed', function (LessonCompleted $e) use ($mailer) {
    $mailer->sendCongrats($e->userId);
});

$bus->subscribe('lesson.completed', function (LessonCompleted $e) use ($achievements) {
    $achievements->check($e->userId);
});
import threading
from collections import defaultdict
from dataclasses import dataclass
from typing import Any, Callable

Event = Any
Handler = Callable[[Event], None]


class EventBus:
    def __init__(self) -> None:
        self._subs: dict[str, list[Handler]] = defaultdict(list)
        self._lock = threading.Lock()  # аналог sync.RWMutex, если шина общая для потоков

    def subscribe(self, event: str, handler: Handler) -> None:
        with self._lock:
            self._subs[event].append(handler)

    def publish(self, event: str, data: Event) -> None:
        with self._lock:
            handlers = list(self._subs[event])
        for handler in handlers:
            handler(data)

Use-case публикует событие, а не вызывает всех руками:

@dataclass(frozen=True, slots=True)
class LessonCompleted:
    user_id: int
    lesson_id: int


class LessonService:
    def __init__(self, repo: LessonRepository, bus: EventBus) -> None:
        self._repo = repo
        self._bus = bus

    def complete(self, user_id: int, lesson_id: int) -> None:
        self._repo.mark_completed(user_id, lesson_id)
        self._bus.publish("lesson.completed", LessonCompleted(user_id, lesson_id))

Подписчики регистрируются при старте приложения:

bus.subscribe("lesson.completed", lambda e: mailer.send_congrats(e.user_id))
bus.subscribe("lesson.completed", lambda e: achievements.check(e.user_id))

Готовой шины в stdlib нет, но в Django ту же роль играют signals (post_save.connect(handler)), а в asyncio-приложениях шину делают поверх asyncio.Queue.

ℹ️ Развязка зависимостей

Use-case зависит только от EventBus, а не от 5 сервисов. Добавить нового подписчика - одна строка при регистрации, use-case не трогаем.

Observer vs Pub/Sub: в чём разница

Observer (GoF)Pub/Sub
Внутри одного процессаМежду процессами/сервисами
Синхронный (обычно)Асинхронный (брокер сообщений)
Прямая подписка на объектПодписка через канал/топик
Простая реализацияRabbitMQ, Kafka, NATS

Observer - это «маленький Pub/Sub» внутри приложения. Если обработчики тяжёлые (HTTP-вызовы, запись в БД), стоит перейти к полноценной очереди.

Observer с channels в Go

В Go события можно реализовать через каналы - это Go-специфичная конструкция, в PHP роль канала с буфером играет внешняя очередь (Redis/RabbitMQ через Symfony Messenger):

type LessonEvent struct {
    UserID   int64
    LessonID int64
}

func StartWorker(ch <-chan LessonEvent) {
    for evt := range ch {
        log.Printf("lesson %d completed by user %d", evt.LessonID, evt.UserID)
    }
}

// Публикация
ch := make(chan LessonEvent, 100)
go StartWorker(ch)

ch <- LessonEvent{UserID: 1, LessonID: 42}

Канал - встроенный примитив Go для передачи данных между горутинами. Его удобно использовать как основу для событий, но «Observer из коробки» он не даёт.

⚠️ Канал - это доставка одному, а Observer - рассылка всем

Разница ровно в этом, и она проявляется на первом же втором подписчике:

один канал, два читателя:

    ch := make(chan Event)
    go subscriberA(ch)   ← получит примерно половину событий
    go subscriberB(ch)   ← и вторую половину

Две горутины, читающие один канал, конкурируют за сообщения: каждое уйдёт кому-то одному. Observer подразумевает обратное - событие получают все подписчики.

Чтобы получить рассылку, fan-out делают руками: свой канал каждому подписчику и цикл, который копирует событие во все.

рассылка всем - это отдельный код:

    Publish(event):
        для каждого подписчика:      ← у каждого свой канал
            отправить event в его канал

И тут же появляются вопросы, которых у Observer с прямыми вызовами нет: что делать, если один подписчик медленный (буфер? отбрасывать?), как его отписать, что случится при закрытии канала. Канал - хороший строительный блок для асинхронной шины, но шину всё равно пишут.

EventBus (map + callbacks)Channels
Событие получают все подписчикиКаждое сообщение уходит одному читателю; рассылка - только через ручной fan-out
Синхронный вызовМожно асинхронно (буферизация)
Проще для простых случаевЛучше для concurrency
Нет backpressureБуфер = встроенный backpressure

Обработка ошибок в Observer

Что делать, если один подписчик упал? Варианты:

// Вариант 1: логировать и продолжать (обычно лучший выбор)
func (b *EventBus) Publish(event string, data Event) {
    b.mu.RLock()
    handlers := append([]Handler(nil), b.subs[event]...)
    b.mu.RUnlock()
    for _, h := range handlers {
        func() {
            defer func() {
                if r := recover(); r != nil {
                    log.Printf("handler panic: %v", r)
                }
            }()
            h(data)
        }()
    }
}

// Вариант 2: критические обработчики - в use-case, некритические - через bus
<?php
declare(strict_types=1);

final class EventBus
{
    /** @var array<string, list<callable>> */
    private array $subs = [];

    public function __construct(
        private readonly LoggerInterface $logger,
    ) {}

    public function subscribe(string $event, callable $handler): void
    {
        $this->subs[$event][] = $handler;
    }

    // Вариант 1: логировать и продолжать (обычно лучший выбор)
    public function publish(string $event, mixed $data): void
    {
        foreach ($this->subs[$event] ?? [] as $handler) {
            try {
                $handler($data);
            } catch (Throwable $e) {
                $this->logger->error('handler failed', [
                    'event' => $event,
                    'err'   => $e->getMessage(),
                ]);
            }
        }
    }
}

// Вариант 2: критические обработчики - в use-case, некритические - через bus
import logging

logger = logging.getLogger(__name__)


class EventBus:
    # ...subscribe как выше

    # Вариант 1: логировать и продолжать (обычно лучший выбор)
    def publish(self, event: str, data: Event) -> None:
        for handler in self._subs.get(event, []):
            try:
                handler(data)
            except Exception:
                logger.exception("handler failed", extra={"event": event})


# Вариант 2: критические обработчики - в use-case, некритические - через bus

⚠️ Синхронно vs асинхронно

Observer внутри процесса обычно синхронный - подписчики выполняются в том же потоке. Если обработчик может «зависнуть» (HTTP-вызов, тяжёлая БД) - запускай его в горутине или используй очередь.

Когда НЕ использовать

Один подписчик - если на событие реагирует одна функция, проще вызвать её напрямую. Observer оправдан при 2+ подписчиках.

Критическая последовательность - если порядок обработчиков важен (сначала записать в БД, потом отправить email), Observer плохо подходит - порядок зависит от того, в какой последовательности подписчиков зарегистрировали при старте, и легко ломается при переносе строк; надёжнее вызвать шаги явно в use-case.

Отладка - событийная модель сложнее отлаживать. Стек вызовов не покажет, кто подписан. Используй хорошее логирование.

Связь с другими паттернами

Observer + Command - подписчик получает команду и выполняет её
Observer + Mediator - Mediator координирует объекты, Observer - уведомляет
Observer + Factory - фабрика создаёт подписчиков при регистрации

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

  • Реализуй EventBus и подпиши 2 обработчика на событие user.registered
  • Добавь обработку паники в Publish - чтобы один упавший подписчик не валил остальных
  • Попробуй channels: сначала один канал и 3 горутины (убедись, что каждое событие получает одна), затем fan-out - свой канал каждой горутине
  • Подумай: какие события в твоём проекте стоит вынести из use-case в подписчики?

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