D - Dependency Inversion: зависимости наружу
D - Dependency Inversion: зависимости наружу
DIP: зависеть нужно от абстракций, а не от деталей.
Чтобы бизнес‑логика не была приклеена к PostgreSQL, Redis и внешним API скотчем.
Плохой пример
type OrderService struct {
db *sql.DB
}
func (s *OrderService) Create(userID int64) error {
// напрямую пишем SQL
_, err := s.db.Exec("INSERT INTO orders(user_id) VALUES ($1)", userID)
return err
}
final class OrderService {
public function __construct(private PDO $db) {}
public function create(int $userId): void {
// напрямую дёргаем PDO
$stmt = $this->db->prepare('INSERT INTO orders(user_id) VALUES (?)');
$stmt->execute([$userId]);
}
}
from psycopg import Connection
class OrderService:
def __init__(self, db: Connection) -> None:
self._db = db
def create(self, user_id: int) -> None:
# напрямую пишем SQL
with self._db.cursor() as cur:
cur.execute("INSERT INTO orders(user_id) VALUES (%s)", (user_id,))
Тестировать без базы? Ну... удачи.
Лучше: зависимость от интерфейса
type OrderRepo interface { Create(userID int64) error }
type OrderService struct {
repo OrderRepo
}
func (s *OrderService) Create(userID int64) error {
if userID <= 0 { return fmt.Errorf("bad user") }
return s.repo.Create(userID)
}
Реализация для Postgres (деталь):
type PgOrderRepo struct { db *sql.DB }
func (r PgOrderRepo) Create(userID int64) error {
_, err := r.db.Exec("INSERT INTO orders(user_id) VALUES ($1)", userID)
return err
}
Тестовая реализация (фейк):
type FakeOrderRepo struct{ Calls int }
func (r *FakeOrderRepo) Create(userID int64) error { r.Calls++; return nil }
interface OrderRepo
{
public function create(int $userId): void;
}
final class OrderService
{
public function __construct(
private readonly OrderRepo $repo,
) {}
public function create(int $userId): void
{
if ($userId <= 0) {
throw new InvalidArgumentException('bad user');
}
$this->repo->create($userId);
}
}
Реализация для Postgres (деталь):
final class PdoOrderRepo implements OrderRepo
{
public function __construct(
private readonly PDO $db,
) {}
public function create(int $userId): void
{
$this->db->prepare('INSERT INTO orders(user_id) VALUES (?)')->execute([$userId]);
}
}
Тестовая реализация (фейк):
final class FakeOrderRepo implements OrderRepo
{
public int $calls = 0;
public function create(int $userId): void
{
$this->calls++;
}
}
from typing import Protocol
class OrderRepo(Protocol):
def create(self, user_id: int) -> None: ...
class OrderService:
def __init__(self, repo: OrderRepo) -> None:
self._repo = repo
def create(self, user_id: int) -> None:
if user_id <= 0:
raise ValueError("bad user")
self._repo.create(user_id)
Реализация для Postgres (деталь):
from psycopg import Connection
class PgOrderRepo:
def __init__(self, db: Connection) -> None:
self._db = db
def create(self, user_id: int) -> None:
with self._db.cursor() as cur:
cur.execute("INSERT INTO orders(user_id) VALUES (%s)", (user_id,))
Тестовая реализация (фейк):
from dataclasses import dataclass
@dataclass
class FakeOrderRepo:
calls: int = 0
def create(self, user_id: int) -> None:
self.calls += 1
⚠️ DIP не про «сто интерфейсов ради интерфейсов»
Абстракции нужны там, где есть вариативность или где ты хочешь тестировать без тяжёлых зависимостей.
DIP в Hexagonal Architecture
DIP - это краеугольный камень гексагональной архитектуры (другое название - ports and adapters). Идея простая:
- В центре - домен (бизнес-правила) и use cases, которые владеют интерфейсами своих зависимостей (
OrderRepo,Mailer,PaymentGateway) - На периферии - адаптеры: реализации этих интерфейсов поверх Postgres, SMTP, Stripe
- Зависимости идут снаружи внутрь: адаптеры знают про домен, домен про адаптеры - нет
Это и есть «инверсия» в DIP: естественное направление зависимостей в коде (бизнес → инфраструктура) разворачивается, и инфраструктура зависит от бизнеса. Решение, какую именно реализацию порта подставить (Postgres или in-memory, реальный платёжный шлюз или заглушка), принимается на входе в приложение, и как только вариантов становится больше одного, этот выбор выносят в фабрику. Это та же слоистая структура проекта, которую разбирали в clean-code: домен и use cases импортируют только Go stdlib и собственные интерфейсы, а пакеты infra/ подставляют реализации.
Constructor injection в Go: почему через конструктор
Способов «впрыснуть» зависимость в Go два - через поле структуры или через конструктор. Идиома проекта - constructor injection:
// Плохо: зависимость можно забыть выставить, и сервис упадёт в рантайме
type OrderService struct {
Repo OrderRepo // public - внешний код может оставить nil
}
// Лучше: конструктор - единственный документированный способ создать сервис
// и явно перечисляет зависимости.
type OrderService struct {
repo OrderRepo // unexported
}
// Литерал &OrderService{} снаружи пакета всё ещё возможен (поле останется nil),
// а NewOrderService(nil) компилируется - поэтому критичные зависимости проверяют:
func NewOrderService(repo OrderRepo) *OrderService {
if repo == nil {
panic("usecase: nil OrderRepo")
}
return &OrderService{repo: repo}
}
<?php
declare(strict_types=1);
// Плохо: setter injection - сервис можно создать без репозитория и упасть в рантайме
final class OrderService
{
private OrderRepo $repo;
public function setRepo(OrderRepo $repo): void { $this->repo = $repo; }
}
<?php
declare(strict_types=1);
// Хорошо: constructor injection через property promotion.
// Без зависимости сервис не создать; Symfony DI собирает граф автоматически.
final class OrderService
{
public function __construct(
private readonly OrderRepo $repo,
) {}
}
# Плохо: зависимость можно забыть выставить, и сервис упадёт в рантайме
class OrderService:
repo: OrderRepo | None = None # public - внешний код может оставить None
# Хорошо: конструктор гарантирует, что без зависимости сервис не создать
class OrderService:
def __init__(self, repo: OrderRepo) -> None:
self._repo = repo # одно подчёркивание - «не трогать снаружи»
Конструктор - это контракт: он явно перечисляет, без чего сервис не работает. Это полезно и для читаемости, и для статических проверок (DI-фреймворки умеют по сигнатуре конструктора собирать граф зависимостей).
DIP в проекте: сборка графа зависимостей
Самый простой способ - собрать граф вручную в main.go (composition root): вызвать конструкторы по порядку и передать результаты друг другу. Для больших графов есть инструменты. Известный пример - Google Wire: он читает конструкторы и генерирует код, который их склеивает, без рантайм-рефлексии.
⚠️ Wire - известный, но архивный
Оригинальный репозиторий google/wire в архиве и больше не поддерживается (см. README). Для новых проектов чаще собирают граф вручную в
main.goили используют uber-go/fx, который собирает граф в рантайме. Приёмы ниже от выбора инструмента не меняются.
// internal/usecase/order_service.go
type OrderRepo interface {
Save(ctx context.Context, o Order) error
}
func NewOrderService(repo OrderRepo, log *slog.Logger) *OrderService {
return &OrderService{repo: repo, log: log}
}
// cmd/app/main.go - ручная сборка (рекомендуемый вариант для новых проектов)
func buildApp(db *sql.DB, log *slog.Logger) *App {
repo := infra.NewPgOrderRepo(db) // *infra.PgOrderRepo удовлетворяет usecase.OrderRepo
svc := usecase.NewOrderService(repo, log)
return NewApp(svc)
}
// internal/wire/wire.go - то же на Wire (упрощённо)
func InitializeApp(db *sql.DB, log *slog.Logger) *App {
wire.Build(
infra.NewPgOrderRepo, // *sql.DB → *infra.PgOrderRepo
// Wire сам не связывает конкретный тип с интерфейсом - нужен Bind:
wire.Bind(new(usecase.OrderRepo), new(*infra.PgOrderRepo)),
usecase.NewOrderService,
NewApp,
)
return nil
}
<?php
declare(strict_types=1);
// PHP-эквивалент - Symfony DI контейнер с autowiring.
// Сборка графа происходит в compile-time при cache:warmup,
// а не в рантайме на каждый запрос.
namespace App\UseCase;
use Psr\Log\LoggerInterface;
interface OrderRepo
{
public function save(Order $order): void;
}
final class OrderService
{
public function __construct(
private readonly OrderRepo $repo,
private readonly LoggerInterface $logger,
) {}
}
# config/services.yaml
services:
_defaults:
autowire: true
autoconfigure: true
App\:
resource: '../src/'
# Связывание интерфейса с реализацией
App\UseCase\OrderRepo:
class: App\Infrastructure\Doctrine\DoctrineOrderRepo
# app/usecase/order_service.py
import logging
from typing import Protocol
class OrderRepo(Protocol):
def save(self, order: Order) -> None: ...
class OrderService:
def __init__(self, repo: OrderRepo, log: logging.Logger) -> None:
self._repo = repo
self._log = log
# app/wiring.py (упрощённо)
# Кодогенерирующего аналога Wire в экосистеме нет: граф собирают руками
# в composition root (или контейнером вроде dependency-injector / FastAPI Depends).
# Проверку «у OrderRepo есть реализация» берёт на себя mypy: PgOrderRepo обязан
# структурно совпасть с Protocol, иначе build_app не пройдёт тайпчек.
def build_app(db: Connection, log: logging.Logger) -> App:
repo = PgOrderRepo(db) # Connection -> OrderRepo
service = OrderService(repo, log)
return App(service)
При ручной сборке несовпадение типов покажет компилятор. Wire генерирует функцию-инициализатор и проверяет, что все зависимости разрешимы: если для интерфейса OrderRepo нет провайдера, упадёт генерация (wire сообщит «no provider found»). В Symfony аналог - bin/console lint:container и cache:warmup: контейнер падает при сборке, а не при первом запросе. DIP здесь не «надстройка», а свойство проектной структуры.
Где DIP вредит: правило трёх
Не каждая зависимость заслуживает интерфейса. Признаки, что DIP здесь - над-инжиниринг:
- Один handler вызывает одну конкретную детерминированную функцию из stdlib (
json.Marshal,strings.ToLower) - заворачивать это в интерфейс не нужно - В тесте подходит реальная реализация (например,
crypto/sha256- детерминированная и быстрая, мокать незачем) - Реализация одна и не предвидится второй до конца квартала - добавишь интерфейс, когда появится реальный второй кейс
DIP включается там, где есть реальная вариативность или внешняя зависимость, тяжёлая для теста (БД, сеть, файловая система, время, рандом).
Тестируемость как побочный эффект DIP
Главный практический выигрыш DIP - компактные unit-тесты бизнес-логики (в PHP аналогично - PHPUnit). Тестируем версию сервиса из раздела про сборку графа - с репозиторием Save и логгером:
type Order struct{ UserID int64 }
func (s *OrderService) Create(ctx context.Context, userID int64) error {
if userID <= 0 {
return errors.New("bad user")
}
return s.repo.Save(ctx, Order{UserID: userID})
}
// require - из библиотеки github.com/stretchr/testify
type fakeOrderRepo struct {
saved []Order
err error
}
func (f *fakeOrderRepo) Save(_ context.Context, o Order) error {
if f.err != nil { return f.err }
f.saved = append(f.saved, o)
return nil
}
func TestOrderService_Create(t *testing.T) {
repo := &fakeOrderRepo{}
svc := NewOrderService(repo, slog.Default())
err := svc.Create(context.Background(), 42)
require.NoError(t, err)
require.Len(t, repo.saved, 1)
require.Equal(t, int64(42), repo.saved[0].UserID)
}
<?php
declare(strict_types=1);
// Сервис, который тестируем (src/UseCase/OrderService.php):
//
// final class Order { public function __construct(public readonly int $userId) {} }
//
// public function create(int $userId): void
// {
// if ($userId <= 0) {
// throw new \InvalidArgumentException('bad user');
// }
// $this->repo->save(new Order($userId));
// }
namespace App\Tests\UseCase;
use App\UseCase\Order;
use App\UseCase\OrderRepo;
use App\UseCase\OrderService;
use PHPUnit\Framework\TestCase;
use Psr\Log\NullLogger;
final class FakeOrderRepo implements OrderRepo
{
/** @var Order[] */
public array $saved = [];
public function save(Order $order): void
{
$this->saved[] = $order;
}
}
final class OrderServiceTest extends TestCase
{
public function testCreatePersistsOrder(): void
{
$repo = new FakeOrderRepo();
$service = new OrderService($repo, new NullLogger());
$service->create(42);
self::assertCount(1, $repo->saved);
self::assertSame(42, $repo->saved[0]->userId);
}
}
import logging
from dataclasses import dataclass, field
# Сервис, который тестируем:
@dataclass
class Order:
user_id: int
class OrderService:
def __init__(self, repo: OrderRepo, log: logging.Logger) -> None:
self._repo = repo
self._log = log
def create(self, user_id: int) -> None:
if user_id <= 0:
raise ValueError("bad user")
self._repo.save(Order(user_id=user_id))
@dataclass
class FakeOrderRepo:
saved: list[Order] = field(default_factory=list)
err: Exception | None = None
def save(self, order: Order) -> None:
if self.err is not None:
raise self.err
self.saved.append(order)
def test_order_service_create() -> None:
repo = FakeOrderRepo()
svc = OrderService(repo, logging.getLogger(__name__))
svc.create(42) # исключения нет - аналог require.NoError
assert len(repo.saved) == 1
assert repo.saved[0].user_id == 42
Никакой БД, никакой докер-сетки, никаких миграций - тест бежит за миллисекунды и проверяет именно бизнес-логику.
Мини‑задание
- Выдели интерфейс репозитория в сервисе
- Напиши фейковую реализацию для теста
- Перепиши конструктор сервиса так, чтобы все зависимости приходили снаружи (constructor injection)
- Проверь по своему проекту: импортирует ли пакет
usecase/domainчто-то изinfra/db? Если да - это сигнал, что DIP нарушен