Django REST Framework में serializers क्या हैं?

Question

Accepted Answer

**Django REST Framework (DRF)** Django के साथ REST APIs बनाने के लिए वास्तविक मानक है, और **serializers** इसकी मुख्य अवधारणा हैं। एक serializer जटिल data (model instances, querysets) को API responses के लिए JSON **में** बदलता है, और आने वाले JSON को validated Python objects में **वापस** बदलता है — serialization और validation दोनों को संभालते हुए, जैसा forms HTML के लिए करते हैं।

## ModelSerializer — सामान्य मामला

```python
from rest_framework import serializers
from .models import Article

class ArticleSerializer(serializers.ModelSerializer):
    class Meta:
        model = Article                              # build from a model (DRY)
        fields = ["id", "title", "body", "published", "created_at"]
        read_only_fields = ["id", "created_at"]
```

एक `ModelSerializer` model से fields को auto-generate करता है (एक ModelForm की तरह) — एक model को serialize और validate करने के लिए न्यूनतम code।

## Serializing: object → JSON

```python
article = Article.objects.get(pk=1)
serializer = ArticleSerializer(article)
serializer.data        # {"id": 1, "title": "Hello", "body": "...", ...} → return as JSON

# serialize a queryset (many objects)
serializer = ArticleSerializer(Article.objects.all(), many=True)
serializer.data        # a list of dicts
```

## Deserializing + validation: JSON → validated object

```python
serializer = ArticleSerializer(data=request.data)   # incoming JSON
if serializer.is_valid():                            # VALIDATE (like a form)
    article = serializer.save()                       # create/update the model
else:
    return Response(serializer.errors, status=400)   # validation error details
```

यह pattern forms को प्रतिबिंबित करता है: `is_valid()` field rules और model के विरुद्ध आने वाले data को validate करता है, और `save()` इसे persist करता है। अमान्य data संरचित error messages देता है।

## Custom validation और fields

```python
class ArticleSerializer(serializers.ModelSerializer):
    word_count = serializers.SerializerMethodField()   # a computed, read-only field

def get_word_count(self, obj):
        return len(obj.body.split())

def validate_title(self, value):                    # field-level validation
        if "spam" in value.lower():
            raise serializers.ValidationError("No spam")
        return value
```

## Nested serializers (related data)

```python
class AuthorSerializer(serializers.ModelSerializer):
    class Meta: model = Author; fields = ["name"]

class ArticleSerializer(serializers.ModelSerializer):
    author = AuthorSerializer(read_only=True)          # embed related author data
    class Meta: model = Article; fields = ["title", "author"]
```

Serializers related objects को दर्शाने के लिए **nest** हो सकते हैं (एक article के JSON के भीतर एक author का data embed करना) — और आप API के आकार को database से स्वतंत्र रूप से नियंत्रित करते हैं।

## यह क्यों महत्वपूर्ण है

Serializers Django REST Framework के साथ REST APIs बनाने की आधारशिला हैं, जो Django APIs के लिए मानक उपकरण है — इसलिए इन्हें समझना किसी भी आधुनिक Django back-end के लिए आवश्यक है जो frontends, mobile apps, या अन्य services को JSON परोसता है।

Serializers एक API की दो मूलभूत आवश्यकताओं को हल करते हैं: responses के लिए Python/model data को **JSON में** बदलना (serialization) और data बनाने/update करने के लिए आने वाले **JSON को validated Python objects में** बदलना (deserialization + validation)।

validation पहलू **security और मजबूती** के लिए महत्वपूर्ण है — HTML के लिए forms की तरह, serializers यह सुनिश्चित करते हैं कि आप कभी भी raw API input पर भरोसा न करें, इसे database तक पहुँचने से पहले field rules के विरुद्ध validate करते हुए। **ModelSerializer** models से fields को auto-generate करके एक प्रमुख उत्पादकता जीत प्रदान करता है (DRY, ModelForm की तरह), models को API resources के रूप में expose करना तुच्छ बनाते हुए, जबकि `is_valid()`/`save()` pattern पूरे create/update जीवनचक्र को साफ़-सुथरे ढंग से संभालता है।

objects और querysets को serialize करना, input को deserialize और validate करना, custom validation और computed fields जोड़ना, और related data के लिए **nested serializers** का उपयोग करना (API के आकार को database schema से स्वतंत्र रूप से नियंत्रित करते हुए) समझना APIs बनाने के लिए मूलभूत है।

Serializers वह जगह हैं जहाँ DRF data transformation और validation की मुख्य API concerns को संभालता है, जिससे ये केंद्रीय, अवश्य-जानने योग्य ज्ञान बन जाते हैं — पारंपरिक Django के लिए forms के समान महत्व का, लेकिन उन API-driven applications के लिए जो आधुनिक web विकास पर हावी हैं।