Çfarë janë serializers në Django REST Framework?

Question

IT Interview Practice · Accepted Answer

**Django REST Framework (DRF)** është standardi de facto për ndërtimin e REST API-ve me Django, dhe **serializers** janë koncepti i tij bërthamor. Një serializer konverton të dhëna komplekse (instanca modelesh, querysets) **në** JSON për përgjigjet e API-ve, dhe konverton JSON-in që vjen **prapa** në objekte të validuara Python — duke trajtuar si serializimin ashtu edhe validimin, ashtu siç bëjnë formet për HTML.

## ModelSerializer — rasti i zakonshëm

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

Një `ModelSerializer` gjeneron automatikisht fusha nga modeli (si një ModelForm) — kodi minimal për të serializuar dhe validuar një model.

## Serializimi: objekt → 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
```

## Deserializimi + validimi: JSON → objekt i validuar

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

Shtreja pasqyron formet: `is_valid()` validon të dhënat që vijnë kundrejt rregullave të fushave dhe modelit, dhe `save()` e ruan atë. Të dhënat e pavlefshme japin mesazhe gabimi të strukturuar.

## Validimi dhe fushat e vetëm

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

## Serializers të ndërthurur (të dhëna të lidhura)

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

Serializer-at mund të **ndërthuren** për të përfaqësuar objekte të lidhura (duke futur të dhënat e autorit brenda JSON-it të një artikulli) — dhe ju kontrolloni formën e API-ve në mënyrë të pavarur nga baza e të dhënave.

## Pse ka rëndësi

Serializer-at janë themeli i ndërtimit të REST API-ve me Django REST Framework, i cili është mjeti standard për Django API-ve — kështu që kuptimi i tyre është thelbësor për çdo back-end Django moderne që shërben JSON në frontends, aplikacione mobile, ose shërbime të tjera.

Serializer-at zgjidhin dy nevojat themelore të një API-je: konvertimi i të dhënave Python/modelesh **në JSON** për përgjigje (serializimi) dhe konvertimi i JSON-it që vjen **në objekte të validuara Python** për krijimin/azhurnimin e të dhënave (deserializimi + validimi).

Aspekti i validimit është kritik për **siguri dhe qëndrueshmëri** — si formet për HTML, serializers sigurohen që asnjëherë nuk i besoni hyrjeve të papërpunuara të API-ve, duke i validuar ato kundrejt rregullave të fushave përpara se të arrijnë në bazën tuaj të të dhënave. **ModelSerializer** ofron një fitim të madh produktiviteti duke gjeneruar automatikisht fusha nga modelet (DRY, si ModelForm), duke e bërë trivial të ekspozoni modelet si burime API-je, ndërsa modeli `is_valid()`/`save()` trajtuar ciklin e plotë të krijimit/azhurnimit në mënyrë të pastër.

Kuptimi se si të serializoni objektet dhe querysets, deserializoni dhe validoni hyrjen, shtoni validimin e vetëm dhe fushat e llogaritura, dhe përdorni **serializers të ndërthurur** për të dhëna të lidhura (kontrollimi i formës së API-ve në mënyrë të pavarur nga skema e bazës së të dhënave) është themelor për ndërtimin e API-ve.

Serializer-at janë vendi ku DRF trajtojnë shqetësimet bazë të API-ve të transformimit dhe validimit të të dhënave, duke i bërë ato njohuri qendrore, të domosdoshmërisht të njohura — analoge në rëndësi ndaj formave për Django-n tradicional, por për aplikacionet e drejtuar nga API-ja që dominojnë zhvillimin e uebit modern.

ModelSerializer — rasti i zakonshëm

Serializimi: objekt → JSON

Deserializimi + validimi: JSON → objekt i validuar

Validimi dhe fushat e vetëm

Serializers të ndërthurur (të dhëna të lidhura)

Pse ka rëndësi

Pyetje të ngjashme