Observer: события и подписчики (внутри приложения)
Когда одно событие должно запустить пять реакций, проще всего написать всё в одну функцию - и пожалеть через месяц. Observer аккуратно разводит источник и подписчиков.
Проблема
Пользователь прошёл урок. Нужно:
- Записать прогресс в БД
- Отправить email
- Обновить ачивки
- Отправить событие в аналитику
Если всё это засунуть в один 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 в подписчики?