Python DRF Serializer Relations: Sisseehitatud objektide serialiseerimise valdamine

Django REST Framework (DRF) pakub võimsa ja paindliku süsteemi veebi-API-de ehitamiseks. API arenduse oluline aspekt on andmemudelite vaheliste suhete käsitlemine ning DRF-i serialiseerijad pakuvad tugevaid mehhanisme sisseehitatud objektide serialiseerimiseks ja deserialiseerimiseks. See juhend uurib erinevaid viise suhete haldamiseks DRF-i serialiseerijates, pakkudes praktilisi näiteid ja parimaid tavasid.

Serialiseerija seoste mõistmine

Relatsioonilistes andmebaasides määratlevad seosed, kuidas erinevad tabelid või mudelid on ühendatud. DRF-i serialiseerijad peavad neid seoseid kajastama, kui andmebaasi objekte teisendatakse JSON-vormingusse või muudesse andmevormingutesse API tarbimiseks. Me käsitleme kolme peamist seoste tüüpi:

• ForeignKey (üks-mitmele): Üks objekt on seotud mitme muu objektiga. Näiteks võib üks autor kirjutada palju raamatuid.
• ManyToManyField (mitu-mitmele): Mitu objekti on seotud mitme muu objektiga. Näiteks võivad mitu autorit teha koostööd mitme raamatu kallal.
• OneToOneField (üks-ühele): Üks objekt on unikaalselt seotud teise objektiga. Näiteks on kasutajaprofiil sageli ühendatud üks-ühele kasutajakontoga.

Põhiline sisseehitatud serialiseerimine ForeignKeyga

Alustame lihtsa näitega ForeignKey seose serialiseerimisest. Vaatame neid mudeleid:

from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=100)
    country = models.CharField(max_length=50, default='USA') # Lisades riigi välja rahvusvahelise konteksti jaoks

    def __str__(self):
        return self.name

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(Author, on_delete=models.CASCADE, related_name='books')
    publication_date = models.DateField()

    def __str__(self):
        return self.title

Raamatu `Book` serialiseerimiseks koos sellega seotud autori `Author` andmetega saame kasutada sisseehitatud serialiseerijat:

from rest_framework import serializers

class AuthorSerializer(serializers.ModelSerializer):
    class Meta:
        model = Author
        fields = ['id', 'name', 'country']

class BookSerializer(serializers.ModelSerializer):
    author = AuthorSerializer(read_only=True) # Muudetud PrimaryKeyRelatedFieldist

    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'publication_date']

Selles näites sisaldab `BookSerializer` välja `AuthorSerializer`. `read_only=True` muudab välja `author` ainult loetavaks, takistades autori muutmist raamatu lõpp-punkti kaudu. Kui teil on vaja luua või värskendada raamatuid autori teabega, peate kirjutamistoiminguid käsitlema erinevalt (vt allpool).

Nüüd, kui serialiseerite objekti `Book`, sisaldab JSON-väljund täielikke autori andmeid, mis on raamatu andmetesse sisseehitatud:

{
    "id": 1,
    "title": "Pöidlaküüdi reisijuht Galaktikas",
    "author": {
        "id": 1,
        "name": "Douglas Adams",
        "country": "UK"
    },
    "publication_date": "1979-10-12"
}

ManyToManyField seoste serialiseerimine

Vaatame `ManyToManyField` seost. Oletame, et meil on `Category` mudel ja raamat võib kuuluda mitmesse kategooriasse.

class Category(models.Model):
    name = models.CharField(max_length=100)

    def __str__(self):
        return self.name

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(Author, on_delete=models.CASCADE, related_name='books')
    categories = models.ManyToManyField(Category, related_name='books')
    publication_date = models.DateField()

    def __str__(self):
        return self.title

Me saame serialiseerida kategooriaid kasutades `serializers.StringRelatedField` või `serializers.PrimaryKeyRelatedField` või luua sisseehitatud serialiseerija.

class CategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = Category
        fields = ['id', 'name']

class BookSerializer(serializers.ModelSerializer):
    author = AuthorSerializer(read_only=True)
    categories = CategorySerializer(many=True, read_only=True) # many=True on ManyToManyFieldi jaoks oluline

    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'categories', 'publication_date']

Argument `many=True` on `ManyToManyField` serialiseerimisel ülioluline. See ütleb serialiseerijale, et ta ootaks kategooria objektide loendit. Väljund näeb välja selline:

{
    "id": 1,
    "title": "Uhkus ja eelarvamus",
    "author": {
        "id": 2,
        "name": "Jane Austen",
        "country": "UK"
    },
    "categories": [
        {
            "id": 1,
            "name": "Klassikaline kirjandus"
        },
        {
            "id": 2,
            "name": "Romantika"
        }
    ],
    "publication_date": "1813-01-28"
}

OneToOneField seoste serialiseerimine

`OneToOneField` seoste puhul on lähenemine sarnane ForeignKeyle, kuid oluline on käsitleda juhtumeid, kus seotud objekt ei pruugi eksisteerida.

from django.contrib.auth.models import User

class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='profile')
    bio = models.TextField(blank=True)
    location = models.CharField(max_length=100, blank=True, default='Global') # Lisatud asukoht rahvusvahelise konteksti jaoks

    def __str__(self):
        return self.user.username

class UserProfileSerializer(serializers.ModelSerializer):
    class Meta:
        model = UserProfile
        fields = ['id', 'bio', 'location']

class UserSerializer(serializers.ModelSerializer):
    profile = UserProfileSerializer(read_only=True)

    class Meta:
        model = User
        fields = ['id', 'username', 'email', 'profile']

Väljund oleks:

{
    "id": 1,
    "username": "johndoe",
    "email": "john.doe@example.com",
    "profile": {
        "id": 1,
        "bio": "Tarkvara insener.",
        "location": "London, UK"
    }
}

Kirjutamistoimingute (loomine ja värskendamine) käsitlemine

Ülaltoodud näited keskenduvad peamiselt ainult loetavale serialiseerimisele. Seotud objektide loomiseks või värskendamiseks peate oma serialiseerijas üle kirjutama meetodid `create()` ja `update()`.

Sisseehitatud objektide loomine

Oletame, et soovite luua uue raamatu ja autori samaaegselt.

class BookSerializer(serializers.ModelSerializer):
    author = AuthorSerializer()

    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'publication_date']

    def create(self, validated_data):
        author_data = validated_data.pop('author')
        author = Author.objects.create(**author_data)
        book = Book.objects.create(author=author, **validated_data)
        return book

Meetodis `create()` eraldame autori andmed, loome uue autori objekti `Author` ja seejärel loome raamatu objekti `Book`, sidudes selle äsja loodud autoriga.

Tähtis: Peate käsitlema võimalikke valideerimisvigu `author_data`. Saate kasutada try-except plokki ja tõsta `serializers.ValidationError`, kui autori andmed on valed.

Sisseehitatud objektide värskendamine

Sarnaselt, et värskendada nii raamatut kui ka selle autorit:

class BookSerializer(serializers.ModelSerializer):
    author = AuthorSerializer()

    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'publication_date']

    def update(self, instance, validated_data):
        author_data = validated_data.pop('author', None)

        if author_data:
            author = instance.author
            for attr, value in author_data.items():
                setattr(author, attr, value)
            author.save()

        for attr, value in validated_data.items():
            setattr(instance, attr, value)
        instance.save()

        return instance

Meetodis `update()` hangime olemasoleva autori, värskendame selle atribuute vastavalt esitatud andmetele ja seejärel värskendame raamatu atribuute. Kui `author_data` pole esitatud (mis tähendab, et autorit ei värskendata), jätab kood autori värskendamise osa vahele. Vaikeväärtus `None` väärtuses `validated_data.pop('author', None)` on ülioluline, et käsitleda juhtumeid, kus autori andmeid värskendustaotluses ei ole.

`PrimaryKeyRelatedField` kasutamine

Sisseehitatud serialiseerijate asemel saate kasutada `PrimaryKeyRelatedField`, et esitada seoseid, kasutades seotud objekti primaarvõtit. See on kasulik, kui teil on vaja ainult viidata seotud objekti ID-le ja te ei soovi kogu objekti serialiseerida.

class BookSerializer(serializers.ModelSerializer):
    author = serializers.PrimaryKeyRelatedField(queryset=Author.objects.all())

    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'publication_date']

Nüüd sisaldab väli `author` autori ID-d:

{
    "id": 1,
    "title": "1984",
    "author": 3,  // Autori ID
    "publication_date": "1949-06-08"
}

Loomise ja värskendamise jaoks edastaksite autori ID taotluse andmetes. `queryset=Author.objects.all()` tagab, et esitatud ID on andmebaasis olemas.

`HyperlinkedRelatedField` kasutamine

`HyperlinkedRelatedField` esitab seoseid, kasutades hüperlinke seotud objekti API lõpp-punkti. See on tavaline hüpermeedia API-des (HATEOAS).

class BookSerializer(serializers.ModelSerializer):
    author = serializers.HyperlinkedRelatedField(view_name='author-detail', read_only=True)

    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'publication_date']

Argument `view_name` määrab vaate nime, mis käsitleb seotud objekti taotlusi (nt `author-detail`). Peate selle vaate määratlema oma failis `urls.py`.

Väljund sisaldab URL-i, mis viitab autori detailivaate lõpp-punktile:

{
    "id": 1,
    "title": "Hea uus ilm",
    "author": "http://example.com/api/authors/4/",
    "publication_date": "1932-01-01"
}

Täiustatud tehnikad ja kaalutlused

• `depth` Valik: Failis `ModelSerializer` saate kasutada valikut `depth`, et luua automaatselt sisseehitatud serialiseerijaid ForeignKey seostele kuni teatud sügavuseni. Kuid `depth` kasutamine võib põhjustada jõudlusprobleeme, kui seosed on keerulised, seega on üldiselt soovitatav serialiseerijad selgesõnaliselt määratleda.
• `SerializerMethodField`: Kasutage `SerializerMethodField`, et luua seotud andmete jaoks kohandatud serialiseerimisloogikat. See on kasulik, kui teil on vaja andmeid konkreetsel viisil vormindada või lisada arvutatud väärtusi. Näiteks saate kuvada autori täisnime erinevas järjekorras, lähtudes lokaadist. Paljude Aasia kultuuride puhul on perekonnanimi enne eesnime.
• Esituse kohandamine: Kirjutage oma serialiseerijas üle meetod `to_representation()`, et kohandada seotud andmete esitusviisi.
• Jõudluse optimeerimine: Keeruliste seoste ja suurte andmekogumite puhul kasutage selliseid tehnikaid nagu select_related ja prefetch_related, et optimeerida andmebaasipäringuid ja vähendada andmebaasi tabamuste arvu. See on eriti oluline API-de puhul, mis teenindavad globaalseid kasutajaid, kellel võivad olla aeglasemad ühendused.
• Nullväärtuste käsitlemine: Olge teadlik sellest, kuidas nullväärtusi teie serialiseerijates käsitletakse, eriti valikuliste seoste korral. Vajadusel kasutage oma serialiseerija väljadel `allow_null=True`.
• Valideerimine: Rakendage tugev valideerimine, et tagada andmete terviklikkus, eriti seotud objektide loomisel või värskendamisel. Kaaluge kohandatud valideerijate kasutamist ärireeglite jõustamiseks. Näiteks ei tohiks raamatu avaldamiskuupäev olla tulevikus.
• Rahvusvahelistamine ja lokaliseerimine (i18n/l10n): Kaaluge, kuidas teie andmeid kuvatakse erinevates keeltes ja piirkondades. Vormindage kuupäevi, numbreid ja valuutasid sobivalt kasutaja lokaadi jaoks. Salvestage rahvusvahelistatavad stringid oma mudelites ja serialiseerijates.

Serialiseerija seoste parimad tavad

• Hoidke serialiseerijad keskendunud: Iga serialiseerija peaks vastutama konkreetse mudeli või tihedalt seotud andmekogumi serialiseerimise eest. Vältige liiga keeruliste serialiseerijate loomist.
• Kasutage selgesõnalisi serialiseerijaid: Vältige liigset tuginemist valikule `depth`. Määratlege iga seotud mudeli jaoks selgesõnalised serialiseerijad, et omada suuremat kontrolli serialiseerimisprotsessi üle.
• Testige põhjalikult: Kirjutage ühiku testid, et kontrollida, kas teie serialiseerijad serialiseerivad ja deserialiseerivad andmeid õigesti, eriti keeruliste seoste korral.
• Dokumenteerige oma API: Dokumenteerige selgelt oma API lõpp-punktid ja andmevormingud, mida nad ootavad ja tagastavad. Kasutage selliseid tööriistu nagu Swagger või OpenAPI, et genereerida interaktiivne API dokumentatsioon.
• Kaaluge API versioonimist: Kuna teie API areneb, kasutage versioonimist, et säilitada ühilduvus olemasolevate klientidega. See võimaldab teil tutvustada murrangulisi muudatusi, mõjutamata vanemaid rakendusi.
• Jälgige jõudlust: Jälgige oma API jõudlust ja tuvastage kõik serialiseerija seostega seotud kitsaskohad. Kasutage profileerimistööriistu andmebaasipäringute ja serialiseerimisloogika optimeerimiseks.

Järeldus

Serialiseerija seoste valdamine Django REST Frameworkis on oluline tugevate ja tõhusate veebi-API-de ehitamiseks. Mõistes erinevaid seoste tüüpe ja erinevaid DRF-i serialiseerijates saadaolevaid valikuid, saate tõhusalt serialiseerida ja deserialiseerida sisseehitatud objekte, käsitleda kirjutamistoiminguid ja optimeerida oma API-t jõudluse saavutamiseks. Pidage meeles, et API kujundamisel tuleb arvestada rahvusvahelistamise ja lokaliseerimisega, et tagada selle kättesaadavus globaalsele vaatajaskonnale. Põhjalik testimine ja selge dokumentatsioon on võti teie API pikaajalise hooldatavuse ja kasutatavuse tagamiseks.