Django REST Framework இல் serializers என்றால் என்ன?

Question

Accepted Answer

**Django REST Framework (DRF)** ஆனது Django உடன் REST APIs உருவாக்குவதற்கான நிலையான தரமாகும், மற்றும் **serializers** என்பது அதன் மைய கருத்தாகும். ஒரு serializer சிக்கலான தரவை (model instances, querysets) **முதல்** JSON ஆக API பதிலுக்கு மாற்றுகிறது, மற்றும் வரும் JSON ஐ **திரும்பி** validated Python objects ஆக மாற்றுகிறது — serialization மற்றும் validation இரண்டையும் கையாளுகிறது, HTML க்கான forms போலவே.

## ModelSerializer — common case

```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 போலவே) — minimal code உடன் ஒரு model ஐ 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
```

இந்த pattern forms போலவே உள்ளது: `is_valid()` incoming data ஐ field rules மற்றும் model க்கு எதிராக validate செய்கிறது, மற்றும் `save()` அதை persist செய்கிறது. Invalid data structured 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 ஆனது **nest** செய்யக்கூடியவையாகும் related objects ஐ represent செய்ய (ஒரு article இன் JSON க்குள் ஒரு author இன் தரவை embedding) — மற்றும் நீங்கள் database க்கு சுயாதீனமாக API இன் வடிவம் கட்டுப்படுத்தலாம்.

## என்ன முக்கியமாகும்

Serializers ஆனது Django REST Framework உடன் REST APIs உருவாக்குவதின் மூலக்கல்லாகும், இது Django APIs க்கான நிலையான tool ஆகும் — எனவே அவற்றை புரிந்துகொள்ள என்பது JSON ஐ frontends, mobile apps, அல்லது மற்ற services க்கு serving செய்யும் எந்தவொரு நவீன Django back-end க்கும் இன்றியமையாதது.

Serializers API இன் இரண்டு அடிப்படை தேவைகளை தீர்க்கிறது: Python/model data ஐ responses க்கு **JSON க்கு convert** செய்தல் (serialization) மற்றும் வரும் **JSON ஐ validated Python objects ற்கு convert** செய்தல் data ஐ create/update செய்ய (deserialization + validation).

Validation aspect **security மற்றும் robustness** க்கு গুருத்வமாகும் — HTML க்கான forms போலவே, serializers ஆனது நீங்கள் raw API input ஐ நம்பவே கூடாது என்பதை உறுதிசெய்கிறது, அது உங்கள் database ஐ அடைய முன்பு அதை field rules க்கு எதிராக validate செய்கிறது. **ModelSerializer** ஆனது models இலிருந்து fields ஐ auto-generate செய்வதன் மூலம் ஒரு பெரிய productivity win ஐ வழங்குகிறது (DRY, ModelForm போலவே), models ஐ API resources ஆக expose செய்ய trivial செய்கிறது, மற்றும் `is_valid()`/`save()` pattern ஆனது full create/update lifecycle ஐ cleanly handle செய்கிறது.

Objects மற்றும் querysets ஐ serialize செய்ய, input ஐ deserialize மற்றும் validate செய்ய, custom validation மற்றும் computed fields ஐ சேர்க்க, மற்றும் related data க்கு **nested serializers** ஐ பயன்படுத்த (database schema க்கு சுயாதீனமாக API இன் வடிவம் கட்டுப்படுத்த) எவ்வாறு செய்ய வேண்டும் என்பதை புரிந்துகொள்ளுதல் APIs உருவாக்குவதற்கு அடிப்படையாகும்.

Serializers ஆனது DRF க்கு data transformation மற்றும் validation இன் core API concerns ஐ handle செய்யும் இடமாகும், அவற்றை central, must-know knowledge ஆக செய்கிறது — traditional Django க்கான forms க்கு analogy இல் महत्व இல், ஆனால் நவீன web development ஐ support செய்யும் API-driven applications க்கு.