Factory: создаём объекты без if‑адских условий

Factory: создаём объекты без if‑адских условий

Когда new начинает плодиться по коду с одинаковыми условиями - пора звать Factory. Разберём, как и зачем, без академической путаницы вариантов.

Проблема

Представь: в проекте есть 3 способа отправить уведомление - email, SMS, push. Создание нужного отправителя размазано по 10 файлам:

// handler.go
if cfg.Channel == "email" {
    sender = &EmailSender{host: cfg.SMTPHost, port: cfg.SMTPPort}
} else if cfg.Channel == "sms" {
    sender = &SmsSender{apiKey: cfg.SmsKey}
} else {
    sender = &PushSender{token: cfg.PushToken}
}
<?php
declare(strict_types=1);

// handler.php
if ($cfg->channel === 'email') {
    $sender = new EmailSender($cfg->smtpHost, $cfg->smtpPort);
} elseif ($cfg->channel === 'sms') {
    $sender = new SmsSender($cfg->smsKey);
} else {
    $sender = new PushSender($cfg->pushToken);
}
# handler.py
if cfg.channel == "email":
    sender = EmailSender(cfg.smtp_host, cfg.smtp_port)
elif cfg.channel == "sms":
    sender = SmsSender(cfg.sms_key)
else:
    sender = PushSender(cfg.push_token)

Тот же if-else в другом сервисе, в тестах, в CLI. Добавил четвёртый канал - правишь 10 мест. Забыл одно - баг.

Решение: фабрика

Factory - функция (или структура), которая инкапсулирует создание объектов. Вызывающий код не знает, как именно создаётся реализация - он получает интерфейс.

До применения Factory

Каждый caller (handler, worker, cli) сам решает, какую реализацию создавать. Знание о всех типах протекает в каждое место создания: цепочки if/else, прямые new EmailSender(...). Любая правка - синхронно во всех местах.

После применения Factory

Caller вызывает один метод фабрики и получает обратно интерфейс Sender. Какая именно реализация - Email, SMS или Push - спрятано внутри. Новый канал добавляется одной правкой в фабрике, остальной код не трогается.

Выбор платёжного провайдера

type Payment interface {
    Charge(amount int) error
}

type StripePayment struct{ apiKey string }
func (s StripePayment) Charge(amount int) error {
    // вызов Stripe API
    return nil
}

type YooKassaPayment struct{ shopID string }
func (y YooKassaPayment) Charge(amount int) error {
    // вызов YooKassa API
    return nil
}

func NewPayment(provider string, cfg Config) (Payment, error) {
    switch provider {
    case "stripe":
        return StripePayment{apiKey: cfg.StripeKey}, nil
    case "yookassa":
        return YooKassaPayment{shopID: cfg.YooKassaShop}, nil
    default:
        return nil, fmt.Errorf("unknown payment provider: %s", provider)
    }
}

Теперь добавление нового провайдера - одна правка в фабрике.

interface Payment
{
    public function charge(int $amount): void;
}

final class StripePayment implements Payment
{
    public function __construct(
        private readonly string $apiKey,
    ) {}

    public function charge(int $amount): void
    {
        // Stripe API
    }
}

final class YooKassaPayment implements Payment
{
    public function __construct(
        private readonly string $shopId,
    ) {}

    public function charge(int $amount): void
    {
        // YooKassa API
    }
}

final class PaymentFactory
{
    public static function make(string $provider, Config $cfg): Payment
    {
        return match ($provider) {
            'stripe' => new StripePayment($cfg->stripeKey),
            'yookassa' => new YooKassaPayment($cfg->yooKassaShop),
            default => throw new InvalidArgumentException("unknown: $provider"),
        };
    }
}

Добавление нового провайдера - один кейс в match.

from dataclasses import dataclass
from typing import Protocol


class Payment(Protocol):
    def charge(self, amount: int) -> None: ...


@dataclass(slots=True)
class StripePayment:
    api_key: str

    def charge(self, amount: int) -> None:
        pass  # вызов Stripe API


@dataclass(slots=True)
class YooKassaPayment:
    shop_id: str

    def charge(self, amount: int) -> None:
        pass  # вызов YooKassa API


def new_payment(provider: str, cfg: Config) -> Payment:
    match provider:
        case "stripe":
            return StripePayment(api_key=cfg.stripe_key)
        case "yookassa":
            return YooKassaPayment(shop_id=cfg.yookassa_shop)
        case _:
            raise ValueError(f"unknown payment provider: {provider}")

Фабрика - обычная функция с match; неизвестный провайдер - исключение, а не возврат ошибки. Добавление нового провайдера - один case.

Factory Method vs Abstract Factory

Это два разных паттерна, хотя название похоже:

Factory Method vs Abstract Factory: один объект против семейства

В Go роль «спрятать создание объекта» обычно играет функция New...().

Factory в Go stdlib

Функции-конструкторы в Go встречаются повсюду:

http.NewRequest(method, url, body) - создаёт *Request
bufio.NewReader(r) - создаёт *Reader с буфером
sql.Open(driver, dsn) - создаёт *DB по имени драйвера
errors.New(text) - создаёт error

⚠️ NewXxx() - это factory function, а не GoF Factory Method

Называть каждую NewReader «паттерном Factory Method» - распространённая неточность, и она стирает смысл самого паттерна.

GoF Factory Method - это про наследование: базовый класс объявляет метод создания и пользуется им в своём алгоритме, а подкласс решает, какой конкретный продукт вернуть. Вариативность живёт в иерархии типов.

Creator.SomeOperation()      ← алгоритм в базовом классе
    └── createProduct()      ← переопределяют наследники
ConcreteCreatorA → ProductA
ConcreteCreatorB → ProductB

func NewReader(r io.Reader) *Reader - просто функция-конструктор: инкапсулирует создание и настройку, но никакого выбора между реализациями в ней нет. Задача похожая, механизм другой.

Разница различима по вопросу: кто выбирает конкретный тип результата? Если вызывающий (передал аргумент - получил ровно то, что просил) - это конструктор. Если решение принимает подтип или конфигурация внутри - это уже Factory Method по смыслу.

Из примеров выше под второе описание подходит только sql.Open: там строка "postgres" выбирает драйвер из зарегистрированных, и вызывающий получает разные реализации через один вызов. Остальные - конструкторы.

В Go идею Factory Method выражают без наследования: функцией, которая по параметру выбирает одну из зарегистрированных реализаций и прячет её за общим типом, - как раз sql.Open. Он возвращает конкретный *sql.DB, но выбранный драйвер (driver.Driver) спрятан внутри, и вызывающий не знает, какой именно.

ℹ️ Где хранить фабрику

Фабрика живёт рядом с конфигом или композицией приложения (пакет app, cmd, internal/config). Бизнес-логика работает с интерфейсом и не знает, какая реализация создана.

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

Один тип - если у тебя одна реализация и вторая не планируется, фабрика - лишний слой. Просто создай объект напрямую.

Тривиальное создание - если конструктор не содержит логики (&MyStruct{field: val}), оборачивать его в фабрику бессмысленно.

Фабрика ради фабрики - если switch по типам встречается в одном месте и не растёт, можно оставить как есть. Фабрика нужна когда создание объектов дублируется или усложняется.

⚠️ Частая ошибка: фабрика из одного типа

Не создавай NewLogger(kind string) если у тебя только ConsoleLogger. Фабрика оправдана при 2+ реализациях. До этого - YAGNI (You Ain't Gonna Need It).

Factory + Registry: расширяемая фабрика

Если типы добавляются часто, можно вместо switch использовать реестр:

var registry = map[string]func(Config) (Payment, error){}

func Register(name string, fn func(Config) (Payment, error)) {
    registry[name] = fn
}

func NewPayment(name string, cfg Config) (Payment, error) {
    fn, ok := registry[name]
    if !ok {
        return nil, fmt.Errorf("unknown payment: %s", name)
    }
    return fn(cfg)
}

func init() {
    Register("stripe", func(c Config) (Payment, error) {
        return StripePayment{apiKey: c.StripeKey}, nil
    })
}

Именно так работает database/sql - драйверы регистрируют себя через sql.Register() в init().

final class PaymentRegistry
{
    /** @var array<string, callable(Config): Payment> */
    private array $factories = [];

    public function register(string $name, callable $factory): void
    {
        $this->factories[$name] = $factory;
    }

    public function make(string $name, Config $cfg): Payment
    {
        if (!isset($this->factories[$name])) {
            throw new InvalidArgumentException("unknown payment: $name");
        }

        return ($this->factories[$name])($cfg);
    }
}

$registry = new PaymentRegistry();
$registry->register('stripe', fn (Config $c) => new StripePayment($c->stripeKey));
$registry->register('yookassa', fn (Config $c) => new YooKassaPayment($c->yooKassaShop));

Похожая идея - в Symfony DI: интерфейс Payment помечают #[AutoconfigureTag('payment')], реализации - #[AsTaggedItem('stripe')] (это ключ в коллекции, а не тег), а фабрика получает их через #[AutowireLocator('payment')]. Контейнер собирает коллекцию автоматически.

from typing import Callable

_registry: dict[str, Callable[[Config], Payment]] = {}


def register(name: str, fn: Callable[[Config], Payment]) -> None:
    _registry[name] = fn


def new_payment(name: str, cfg: Config) -> Payment:
    fn = _registry.get(name)
    if fn is None:
        raise ValueError(f"unknown payment: {name}")
    return fn(cfg)


# Аналог init() в Go - код на уровне модуля выполняется при импорте
register("stripe", lambda c: StripePayment(api_key=c.stripe_key))
register("yookassa", lambda c: YooKassaPayment(shop_id=c.yookassa_shop))

Реестр - словарь на уровне модуля; регистрация при импорте, как init() в Go. Если реализаций много и они лежат в плагинах, тот же приём делают через entry points в pyproject.toml.

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

Factory + Strategy - фабрика создаёт стратегию по конфигу
Factory + Singleton - фабрика может кэшировать единственный экземпляр
Factory + DI - в Clean Architecture фабрика живёт в composition root

Подробнее о роли фабрики в правильном направлении зависимостей - в уроке Dependency Inversion.

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

  • Найди в проекте 2-3 места, где создаётся один и тот же тип с разной конфигурацией - собери в одну фабрику
  • Посмотри database/sql.Open() - как он выбирает драйвер? Найди sql.Register()
  • Попробуй реализовать фабрику с registry (map + Register) для своего use case

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