Django REST Framework లో సీరియలైజర్లు ఏమిటి?

Question

Accepted Answer

**Django REST Framework (DRF)** Django తో REST APIs నిర్మించడానికి వాస్తవ ప్రమాణం, మరియు **సీరియలైజర్లు** దీని ప్రధాన భావన. సీరియలైజర్ సంక్లిష్ట డేటా (మోడల్ ఇన్‌స్టెన్సెస్, querysets) API రెస్పాన్సెల కోసం JSON కు **మార్చుతుంది**, మరియు ఇన్‌కమింగ్ JSON **తిరిగి** ధృవీకరించిన Python ఆబ్జెక్ట్‌లకు మార్చుతుంది — సీరియలైజేషన్ మరియు ధృవీకరణ రెండింటిని నిర్వహిస్తూ, 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` మోడల్ నుండి ఫీల్డ్‌లను స్వయంచాలకంగా ఉత్పాదిస్తుంది (ModelForm వలె) — సీరియలైజ్ మరియు ధృవీకరించడానికి కనిష్ట కోడ్.

## సీరియలైజింగ్: 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
```

## డీసీరియలైజింగ్ + ధృవీకరణ: JSON → ధృవీకరించిన 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
```

ఈ నమూనా ఫారమ్‌లను ప్రతిబింబిస్తుంది: `is_valid()` ఇన్‌కమింగ్ డేటాను ఫీల్డ్ నియమాలు మరియు మోడల్‌కు వ్యతిరేకంగా ధృవీకరిస్తుంది, మరియు `save()` దానిని సংরక్షించుకుంటుంది. చెల్లని డేటా నిర్మాణిత ఎర్రర్ సందేశాలను ఇస్తుంది.

## కస్టమ్ ధృవీకరణ మరియు ఫీల్డ్‌లు

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

## నెస్టెడ్ సీరియలైజర్లు (సంబంధిత డేటా)

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

సీరియలైజర్లు సంబంధిత ఆబ్జెక్ట్‌లను సూచించడానికి **నెస్ట్** చేయవచ్చు (ఒక లేఖ యొక్క JSON లో రచయిత యొక్క డేటాను పొందుపరచడం) — మరియు మీరు డేటాబేస్ నుండి స్వతంత్రంగా API ఆకారాన్ని నియంత్రిస్తారు.

## ఇది ఎందుకు ముఖ్యమైనది

Django REST Framework తో REST APIs నిర్మించడానికి సీరియలైజర్లు మూలస్తంభం, ఇది Django APIs కోసం ప్రామాణిక సాధనం — కాబట్టి వాటిని అర్థం చేసుకోవడం ఏదైనా ఆధునిక Django బ్యాక్‌ఎండ్‌కు అవసరం, ఫ్రంటెండ్‌లు, మొబైల్ ఆప్‌లు, లేదా ఇతర సేవలకు JSON సేవ చేస్తుంది.

సీరియలైజర్లు API యొక్క రెండు ప్రాథమిక అవసరాలను పరిష్కరిస్తాయి: Python/మోడల్ డేటాను రెస్పాన్సెల కోసం **JSON కు** మార్చడం (సీరియలైజేషన్) మరియు డేటా సృష్టించడానికి/నవీకరించడానికి ఇన్‌కమింగ్ **JSON ను ధృవీకరించిన Python ఆబ్జెక్ట్‌లకు** మార్చడం (డీసీరియలైజేషన్ + ధృవీకరణ).

ధృవీకరణ అంశం **భద్రత మరియు దృఢత్వం** కోసం విమర్శనీయం — HTML కోసం ఫారమ్‌ల వలె, సీరియలైజర్లు మీరు ఎప్పుడూ raw API ఇన్‌పుట్‌ను విశ్వసించకుండా నిర్ధారిస్తారు, ఇది డేటాబేస్‌కు చేరుకోవడానికి ముందు ఫీల్డ్ నియమాలకు వ్యతిరేకంగా ధృవీకరిస్తుంది. **ModelSerializer** మోడల్‌ల నుండి ఫీల్డ్‌లను స్వయంచాలకంగా ఉత్పాదించడం ద్వారా ప్రధాన ఉత్పాదకత లాభాన్ని అందిస్తుంది (DRY, ModelForm వలె), API సంపদలుగా నమూనాలను బహిర్గతం చేయడం చాలా సులభం చేస్తుంది, while the `is_valid()`/`save()` pattern సృష్టి/నవీకరణ జీవితచక్రాన్ని క్లीన్‌గా నిర్వహిస్తుంది.

ఆబ్జెక్ట్‌లను మరియు querysets లను సీరియలైజ్ చేయడం, ఇన్‌పుట్‌ను డీసీరియలైజ్ మరియు ధృవీకరించడం, కస్టమ్ ధృవీకరణ మరియు గణన చేసిన ఫీల్డ్‌లను జోడించడం, మరియు సంబంధిత డేటా కోసం **నెస్టెడ్ సీరియలైజర్‌లను** ఉపయోగించడం (డేటాబేస్ స్కీమా నుండి స్వతంత్రంగా API ఆకారాన్ని నియంత్రించడం) APIs నిర్మించడానికి ప్రాథమికం.

సీరియలైజర్లు డేటా పరివర్తన మరియు ధృవీకరణ యొక్క ప్రధాన API సమస్యలను DRF నిర్వహించే చోట, వాటిని కేంద్రీయ, తప్పనిసరి-తెలుసుకోవలసిన జ్ఞానం చేస్తాయి — సాంప్రదాయ Django కోసం ఫారమ్‌ల ప్రాధాన్యతలో సమానం, కానీ ఆధునిక వెబ్ డెవలప్‌మెంట్‌ను ఆధిపత్యం చేసే API-ప్రేరిత అనువర్తనాల కోసం.