Django REST Framework માં serializers શું છે?

Question

Accepted Answer

**Django REST Framework (DRF)** Django સાથે REST APIs બનાવવા માટે વાસ્તવિક માનક છે, અને **serializers** તેનું મૂળ ખ્યાલ છે। Serializer જટિલ ડેટા (model instances, querysets) **to** JSON માં API responses માટે રૂપાંતરિત કરે છે, અને આવતો JSON **back** 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"]
```

A `ModelSerializer` મોડેલ પાસેથી fields auto-generate કરે છે (ModelForm જેમ) — 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
```

પેટર્ન forms જેવો છે: `is_valid()` આવતા ડેટાને field rules અને મોડેલ સામે validate કરે છે, અને `save()` તેને persist કરે છે. Invalid ડેટા structured error messages આપે છે.

## કસ્ટમ 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 related objects (author ના ડેટાને article ના JSON માં embed કરવા) **nest** કરી શકે છે — અને તમે database પર આધાર રાખ્યા વિના API નો આકાર control કરી શકો છો.

## શા માટે તે મહત્વપૂર્ણ છે

Serializers Django REST Framework સાથે REST APIs બનાવવાનો કોણીય પત્થર છે, જે Django APIs માટે માનક સાધન છે — તેથી તેમને સમજવું કોઈપણ આધુનિક Django back-end માટે જરૂરી છે જે JSON frontends, mobile apps, અથવા અન્ય સેવાઓને પરોસે છે.

Serializers API ની બે મૌલિક જરૂરિયાત સમાધાન કરે છે: Python/model ડેટા **to JSON** માં responses (serialization) માટે રૂપાંતરિત કરવું અને આવતો **JSON validated Python objects માટે** ડેટા બનાવવા/અપડેટ કરવા માટે (deserialization + validation) રૂપાંતરિત કરવું.

Validation પાસું **security અને robustness** માટે critical છે — HTML માટે forms જેમ, serializers નિશ્ચિત કરે છે કે તમે raw API input પર ક્યારેય વિશ્વાસ કરશો નહીં, તેને database સુધી પહોંચતા પહેલા field rules સામે validate કરો. **ModelSerializer** મોડેલ પાસેથી fields auto-generate કરીને એક મોટો productivity win પ્રદાન કરે છે (DRY, ModelForm જેમ), મોડેલને API resources તરીકે expose કરવું trivial બનાવે છે, જ્યારે `is_valid()`/`save()` પેટર્ન સંપૂર્ણ create/update lifecycle સાફ રીતે સંભાળે છે.

Objects અને querysets કેવી રીતે serialize કરવા, input deserialize અને validate કરવા, custom validation અને computed fields ઉમેરવા, અને **nested serializers** ને related data માટે (database schema પર આધાર રાખ્યા વિના API નો આકાર control કરવું) ઉપયોગ કરવા તે સમજવું APIs બનાવવા માટે મૌલિક છે.

Serializers એ છે જ્યાં DRF API ના મૂળ સરોકારો ડેટા transformation અને validation સંભાળે છે, તેમને કેન્દ્રીય, must-know જ્ઞાન બનાવે છે — traditional Django માટે forms ની મહત્તા જેવો, પરંતુ API-driven applications માટે જે આધુનિક web development પર પ્રભુત્વ ધરાવે છે.