Kaj so Django signali?

Question

Accepted Answer

**Signali** so Django-jeva implementacija observer vzorca — omogočajo določenim pošiljateljem, da obvestijo niz prejemnikov, ko se zgodijo specifični **dogodki** (kot je shranjevanje ali brisanje modela). Omogočajo **sklopljeno** kodo: en del aplikacije se odziva na dogodke v drugem delu brez direktne sklopitve.

## Pogosti vgrajeni signali

```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
```

## Povezovanje prejemnika na signal

```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)
```

Dekorator `@receiver` poveže funkcijo na signal za specifičnega pošiljatelja. Ko se `User` shrani, Django pokliče to funkcijo — tukaj samodejno ustvari povezani `Profile`. Zastava `created` loči ustvarjanje od posodobitev.

## Tipičen primer uporabe

```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
```

Koda za ustvarjanje naročil ostane osredotočena na naročila; logika za e-pošto živi ločeno in se odziva na dogodek — kar ohranja skrbi ločene.

## Kdaj so signali uporabni

```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
```

## Pomembno opozorilo: signali lahko škodijo jasnosti

```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.
```

## Zakaj je to pomembno

Signali so koristna Django-jeva možnost za **ločevanje** kode — omogočajo različnim delom aplikacije, da se odzivajo na dogodke (shranjevanje/brisanje modelov, avtentifikacijski dogodki) brez direktnih odvisnosti, kar je dragoceno za prečne skrbi, kot so samodejno ustvarjanje povezanih objektov, razveljavitev predpomnilnika, audit logiranje in odzivanje na dogodke čez meje aplikacij.

Razumevanje jih je pomembno tako za *pravilno* uporabo kot za prepoznavanje jih v obstoječih kodnih bazah (so pogost vir zmede "zakaj se je to zgodilo?").

Vendor pa je signale posebej pomembna tema **niansirane presoje, kdaj jih uporabiti**: medtem ko omogočajo elegantno ločevanje, tudi ustvarjajo **implicitno, "delovanje na razdaljo" obnašanje**, ki lahko naredi kodo težje razumljivo in razhroščevalno (shranjevanje objekta skrivnostno sproži učinke, definirane drugje).

Izkušeni Django razvijalci razumejo to kompromis — uporabljajo signale za *pravo* ločevanje (odzivanje čez meje modulov/aplikacij na dogodke, ki jih ne bi smeli sklopliti s源) medtem ko imajo **eksplicitno kodo** (direktni klic logike, preglasitev `save()` ali uporaba servisnih funkcij) prednost, ko logika jasno sodi v isti tok, ker je eksplicitna koda bolj berljiva in sledljiva.

Znanje, kako signali delujejo (povezovanje prejemnikov, zastava `created`, pogosti signali), njihovi legitimni primeri uporabe in ključno **kdaj jih NE uporabiti** (izogibanje skritemu, težko razhroščljivemu obnašanju) odraža praktično, izkušeno razumevanje, ki loči razvijalce, ki napišejo vzdržljivo Django kodo, od tistih, ki prekomerno uporabljajo signale in ustvarijo zapletene, neprozorne aplikacije.