Onderzoek van klasse-gebaseerde views (CBV) serie③ – Eenvoudige formulierverwerking met FormView

gemaakt: 2025-05-30 tags: - python - CBV - formview - django - tutorial - FBV

“Los formulierverwerking gestroomlijnd op met klasse-gebaseerde views en verhoog de productiviteit van je ontwikkeling!”

In het vorige artikel zijn we begonnen met de basis View-klasse van Django en hebben we de voordelen van onderhoudbaarheid en uitbreidbaarheid van het schrijven van view-logica in een klasse besproken.

In deze post zullen we ons richten op de generieke view voor formulierverwerking die Django biedt, FormView.
Formulierverwerking is essentieel voor bijna elke website en webdienst die gebruikersinvoer vereist, dus als je Django FormView goed begrijpt, kun je zowel de ontwikkelingstijd als de codekwaliteit verhogen.

1. Wat is FormView?

---

---

Django's FormView is een krachtig hulpmiddel dat je helpt bij het eenvoudig implementeren van gebruikersinvoer verwerking.
Met FormView profiteer je van de volgende voordelen:

1. Geautomatiseerde formuliervalidatie: Er is geen noodzaak om opnieuw de logica te schrijven die controleert of de gebruikersinvoer geldig is en foutmeldingen afhandelt.

2. Vereenvoudigde sjabloonrendering: Je kunt gemakkelijk processen configureren zoals redirectie bij succes of opnieuw weergeven van het formulier bij foutmeldingen.

3. Duidelijke structuur: Door gebruik te maken van methoden zoals form_valid() en form_invalid() is de logica goed gescheiden, wat de leesbaarheid vergroot bij samenwerking.

4. Erfelijkheid en herbruikbaarheid: Je kunt eerder gemaakte FormViews erven om eenvoudig nieuwe formulieren toe te voegen, wat het onderhoud vergemakkelijkt, zelfs in grotere projecten.

Belangrijke sleutelwoorden: "automatisering van formulierverwerking", "herbruikbaarheid van code", "verhoging van productiviteit", "efficiënte formuliervalidatie"

2. Basisstructuur en werkingsprincipe van FormView

Bij het gebruik van FormView geef je doorgaans de volgende eigenschappen en methoden op:

from django.views.generic.edit import FormView
from .forms import MyForm

class MyFormView(FormView):
    template_name = 'form_template.html'  # Pad naar sjabloon dat het formulier toont
    form_class = MyForm                  # Te gebruiken formulierklasse
    success_url = '/success/'            # URL om naar door te zenden na succesvolle verwerking van het formulier

    def form_valid(self, form):
        # Logica die wordt uitgevoerd wanneer de formuliervalidatie succesvol is
        return super().form_valid(form)

    def form_invalid(self, form):
        # Logica die wordt uitgevoerd wanneer de formuliervalidatie mislukt (optioneel)
        return super().form_invalid(form)

Belangrijke eigenschappen

• template_name: Pad naar het sjabloonbestand dat het formulier rendert voor de gebruiker

• form_class: De daadwerkelijk te gebruiken Django forms.Form of forms.ModelForm

• success_url: Pad waar naartoe moet worden geleid na een succesvolle validatie van het formulier (redirectie)

Kernmethoden

• form_valid(form)

  • Wordt aangeroepen wanneer de gegevens die door de gebruiker zijn ingediend geldig zijn (cleaned_data).

  • Hier kun je logica implementeren voor het opslaan in de database, het doen van externe API-aanroepen, het verzenden van e-mails, enz.

• form_invalid(form) (optioneel)

  • Wordt aangeroepen wanneer de formuliervalidatie mislukt.

  • Je kunt het gebruiken om foutmeldingen in het sjabloon weer te geven of extra logboeken op te slaan als je dat wilt.

Django FormView beheert automatisch de stroom van “formulier weergeven bij GET-aanroep → formulier validatie bij POST-aanroep → uitvoeren van succeslogica als geldig, anders foutafhandeling”, waardoor je herhalende code minimaliseert.

3. Praktijkvoorbeeld: Verwerken van gebruikersinvoer

---

---

Bijvoorbeeld, laten we een formulier maken dat de e-mailadres van de gebruiker registreert en dit opslaat in de database of een eenvoudige bevestigingsboodschap weergeeft.

3.1 Schrijven van forms.py

# forms.py
from django import forms

class EmailForm(forms.Form):
    email = forms.EmailField(label='E-mailadres')

• De standaard EmailField van Django wordt gebruikt om automatisch de e-mailformaatvalidatie te verwerken.

3.2 Gebruik van FormView in views.py

# views.py
from django.views.generic.edit import FormView
from django.urls import reverse_lazy
from .forms import EmailForm

class EmailFormView(FormView):
    template_name = 'email_form.html'
    form_class = EmailForm
    success_url = reverse_lazy('email_success')  # Verwijzing naar URL-patroon

    def form_valid(self, form):
        email_data = form.cleaned_data['email']
        # Hier kun je de gegevens opslaan in de database of naar een externe service verzenden.
        print(f"E-mailadres ingevoerd door de gebruiker: {email_data}")
        return super().form_valid(form)

3.3 Sjabloon: email_form.html

<!-- email_form.html -->
<!DOCTYPE html>
<html>
<head>
    <title>E-mailadres invoeren</title>
</head>
<body>
    <h1>Voer uw e-mailadres in</h1>
    <form method="post">
        {% csrf_token %}
        {{ form.as_p }}
        <button type="submit">Bevestigen</button>
    </form>
</body>
</html>

3.4 Registreren in urls.py

# urls.py
from django.urls import path
from .views import EmailFormView

urlpatterns = [
    path('email/', EmailFormView.as_view(), name='email_form'),
    path('email/success/', TemplateView.as_view(template_name='success.html'), name='email_success'),
]

• Wanneer de gebruiker toegang heeft tot /email/, kan hij het e-mailformulier zien, en na indienen zal EmailFormView de validiteit van het formulier controleren.

• Als het geldig is, vindt er een redirect plaats naar het success_url, /email/success/.

4. Nuttige tips bij het gebruik van FormView

4.1 Overschrijven van success_url met get_success_url()

Als je naar een dynamisch pad wilt redirecten, is het nuttig om een methode in plaats van een eigenschap te gebruiken.

def get_success_url(self):
    # Bijvoorbeeld: als je de gebruiker naar een andere URL wilt sturen op basis van het ingevoerde e-mailadres?
    email_data = self.request.POST.get('email')
    return reverse('user_profile', kwargs={'email': email_data})

4.2 Refactoren naar ModelForm

Als je gegevens direct in de database moet opslaan, kun je forms.ModelForm gebruiken voor een meer vereenvoudigde verwerking.
In dat geval kun je ook overwegen om generieke views zoals CreateView en UpdateView te gebruiken. Dit zal in toekomstige artikelen over CRUD verder worden behandeld.

4.3 Foutenafhandeling en verbeteren van de gebruikerservaring (UX)

• FormView rendert standaard dezelfde sjabloon weer in geval van fouten en geeft foutmeldingen weer.

• Indien nodig kun je CSS-frameworks zoals Bootstrap gebruiken om foutmeldingen meer op te laten vallen, of je kunt AJAX gebruiken om alleen delen van het formulier opnieuw te laden.

5. Voordelen van FormView in vergelijking met bestaande FBV

De onderstaande tabel geeft kort de verschillen aan tussen het direct verwerken van formulieren met FBV (functie-gebaseerde views) en het gebruik van FormView (klasse-gebaseerde views):

6. Conclusie: voltooi efficiënte formulierverwerking met FormView!

Django FormView vereenvoudigt het proces van “gebruikersinvoer → validatie → resultaatverwerking”.
Daarom is het zeker de moeite waard om het een keer te proberen, als je de herhalende formulierlogica wilt verminderen en tegelijkertijd schone code en een productieve ontwikkelomgeving wilt bereiken.

Aankondiging van het volgende artikel: ListView & DetailView

In het volgende artikel zullen we bekijken hoe we ListView en DetailView kunnen gebruiken om gegevens efficiënt op te vragen. We zullen krachtige generieke views ontdekken die ons in staat stellen om snel lijsten en detailpagina's te implementeren, en we zullen opnieuw onder de indruk zijn van het gemak dat Django biedt.

De CBV-serie gaat verder!

• Deel 4: “Gebruik van ListView & DetailView”

• Deel 5: “CRUD-implementatie met CreateView, UpdateView en DeleteView”

• … (en verder)

Bekijk eerdere artikelen

• Onderzoek van klasse-gebaseerde views (CBV) serie #1 – Redenen voor de overstap van FBV naar CBV en de houding van ontwikkelaars

• Onderzoek van klasse-gebaseerde views (CBV) serie #2 – Het begrijpen van de basis View-klasse van Django

“Maak formulieren nog eenvoudiger en schoner met Django FormView!
Bespaar tijd (tijd besparen), verbeter de codekwaliteit (verbetering van de codekwaliteit),
en creëer geweldige webservices!”