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 - функция (или структура), которая инкапсулирует создание объектов. Вызывающий код не знает, как именно создаётся реализация - он получает интерфейс.
Каждый caller (handler, worker, cli) сам решает, какую реализацию создавать. Знание о всех типах протекает в каждое место создания: цепочки if/else, прямые new EmailSender(...). Любая правка - синхронно во всех местах.
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
Это два разных паттерна, хотя название похоже:
В 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