Django signals nima ne?

Question

Accepted Answer

**Signals** su buƙatun Django don aiwatar da ƙirar observer pattern — suna ba da damar wasu aiki na jibi da jama'a a faɗi sa'ad da takamaiman **events** ke faruwa (kamar model da aka ajiye ko sanyare). Suna ba da damar **decoupled** code: satu daya na app na maimaita events a wani sashi ba tare da jidi kai tsaye ba.

## Yawaitar built-in signals

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

## Haɗi masu karɓa da 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)
```

Decorator `@receiver` yana haɗi function zuwa signal don takamaiman aiki. Sa'ad da User ya sauran ajiye, Django yana kira wannan function — a nan, yana aiki da sauri ta ƙirƙira malaƙa `Profile`. Flag `created` yana bambanta ƙirƙira daga sauyes.

## Takamaiman lamari na amfani

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

Code na ƙirƙira order ya zauna da juriya kan orders; logic na imel yana rayuwa daban kuma yana maimaita event — yana yin kide kudi.

## Sa'ad da signals ke da amfani

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

## Mahalacciyar gida: signals na iya kaiwa fito

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

## Me yasa yana da mahaɗi

Signals shine fasaha masu amfani na Django don **decoupling** code — yana ba da damar sassa ɗaban-ɗaban na aikace-aikacen da za su maimaita events (model saves/deletes, auth events) ba tare da jidi kai tsaye ba, wanda ke da daraja don cross-cutting concerns kamar ƙirƙira malaƙa ta atomatik, cache invalidation, audit logging, da maimaita events a wajiren app.
\