Django REST Framework मध्ये serializers म्हणजे काय?

Question

Accepted Answer

**Django REST Framework (DRF)** हे Django सह REST APIs बांधण्यासाठी de facto standard आहे, आणि **serializers** हा त्याचा मूल संकल्पना आहे. एक serializer जटिल डेटा (model instances, querysets) **to** JSON मध्ये API responses साठी रूपांतरित करतो, आणि येणारे JSON **back** validated Python objects मध्ये रूपांतरित करतो — serialization आणि validation दोन्ही हाताळतो, HTML साठी forms करते तसे.

## 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 स्वयंचलितपणे तयार करतो (ModelForm सारखे) — minimal code serialization आणि validation साठी.

## 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 ला mirror करतो: `is_valid()` येणार्या डेटाला field rules आणि model विरुद्ध validate करतो, आणि `save()` ते persist करतो. Invalid data structured error messages yield करतो.

## 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 (संबंधित डेटा)

```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 **nest** करू शकतात संबंधित objects प्रतिनिधित्व करण्यासाठी (article च्या JSON मध्ये author चा डेटा embed करणे) — आणि आप database पासून स्वतंत्रपणे API चा आकार नियंत्रित करता.

## हे महत्वाचे का आहे

Serializers Django REST Framework सह REST APIs बांधण्याचा cornerstone आहेत, जो Django APIs साठी standard tool आहे — म्हणून त्यांची समज कोणत्याही आधुनिक Django back-end साठी essential आहे जो frontends, mobile apps, किंवा इतर services ला JSON serve करतो.

Serializers API च्या दोन fundamental needs सोडवतात: Python/model डेटा **to JSON** responses साठी रूपांतरित करणे (serialization) आणि yeणारे **JSON to validated Python objects** data create/update करण्यासाठी (deserialization + validation).

validation aspect **security आणि robustness** साठी critical आहे — HTML साठी forms सारखे, serializers सुनिश्चित करतात की आप raw API input ला कधीही विश्वास करत नाही, field rules विरुद्ध validate करत नाही तर ते database पर्यंत पोहोचते. **ModelSerializer** एक मोठा productivity win प्रदान करतो models पासून fields auto-generate करून (DRY, ModelForm सारखे), models ला API resources म्हणून expose करणे trivial बनवतो, जेव्हा `is_valid()`/`save()` pattern संपूर्ण create/update lifecycle cleanly हाताळते.

कसे objects आणि querysets serialize करायचे, input deserialize आणि validate करायचे, custom validation आणि computed fields जोडायचे, आणि **nested serializers** संबंधित डेटाने (database schema पासून स्वतंत्रपणे API चा आकार नियंत्रित करणे) कसे वापरायचे हे समजणे APIs बांधण्यासाठी fundamental आहे.

Serializers जेथे DRF data transformation आणि validation ची core API concerns हाताळतात, त्यांना central, must-know knowledge बनवतात — traditional Django साठी forms च्या महत्त्वाशी analogous, परंतु API-driven applications साठी जे आधुनिक web development वर dominate करतात.