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 разделили паттерны на три группы. На каждой схеме насыщенные точки - паттерны, которые встретятся в курсе (отдельным уроком или коротко по ходу); полупрозрачные - упомянуты для полноты картины.
Отвечают за то, как создаются объекты: скрывают конструкторы за фабриками, гарантируют единственность экземпляра, собирают сложные объекты пошагово.
Когда применять: конструктор разрастается, в коде много if/switch по типу при создании, нужно подменять реализации в зависимости от конфига или окружения.
Отдельным уроком разберём Factory Method. Singleton коротко встретится ниже, в разделе про sync.Once, а Builder - только упоминанием. С фабрики удобно начинать: она нужна ровно тогда, когда в коде вырастает switch по типу создаваемого объекта.
Описывают, как объекты собираются в большие структуры: оборачивают, скрывают за фасадом, подменяют прокси - всё ради того, чтобы не трогать остальной код при расширении.
Когда применять: чужой SDK с неудобным интерфейсом, нужно навесить кэш/логи вокруг сервиса, клиент дёргает 5 методов вместо одного.
Разберём Adapter, Decorator и Facade; Proxy упомянем при сравнении с Decorator.
Регулируют, как объекты передают друг другу сообщения и распределяют обязанности: команды, события, стратегии, цепочки обработчиков.
Когда применять: поведение меняется в зависимости от роли или конфига, действия нужно ставить в очередь либо откатывать, события одной части системы запускают каскад реакций в другой.
Разберём Command, Observer и Strategy. Действие нужно поставить в очередь, залогировать или откатить - это Command. А когда на один факт независимо реагируют несколько подписчиков и они не должны знать друг о друге - это Observer.
Из 23 мы подробно возьмём 7 (по уроку на каждый) - те, которые чаще всего встречаются в Go-проектах и бэкенд-разработке.
Паттерн - это словарное слово
Главная ценность паттерна - общий язык. Когда ты говоришь коллеге «тут нужен адаптер», он сразу понимает идею. Не нужно рисовать диаграммы и объяснять полчаса.
ℹ️ Паттерн ≠ обязанность
Если без паттерна проще - делай проще. Паттерны нужны там, где код начинает повторяться или усложняться. Преждевременная абстракция вредит не меньше, чем её отсутствие.
Как понять, что паттерн нужен
Паттерн не применяют «на всякий случай». Есть конкретные сигналы - слева запах в коде, справа паттерн, которым его обычно лечат:
Паттерны в 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 паттерна:
- «Program to an interface, not an implementation» - программируй к контракту, а не к конкретной реализации.
- «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.As | Iterator | обход цепочки 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 - и никаких «фабрик фабрик».
Как мы будем изучать
Каждый урок этого трека - один паттерн:
- Проблема - какой код «болит» без паттерна
- Решение - как паттерн это исправляет (Go + PHP примеры)
- Когда НЕ использовать - границы применимости
- Связь с другими паттернами - чем отличается от похожих
Что почитать
- PHP - Наследование, abstract и интерфейсы - фундамент GoF паттернов в PHP: abstract class, interface, LSP и DIP на практике
Мини-задание
- Найди в проекте один большой
if/switchпо типам - Подумай, какой паттерн мог бы его убрать (часто Strategy или Factory)
- Вспомни последний раз, когда добавление фичи потребовало правок в 5+ файлах - какой паттерн мог бы помочь?
- Открой Go stdlib (
net/http,io,sort) и возьми один интерфейс. Определи: реализует ли он намерение конкретного паттерна GoF - или это просто полиморфизм, за которым паттерна нет. Обоснуй. Подсказка:hash.Hashиio.Readerдают разные ответы, и разница между ними - весь смысл этого задания