Was sind DRF ViewSets und Router?

Question

Accepted Answer

In Django REST Framework gruppieren **ViewSets** die Logik für einen Satz verwandter API-Endpunkte (die CRUD-Operationen für eine Ressource) in einer einzigen Klasse, und **Router** generieren automatisch das URL-Routing dafür. Zusammen reduzieren sie den Boilerplate für die Erstellung von RESTful APIs dramatisch.

## ModelViewSet — vollständiges CRUD in wenigen Zeilen

```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)
```

Ein `ModelViewSet` stellt automatisch den **kompletten Satz von RESTful CRUD-Endpunkten** für ein Modell bereit — list, create, retrieve, update, partial update und delete — nur aus einem Queryset und einem Serializer. Es ist nicht nötig, jede View separat zu schreiben.

## Router — automatische URL-Generierung

```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
```

Ein **Router** ordnet ein ViewSet automatisch einem vollständigen Satz von Standard-RESTful-URLs zu — das Registrieren eines ViewSet generiert alle konventionellen Endpunkte mit korrekten HTTP-Methoden und eliminiert die manuelle URL-Konfiguration.

## ViewSets anpassen

```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 werden angepasst, indem man Methoden überschreibt (`get_queryset`, `perform_create`), Berechtigungen festlegt und **benutzerdefinierte Aktionen** (`@action`) für Endpunkte über das Standard-CRUD hinaus hinzufügt.

## ViewSets vs. generische 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.
```

## Warum es wichtig ist

ViewSets und Router sind eine leistungsstarke DRF-Funktion zum effizienten Erstellen von RESTful APIs — sie stellen die höchste Abstraktionsebene für den äußerst häufigen Fall dar, ein Modell als vollständige REST-Ressource bereitzustellen, und das Verständnis dafür ist für produktive API-Entwicklung wertvoll.

Der Hauptvorteil ist eine dramatische **Boilerplate-Reduktion**: Ein `ModelViewSet` plus ein Router geben dir eine komplette, konventionelle REST API für eine Ressource (alle CRUD-Endpunkte mit korrekten HTTP-Methoden und URLs) nur aus einem Queryset und Serializer — ersetzt das, was sonst viele separate Views und manuelle URL-Muster wären.

Dies macht die Erstellung von Standard-REST-APIs bemerkenswert schnell, während **RESTful-Konventionen** (konsistente URL-Struktur und HTTP-Methoden-Semantik) automatisch befolgt werden.

ViewSets bleiben flexibel — du passt sie an, indem du Methoden überschreibst (Filterung des Querysets pro Benutzer, Kontrolle von Berechtigungen, Einhängung in create/update) und **benutzerdefinierte Aktionen** (`@action`) für Endpunkte über das grundlegende CRUD hinaus hinzufügst.

Das Verständnis von ViewSets und Routern, wie sie Endpunkte generieren, wie man sie anpasst, und **wann man sie einsetzt** (konventionelle REST-Ressourcen) versus explizitere generische Views oder APIView (benutzerdefinierte/nicht standardisierte Endpunkte) ist wichtiges praktisches Wissen für die DRF-Entwicklung.

Da die Erstellung von REST APIs heute eine primäre Verwendung von Django ist, und ViewSets+Router sind der idiomatische, produktivste Weg, um es für Standard-Ressourcen zu tun, sind sie ein häufig verwendeter, wichtiger Teil des DRF-Toolkits, der es Entwicklern ermöglicht, robuste APIs mit minimalem Code zu erstellen und dabei die Flexibilität zu behalten, um benutzerdefinierte Anforderungen zu erfüllen.