Wat is de MVT-architectuur?

Question

Accepted Answer

Django volgt de **MVT (Model-View-Template)** architectuur — een variatie op het klassieke MVC-patroon. Het verdeelt een applicatie in drie lagen: **Models** (gegevens), **Views** (logica) en **Templates** (presentatie). Het begrijpen van de lagen maakt duidelijk waar elk stuk code thuishoort. ## De drie lagen ```text Model → the DATA layer: defines structure & talks to the database (the ORM) View → the LOGIC layer: processes requests, fetches data, returns responses Template → the PRESENTATION layer: HTML with placeholders for dynamic data ``` ## Hoe ze samenwerken (de request flow) ```text Request → URLconf (routing) → VIEW → queries MODELS → renders TEMPLATE → Response ``` ```python # MODEL — defines the data (models.py) class Article(models.Model): title = models.CharField(max_length=200) body = models.TextField() # VIEW — the logic: fetch data, pass to a template (views.py) def article_list(request): articles = Article.objects.all() # query the MODEL return render(request, "articles.html", {"articles": articles}) # render a TEMPLATE ``` ```html {% for article in articles %}

{% endfor %} ``` De view bindt alles samen: deze ontvangt het request, vraagt gegevens op uit de models en rendert een template met die gegevens om het response te produceren. ## MVT vs MVC ```text Classic MVC: Model — View — Controller Django MVT: Model — Template — View The mapping (a common point of confusion): Django's VIEW ≈ MVC's CONTROLLER (the logic that handles requests) Django's TEMPLATE ≈ MVC's VIEW (the presentation) Model is the same in both → Django says the framework itself acts as the "controller" (URL routing/dispatch). ``` De naamgeving verschilt van MVC: Django's **View** speelt de rol van MVC's *Controller* (request-handling logica), en Django's **Template** speelt MVC's *View* (presentatie). De routing van het framework verzorgt de dispatch. ## Waarom deze scheiding ertoe doet ```text ✓ Separation of concerns — data, logic, and presentation are independent ✓ Maintainability — change the template without touching logic, etc. ✓ Reusability & testability — test views independently, reuse models/templates ``` ## Waarom het belangrijk is De MVT-architectuur is het fundamentele structuurpatroon van elke Django-applicatie — het begrijpen ervan vertelt je **waar elk stuk code thuishoort** (gegevensdefinities in models, request-handling logica in views, HTML-presentatie in templates), wat essentieel is voor het correct organiseren van elk Django-project. De scheiding van concerns die het afdwingt, maakt applicaties onderhoudbaar (presentatie wijzigen zonder de logica aan te raken), testbaar (views en models onafhankelijk testen) en herbruikbaar. Evenals belangrijk is het begrijpen van de **MVT-vs-MVC-toewijzing** — een frequente bron van verwarring — waarbij Django's "View" eigenlijk de controller-equivalent is (de logica) en Django's "Template" de view-equivalent is (de presentatie); het weten hiervan verduidelijkt de naamgeving en helpt ontwikkelaars van MVC-frameworks. De request flow (URL routing → view → models → template → response) is het mentale model voor hoe elk Django-request wordt verwerkt, waardoor MVT fundamenteel, must-know kennis is die onderbouwt hoe je alle Django-code structureert en erover nadenkt.