Wat zijn DRF viewsets en routers?

Question

Accepted Answer

In Django REST Framework groeperen **viewsets** de logica voor een set gerelateerde API-eindpunten (de CRUD-bewerkingen voor een resource) in een enkele klasse, en **routers** genereren automatisch de URL-routering ervoor. Samen reduceren zij drastisch de boilerplate voor het bouwen van RESTful APIs.

## ModelViewSet — volledige CRUD in enkele regels

```python
from rest_framework import viewsets

class ArticleViewSet(viewsets.ModelViewSet):
    queryset = Article.objects.all()             # the data
    serializer_class = ArticleSerializer          # how to serialize it
    # That's it! This provides ALL standard CRUD endpoints automatically:
    #   list (GET), create (POST), retrieve (GET /id), update (PUT/PATCH /id), destroy (DELETE /id)
```

Een `ModelViewSet` biedt automatisch de **volledige set RESTful CRUD-eindpunten** voor een model — list, create, retrieve, update, partial update en delete — op basis van alleen een queryset en serializer. Geen behoefte om elke view afzonderlijk te schrijven.

## Routers — automatische URL-generatie

```python
from rest_framework.routers import DefaultRouter

router = DefaultRouter()
router.register(r"articles", ArticleViewSet)     # register the viewset

urlpatterns = router.urls
# automatically creates the RESTful URLs:
#   GET    /articles/        → list
#   POST   /articles/        → create
#   GET    /articles/{id}/   → retrieve
#   PUT    /articles/{id}/   → update
#   PATCH  /articles/{id}/   → partial update
#   DELETE /articles/{id}/   → destroy
```

Een **router** wijst een viewset automatisch toe aan een volledige set standaard RESTful URL's — het registreren van één viewset genereert alle conventionele eindpunten met correcte HTTP-methoden, wat handmatige URL-configuratie elimineert.

## Viewsets aanpassen

```python
class ArticleViewSet(viewsets.ModelViewSet):
    serializer_class = ArticleSerializer
    permission_classes = [IsAuthenticated]        # authorization

def get_queryset(self):                        # customize the data per request
        return Article.objects.filter(author=self.request.user)

# add CUSTOM endpoints beyond CRUD with @action
    @action(detail=True, methods=["post"])
    def publish(self, request, pk=None):           # POST /articles/{id}/publish/
        article = self.get_object()
        article.published = True
        article.save()
        return Response({"status": "published"})
```

Viewsets worden aangepast door methoden (`get_queryset`, `perform_create`) te overridden, machtigingen in te stellen en **custom actions** (`@action`) toe te voegen voor eindpunten voorbij standaard CRUD.

## Viewsets vs generieke API views

```text
ModelViewSet  → ALL CRUD in one class + router → least code for standard REST resources
Generic views (ListCreateAPIView, etc.) → more explicit, one class per endpoint group
APIView       → full manual control for non-standard/custom endpoints
→ Use viewsets+routers for conventional REST resources; generic/APIView for custom needs.
```

## Waarom het belangrijk is

Viewsets en routers zijn een krachtig DRF-feature voor het efficiënt bouwen van RESTful APIs — zij vertegenwoordigen het hoogste abstractieniveau voor het uitermate gebruikelijke geval van het blootstellen van een model als volledige REST-resource, en het begrijpen ervan is waardevol voor productieve API-ontwikkeling.

Het belangrijkste voordeel is drastische **boilerplate-reductie**: een `ModelViewSet` plus een router geeft u een volledige, conventionele REST API voor een resource (alle CRUD-eindpunten met correcte HTTP-methoden en URL's) op basis van alleen een queryset en serializer — wat anders vele afzonderlijke views en handmatige URL-patronen zouden zijn.

Dit maakt het bouwen van standaard REST APIs opmerkelijk snel mogelijk terwijl **RESTful-conventies** (consistente URL-structuur en HTTP-methode-semantiek) automatisch worden gevolgd.

Viewsets blijven flexibel — u past ze aan door methoden te overridden (het queryset per gebruiker filteren, machtigingen controleren, hooks in create/update plaatsen) en **custom actions** (`@action`) toe te voegen voor eindpunten voorbij basis-CRUD.

Het begrijpen van viewsets en routers, hoe zij eindpunten genereren, hoe u ze aanpast en **wanneer u ze gebruikt** (conventionele REST-resources) versus meer expliciete generieke views of APIView (aangepaste/niet-standaard eindpunten) is belangrijke praktische kennis voor DRF-ontwikkeling.

Omdat het bouwen van REST APIs vandaag een primair gebruik van Django is, en viewsets+routers de idiosyncratische, meest productieve manier zijn om het te doen voor standaardresources, zijn zij een veelvuldig gebruikt, belangrijk onderdeel van de DRF-toolkit die ontwikkelaars in staat stelt om robuuste APIs met minimale code te bouwen terwijl de flexibiliteit behouden blijft om aangepaste vereisten te verwerken.