Django Form en DRF Serializer: Vergelijkbaar, maar toch verschillend – een diepgaande analyse

• Django Form is een tool voor het valideren van HTML-invoergegevens.
• DRF Serializer is een tool voor het valideren en transformeren van JSON API-gegevens.
• Beide tools hebben een zeer vergelijkbare stroom voor is_valid(), gevalideerde gegevens en foutafhandeling.
• ModelForm en ModelSerializer lijken ook op elkaar wat betreft modelgebaseerde automatische veldgeneratie en opslagstructuur.

De overeenkomsten tussen Django Form en DRF Serializer

Wanneer we Django gebruiken, zijn er twee 'poortwachters' die ons het meest ondersteunen (en soms hoofdpijn bezorgen): Django Form en de DRF (Django REST Framework) Serializer. Laten we hun overeenkomsten eens op een rijtje zetten.

Hoewel deze twee 'vrienden' op verschillende podia opereren (webpagina's versus API's), lijken hun fundamentele rol en structuur, namelijk "externe gegevens veilig valideren en intern verwerken, en interne gegevens mooi verpakken voor extern gebruik", griezelig veel op elkaar.

1. Rollen in één oogopslag

Om een eenvoudige analogie te gebruiken: ze zijn als de 'beveiligingsbeambten en receptionisten' bij de ingang van een warenhuis.

• Django Form: Werkt voornamelijk in de wereld van HTML-webpagina's. Het controleert of de gegevens (Form Data) die door de gebruiker in het browservenster zijn ingevoerd correct zijn, en als er fouten zijn, wordt er vriendelijk op het scherm getekend: "Voer opnieuw in".
• DRF Serializer: Werkt voornamelijk in de API-wereld waar JSON wordt uitgewisseld. Het converteert JSON-gegevens die door mobiele apps of front-ends (zoals React, Vue) zijn verzonden naar Python-objecten, en verpakt (serialiseert) omgekeerd databasegegevens netjes in JSON.

2. Waarom lijken ze zo op elkaar? Drie structurele overeenkomsten

De ontwikkelaars van DRF waren zo onder de indruk van de uitstekende structuur van Django Form dat ze deze vrijwel direct hebben overgenomen om de Serializer te creëren. Daarom lijken de codestructuur en het gebruik ervan op een tweeling.

① Identieke manier van velddefinities

De manier waarop wordt gespecificeerd welk type gegevens moeten worden ingevoerd, is exact hetzelfde.

• Django Form:

from django import forms

class UserForm(forms.Form):
    username = forms.CharField(max_length=100)
    email = forms.EmailField()
    age = forms.IntegerField()

• DRF Serializer:

    from rest_framework import serializers

    class UserSerializer(serializers.Serializer):
        username = serializers.CharField(max_length=100)
        email = serializers.EmailField()
        age = serializers.IntegerField()

Afgezien van het feit dat forms is vervangen door serializers, is de logica voor het declareren van velden volledig identiek.

② Identieke validatie en gegevensbenadering

De workflow voor het controleren van de veiligheid van gegevens en het benaderen van gevalideerde gegevens is consistent.

1. Validatie: Beide methoden roepen if form.is_valid(): of if serializer.is_valid(): aan nadat de gegevens zijn ingevoerd.
2. Toegang tot gevalideerde gegevens: De gevalideerde, schone gegevens worden opgeslagen in een dictionary: form.cleaned_data voor een Form, en serializer.validated_data voor een Serializer. De namen verschillen enigszins, maar de functionaliteit is hetzelfde.
3. Foutcontrole: Als de validatie mislukt, wordt via form.errors of serializer.errors een dictionary met foutmeldingen gegeven die aangeven wat er mis is gegaan.

③ Integratie met modellen (ModelForm vs ModelSerializer)

De kern van Django is de integratie met de database (Model). Beide tools hebben 'cheatsheet'-klassen die automatisch velden genereren op basis van een model.

• Django ModelForm:

    class MyModelForm(forms.ModelForm):
        class Meta:
            model = MyModel
            fields = ['title', 'content']

• DRF ModelSerializer:

    class MyModelSerializer(serializers.ModelSerializer):
        class Meta:
            model = MyModel
            fields = ['title', 'content']

De syntaxis voor het specificeren van het model en de velden via de interne Meta-klasse is griezelig identiek. Hierdoor kunnen gegevens in de database automatisch worden aangemaakt (create) of gewijzigd (update) door de save()-methode aan te roepen.

Tot slot

• Django Form fungeert als een tolk tussen HTML en Python, en valideert daarbij gegevens.
• DRF Serializer fungeert als een tolk tussen JSON en Python, en valideert daarbij gegevens.

Als je in het verleden met Django Form hebt gewerkt, dan is de gedachte "Ah, een Form die JSON verwerkt in plaats van HTML!" voor DRF Serializer voor meer dan 90% correct. Omgekeerd, als je eerst met Serializer in aanraking bent gekomen, zul je Form ook gemakkelijk begrijpen.

Toch denk ik dat veel backend-engineers, hoewel ze deze twee tools behoorlijk vergelijkbaar vinden, zich comfortabel voelen bij de Serializer, maar ongemak ervaren bij de Form, de basis van de Serializer. Ikzelf ervaar dat ook.

Heb je er ooit over nagedacht waarom je dat gevoel hebt? In het volgende deel wil ik ingaan op de redenen waarom Django Form, hoewel vergelijkbaar met Serializer, toch een ongemakkelijk gevoel kan geven naarmate je het meer gebruikt.

Als dit artikel nuttig was, geef dan een like! En kijk uit naar het volgende artikel.