GoF паттерны: как не выучить 23 штуки зря

GoF паттерны: как не выучить 23 штуки зря

В 1994 году четыре автора - Erich Gamma, Richard Helm, Ralph Johnson и John Vlissides - выпустили книгу «Design Patterns: Elements of Reusable Object-Oriented Software». Их прозвали Gang of Four (GoF), а книга стала классикой разработки.

В книге 23 паттерна. Но начинающему разработчику не нужно учить все - достаточно 6-8, которые встречаются в реальных проектах каждый день.

Три категории паттернов

GoF разделили паттерны на три группы. На каждой схеме насыщенные точки - паттерны, которые встретятся в курсе (отдельным уроком или коротко по ходу); полупрозрачные - упомянуты для полноты картины.

Порождающие паттерны GoF

Отвечают за то, как создаются объекты: скрывают конструкторы за фабриками, гарантируют единственность экземпляра, собирают сложные объекты пошагово.

Когда применять: конструктор разрастается, в коде много if/switch по типу при создании, нужно подменять реализации в зависимости от конфига или окружения.

Отдельным уроком разберём Factory Method. Singleton коротко встретится ниже, в разделе про sync.Once, а Builder - только упоминанием. С фабрики удобно начинать: она нужна ровно тогда, когда в коде вырастает switch по типу создаваемого объекта.

Структурные паттерны GoF

Описывают, как объекты собираются в большие структуры: оборачивают, скрывают за фасадом, подменяют прокси - всё ради того, чтобы не трогать остальной код при расширении.

Когда применять: чужой SDK с неудобным интерфейсом, нужно навесить кэш/логи вокруг сервиса, клиент дёргает 5 методов вместо одного.

Разберём Adapter, Decorator и Facade; Proxy упомянем при сравнении с Decorator.

Поведенческие паттерны GoF

Регулируют, как объекты передают друг другу сообщения и распределяют обязанности: команды, события, стратегии, цепочки обработчиков.

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

Разберём Command, Observer и Strategy. Действие нужно поставить в очередь, залогировать или откатить - это Command. А когда на один факт независимо реагируют несколько подписчиков и они не должны знать друг о друге - это Observer.

Из 23 мы подробно возьмём 7 (по уроку на каждый) - те, которые чаще всего встречаются в Go-проектах и бэкенд-разработке.

Паттерн - это словарное слово

Главная ценность паттерна - общий язык. Когда ты говоришь коллеге «тут нужен адаптер», он сразу понимает идею. Не нужно рисовать диаграммы и объяснять полчаса.

Паттерн как словарное слово: длинное описание заменяется одним термином

ℹ️ Паттерн ≠ обязанность

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

Как понять, что паттерн нужен

Паттерн не применяют «на всякий случай». Есть конкретные сигналы - слева запах в коде, справа паттерн, которым его обычно лечат:

Сигналы в коде и соответствующие паттерны GoF

Паттерны в Go и PHP: без классов, но с интерфейсами

В языках с глубокими иерархиями классов паттерны традиционно реализуются через наследование и абстрактные классы. В Go наследования нет - вместо него композиция и интерфейсы. В PHP интерфейсы тоже есть, и идиоматический код современного PHP давно ушёл от глубоких иерархий к композиции.

// Интерфейс + структура - проще и гибче, чем абстрактный класс
type Logger interface {
    Log(msg string)
}

type ConsoleLogger struct{}
func (ConsoleLogger) Log(msg string) { fmt.Println(msg) }

type FileLogger struct{ path string }
func (l FileLogger) Log(msg string) {
    // Дописываем в конец файла, как FILE_APPEND в PHP-версии
    f, err := os.OpenFile(l.path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        return // в учебном примере просто выходим; в реальном коде ошибку стоит вернуть или залогировать
    }
    defer f.Close()
    fmt.Fprintln(f, msg)
}

В Go интерфейс реализуется неявно - не нужно писать implements. Если структура имеет нужные методы - она уже реализует интерфейс. Это делает паттерны легковеснее.

interface Logger
{
    public function log(string $msg): void;
}

final class ConsoleLogger implements Logger
{
    public function log(string $msg): void
    {
        echo $msg, PHP_EOL;
    }
}

final class FileLogger implements Logger
{
    public function __construct(
        private readonly string $path,
    ) {}

    public function log(string $msg): void
    {
        file_put_contents($this->path, $msg . "\n", FILE_APPEND);
    }
}

В PHP интерфейс реализуется явно через implements - компилятор контролирует контракт. В отличие от Go, где интерфейсы неявные (тип удовлетворяет интерфейсу автоматически, если у него есть нужные методы) - в PHP контракт декларируется в сигнатуре класса. Для большинства паттернов хватает интерфейса + final-классов + DI через конструктор. Symfony и Laravel опираются на эту модель.

from typing import Protocol


# Протокол + класс - проще и гибче, чем абстрактный класс
class Logger(Protocol):
    def log(self, msg: str) -> None: ...


class ConsoleLogger:
    def log(self, msg: str) -> None:
        print(msg)


class FileLogger:
    def __init__(self, path: str) -> None:
        self._path = path

    def log(self, msg: str) -> None:
        with open(self._path, "a", encoding="utf-8") as f:
            f.write(msg + "\n")

Контракт здесь - Protocol из typing: структурная типизация, как в Go. Класс не пишет implements, достаточно иметь метод log() с нужной сигнатурой; проверяет это не интерпретатор, а статический анализатор (mypy, pyright). Нужен явный контракт с проверкой при создании экземпляра - берут abc.ABC и @abstractmethod.

Композиция вместо наследования: главный мета-принцип GoF

Сама книга GoF выводит два базовых правила объектно-ориентированного дизайна, на которых стоят все 23 паттерна:

  1. «Program to an interface, not an implementation» - программируй к контракту, а не к конкретной реализации.
  2. «Favor object composition over class inheritance» - предпочитай композицию объектов наследованию классов.

Вторая идея - фундамент. Большинство «структурных» и «поведенческих» паттернов (Strategy, Decorator, Adapter, Bridge, Composite, Command, State) - это конкретные способы заменить наследование композицией.

Проблема глубоких иерархий

Классический путь в ад на любом ООП-языке:

Глубокая иерархия классов: новой роли некуда упасть

Иерархия зафиксирована на этапе компиляции. Появилась новая роль («читатель + редактор», «премиум + временный») - её некуда положить. Конкретный класс может быть только в одной точке дерева.

Композиция:

type User struct {
    Email        string
    Subscription Subscription // Free / Premium
    Roles        []Role       // [Reader, Editor, Admin]
}

// «Премиум-админ» - это просто значение
u := User{
    Email:        "a@b.c",
    Subscription: Premium{},
    Roles:        []Role{Admin{}},
}
<?php
declare(strict_types=1);

final readonly class User
{
    /** @param list<Role> $roles */
    public function __construct(
        public string $email,
        public Subscription $subscription, // Free / Premium
        public array $roles,               // [Reader, Editor, Admin]
    ) {}
}

// «Премиум-админ» - это просто значение
$user = new User('a@b.c', new Premium(), [new Admin()]);
from dataclasses import dataclass


@dataclass(frozen=True)
class User:
    email: str
    subscription: Subscription  # Free / Premium
    roles: list[Role]           # [Reader, Editor, Admin]


# «Премиум-админ» - это просто значение
user = User(email="a@b.c", subscription=Premium(), roles=[Admin()])

«Премиум-админ» - это любая комбинация полей. Никаких новых классов.

Пять причин предпочитать композицию

1. Liskov Substitution Principle (LSP) - подкласс обязан быть совместимой заменой родителя. Это требование жёсткое: подкласс не может расширять тип возврата (сузить до подтипа можно), сужать типы параметров, расширять список выбрасываемых исключений, нарушать постусловия родителя. На практике сохранять LSP по всему дереву - ад. Композиция требований не предъявляет.

2. Fragile Base Class - изменение в родителе ломает наследников. Добавил поле, переименовал protected-метод, поменял внутренний вызов - и пятеро потомков в проде сломались. У композиции «родителя» нет: класс пользуется зависимостью только через её публичный контракт.

3. Hidden coupling - наследник связан с родителем неявно через protected-API, перекрытие методов, порядок вызовов. Это «скрытая связь», которая не видна по сигнатурам. Композиция делает связь явной: зависимость в конструкторе видна каждому.

4. Отсутствие множественного наследования. PHP не поддерживает extends A, B. Нужно поведение из двух источников - есть только композиция (или trait как обходной механизм, но без полноценной типизации). В Go вообще нет наследования классов - только композиция.

5. Open/Closed Principle (OCP). При композиции расширить поведение можно, не трогая существующий класс: подменил зависимость на новую реализацию интерфейса - и готово. При наследовании ради расширения часто нужно править родителя (protected-крючки, hook-методы) - это нарушает OCP.

Когда наследование всё-таки уместно

Не «никогда», а «по делу»:

  • Шаблонный метод (abstract + final методы) - родитель фиксирует скелет алгоритма, наследник заполняет шаги. Если шагов мало и API стабильно - окей.
  • Истинное is-a - class Square extends Shape валидно: квадрат является фигурой, заменяет её везде, LSP не нарушается.
  • Расширение чужого фреймворка, который ждёт именно extends BaseController - здесь альтернативы часто нет.

Сигналы, что наследование не к месту:

  • Глубина иерархии 3+ уровня
  • Наследник переопределяет половину родительских методов
  • В наследниках встречаются if ($this instanceof X) или throw new \LogicException('not supported')
  • Хочется унаследоваться сразу от двух баз

Композиция как реализация паттернов

Большинство паттернов из этого трека - это композиция в чистом виде:

ПаттернЧто внутри - наследование или композиция?
Strategyкомпозиция: контекст хранит ссылку на Strategy
Decoratorкомпозиция: декоратор оборачивает Component через поле
Adapterкомпозиция (Object Adapter): адаптер хранит адаптируемое
Commandкомпозиция: Invoker держит Command, Command - Receiver
Observerкомпозиция: Subject хранит список Observer'ов
Bridgeкомпозиция: Abstraction делегирует Implementor'у
Compositeкомпозиция: Composite хранит детей того же типа

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

ℹ️ Связка с SOLID

«Favor composition over inheritance» работает в паре с Dependency Inversion из SOLID: класс зависит от абстракции (интерфейса) и получает её через конструктор. Эта пара - composition + DI - фундамент Clean Architecture и Hexagonal Architecture.

Паттерны GoF в stdlib и фреймворках

Авторы Go встроили классические паттерны в стандартную библиотеку - обычно так глубоко, что их не замечают. В PHP-мире та же роль у PSR-стандартов и Symfony. Когда узнаёшь - понимаешь, что уже пользуешься ими каждый день.

Потоки чтения - подменяемый источник (не Strategy)

type Reader interface { Read(p []byte) (n int, err error) }
type Writer interface { Write(p []byte) (n int, err error) }

// Один и тот же json.Decoder работает с любым источником данных
json.NewDecoder(os.Stdin).Decode(&v)              // из stdin
json.NewDecoder(file).Decode(&v)                  // из файла
json.NewDecoder(resp.Body).Decode(&v)             // из HTTP-ответа (resp, err := http.Get(url))
json.NewDecoder(strings.NewReader(s)).Decode(&v)  // из строки
<?php
declare(strict_types=1);

use Psr\Http\Message\StreamInterface;

// PSR-7 StreamInterface - тот же приём: один интерфейс над разными источниками
function decode(StreamInterface $stream): array
{
    /** @var array<string, mixed> $data */
    $data = json_decode((string) $stream, associative: true, flags: JSON_THROW_ON_ERROR);

    return $data;
}

decode($psrRequest->getBody());          // из HTTP-запроса
decode(Utils::streamFor($fileResource)); // из файлового ресурса
decode(Utils::streamFor($jsonString));   // из строки
import io
import json
import sys
import urllib.request
from typing import Protocol


class Reader(Protocol):
    def read(self, size: int = -1) -> str: ...


# Один и тот же json.load работает с любым объектом, у которого есть .read()
v = json.load(sys.stdin)                        # из stdin
v = json.load(file)                             # из файла
v = json.load(urllib.request.urlopen(url))      # из HTTP-ответа
v = json.load(io.StringIO(s))                   # из строки

Любая функция, принимающая io.Reader (Go) или StreamInterface (PHP/PSR-7), работает с любым источником: файлом, HTTP-телом, сетевым сокетом, gzip-потоком, in-memory буфером. Алгоритм декодирования не знает, что у него за источник - это та же идея подменяемости, что в Strategy, только подменяется здесь источник данных, а не способ их обработки (в чём разница).

HTTP Handler - Adapter

type Handler interface { ServeHTTP(w ResponseWriter, r *Request) }

// HandlerFunc - адаптер, превращающий обычную функцию в Handler
type HandlerFunc func(ResponseWriter, *Request)
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) { f(w, r) }

http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("hello"))
})
// HandleFunc внутри делает: handler := HandlerFunc(f); router.Register(handler)
<?php
declare(strict_types=1);

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;

// PSR-15 RequestHandlerInterface - интерфейс с одним методом handle()
// Адаптер превращает обычное замыкание в RequestHandlerInterface
final class CallableHandler implements RequestHandlerInterface
{
    /** @param callable(ServerRequestInterface): ResponseInterface $fn */
    public function __construct(
        private $fn,
    ) {}

    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        return ($this->fn)($request);
    }
}

$router->add('/hello', new CallableHandler(
    fn (ServerRequestInterface $r) => $responses->text('hello'),
));
from typing import Callable, Protocol

Request = dict[str, str]
Response = bytes


class Handler(Protocol):
    def serve_http(self, req: Request) -> Response: ...


class HandlerFunc:
    """Адаптер, превращающий обычную функцию в Handler."""

    def __init__(self, fn: Callable[[Request], Response]) -> None:
        self._fn = fn

    def serve_http(self, req: Request) -> Response:
        return self._fn(req)


def hello(req: Request) -> Response:
    return b"hello"


router.register("/hello", HandlerFunc(hello))
# Тот же приём в WSGI: сервер ждёт вызываемый объект app(environ, start_response),
# а класс с __call__ адаптирует под него что угодно. В Flask/FastAPI
# декоратор @app.get("/hello") точно так же заворачивает функцию в объект маршрута.

Сервер ждёт интерфейс с одним методом, а у тебя обычная функция той же сигнатуры - обёртка соединяет их. В Go это http.HandlerFunc, в PHP - invokable-класс или адаптер вроде показанного выше.

Middleware-цепочки - Decorator

func logging(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        slog.Info("req", "path", r.URL.Path, "took", time.Since(start))
    })
}

handler = recovery(logging(auth(myHandler)))
<?php
declare(strict_types=1);

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Psr\Log\LoggerInterface;

final class LoggingMiddleware implements MiddlewareInterface
{
    public function __construct(
        private readonly LoggerInterface $logger,
    ) {}

    public function process(
        ServerRequestInterface $request,
        RequestHandlerInterface $handler,
    ): ResponseInterface {
        $t = microtime(true);
        try {
            return $handler->handle($request);
        } finally {
            $ms = (int) ((microtime(true) - $t) * 1000);
            $this->logger->info(sprintf('%s %d ms', $request->getUri(), $ms));
        }
    }
}

// Стек = recovery + logging + auth + handler
$pipeline = new Pipeline([$recovery, $logging, $auth], $myHandler);
import logging
import time
from typing import Callable

Handler = Callable[[Request], Response]
logger = logging.getLogger(__name__)


# Имя log_requests, а не logging - чтобы не перекрыть stdlib-модуль
def log_requests(next_handler: Handler) -> Handler:
    def wrapper(req: Request) -> Response:
        start = time.perf_counter()
        resp = next_handler(req)
        logger.info("req", extra={"path": req["PATH_INFO"], "took": time.perf_counter() - start})
        return resp

    return wrapper


handler = recovery(log_requests(auth(my_handler)))
# В Django то же самое: каждый элемент MIDDLEWARE получает get_response и оборачивает его

Каждое middleware «оборачивает» handler, добавляя поведение (логирование, recovery, auth) без изменения внутреннего обработчика - это классический Decorator.

Ленивая инициализация - Singleton без боли

var (
    once sync.Once
    db   *sql.DB
)

var dbErr error

func GetDB() (*sql.DB, error) {
    once.Do(func() {
        // Ошибку храним рядом: once.Do не повторит попытку, и её нельзя терять
        db, dbErr = sql.Open("postgres", os.Getenv("DATABASE_URL"))
    })
    return db, dbErr
}
<?php
declare(strict_types=1);

// В Symfony DI-контейнер сам делает сервис лениво-singleton-ом.
// Без контейнера - простой кэш на статическом поле фабрики.
final class DbFactory
{
    private static ?PDO $db = null;

    public static function get(): PDO
    {
        return self::$db ??= new PDO(getenv('DATABASE_URL'));
    }
}

$pdo = DbFactory::get();
import os
import threading

import psycopg

_lock = threading.Lock()
_db: psycopg.Connection | None = None


def get_db() -> psycopg.Connection:
    global _db
    # Аналог sync.Once: замок + проверка. В однопоточном коде хватит functools.cache
    with _lock:
        if _db is None:
            _db = psycopg.connect(os.environ["DATABASE_URL"])
    return _db

Singleton как «глобальная переменная с приватным конструктором» - классический boilerplate из языков без встроенных DI-контейнеров. В Go вместо паттерна - стандартный примитив sync.Once: thread-safe, ленивый, без двойной проверки. В PHP - контейнер из Symfony/Laravel, который сам управляет жизненным циклом сервисов. В большинстве случаев передача зависимости через параметр конструктора лучше Singleton-а - но если уж нужен - sync.Once или DI-контейнер.

Сортировка - Strategy + Template Method

type Interface interface {
    Len() int
    Less(i, j int) bool
    Swap(i, j int)
}
func Sort(data Interface)        // алгоритм фиксирован, шаги переопределяются
<?php
declare(strict_types=1);

// usort - алгоритм сортировки фиксирован, стратегия сравнения передаётся колбэком
$users = [/* ... */];

usort($users, static fn (User $a, User $b): int => $a->createdAt <=> $b->createdAt);
# sorted / list.sort - алгоритм (Timsort) фиксирован,
# стратегия сравнения передаётся через key
users = [...]

users.sort(key=lambda u: u.created_at)

Алгоритм сортировки (pdqsort в Go, в PHP - гибрид quicksort и сортировки вставками, стабильный с 8.0) фиксирован - это Template Method. А реализация сравнения - твоя «стратегия». С Go 1.21 появился slices.SortFunc - более удобная generic-альтернатива, но идея та же.

Другие явные паттерны в stdlib

stdlibПаттернЧто делает
bufio.NewReader(r)Decoratorоборачивает Reader буферизацией
io.MultiWriter(a, b)Compositeнесколько Writer как один
errors.Is / errors.AsIteratorобход цепочки wrapped errors

context.Context и text/template часто записывают в паттерны по созвучию, но это не GoF. context не передаёт запрос по цепочке обработчиков, как Chain of Responsibility, а просто несёт отмену, дедлайн и значения вниз по вызовам. template.Template - шаблонизатор (разбирает шаблон и исполняет его), а не Template Method с переопределяемыми шагами.

Когда паттерны вредят

Паттерны - инструмент, а не цель. Вот типичные ошибки:

Overengineering - фабрика для одного типа, декоратор для одного слоя, Observer с одним подписчиком. Если сценарий не растёт - паттерн лишний.

Pattern-driven development - когда разработчик выбирает паттерн, а потом подгоняет задачу под него. Правильный порядок обратный: задача → проблема → паттерн.

Преждевременная абстракция - два одинаковых if в коде ещё не повод для Strategy. Дождись третьего случая: «Rule of Three» работает и здесь.

⚠️ Антипаттерн: Golden Hammer

Когда у тебя есть молоток, всё кажется гвоздём. Если ты только выучил Factory - не надо оборачивать каждое создание объекта в фабрику. Применяй паттерн когда он решает конкретную проблему.

Антипаттерн «Factory factory»

Классический симптом перебора, который иногда тянут в Go и PHP: фабрика, которая создаёт фабрику, которая создаёт объект.

// Over-engineering
type ServiceFactoryFactory interface {
    NewServiceFactory(env string) ServiceFactory
}
type ServiceFactory interface {
    NewService(cfg Config) Service
}
type Service interface {
    Do(ctx context.Context, req Req) (Resp, error)
}

// Чтобы получить Service:
ff := NewProdFactoryFactory()
f  := ff.NewServiceFactory("prod")
s  := f.NewService(cfg)
<?php
declare(strict_types=1);

// Over-engineering
interface ServiceFactoryFactory
{
    public function newServiceFactory(string $env): ServiceFactory;
}

interface ServiceFactory
{
    public function newService(Config $cfg): Service;
}

interface Service
{
    public function do(Request $req): Response;
}

// Чтобы получить Service:
$ff = new ProdFactoryFactory();
$f  = $ff->newServiceFactory('prod');
$s  = $f->newService($cfg);
from __future__ import annotations

from typing import Protocol


# Over-engineering
class ServiceFactoryFactory(Protocol):
    def new_service_factory(self, env: str) -> ServiceFactory: ...


class ServiceFactory(Protocol):
    def new_service(self, cfg: Config) -> Service: ...


class Service(Protocol):
    def do(self, req: Req) -> Resp: ...


# Чтобы получить Service:
ff = ProdFactoryFactory()
f = ff.new_service_factory("prod")
s = f.new_service(cfg)
// В Go обычно достаточно конструктора-функции
func NewService(cfg Config) (*Service, error) {
    return &Service{cfg: cfg}, nil
}
s, err := NewService(cfg)
<?php
declare(strict_types=1);

// В PHP обычно достаточно конструктора + DI-контейнера (Symfony)
final class Service
{
    public function __construct(
        private readonly Config $cfg,
    ) {}
}

$service = new Service($cfg);
from dataclasses import dataclass


# Обычно достаточно конструктора + DI через параметры
@dataclass(slots=True)
class Service:
    cfg: Config


service = Service(cfg)

Признаки, что ты ушёл слишком далеко:

  • В коде больше слов Factory, Provider, Manager, Builder, Strategy чем доменных терминов.
  • Чтобы создать один объект, нужно пройти 3+ уровня абстракций.
  • Половина кода - «связь между интерфейсами», бизнес-логика теряется.

В Go идиома проще: конструктор-функция NewX(deps) *X + Dependency Injection через параметры. Для больших графов зависимостей есть uber-go/fx (известен и Google Wire, но его репозиторий архивный и не развивается); чаще всего хватает ручной сборки в main - и никаких «фабрик фабрик».

Как мы будем изучать

Каждый урок этого трека - один паттерн:

  1. Проблема - какой код «болит» без паттерна
  2. Решение - как паттерн это исправляет (Go + PHP примеры)
  3. Когда НЕ использовать - границы применимости
  4. Связь с другими паттернами - чем отличается от похожих

Что почитать

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

  • Найди в проекте один большой if/switch по типам
  • Подумай, какой паттерн мог бы его убрать (часто Strategy или Factory)
  • Вспомни последний раз, когда добавление фичи потребовало правок в 5+ файлах - какой паттерн мог бы помочь?
  • Открой Go stdlib (net/http, io, sort) и возьми один интерфейс. Определи: реализует ли он намерение конкретного паттерна GoF - или это просто полиморфизм, за которым паттерна нет. Обоснуй. Подсказка: hash.Hash и io.Reader дают разные ответы, и разница между ними - весь смысл этого задания

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