Wat zijn views in Django?

Question

Accepted Answer

Een **view** is de logica-laag van Django — een functie of klasse die een HTTP **request** ontvangt, logica uitvoert (modellen opvragen, input verwerken) en een HTTP **response** retourneert. Views zijn waar u regelt wat er gebeurt wanneer een URL wordt bezocht.

## Function-based views (FBVs)

```python
from django.shortcuts import render, get_object_or_404
from django.http import JsonResponse, HttpResponse

def article_list(request):
    articles = Article.objects.all()                    # query models
    return render(request, "articles.html", {"articles": articles})  # render a template

def article_detail(request, pk):
    article = get_object_or_404(Article, pk=pk)         # 404 if not found
    return render(request, "detail.html", {"article": article})

def api_articles(request):
    data = list(Article.objects.values("title", "body"))
    return JsonResponse(data, safe=False)               # return JSON instead of HTML
```

Een function-based view ontvangt de `request` (plus eventuele URL-parameters), voert zijn werk uit en retourneert een response — `render()` voor HTML, `JsonResponse` voor JSON, `HttpResponse` voor onbewerkte output.

## Het afhandelen van verschillende HTTP-methoden en input

```python
def create_article(request):
    if request.method == "POST":
        form = ArticleForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect("article_list")             # redirect after a successful POST
    else:
        form = ArticleForm()
    return render(request, "create.html", {"form": form})
```

Views inspecteren `request.method` (GET, POST, enz.) en hebben toegang tot input via `request.POST`, `request.GET`, `request.user`, enz.

## Class-based views (CBVs) — herbruikbaar, minder boilerplate

```python
from django.views.generic import ListView, DetailView

# generic CBVs handle common patterns with minimal code
class ArticleListView(ListView):
    model = Article                                     # automatically lists all articles
    template_name = "articles.html"

class ArticleDetailView(DetailView):
    model = Article
```

Django biedt ook **class-based views** — inclusief generic views (`ListView`, `DetailView`, `CreateView`) die veel voorkomende patronen (listing, detail, CRUD) implementeren met zeer weinig code, waardoor boilerplate wordt gereduceerd.

## De rol van de view in de request-flow

```text
Request → URL routing → VIEW (logic) → queries models, renders template → Response
The view is the orchestrator: it connects the URL, the data (models), and the
presentation (template) to produce a response.
```

## Waarom het belangrijk is

Views zijn de logica-laag van Django (de "V" in MVT, equivalent aan MVC's controller) — dit is waar u elke request afhandelt, waardoor ze fundamenteel zijn voor het bouwen van elke Django-applicatie.

Views begrijpen is essentieel omdat zij de orkestrators zijn die alles samenbrengen: de request ontvangen, bedrijfslogica toepassen, modellen opvragen voor data, gebruikersinput verwerken (formulieren) en de juiste response retourneren (HTML via templates of JSON voor APIs).
">Kennis hebben van hoe u **function-based views** schrijft (expliciet, flexibel — goed voor aangepaste logica), verschillende HTTP-methoden afhandelt en request-data benadert, en **class-based/generic views** gebruikt (die boilerplate voor veel voorkomende patronen zoals listing en CRUD drastisch verminderen) dekt het praktische spectrum voor het bouwen van Django-endpoints.

Views zijn waar het grootste deel van de request-handling logica van een applicatie zich bevindt, dus het beheersen ervan — de request/response-cyclus, de keuze tussen function-based en class-based benaderingen en hoe views URLs met modellen en templates verbinden — is kernkennis op dagelijks niveau voor elke Django-ontwikkelaar en centraal voor hoe het framework requests verwerkt.