Django signals என்றால் என்ன?

Question

Accepted Answer

**Signals** என்பது Django-ன் observer pattern-ன் implementation — அவை certain senders-ஐ ஒரு set of receivers-ஐ notify செய்ய அனுமதி கொடுக்கிறது specific **events** நடக்கும் போது (ஒரு model save அல்லது delete செய்யப்படுவது போல). அவை **decoupled** code-ஐ enable செய்கிறது: app-ன் ஒரு பகுதி மற்றொரு பகுதியில் நடக்கும் events-ஐ direct coupling இல்லாமல் react செய்யுமாறு.ஐ

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

## Receiver-ஐ signal-க்கு connect செய்தல்

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

Deputies `@receiver` decorator ஒரு function-ஐ ஒரு signal-க்கு specific sender-க்கு connect செய்கிறது. ஒரு `User` save செய்யப்படும் போது, Django இந்த function-ஐ call செய்கிறது — இங்கே, related `Profile`-ஐ auto-create செய்கிறது. `created` flag creation-ஐ updates-இல் இருந்து distinguish செய்கிறது.

## ஒரு typical use case

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

Order-creating code orders-ஆக focused இருக்கிறது; email logic separately இருக்கிறது மற்றும் event-க்கு react செய்கிறது — concerns-ஐ decoupled state-ல் வைக்கிறது.

## Signals எப்போது useful

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

## முக்கியமான caveat: signals clarity-ஐ hurt செய்யலாம்

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

## ஏன் இது முக்கியமாக இருக்கிறது

Signals என்பது **decoupling** code-க்கான ஒரு useful Django feature — application-ன் different parts-க்கு events (model saves/deletes, auth events) என்க react செய்ய அனுமதி கொடுக்கிறது direct dependencies இல்லாமல், இது cross-cutting concerns போல auto-creating related objects, cache invalidation, audit logging, மற்றும் app boundaries-க்கு across events-க்கு react செய்வதற்கு valuable.

அவற்றைப் புரிந்துகொள்ளுதல் *using* அவற்றை appropriately-க்கு மற்றும் existing codebases-ல் அவற்றை recognize செய்வதற்கு முக்கியமாக இருக்கிறது (அவை "ஏன் இது நடந்தது?" confusion-ன் ஒரு common source).

al, signals என்பது ஒரு particularly important topic என்பது **nuanced judgment about when to use them**-ஆக இருக்கிறது: அவை elegant decoupling-ஐ enable செய்தாலும், அவை create செய்கிறது **implicit, "action-at-a-distance" behavior** code-ஐ follow மற்றும் debug செய்வதற்கு harder வைக்கிறது (ஒரு object-ஐ save செய்வது mysteriously triggers செய்கிறது effects defined elsewhere-ல்).

Mature Django developers புரிந்துகொள்கிறது இந்த trade-off — *genuine* decoupling-க்கு signals-ஐ use செய்கிறது (module/app boundaries-க்கு across react செய்கிறது events-க்கு you shouldn't couple source-க்கு) while prefer செய்கிறது **explicit code** (logic-ஐ directly call செய்கிறது, `save()`-ஐ override செய்கிறது, அல்லது service functions-ஐ use செய்கிறது) logic clearly belong செய்யும் போது same flow-ஆக, explicit code என்பது more readable மற்றும் traceable-க்கு.

Signals எப்படி work செய்கிறது (connecting receivers, `created` flag, common signals), அவற்றின் legitimate use cases, மற்றும் crucially **when NOT to use them** (avoiding hidden, hard-to-debug behavior) பற்றி knowing செய்வது practical, experienced understanding-ஐ reflect செய்கிறது maintainable Django code-ஐ write செய்யும் developers-க்கு distinguish செய்கிறது signals-ஐ overuse செய்யும் developers-இல் இருந்து tangles செய்து, opaque applications-ஐ create செய்கிறது.