Что такое принцип DIP?

Принцип DIP (Dependency Inversion Principle)

DIP — это пятый принцип SOLID, который гласит: "Класс должен зависеть от абстракций, а не от конкретных реализаций". Это означает, что высокоуровневые модули не должны зависеть от низкоуровневых; оба должны зависеть от абстракций.

Основная идея

Обычно мы думаем о зависимостях так: класс A использует класс B, значит A зависит от B. DIP говорит: введи промежуточную абстракцию (интерфейс или базовый класс), и тогда A и B оба зависят от этой абстракции, а не друг от друга.

Это делает код более гибким и тестируемым.

Плохой пример (нарушение DIP)

# Конкретная реализация БД
class MySQLDatabase:
    def save(self, data):
        print(f"Saving to MySQL: {data}")

# Высокоуровневый класс, который ЗАВИСИТ от конкретной БД
class UserService:
    def __init__(self):
        self.db = MySQLDatabase()  # Жёсткая зависимость!
    
    def save_user(self, user):
        self.db.save(user)

# Проблемы:
# 1. Сложно тестировать (нельзя использовать mock-БД)
# 2. Сложно менять БД на PostgreSQL (нужно менять UserService)
# 3. UserService слишком тесно связан с MySQLDatabase

Хороший пример (следование DIP)

from abc import ABC, abstractmethod

# Абстракция (интерфейс)
class Database(ABC):
    @abstractmethod
    def save(self, data):
        pass

# Конкретные реализации
class MySQLDatabase(Database):
    def save(self, data):
        print(f"Saving to MySQL: {data}")

class PostgreSQLDatabase(Database):
    def save(self, data):
        print(f"Saving to PostgreSQL: {data}")

class MongoDatabase(Database):
    def save(self, data):
        print(f"Saving to MongoDB: {data}")

# Высокоуровневый класс, зависит от абстракции
class UserService:
    def __init__(self, db: Database):
        self.db = db  # Инъекция зависимости (зависит от абстракции)
    
    def save_user(self, user):
        self.db.save(user)

# Использование
mysql_db = MySQLDatabase()
service1 = UserService(mysql_db)
service1.save_user({"name": "John"})
# "Saving to MySQL: {'name': 'John'}"

# Легко менять БД
postgres_db = PostgreSQLDatabase()
service2 = UserService(postgres_db)
service2.save_user({"name": "Jane"})
# "Saving to PostgreSQL: {'name': 'Jane'}"

# Легко тестировать
class MockDatabase(Database):
    def save(self, data):
        self.last_saved = data

def test_save_user():
    mock_db = MockDatabase()
    service = UserService(mock_db)
    service.save_user({"name": "Test"})
    assert mock_db.last_saved == {"name": "Test"}

Инъекция зависимостей (Dependency Injection)

DIP часто реализуется через инъекцию зависимостей — передачу зависимостей через конструктор (или другие способы):

# Способ 1: через конструктор (самый частый)
class UserService:
    def __init__(self, db: Database):
        self.db = db

# Способ 2: через setter
class UserService:
    def set_database(self, db: Database):
        self.db = db

# Способ 3: через параметр метода
class UserService:
    def save_user(self, user, db: Database):
        db.save(user)

Способ 1 (конструктор) — самый распространённый.

Более сложный пример

from abc import ABC, abstractmethod

# Абстракции
class Logger(ABC):
    @abstractmethod
    def log(self, message):
        pass

class EmailService(ABC):
    @abstractmethod
    def send_email(self, to: str, subject: str, body: str):
        pass

class Repository(ABC):
    @abstractmethod
    def save(self, entity):
        pass

# Конкретные реализации
class ConsoleLogger(Logger):
    def log(self, message):
        print(f"[LOG] {message}")

class SMTPEmailService(EmailService):
    def send_email(self, to: str, subject: str, body: str):
        print(f"Sending email to {to}")

class PostgreSQLUserRepository(Repository):
    def save(self, entity):
        print(f"Saving user to PostgreSQL: {entity}")

# Бизнес-логика
class UserRegistration:
    def __init__(
        self,
        repo: Repository,
        email_service: EmailService,
        logger: Logger
    ):
        self.repo = repo
        self.email_service = email_service
        self.logger = logger
    
    def register_user(self, email: str, password: str):
        try:
            user = {"email": email, "password": password}
            self.repo.save(user)
            self.email_service.send_email(email, "Welcome", "Thanks for signing up!")
            self.logger.log(f"User registered: {email}")
        except Exception as e:
            self.logger.log(f"Registration failed: {e}")

# Использование
repo = PostgreSQLUserRepository()
email = SMTPEmailService()
logger = ConsoleLogger()

registration = UserRegistration(repo, email, logger)
registration.register_user("john@example.com", "secret123")
# Saving user to PostgreSQL: {'email': 'john@example.com', 'password': 'secret123'}
# Sending email to john@example.com
# [LOG] User registered: john@example.com

# При тестировании
class MockRepository(Repository):
    def save(self, entity):
        self.saved_entities = []
        self.saved_entities.append(entity)

class MockEmailService(EmailService):
    def send_email(self, to, subject, body):
        self.sent_emails = []
        self.sent_emails.append((to, subject, body))

mock_repo = MockRepository()
mock_email = MockEmailService()
mock_logger = ConsoleLogger()

registration = UserRegistration(mock_repo, mock_email, mock_logger)
registration.register_user("test@example.com", "test123")
# Тестирование проходит без реального БД и SMTP!

Правила DIP

1. Определи абстракцию (интерфейс или базовый класс)
2. Реализуй конкретные версии абстракции
3. Передавай абстракции в конструктор, не создавай их внутри класса
4. Используй абстракции в типизации, не конкретные классы

Преимущества DIP

• Тестируемость: легко подменять реальные зависимости на mock-объекты
• Гибкость: легко менять реализацию без изменения кода
• Слабая связанность: классы не зависят друг от друга напрямую
• Переиспользование: один класс работает с разными реализациями

Антипаттерны (чего избегать)

# ❌ Плохо: создание зависимостей внутри класса
class OrderService:
    def __init__(self):
        self.db = MySQLDatabase()  # Жёсткая зависимость
        self.logger = FileLogger()  # Жёсткая зависимость

# ✅ Хорошо: инъекция зависимостей
class OrderService:
    def __init__(self, db: Database, logger: Logger):
        self.db = db
        self.logger = logger

DIP — это не просто принцип, это философия проектирования, которая делает код гибким, тестируемым и легким для поддержки. Это особенно важно в больших проектах.