В чем разница между ActiveRecord и Чистой Архитектурой?

# ActiveRecord vs Чистая архитектура

Это два кардинально разных подхода к организации кода при работе с базами данных и логикой приложения. Рассмотрим различия, примеры и когда использовать каждый.

ActiveRecord паттерн

ActiveRecord — это паттерн, при котором объект знает как себя сохранять и загружать из БД. Модель = Данные + Логика БД.

Пример ActiveRecord

# Django ORM — классический ActiveRecord
from django.db import models

class User(models.Model):  # Модель = данные + логика БД
    name = models.CharField(max_length=100)
    email = models.EmailField()
    age = models.IntegerField()
    
    # Методы для работы с БД
    def save(self, *args, **kwargs):
        # Валидация перед сохранением
        if not self.email:
            raise ValueError("Email required")
        super().save(*args, **kwargs)
    
    def delete(self, *args, **kwargs):
        # Логика удаления
        print(f"Deleting user {self.id}")
        super().delete(*args, **kwargs)
    
    @classmethod
    def find_by_email(cls, email):
        return cls.objects.get(email=email)
    
    def send_email(self, message):
        # Бизнес-логика в модели!
        send_email_to(self.email, message)

# Использование
user = User(name="John", email="john@example.com", age=30)
user.save()  # Сохранить в БД

user = User.find_by_email("john@example.com")  # Найти в БД
user.send_email("Hello")  # Отправить письмо
user.delete()  # Удалить из БД

Ruby on Rails — классический ActiveRecord

class User < ApplicationRecord  # ActiveRecord::Base
  validates :email, presence: true
  has_many :posts
  
  def authenticate(password)
    # Логика аутентификации
    bcrypt.compare(password)
  end
  
  def full_name
    "#{first_name} #{last_name}"
  end
end

# Использование
user = User.find(1)  # Загрузить из БД
user.email = "new@example.com"
user.save()  # Сохранить в БД

if user.authenticate(password)
  puts user.full_name
end

Чистая архитектура

Чистая архитектура (Clean Architecture) — это подход, при котором бизнес-логика отделена от деталей реализации (БД, фреймворки). Модель ≠ БД, модель = исключительно бизнес-логика.

Структура Clean Architecture

┌─────────────────────────────────────┐
│   Presentation / Controllers         │
├─────────────────────────────────────┤
│   Application / Use Cases            │
├─────────────────────────────────────┤
│   Domain / Business Logic            │ ← Модели
├─────────────────────────────────────┤
│   Infrastructure / Repositories      │ ← БД
└─────────────────────────────────────┘

Пример Clean Architecture

# 1. DOMAIN LAYER — бизнес-логика (не знает о БД)
class User:  # Просто класс данных
    def __init__(self, id: int, name: str, email: str, age: int):
        self.id = id
        self.name = name
        self.email = email
        self.age = age
    
    def is_adult(self) -> bool:
        """Бизнес-логика — проверка возраста"""
        return self.age >= 18
    
    def update_email(self, new_email: str) -> None:
        """Валидация и обновление"""
        if "@" not in new_email:
            raise ValueError("Invalid email")
        self.email = new_email

# 2. APPLICATION LAYER — Use Cases (оркестрация)
from abc import ABC, abstractmethod

class UserRepository(ABC):
    """Абстракция для работы с БД"""
    @abstractmethod
    def save(self, user: User) -> None:
        pass
    
    @abstractmethod
    def find_by_email(self, email: str) -> User:
        pass
    
    @abstractmethod
    def delete(self, user_id: int) -> None:
        pass

class AuthenticateUserUseCase:
    """Use Case для аутентификации"""
    def __init__(self, repository: UserRepository):
        self.repository = repository  # Инъекция зависимости
    
    def execute(self, email: str, password: str) -> User:
        user = self.repository.find_by_email(email)
        if not user:
            raise ValueError("User not found")
        
        if not self.verify_password(password, user.id):
            raise ValueError("Invalid password")
        
        return user
    
    def verify_password(self, password: str, user_id: int) -> bool:
        # Логика проверки пароля
        return True

# 3. INFRASTRUCTURE LAYER — детали реализации БД
from sqlalchemy import Column, Integer, String, create_engine
from sqlalchemy.orm import sessionmaker

class SQLAlchemyUserRepository(UserRepository):
    """Конкретная реализация репозитория с SQLAlchemy"""
    
    def __init__(self, session):
        self.session = session
    
    def save(self, user: User) -> None:
        db_user = UserModel(  # Маппирование на DB модель
            id=user.id,
            name=user.name,
            email=user.email,
            age=user.age
        )
        self.session.add(db_user)
        self.session.commit()
    
    def find_by_email(self, email: str) -> User:
        db_user = self.session.query(UserModel).filter_by(email=email).first()
        if not db_user:
            return None
        
        return User(  # Маппирование на Domain модель
            id=db_user.id,
            name=db_user.name,
            email=db_user.email,
            age=db_user.age
        )
    
    def delete(self, user_id: int) -> None:
        self.session.query(UserModel).filter_by(id=user_id).delete()
        self.session.commit()

class UserModel:  # SQLAlchemy модель (деталь реализации)
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String(100))
    email = Column(String(100), unique=True)
    age = Column(Integer)

# 4. PRESENTATION LAYER — контроллеры/endpoints
from flask import Flask, request, jsonify

app = Flask(__name__)
session = sessionmaker(bind=engine)()
repository = SQLAlchemyUserRepository(session)
authenticate_use_case = AuthenticateUserUseCase(repository)

@app.route('/login', methods=['POST'])
def login():
    data = request.json
    try:
        user = authenticate_use_case.execute(data['email'], data['password'])
        return jsonify({'id': user.id, 'name': user.name})
    except ValueError as e:
        return jsonify({'error': str(e)}), 400

# Использование
if __name__ == '__main__':
    app.run()

Сравнение: Таблица

Преимущества и недостатки

ActiveRecord

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

✓ Быстрая разработка (намного меньше кода)
✓ Низкая кривая обучения
✓ Наглядно для простых приложений
✓ Меньше boilerplate
✓ Встроенная валидация и hooks

Пример: быстрая MVP за день

Недостатки:

✗ Нарушает SRP — модель делает слишком много
✗ Трудно тестировать (модель тесно связана с БД)
✗ Трудно переиспользовать модели в других контекстах
✗ Возникают проблемы с масштабированием
✗ Fat models, thin controllers (логика размазана по моделям)
✗ Невозможно использовать без БД

Пример: когда проект растёт, код становится неуправляемым

Clean Architecture

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

✓ Чистое разделение ответственности (SRP)
✓ Легко тестировать (mock репозиторий)
✓ Легко переиспользовать логику
✓ Легко менять БД (от PostgreSQL к MongoDB)
✓ Масштабируемость
✓ Lean models, fat use cases
✓ Бизнес-логика независима от фреймворка

Пример: тестирование без БД

Недостатки:

✗ Много кода (boilerplate)
✗ Сложная кривая обучения
✗ Может быть overengineering для малых проектов
✗ Медленнее разработка
✗ Требует дисциплины команды

Пример: простой CRUD взлетает в цене сложности

Когда использовать ActiveRecord

✓ Стартап / MVP — нужно быстро протестировать идею
✓ Маленькие проекты (< 5000 строк кода)
✓ Простой CRUD (типичный блог, форум)
✓ Команда из 1-2 разработчиков
✓ Быстрое время выхода на рынок критично
✓ Стабильные требования (не меняются часто)

Примеры: Django проект с 10 моделями, Rails blog

Когда использовать Clean Architecture

✓ Большой проект (> 10,000 строк кода)
✓ Сложная бизнес-логика
✓ Команда > 5 разработчиков
✓ Длительный проект (> 1 года)
✓ Частые изменения требований
✓ Критична надёжность и поддерживаемость
✓ Нужна высокая тестовая покрытие
✓ Планируется микросервисная архитектура

Примеры: Финтех, HealthTech, платформы с 100+ моделями

Гибридный подход (рекомендуется для Python)

# Django + Clean Architecture
# Лучшее из обоих миров

from django.db import models as django_models
from dataclasses import dataclass

# 1. Django модель для БД
class UserDjangoModel(django_models.Model):
    name = django_models.CharField(max_length=100)
    email = django_models.EmailField()
    age = django_models.IntegerField()
    
    class Meta:
        db_table = 'users'

# 2. Domain модель (чистая бизнес-логика)
@dataclass
class User:
    id: int
    name: str
    email: str
    age: int
    
    def is_adult(self) -> bool:
        return self.age >= 18

# 3. Репозиторий (маппирование)
class UserRepository:
    def save(self, user: User) -> None:
        django_user = UserDjangoModel(
            name=user.name,
            email=user.email,
            age=user.age
        )
        django_user.save()
    
    def find_by_email(self, email: str) -> User:
        django_user = UserDjangoModel.objects.get(email=email)
        return User(
            id=django_user.id,
            name=django_user.name,
            email=django_user.email,
            age=django_user.age
        )

# 4. Use Case
class CreateUserUseCase:
    def __init__(self, repository: UserRepository):
        self.repository = repository
    
    def execute(self, name: str, email: str, age: int) -> User:
        user = User(id=None, name=name, email=email, age=age)
        self.repository.save(user)
        return user

# 5. View (контроллер)
from django.http import JsonResponse

def create_user_view(request):
    use_case = CreateUserUseCase(UserRepository())
    user = use_case.execute(
        name=request.POST['name'],
        email=request.POST['email'],
        age=int(request.POST['age'])
    )
    return JsonResponse({'id': user.id})

Выводы

ActiveRecord лучше для:

• Быстрого прототипирования
• Малых и средних проектов
• Когда время в приоритете

Clean Architecture лучше для:

• Больших и сложных проектов
• Когда нужна долгосрочная поддержка
• Когда требования часто меняются
• Когда команда растёт

Практический совет:

• Начни с ActiveRecord (быстро)
• По мере роста проекта переходи к Clean Architecture
• Или используй гибридный подход с самого начала
• Не делай преждевременное обобщение (YAGNI)