В чем разница между связанностью и связностью компонентов?

# Связанность vs Связность компонентов

Это два фундаментальных принципа архитектуры и дизайна, описывающие качество взаимодействия между компонентами системы.

Связанность (Coupling)

Связанность — это мера зависимости одного модуля/компонента от другого. Показывает, насколько сильно компоненты зависят друг от друга.

Высокая связанность — ПЛОХО ❌

# Класс А напрямую зависит от класса Б
class PaymentService:
    def __init__(self):
        self.db = Database()  # Прямая зависимость
        self.email = EmailService()  # Прямая зависимость
    
    def process_payment(self, user_id, amount):
        # Изменение Database потребует изменения PaymentService
        user = self.db.query(f"SELECT * FROM users WHERE id={user_id}")
        # Если EmailService сломается, PaymentService не работает
        self.email.send("Payment confirmed")

Проблемы:

• Изменение Database требует изменения PaymentService
• Сложно тестировать (нельзя подменить зависимости)
• Сложно переиспользовать PaymentService в другом контексте
• При добавлении SMS нужно менять PaymentService

Низкая связанность — ХОРОШО ✓

# Используем dependency injection
class PaymentService:
    def __init__(self, db: Database, notifier: Notifier):
        self.db = db  # Инъекция зависимостей
        self.notifier = notifier
    
    def process_payment(self, user_id, amount):
        user = self.db.query(f"SELECT * FROM users WHERE id={user_id}")
        self.notifier.send("Payment confirmed")  # Может быть Email, SMS, Push

# Легко подменять:
db = MockDatabase()
email = EmailNotifier()
service = PaymentService(db, email)

# Или другой notifier
sms = SMSNotifier()
service2 = PaymentService(db, sms)

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

• PaymentService не знает о конкретных реализациях
• Легко тестировать с mock-объектами
• Легко менять реализацию (Email → SMS)
• Компоненты переиспользуемы

Связность (Cohesion)

Связность — это мера того, насколько хорошо элементы внутри компонента работают вместе для достижения единой цели. Показывает, насколько "сплочена" группа функций в компоненте.

Низкая связность — ПЛОХО ❌

# UserService делает слишком много
class UserService:
    def create_user(self, name, email):
        # Создание пользователя
        pass
    
    def send_email(self, to, subject, body):  # Не относится к пользователям!
        # Отправка email
        pass
    
    def generate_report(self):  # Не относится к пользователям!
        # Генерация отчета
        pass
    
    def calculate_tax(self, amount):  # Совсем не относится!
        # Расчет налогов
        pass

Проблемы:

• Класс отвечает за слишком много (нарушение Single Responsibility)
• Сложно понять, что делает класс
• Сложно тестировать
• Высокий риск побочных эффектов при изменении

Высокая связность — ХОРОШО ✓

# Каждый сервис отвечает за одно
class UserService:
    def __init__(self, repository: UserRepository):
        self.repository = repository
    
    def create_user(self, name, email):
        return self.repository.save(User(name, email))
    
    def get_user(self, user_id):
        return self.repository.get(user_id)
    
    def delete_user(self, user_id):
        return self.repository.delete(user_id)
    # ВСЕ методы работают с пользователями!

class EmailService:
    def send(self, to, subject, body):
        pass
    # ТОЛЬКО email функционал

class TaxService:
    def calculate_tax(self, amount):
        pass
    # ТОЛЬКО налоговая логика

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

• Каждый класс имеет одну ясную ответственность
• Легко понять и изменять
• Легко тестировать
• Легко переиспользовать

Наглядное сравнение

Высокая связанность + Низкая связность:
❌ Плохо

Компонент A  ← сильно зависит от → Компонент B
  (делает всё)  ← слабо связан с → (делает всё)

Проблемы: сложно тестировать, менять, переиспользовать

─────────────────────────────────────────────────

Низкая связанность + Высокая связность:
✓ Хорошо

Компонент A  ← слабо зависит от → Компонент B
(делает одно)  ← хорошо связан → (делает одно)

Преимущества: модульно, тестируемо, масштабируемо

Практический пример

ДО (Высокая связанность, низкая связность)

class UserManager:
    def __init__(self):
        self.users = {}  # Прямая зависимость от памяти
    
    def register_user(self, name, email, password):
        # Валидация (не относится!)
        if not self._validate_email(email):
            return False
        
        # Отправка письма (не относится!)
        self._send_welcome_email(email)
        
        # Логирование (не относится!)
        self._log_event(f"User {name} registered")
        
        # Наконец, создание пользователя
        self.users[email] = {"name": name, "password": self._hash_password(password)}
        return True
    
    def _validate_email(self):
        pass
    
    def _send_welcome_email(self):
        pass
    
    def _log_event(self):
        pass
    
    def _hash_password(self):
        pass

ПОСЛЕ (Низкая связанность, высокая связность)

# Валидатор отвечает только за валидацию
class EmailValidator:
    def validate(self, email: str) -> bool:
        return "@" in email

# Сервис уведомлений отвечает только за уведомления
class NotificationService:
    def send_welcome(self, email: str) -> None:
        # Отправить письмо
        pass

# Логгер отвечает только за логирование
class Logger:
    def log(self, message: str) -> None:
        print(f"[LOG] {message}")

# Хеширование отвечает только за это
class PasswordHasher:
    def hash(self, password: str) -> str:
        return hashlib.sha256(password.encode()).hexdigest()

# Repository отвечает только за хранение
class UserRepository:
    def __init__(self):
        self.users = {}
    
    def save(self, user: User) -> None:
        self.users[user.email] = user

# UserService координирует, но имеет низкую связанность
class UserService:
    def __init__(
        self,
        validator: EmailValidator,
        notifier: NotificationService,
        logger: Logger,
        hasher: PasswordHasher,
        repository: UserRepository
    ):
        self.validator = validator
        self.notifier = notifier
        self.logger = logger
        self.hasher = hasher
        self.repository = repository
    
    def register_user(self, name: str, email: str, password: str) -> bool:
        # Валидация
        if not self.validator.validate(email):
            return False
        
        # Создание пользователя
        user = User(name, email, self.hasher.hash(password))
        self.repository.save(user)
        
        # Уведомление
        self.notifier.send_welcome(email)
        
        # Логирование
        self.logger.log(f"User {name} registered")
        
        return True

Правило баланса

Оптимальная архитектура:

✓ НИЗКАЯ Связанность  (Coupling)
  ↓
  Компоненты независимы друг от друга
  Легко менять, тестировать, переиспользовать

✓ ВЫСОКАЯ Связность  (Cohesion)
  ↓
  Элементы внутри компонента работают вместе
  Один класс = одна ответственность

SOLID принципы

• S (Single Responsibility) — высокая связность
• D (Dependency Inversion) — низкая связанность
• L, O, I — тоже помогают достичь баланса

Итог

Стремись к: низкой связанности и высокой связности.