I - Interface Segregation: маленькие интерфейсы лучше

ISP: лучше много маленьких интерфейсов, чем один огромный.

Если интерфейс заставляет тебя реализовать лишние методы - он плохой.

Плохой пример

type Storage interface {
  Get(key string) (string, error)
  Set(key, val string) error
  Delete(key string) error
  Connect() error
  Close() error
}
interface Storage {
  public function get(string $key): string;
  public function set(string $key, string $val): void;
  public function delete(string $key): void;
  public function connect(): void;
  public function close(): void;
}
from typing import Protocol


class Storage(Protocol):
    def get(self, key: str) -> str: ...
    def set(self, key: str, val: str) -> None: ...
    def delete(self, key: str) -> None: ...
    def connect(self) -> None: ...
    def close(self) -> None: ...

А ты хотел просто in-memory map... и внезапно должен писать connect()/close().

Лучше: разделить

type Reader interface { Get(key string) (string, error) }
type Writer interface { Set(key, val string) error }
type Deleter interface { Delete(key string) error }

// нужен только реализациям с соединением (Redis, Postgres), in-memory map обойдётся без него
type Lifecycle interface { Connect() error; Close() error }
interface Reader { public function get(string $key): string; }
interface Writer { public function set(string $key, string $val): void; }
interface Deleter { public function delete(string $key): void; }

// нужен только реализациям с соединением, in-memory массив обойдётся без него
interface Lifecycle { public function connect(): void; public function close(): void; }
from typing import Protocol


class Reader(Protocol):
    def get(self, key: str) -> str: ...


class Writer(Protocol):
    def set(self, key: str, val: str) -> None: ...


class Deleter(Protocol):
    def delete(self, key: str) -> None: ...


# нужен только реализациям с соединением, in-memory dict обойдётся без него
class Lifecycle(Protocol):
    def connect(self) -> None: ...
    def close(self) -> None: ...

ℹ️ Почему ISP помогает

Тесты проще: мокать маленький интерфейс легче. И зависимости становятся честными.

Эталон ISP в stdlib: io.Reader / io.Writer / io.Closer

В стандартной библиотеке Go ISP доведён до совершенства: ключевые операции с потоками - это три однометодных интерфейса:

type Reader interface { Read(p []byte) (n int, err error) }
type Writer interface { Write(p []byte) (n int, err error) }
type Closer interface { Close() error }
<?php
declare(strict_types=1);

// Аналог io.Reader/io.Writer/io.Closer в PHP приходится объявлять самому.
// Заметь: PSR-7 StreamInterface, наоборот, объединяет все роли в одном
// интерфейсе на 15 методов - узнаваемый пример толстого контракта.

interface Reader
{
    public function read(int $length): string;
}

interface Writer
{
    public function write(string $data): int;
}

interface Closer
{
    public function close(): void;
}
from typing import Protocol

# typing.IO и io.RawIOBase - наоборот, один большой базовый класс на все роли.
# Маленькие роли в stdlib есть в collections.abc: Sized, Iterable, Container -
# по одному методу, а Collection собирается из них сложением.


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


class Writer(Protocol):
    def write(self, data: bytes) -> int: ...


class Closer(Protocol):
    def close(self) -> None: ...

Из этих кирпичиков собираются составные интерфейсы - но только когда это нужно:

type ReadWriter   interface { Reader; Writer }            // умеет и читать, и писать
type ReadCloser   interface { Reader; Closer }            // поток с владением
type WriteCloser  interface { Writer; Closer }
<?php
declare(strict_types=1);

// PHP поддерживает множественное наследование интерфейсов через extends -
// аналог Go embedding в интерфейсе.

interface ReadWriter  extends Reader, Writer {}   // умеет и читать, и писать
interface ReadCloser  extends Reader, Closer {}   // поток с владением
interface WriteCloser extends Writer, Closer {}
# Составной Protocol наследует базовые и обязательно указывает Protocol в списке баз -
# иначе получится обычный класс, а не структурный контракт.
class ReadWriter(Reader, Writer, Protocol): ...   # умеет и читать, и писать
class ReadCloser(Reader, Closer, Protocol): ...   # поток с владением
class WriteCloser(Writer, Closer, Protocol): ...

Функция io.Copy(dst Writer, src Reader) принимает минимально-достаточные интерфейсы: ей не нужен Close, поэтому она его и не требует. Это значит, что в io.Copy можно подставить файл, сетевое соединение, gzip-поток, in-memory bytes.Buffer - что угодно, что умеет читать и писать. Сила ISP в том, что клиент не зависит от методов, которыми не пользуется.

Go-идиома: «объявляй интерфейс на стороне потребителя»

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

// Плохо: пакет storage экспортирует «толстый» Storage,
// и каждый его потребитель тянет лишнее
// (набросок двух пакетов, как есть не компилируется)
package storage

type Storage interface { Get(...); Set(...); Delete(...); Connect(...); Close(...) }

// Хорошо: каждый потребитель объявляет свой узкий интерфейс
package billing

import "context"

type orderReader interface {
    Get(ctx context.Context, id string) (Order, error)
}

func ChargeOrder(r orderReader, id string) error { /* ... */ }
<?php
declare(strict_types=1);

// В PHP интерфейсы реализуются явно (implements), но идиома «объявляй
// интерфейс на стороне потребителя» работает: ролевой интерфейс
// объявляется в namespace потребителя, а сторонний класс (Symfony service)
// заявляет реализацию через implements или DI-конфигурацию.

// Плохо: пакет Storage экспортирует «толстый» Storage,
// и каждый потребитель тянет лишнее
namespace App\Storage;

interface Storage
{
    public function get(string $key): mixed;
    public function set(string $key, mixed $value): void;
    public function delete(string $key): void;
    public function connect(): void;
    public function close(): void;
}

// Хорошо: потребитель объявляет свой узкий интерфейс рядом с use case
namespace App\Billing;

interface OrderReader
{
    public function get(string $id): Order;
}

final class ChargeOrder
{
    public function __construct(private readonly OrderReader $orders) {}

    public function execute(string $id): void { /* ... */ }
}
from typing import Protocol

# Плохо: пакет storage экспортирует «толстый» Storage,
# и каждый его потребитель тянет лишнее
# storage/__init__.py
class Storage(Protocol):
    def get(self, key: str) -> str: ...
    def set(self, key: str, val: str) -> None: ...
    def delete(self, key: str) -> None: ...
    def connect(self) -> None: ...
    def close(self) -> None: ...


# Хорошо: каждый потребитель объявляет свой узкий интерфейс
# billing/charge.py
class _OrderReader(Protocol):  # приватный для модуля, как unexported в Go
    def get(self, order_id: str) -> Order: ...


def charge_order(r: _OrderReader, order_id: str) -> None: ...

ChargeOrder теперь зависит не от «всего хранилища», а только от способности достать заказ. Реализация подставится через DI. Это ISP по построению.

Fat interface vs role interface

Martin Fowler в заметке RoleInterface противопоставляет role interface и header interface («интерфейс-заголовок», который повторяет все методы реализации). В Go-сообществе ту же мысль выражает поговорка Go Proverbs «The bigger the interface, the weaker the abstraction». Два стиля:

  • Fat interface - «тип со всеми возможными способностями» (Storage с 10 методами). Описывает реализацию.
  • Role interface - «способность, нужная конкретному коду» (orderReader с одним методом). Описывает требование.

Хорошая ISP-идиома: role interface объявляет потребитель, fat interface не нужен почти никогда. Если ты пишешь интерфейс с 7+ методами - почти наверняка ты описываешь реализацию, а не роль.

Антипаттерн: интерфейс на 20 методов в service.go

В монолитах часто встречается такая схема:

// internal/service/service.go - единый «контракт сервиса»
type Service interface {
    GetUser(...) (*User, error)
    CreateUser(...) error
    UpdateUser(...) error
    DeleteUser(...) error
    ListOrders(...) ([]Order, error)
    PlaceOrder(...) error
    RefundOrder(...) error
    GetReport(...) (*Report, error)
    SendNewsletter(...) error
    // ... и так ещё 12 методов
}
<?php
declare(strict_types=1);

// src/Service/ServiceInterface.php - единый «контракт сервиса»
namespace App\Service;

interface ServiceInterface
{
    public function getUser(int $id): User;
    public function createUser(array $data): void;
    public function updateUser(int $id, array $patch): void;
    public function deleteUser(int $id): void;

    /** @return Order[] */
    public function listOrders(int $userId): array;
    public function placeOrder(int $userId, array $items): void;
    public function refundOrder(int $orderId): void;

    public function getReport(string $period): Report;
    public function sendNewsletter(string $subject, string $body): void;
    // ... и так ещё 12 методов
}
# app/service.py - единый «контракт сервиса»
from typing import Protocol


class Service(Protocol):
    def get_user(self, user_id: int) -> User: ...
    def create_user(self, data: dict[str, object]) -> None: ...
    def update_user(self, user_id: int, patch: dict[str, object]) -> None: ...
    def delete_user(self, user_id: int) -> None: ...
    def list_orders(self, user_id: int) -> list[Order]: ...
    def place_order(self, user_id: int, items: list[dict[str, object]]) -> None: ...
    def refund_order(self, order_id: int) -> None: ...
    def get_report(self, period: str) -> Report: ...
    def send_newsletter(self, subject: str, body: str) -> None: ...
    # ... и так ещё 12 методов

Любому клиенту, которому нужна одна операция, придётся писать мок на все 20. Любому HTTP-хендлеру - принимать на вход «всё хранилище». Любая правка одной из веток методов меняет один большой контракт, на который завязано всё.

ISP-рефакторинг: разнести по предметным областям и оставить интерфейсы рядом с потребителями. Получится 4-5 ролевых интерфейсов на 1-3 метода каждый, и вся кодовая база сразу станет легче для чтения и тестирования.

Связь с SRP

ISP - это SRP, применённый к интерфейсам. SRP говорит: «один модуль - одна причина меняться». ISP уточняет: «один интерфейс - один тип потребителя». Если одни клиенты интерфейса хотят правок, а другие - нет, значит интерфейс совмещает роли и должен быть разрезан.

Когда ISP вредит

Не каждое разделение полезно. Признаки over-engineering:

  • Интерфейс с одним методом, который никогда не используется отдельно (UserGetter, UserSaver, UserDeleter - а в проекте всегда нужны все три)
  • Интерфейс, у которого только одна реализация и не предвидится тестового мока
  • Дробление ради дробления, без пары связанных операций

ISP - это инструмент устранения реальной избыточной зависимости, а не способ доказать аккуратность через мелкие файлы.

Композиция интерфейсов через embedding

После того, как ты разрезал интерфейс на роли, иногда нужен «составной» контракт. Go даёт это через embedding в интерфейсе:

// Базовые роли
type Reader  interface { Read(p []byte) (int, error) }
type Writer  interface { Write(p []byte) (int, error) }
type Closer  interface { Close() error }

// Составные - собираются из базовых, не дублируют методы
type ReadWriter   interface { Reader; Writer }
type ReadCloser   interface { Reader; Closer }
type WriteCloser  interface { Writer; Closer }
type ReadWriteCloser interface { Reader; Writer; Closer }
<?php
declare(strict_types=1);

// PHP даёт ту же сборку через interface extends (множественное наследование интерфейсов).

// Базовые роли
interface Reader { public function read(int $length): string; }
interface Writer { public function write(string $data): int; }
interface Closer { public function close(): void; }

// Составные - собираются из базовых, методы наследуются автоматически
interface ReadWriter      extends Reader, Writer {}
interface ReadCloser      extends Reader, Closer {}
interface WriteCloser     extends Writer, Closer {}
interface ReadWriteCloser extends Reader, Writer, Closer {}
from typing import Protocol


# Базовые роли
class Reader(Protocol):
    def read(self, n: int = -1) -> bytes: ...


class Writer(Protocol):
    def write(self, data: bytes) -> int: ...


class Closer(Protocol):
    def close(self) -> None: ...


# Составные - собираются из базовых, не дублируют методы.
# Protocol в списке баз обязателен: без него класс перестанет быть структурным контрактом.
class ReadWriter(Reader, Writer, Protocol): ...
class ReadCloser(Reader, Closer, Protocol): ...
class WriteCloser(Writer, Closer, Protocol): ...
class ReadWriteCloser(Reader, Writer, Closer, Protocol): ...

Это правильный путь к большим интерфейсам: они получаются через сложение маленьких, а не через декларацию «толстого» с самого начала. Любой клиент может зависеть от минимально нужной комбинации. В Go и Python (Protocol) любой тип, удовлетворяющий частям, автоматически удовлетворяет целому. В PHP типизация номинальная: класс должен явно указать implements ReadWriter, иначе передача его в параметр типа ReadWriter даст TypeError.

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

  • Найди «толстый» интерфейс и разрежь на 2-3 маленьких
  • В одном из своих сервисов перенеси объявление интерфейса на сторону потребителя - стало ли яснее, что именно ему нужно?
  • Прогуляйся по io/net/bufio в stdlib и посмотри, как маленькие интерфейсы складываются в большие через embedding

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