Что лучше, переопределить метод save или использовать сигнал?

Переопределение save() vs сигналы в Django

Это классический вопрос при разработке на Django. Оба подхода имеют свои преимущества и недостатки. Давайте рассмотрим, когда использовать каждый из них.

Подход 1: Переопределение метода save()

from django.db import models
from django.utils.text import slugify

class Article(models.Model):
    title = models.CharField(max_length=200)
    slug = models.SlugField(unique=True, blank=True)
    content = models.TextField()
    
    def save(self, *args, **kwargs):
        # Генерируем slug перед сохранением
        if not self.slug:
            self.slug = slugify(self.title)
        
        # Валидация
        if len(self.title) < 3:
            raise ValueError("Title must be at least 3 characters")
        
        super().save(*args, **kwargs)

Преимущества переопределения save():

• Логика локализирована в одном месте
• Легче отследить (читаемость)
• Работает с bulk_create и batch операциями (частично)
• Нет сложности с сигналами

Недостатки переопределения save():

• Проблемы с bulk_create и update — сигналы не срабатывают
• Может замедлить сохранение больших объёмов
• Сложнее тестировать
• Не срабатывает для update() в QuerySet

# Проблема: save() не вызывается
articles = [Article(title="A"), Article(title="B")]
Article.objects.bulk_create(articles)  # save() не вызовется!

# Проблема: update в QuerySet
Article.objects.filter(title="Old").update(title="New")  # save() не вызовется!

Подход 2: Использование сигналов

from django.db.models.signals import post_save, pre_save
from django.dispatch import receiver
from django.utils.text import slugify

class Article(models.Model):
    title = models.CharField(max_length=200)
    slug = models.SlugField(unique=True, blank=True)
    content = models.TextField()

@receiver(pre_save, sender=Article)
def generate_slug(sender, instance, **kwargs):
    if not instance.slug:
        instance.slug = slugify(instance.title)

@receiver(pre_save, sender=Article)
def validate_title(sender, instance, **kwargs):
    if len(instance.title) < 3:
        raise ValueError("Title must be at least 3 characters")

@receiver(post_save, sender=Article)
def index_article(sender, instance, created, **kwargs):
    if created:
        # Индексируем в Elasticsearch только новые статьи
        es_client.index(index='articles', doc_type='article', id=instance.id, body={
            'title': instance.title,
            'content': instance.content
        })

Преимущества сигналов:

• Разделение ответственности (слабая связанность)
• Работает для всех способов создания/изменения (bulk_create, update и т.д.)
• Легче расширять функционал (добавить новый сигнал)
• Следует SOLID принципам

Недостатки сигналов:

• Сложнее отследить (косвенность)
• Производительность может пострадать (множество сигналов)
• Тяжелее тестировать (нужно мокировать сигналы)
• Может привести к неожиданному поведению

Сравнение практических сценариев

Сценарий 1: Простой случай (автогенерация slug)

Лучше переопределить save():

class Product(models.Model):
    name = models.CharField(max_length=100)
    slug = models.SlugField(unique=True)
    
    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.name)
        super().save(*args, **kwargs)

Простая логика, локализирована, легко понять.

Сценарий 2: Множество побочных эффектов

Лучше использовать сигналы:

class User(models.Model):
    username = models.CharField(max_length=100)
    email = models.EmailField()

# Отправка приветственного письма
@receiver(post_save, sender=User)
def send_welcome_email(sender, instance, created, **kwargs):
    if created:
        send_email.delay(instance.email)

# Создание профиля пользователя
@receiver(post_save, sender=User)
def create_user_profile(sender, instance, created, **kwargs):
    if created:
        UserProfile.objects.create(user=instance)

# Логирование создания
@receiver(post_save, sender=User)
def log_user_creation(sender, instance, created, **kwargs):
    if created:
        logger.info(f"New user created: {instance.username}")

Здесь много побочных эффектов, сигналы разделяют логику.

Сценарий 3: Работа с bulk_create

Только сигналы работают корректно:

# Нужно индексировать все статьи
@receiver(post_save, sender=Article)
def sync_to_elasticsearch(sender, instance, **kwargs):
    es_client.index(index='articles', id=instance.id, body={
        'title': instance.title
    })

# Работает корректно с bulk_create
articles = [Article(title="A"), Article(title="B")]
Article.objects.bulk_create(articles)
# Сигнал post_save НЕ срабатывает для bulk_create в Django < 3.2!

# Для Django 3.2+ нужно явно вызвать сигнал

Лучшие практики

1. Валидация — в clean(), не в save()

from django.core.exceptions import ValidationError

class Article(models.Model):
    title = models.CharField(max_length=200)
    
    def clean(self):
        if len(self.title) < 3:
            raise ValidationError({'title': 'Title must be at least 3 characters'})
    
    def save(self, *args, **kwargs):
        self.full_clean()  # Вызываем валидацию перед сохранением
        super().save(*args, **kwargs)

2. Использовать pre_save для трансформаций данных

@receiver(pre_save, sender=Article)
def normalize_title(sender, instance, **kwargs):
    instance.title = instance.title.strip().title()

3. Использовать post_save для побочных эффектов

@receiver(post_save, sender=Article)
def notify_followers(sender, instance, created, **kwargs):
    if created:
        for follower in instance.author.followers.all():
            Notification.objects.create(
                user=follower,
                message=f"New article: {instance.title}"
            )

4. Правило большого пальца

Как избежать проблем

# Плохо: save() вызывает большие операции
class Article(models.Model):
    def save(self, *args, **kwargs):
        super().save(*args, **kwargs)
        # Отправляем email в save() — может замедлить сохранение!
        send_email_to_subscribers.apply_async(args=[self.id])

# Хорошо: используем post_save сигнал
@receiver(post_save, sender=Article)
def notify_subscribers(sender, instance, created, **kwargs):
    if created:
        send_email_to_subscribers.apply_async(args=[instance.id])

Вывод

Используйте переопределение save() для:

• Простых трансформаций данных (генерация slug, нормализация)
• Логики, специфичной для модели
• Когда нужна гарантия выполнения

Используйте сигналы для:

• Побочных эффектов (email, логирование)
• Разделения ответственности
• Когда логика может быть переиспользована или отключена
• Работы с bulk_create, update QuerySet

Золотая середина: Используйте оба подхода правильно — сохраняйте простоту модели в save(), а побочные эффекты перемещайте в сигналы.