Co jsou Django signály?

Question

Accepted Answer

**Signály** jsou implementace vzoru observer v Django — umožňují určitým odesílatelům oznámit sadu příjemců, když dojde ke konkrétním **událostem** (například při uložení nebo smazání modelu). Umožňují **odpojený** kód: jedna část aplikace reaguje na události v jiné části bez přímého propojení.

## Běžné vestavěné signály

```text
pre_save / post_save      → before / after a model instance is saved
pre_delete / post_delete  → before / after a model instance is deleted
m2m_changed               → a ManyToMany relationship changed
request_started / finished→ request lifecycle
user_logged_in / out      → authentication events
```

## Připojení přijímače na signál

```python
from django.db.models.signals import post_save
from django.dispatch import receiver

# automatically create a Profile whenever a User is created
@receiver(post_save, sender=User)
def create_profile(sender, instance, created, **kwargs):
    if created:                          # only on creation, not every save
        Profile.objects.create(user=instance)
```

Dekorátor `@receiver` připojí funkci na signál pro konkrétního odesílatele. Když je `User` uložen, Django zavolá tuto funkci — zde automaticky vytvoří související `Profile`. Příznak `created` rozlišuje vytvoření od aktualizací.

## Typický případ použití

```python
@receiver(post_save, sender=Order)
def send_order_confirmation(sender, instance, created, **kwargs):
    if created:
        send_email(instance.customer.email, "Order confirmed")
# the Order-creation code doesn't need to know about emails → decoupled
```

Kód vytvářející objednávky zůstává zaměřen na objednávky; logika emailu žije odděleně a reaguje na událost — zachovává tak oddělení zájmů.

## Kdy jsou signály užitečné

```text
✓ Reacting to model events from a DIFFERENT app/module (decoupling)
✓ Auto-creating related objects (Profile on User creation)
✓ Cache invalidation, search-index updates, audit logging on save/delete
✓ Cross-cutting reactions you don't want to embed in the core logic
```

## Důležité upozornění: signály mohou snížit srozumitelnost

```python
# ⚠️ signals create IMPLICIT, "action at a distance" behavior:
# saving an Order triggers an email somewhere else — not obvious from the save call.
# This can make code HARDER to follow and debug.
```

```text
When to PREFER explicit code over signals:
  ✗ If the logic clearly belongs in the same flow → call it directly (more readable)
  ✗ Overusing signals → hidden, hard-to-trace behavior, debugging difficulty
  ✓ A common alternative: override the model's save() method, or use a service function,
    for logic tightly coupled to the operation
Use signals mainly for genuine DECOUPLING (reacting across app boundaries), not as
a default for all post-save logic.
```

## Proč to má smysl

Signály jsou užitečná funkcionalita Django pro **oddělení** kódu — umožňují různým částem aplikace reagovat na události (ukládání/mazání modelů, auth-eventi) bez přímých závislostí, což je cenné pro cross-cutting zájmy jako auto-vytváření souvisejících objektů, zneplatnění cache, audit logging a reagování na události napříč hranicemi aplikací.

Rozumět jim je důležité jak pro *správné* jejich použití, tak pro jejich rozpoznání v existujících kódech (jsou obvyklým zdrojem zmatku "proč se to stalo?").

To, co činí signály zvláště důležitým tématem, je však **nuancované posouzení, kdy je používat**: ačkoli umožňují elegantní oddělení, také vytváří **implicitní chování "na dálku"**, které může kód ztěžovat sledovat a debugovat (uložení objektu záhadně spustí efekty definované jinde).

Zkušení Django vývojáři chápou tento kompromis — používají signály pro *skutečné* oddělení (reagování napříč hranicemi modulů/aplikací na události, které byste se neměli vázat na zdroj), zatímco preferují **explicitní kód** (přímé volání logiky, přepsání `save()`, nebo použití servisních funkcí), když logika jasně patří do stejného toku, protože explicitní kód je čitelnější a lépe sledovatelný.

Vnímání způsobu, jak signály fungují (připojování příjemců, příznak `created`, běžné signály), jejich legitimní případy použití a rozhodující **kdy je NEPOUŽÍVAT** (vyhýbání se skrytému, těžko debugovatelnému chování) odráží praktické, zkušené porozumění, které odlišuje vývojáře pišící udržovatelný Django kód od těch, kteří signály nadmíru používají a vytváří spletitou, nejasnou aplikaci.