Django REST Framework ਵਿੱਚ serializers ਕੀ ਹਨ?

Question

Accepted Answer

**Django REST Framework (DRF)** Django ਨਾਲ REST APIs ਬਣਾਉਣ ਲਈ ਅਸਲ ਮਾਪਦੰਡ ਹੈ, ਅਤੇ **serializers** ਇਸ ਦਾ ਮੂਲ ਸੰਕਲਪ ਹਨ। ਇੱਕ serializer ਗੁੰਝਲਦਾਰ ਡੇਟਾ (ਮਾਡਲ ਇੰਸਟੈਂਸਸ, querysets) ਨੂੰ API ਜਵਾਬਾਂ ਲਈ JSON **ਵਿੱਚ** ਤਬਦੀਲ ਕਰਦਾ ਹੈ, ਅਤੇ ਆਉਣ ਵਾਲੇ JSON ਨੂੰ ਪਰਮਾਣੂ Python ਵਸਤੂਆਂ **ਵਿੱਚ ਵਾਪਸ** ਤਬਦੀਲ ਕਰਦਾ ਹੈ — 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` ਮਾਡਲ ਤੋਂ ਖੇਤ ਆਪ-ਸਿੱਧੀ ਪੀੜ੍ਹੀ ਕਰਦਾ ਹੈ (ModelForm ਵਾਂਗ) — ਇੱਕ ਮਾਡਲ ਨੂੰ serialize ਅਤੇ validate ਕਰਨ ਲਈ ਘੱਟ ਕੋਡ।

## 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()` ਫੀਲਡ ਨਿਯਮਾਂ ਅਤੇ ਮਾਡਲ ਦੇ ਵਿਰੁੱਧ ਆਉਣ ਵਾਲਾ ਡੇਟਾ validate ਕਰਦਾ ਹੈ, ਅਤੇ `save()` ਇਸ ਨੂੰ persist ਕਰਦਾ ਹੈ। ਗਲਤ ਡੇਟਾ ਢਾਂਚਾਗਤ ਗਲਤੀ ਸੁਨੇਹੇ ਦਿੰਦਾ ਹੈ।

## ਕਸਟਮ validation ਅਤੇ ਖੇਤ

```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 ਸਬੰਧਿਤ ਵਸਤੂਆਂ ਦੀ ਪ੍ਰਤੀਨਿਧਤਾ ਕਰਨ ਲਈ **ਨੇਸਟ** ਕਰ ਸਕਦੇ ਹਨ (ਇੱਕ ਲੇਖ ਦੇ JSON ਵਿੱਚ ਲੇਖਕ ਦਾ ਡੇਟਾ ਐਂਬੇਡ ਕਰਦੇ ਹੋਏ) — ਅਤੇ ਤੁਸੀਂ ਡੇਟਾਬੇਸ ਤੋਂ ਸੁਤੰਤਰ API ਦੀ ਸ਼ਕਲ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦੇ ਹੋ।

## ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰਖਦਾ ਹੈ

Serializers Django REST Framework ਨਾਲ REST APIs ਬਣਾਉਣ ਦਾ ਆਧਾਰ ਪੱਥਰ ਹਨ, ਜੋ Django APIs ਲਈ ਸਟੈਂਡਰਡ ਟੂਲ ਹੈ — ਇਸ ਲਈ ਉਨ੍ਹਾਂ ਨੂੰ ਸਮਝਣਾ ਕਿਸੇ ਵੀ ਆਧੁਨਿਕ Django back-end ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਜੋ frontends, ਮੋਬਾਈਲ ਐਪਸ, ਜਾਂ ਹੋਰ ਸੇਵਾਵਾਂ ਨੂੰ JSON ਪਰੋਸ ਕਰਦਾ ਹੈ।

Serializers API ਦੀਆਂ ਦੋ ਬੁਨਿਆਦੀ ਲੋੜਾਂ ਨੂੰ ਹੱਲ ਕਰਦੇ ਹਨ: Python/model ਡੇਟਾ ਨੂੰ ਜਵਾਬਾਂ ਲਈ **JSON ਵਿੱਚ** ਤਬਦੀਲ ਕਰਨਾ (serialization) ਅਤੇ ਆਉਣ ਵਾਲੇ **JSON ਨੂੰ validated Python ਵਸਤੂਆਂ ਵਿੱਚ** ਤਬਦੀਲ ਕਰਨਾ ਡੇਟਾ ਬਣਾਉਣ/ਅੱਪਡੇਟ ਕਰਨ ਲਈ (deserialization + validation)।

Validation ਦਿਹ **ਸੁਰੱਖਿਆ ਅਤੇ ਭਰੋਸੇਯੋਗਤਾ** ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ — HTML ਲਈ forms ਦੀ ਤਰ੍ਹਾਂ, serializers ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਨ ਕਿ ਤੁਸੀਂ ਕਦੀ ਰੌ API ਇਨਪੁਟ 'ਤੇ ਭਰੋਸਾ ਨਹੀਂ ਕਰਦੇ, ਇਸ ਨੂੰ ਆਪਣੇ ਡੇਟਾਬੇਸ ਤੱਕ ਪਹੁੰਚਣ ਤੋਂ ਪਹਿਲਾਂ ਫੀਲਡ ਨਿਯਮਾਂ ਵਿਰੁੱਧ validate ਕਰਦੇ ਹਨ। **ModelSerializer** ਮਾਡਲਾਂ ਤੋਂ ਫੀਲਡ ਆਪ-ਸਿੱਧੀ ਪੀੜ੍ਹੀ ਕਰਕੇ ਵੱਡੀ ਉਤਪਾਦਕਤਾ ਜਿੱਤ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ (DRY, ModelForm ਵਰਗਾ), ਮਾਡਲਾਂ ਨੂੰ API ਸਰੋਤਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਦਾ ਖੁਲਾਸਾ ਕਰਨਾ ਮਾਮੂਲੀ ਬਣਾਉਂਦਾ ਹੈ, ਜਦਕਿ `is_valid()`/`save()` ਪੈਟਰਨ ਪੂਰੇ create/update ਜੀਵਨ ਚੱਕਰ ਨੂੰ ਸਾਫ਼ ਢੰਗ ਨਾਲ ਸੰਭਾਲਦਾ ਹੈ।

ਜਾਣਨਾ ਕਿ ਕਿਵੇਂ ਵਸਤੂਆਂ ਅਤੇ querysets ਨੂੰ serialize ਕਰਨਾ ਹੈ, inbound ਇਨਪੁਟ ਨੂੰ deserialize ਅਤੇ validate ਕਰਨਾ ਹੈ, custom validation ਅਤੇ computed ਖੇਤ ਜੋੜਨਾ ਹੈ, ਅਤੇ ਸਬੰਧਿਤ ਡੇਟਾ ਲਈ **nested serializers** ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹੈ (ਡੇਟਾਬੇਸ ਸਕੀਮਾ ਤੋਂ ਸੁਤੰਤਰ API ਦੀ ਸ਼ਕਲ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦਾ ਹੋਇਆ) APIs ਬਣਾਉਣ ਲਈ ਮੌਲਿਕ ਹੈ।

Serializers ਇੱਥੇ DRF ਡੇਟਾ ਪਰਿਵਰਤਨ ਅਤੇ validation ਦੀਆਂ ਮੂਲ API ਚਿੰਤਾਵਾਂ ਨੂੰ ਸੰਭਾਲਦੇ ਹਨ, ਜੋ ਉਨ੍ਹਾਂ ਨੂੰ ਕੇਂਦਰੀ, ਜ਼ਰੂਰੀ-ਜਾਣਨ ਵਾਲਾ ਗਿਆਨ ਬਣਾਉਂਦਾ ਹੈ — ਰਵਾਇਤੀ Django ਲਈ forms ਦੇ ਮਹੱਤਵ ਵਿੱਚ ਅਨੁਸਾਰੀ, ਪਰ API-ਚਲਾਏ ਅਨੁਪ੍ਰਯੋਗਾਂ ਲਈ ਜੋ ਆਧੁਨਿਕ ਵੈੱਬ ਵਿਕਾਸ ਵਿੱਚ ਪ੍ਰਭਾਵਿਤ ਹਨ।