რა არის serializers Django REST Framework-ში?

Question

Accepted Answer

**Django REST Framework (DRF)** არის de facto სტანდარტი REST API-ების Django-ით აგებისთვის, და **serializers** არის მისი ძირითადი კონცეფცია. Serializer გარდაქმნის რთულ მონაცემებს (model instances, querysets) **JSON-ად** API პასუხებისთვის, და გარდაქმნის შემომავალ JSON-ს **უკან** ვალიდირებულ Python ობიექტებში — ორივე 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` ავტომატურად ქმნის ველებს model-დან (როგორც 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()` ვალიდირებს შემომავალ მონაცემებს ველების წესებისა და model-ის წინააღმდეგ, და `save()` აღსადეგებს მას. არასწორი მონაცემები აძლევენ სტრუქტურირებულ შეცდომის შეტყობინებებს.

## 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** აკეთოს დაკავშირებული ობიექტების წარმოსადგენად (ავტორის მონაცემების ჩაშენება სტატიის JSON-ში) — და თქვენ კონტროლირებთ API-ს ფორმას დამოუკიდებლად მონაცემთა ბაზისგან.

## რატომ არის მნიშვნელოვანი

Serializers არის REST API-ების აგების საფუძველი Django REST Framework-ით, რომელიც არის სტანდარტული ხელსაწყო Django API-ების სათვის — ამიტომ მათი გაგება აუცილებელია ნებისმიერი თანამედროვე Django back-end-ისთვის, რომელიც JSON-ს აწვდის frontends-ს, მობილური აპ-ების ან სხვა სერვისებს.

Serializers ხსნის API-ის ორ ფუნდამენტურ საჭიროებას: Python/model მონაცემების გარდაქმნა **JSON-ზე** პასუხებისთვის (serialization) და შემომავალი **JSON-ის გარდაქმნა ვალიდირებულ Python ობიექტებში** მონაცემების შექმნის/განახლებისთვის (deserialization + validation).

Validation ასპექტი კრიტიკულია **უსაფრთხოებისა და მდგრადობისთვის** — forms-ის მსგავსი HTML-ისთვის, serializers უზრუნველყოფს რომ თქვენ არასდროს დაიჯერებთ ნედლ API input-ს, ვალიდირებთ მას ველების წესების წინააღმდეგ მიღების წინ თქვენს მონაცემთა ბაზაში. **ModelSerializer** უზრუნველყოფს წარმოდგენილობის დიდი გამოწვევის სახით ველების ავტომატური გენერირებით model-დან (DRY, ModelForm-ის მსგავსი), რომელიც ტრივიალური ხდის models-ს API რესურსების როგორც ზედაპირის, ხოლო `is_valid()`/`save()` ნიმუში მოაგვარებს სრულ create/update ცხოვრებას დაკრეფილი.

გაგება თუ როგორ serialize-ს ობიექტები და querysets, deserialize და validate input-ი, დაამატოთ custom validation და computed fields, და გამოიყენეთ **nested serializers** დაკავშირებული მონაცემებისთვის (კონტროლირება API-ს ფორმა დამოუკიდებლად მონაცემთა ბაზის სქემისგან) არის ფუნდამენტური API-ების აგებისთვის.

Serializers არის სადაც DRF მოაგვარებს ჯამურ API კერძოებს მონაცემების ტრანსფორმაცია და validation-ის, რაც აკეთებს მათ ცენტრალურ, მუნიციპალიტეტ-ვიცი ცოდნას — ანალოგიური მნიშვნელობით forms-ის თანამედროვე Django-ში, მაგრამ API-driven აპ-ებისთვის, რომლებიც დომინირებენ თანამედროვე ვებ-განვითარებაში.