O - Open/Closed: расширяем без переписывания

O - Open/Closed: расширяем без переписывания

OCP: модули должны быть открыты для расширения, но закрыты для изменения.

Когда добавляешь новый тип - не должен переписывать полпроекта.

Плохой пример: скидки через if

Во всех примерах урока функция скидки возвращает сумму к оплате - цену после скидки.

// CalcPrice возвращает сумму к оплате после скидки
func CalcPrice(kind string, sum int) int {
  if kind == "student" { return sum * 90 / 100 }
  if kind == "vip" { return sum * 80 / 100 }
  return sum
}
// calcPrice возвращает сумму к оплате после скидки
function calcPrice(string $kind, int $sum): int {
  if ($kind === 'student') return intdiv($sum * 90, 100);
  if ($kind === 'vip') return intdiv($sum * 80, 100);
  return $sum;
}
def calc_price(kind: str, amount: int) -> int:
    """Возвращает сумму к оплате после скидки."""
    if kind == "student":
        return amount * 90 // 100
    if kind == "vip":
        return amount * 80 // 100
    return amount

Добавили новую скидку - полезли править функцию.

Лучше: стратегия

Правка if в монолитном калькуляторе против добавления новой реализации Discount

// Apply возвращает сумму к оплате после скидки
type Discount interface { Apply(sum int) int }

type StudentDiscount struct{}
func (StudentDiscount) Apply(sum int) int { return sum * 90 / 100 }

type VipDiscount struct{}
func (VipDiscount) Apply(sum int) int { return sum * 80 / 100 }

func Calc(d Discount, sum int) int { return d.Apply(sum) }
interface Discount
{
    public function apply(int $sum): int;
}

final class StudentDiscount implements Discount
{
    public function apply(int $sum): int
    {
        return intdiv($sum * 90, 100);
    }
}

final class VipDiscount implements Discount
{
    public function apply(int $sum): int
    {
        return intdiv($sum * 80, 100);
    }
}

function calc(Discount $d, int $sum): int
{
    return $d->apply($sum);
}
from typing import Protocol


class Discount(Protocol):
    def apply(self, amount: int) -> int: ...


class StudentDiscount:
    def apply(self, amount: int) -> int:
        return amount * 90 // 100


class VipDiscount:
    def apply(self, amount: int) -> int:
        return amount * 80 // 100


def calc(d: Discount, amount: int) -> int:
    return d.apply(amount)

Реализацию Discount передают в Calc снаружи - это и есть внедрение зависимости (Dependency Injection, подробно - в уроке про DIP). Вызывающий код выбирает стратегию, а Calc о ней не знает.

ℹ️ Фишка OCP

Новый тип поведения = новый класс, а не правки старого кода. Старый код стабилен - меньше багов.

OCP в Go-роутерах: middleware как точка расширения

Самый знакомый Go-разработчику пример OCP - HTTP middleware (это паттерн Decorator в чистом виде). Роутер один раз пишется так, чтобы принимать произвольную цепочку обработчиков. Дальше добавление новой кросс-функции (логирование, метрики, rate-limit, аутентификация) - это новый middleware, а не правка существующего.

type Middleware func(http.Handler) http.Handler

func Logging(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        log.Printf("%s %s %v", r.Method, r.URL.Path, time.Since(start))
    })
}

func RequireAuth(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.Header.Get("Authorization") == "" {
            http.Error(w, "unauthorized", http.StatusUnauthorized)
            return
        }
        next.ServeHTTP(w, r)
    })
}

// Применение: каждое новое поведение - новая обёртка, без правки роутера
handler := Logging(RequireAuth(routes))
<?php
declare(strict_types=1);

// Symfony EventSubscriber - стандартный механизм OCP в HTTP-стеке.
// Новый аспект (логирование, метрики, rate-limit) - новый subscriber,
// без правки роутера или контроллеров.
namespace App\Http\EventSubscriber;

use Psr\Log\LoggerInterface;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpKernel\Event\RequestEvent;
use Symfony\Component\HttpKernel\Event\TerminateEvent;
use Symfony\Component\HttpKernel\KernelEvents;

final class LoggingSubscriber implements EventSubscriberInterface
{
    private float $start = 0.0;

    public function __construct(private readonly LoggerInterface $logger) {}

    public static function getSubscribedEvents(): array
    {
        return [
            KernelEvents::REQUEST   => 'onRequest',
            KernelEvents::TERMINATE => 'onTerminate',
        ];
    }

    public function onRequest(RequestEvent $event): void
    {
        if (!$event->isMainRequest()) {
            return; // sub-request (forward, ESI) не должен перезаписать время старта
        }
        $this->start = microtime(true);
    }

    public function onTerminate(TerminateEvent $event): void
    {
        $r = $event->getRequest();
        $this->logger->info('http', [
            'method'   => $r->getMethod(),
            'path'     => $r->getPathInfo(),
            'duration' => microtime(true) - $this->start,
        ]);
    }
}

// RequireAuth - отдельный subscriber на KernelEvents::REQUEST
// с приоритетом выше контроллеров. Добавление новой проверки -
// новый subscriber, существующие не трогаем.
# Та же схема, что в Django: middleware - фабрика, которая принимает
# следующий обработчик (get_response) и возвращает новый.
import logging
import time
from typing import Callable

Handler = Callable[[Request], Response]
Middleware = Callable[[Handler], Handler]


def logging_middleware(next_handler: Handler) -> Handler:
    def handler(request: Request) -> Response:
        start = time.perf_counter()
        response = next_handler(request)
        logging.info("%s %s %.3fs", request.method, request.path, time.perf_counter() - start)
        return response
    return handler


def require_auth(next_handler: Handler) -> Handler:
    def handler(request: Request) -> Response:
        if not request.headers.get("Authorization"):
            return Response(status=401, body="unauthorized")
        return next_handler(request)
    return handler


# Применение: каждое новое поведение - новая обёртка, без правки роутера
handler = logging_middleware(require_auth(routes))

Появилась задача добавить трассировку OpenTelemetry? Пишем Tracing middleware и оборачиваем - ни роутер, ни существующие middleware не трогаем.

OCP через generics (Go 1.18+)

Иногда полиморфизм перебор, и достаточно параметризовать поведение функцией или типом. Функция-параметр превращает обычную процедуру в открытую для расширения без интерфейсов, а generics дополнительно позволяют применять её к любому типу данных:

// Закрыто: универсальный «применитель скидки» - больше не правится
func ApplyAll[T any](items []T, fn func(T) T) []T {
    out := make([]T, len(items))
    for i, item := range items {
        out[i] = fn(item)
    }
    return out
}

// Открыто: каждое новое правило - новая функция, а не правка ApplyAll
func studentRule(sum int) int { return sum * 90 / 100 }
func vipRule(sum int) int     { return sum * 80 / 100 }
<?php
declare(strict_types=1);

// В PHP нет generics, но замыкания (arrow functions) + array_map дают тот же эффект.
// PHPStan/Psalm с дженерик-аннотациями @template обеспечивают типобезопасность.

/**
 * @template T
 * @param  T[]            $items
 * @param  callable(T): T $fn
 * @return T[]
 */
function applyAll(array $items, callable $fn): array
{
    return array_map($fn, $items);
}

// Открыто: каждое новое правило - новая функция, а не правка applyAll
$studentRule = static fn (int $sum): int => intdiv($sum * 90, 100);
$vipRule     = static fn (int $sum): int => intdiv($sum * 80, 100);

$discounted = applyAll([1000, 2000], $vipRule); // [800, 1600]
# Generics здесь - это TypeVar: apply_all типобезопасна для любого T
from typing import Callable, TypeVar

T = TypeVar("T")


# Закрыто: универсальный «применитель скидки» - больше не правится
def apply_all(items: list[T], fn: Callable[[T], T]) -> list[T]:
    return [fn(item) for item in items]


# Открыто: каждое новое правило - новая функция, а не правка apply_all
def student_rule(amount: int) -> int:
    return amount * 90 // 100

def vip_rule(amount: int) -> int:
    return amount * 80 // 100


discounted = apply_all([1000, 2000], vip_rule)  # [800, 1600]

Функция-параметр (с generics или без) - лёгкая альтернатива стратегии для случаев, где «поведение» - это просто функция, а не сущность с состоянием.

Связь с GoF Strategy

Если ты уже знаком с треком GoF, OCP - это архитектурное обоснование паттерна Strategy. Strategy решает, как добавлять варианты поведения через композицию объектов; OCP объясняет, зачем мы это делаем - чтобы стабильный код не приходилось править ради новых вариантов. Большинство OCP-рефакторингов в реальной жизни заканчиваются именно стратегией (или Decorator/Chain of Responsibility - для middleware).

Полиморфизм vs параметризация vs композиция

Способов закрыть код для изменений несколько, и они уместны в разных ситуациях:

ПодходКогда использовать
Интерфейс + реализацииПоведение содержит состояние или несколько связанных операций
Функция-параметрПоведение - это одна короткая операция без состояния
GenericsСтруктура алгоритма одна, тип данных - параметр

Главное - выбрать минимально-достаточный механизм. Интерфейс там, где хватит функции, - это шум.

ℹ️ А если пришлось дописать строку при сборке?

Новую реализацию где-то нужно подключить: в main или в другом месте, где приложение собирается из частей (его называют composition root, «корень сборки»). Добавить туда строку discounts["student"] = StudentDiscount{} - не нарушение OCP. Закрытой для изменений должна быть бизнес-логика, которая пользуется абстракцией, а не список того, что подключено. Настоящее нарушение - если ради нового варианта приходится дописывать ещё одну ветку case внутри самой функции расчёта.

Где OCP вредит: правило трёх

OCP не означает «делай всё расширяемым с первого дня». Если у тебя одна реализация скидки и других не предвидится - if/switch короче, понятнее и не плодит лишних типов. Включай OCP, когда видишь третью разновидность, которая просится в этот же код. До этого - YAGNI.

// Над-инжиниринг: только VIP, других категорий не было и не предвидится
type Discount interface { Apply(int) int }
type VipDiscount struct{}
func (VipDiscount) Apply(sum int) int { return sum * 80 / 100 }

// Достаточно:
func vipDiscount(sum int) int { return sum * 80 / 100 }
<?php
declare(strict_types=1);

// Над-инжиниринг: только VIP, других категорий не было и не предвидится
interface Discount
{
    public function apply(int $sum): int;
}

final class VipDiscount implements Discount
{
    public function apply(int $sum): int { return intdiv($sum * 80, 100); }
}

// Достаточно:
function vipDiscount(int $sum): int { return intdiv($sum * 80, 100); }
# Над-инжиниринг: только VIP, других категорий не было и не предвидится
class Discount(Protocol):
    def apply(self, amount: int) -> int: ...

class VipDiscount:
    def apply(self, amount: int) -> int:
        return amount * 80 // 100

# Достаточно:
def vip_discount(amount: int) -> int:
    return amount * 80 // 100

⚠️ Признак того, что пора применять OCP

Ты ловишь себя на мысли «опять трогаю этот switch, чтобы добавить новый case». Это сигнал, что код устал быть закрытым для изменений - пора инвертировать через интерфейс.

Чек-лист «когда применять OCP»

Перед тем как вытаскивать интерфейс, спроси себя:

  • Появилась ли у этого if/switch уже третья ветка, или просто две?
  • Прогнозируется ли четвёртая в обозримом будущем?
  • Стоит ли за каждой веткой собственное состояние/зависимости (тогда стратегия), или просто разные числа (тогда параметр)?
  • Останется ли код понятным после введения интерфейса (цепочка «прочитай - пойми - измени» не удлинится)?

Если хотя бы на половину вопросов ответ «нет» - оставь switch и двигайся дальше. Это не проигрыш, это здравый смысл.

Мини‑задание

  • Возьми кусок кода с if/switch по типу и замени на полиморфизм (интерфейс + реализации)
  • Найди в проекте middleware-пайплайн и попробуй добавить новое поведение (например, request-id) без правки роутера
  • Убедись, что свежий switch на 2 кейса оставлен как есть - не каждое разветвление достойно интерфейса

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