Hvad er DRF viewsets og routers?

Question

Accepted Answer

I Django REST Framework grupperer **viewsets** logikken for et sæt relaterede API-endpoints (CRUD-operationerne for en ressource) i en enkelt klasse, og **routers** genererer automatisk URL-routingen for dem. Sammen reducerer de dramatisk boilerplate ved opbygning af RESTful API'er.

## ModelViewSet — fuldt CRUD på få linjer

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

En `ModelViewSet` tilbyder automatisk **det komplette sæt af RESTful CRUD-endpoints** for en model — list, create, retrieve, update, partial update og delete — fra blot en queryset og serializer. Der er ingen grund til at skrive hver view separat.

## Routers — automatisk URL-generering

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

En **router** kortlægger en viewset til et fuldt sæt af standard RESTful URL'er automatisk — registrering af en viewset genererer alle de konventionelle endpoints med korrekte HTTP-metoder, hvilket eliminerer manuel URL-konfiguration.

## Tilpasning af viewsets

```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 tilpasses ved at overstyre metoder (`get_queryset`, `perform_create`), indstille permissions og tilføje **custom actions** (`@action`) for endpoints ud over standard CRUD.

## Viewsets vs generiske 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.
```

## Hvorfor det betyder noget

Viewsets og routers er en kraftfuld DRF-funktion til effektiv opbygning af RESTful API'er — de repræsenterer det højeste abstraktion-niveau for det ekstremt almindelige tilfælde af at eksponere en model som en fuld REST-ressource, og at forstå dem er værdifuldt for produktiv API-udvikling.

Hovedfordelen er dramatisk **boilerplate-reduktion**: en `ModelViewSet` plus en router giver dig et komplet, konventionelt REST API for en ressource (alle CRUD-endpoints med korrekte HTTP-metoder og URL'er) fra blot en queryset og serializer — hvilket erstatter hvad der ellers ville være mange separate views og manuelle URL-mønstre.

Dette gør opbygning af standard REST API'er bemærkelsesværdig hurtigt, samtidig med at **RESTful-konventioner** (konsistent URL-struktur og HTTP-metode-semantik) følges automatisk.

Viewsets forbliver fleksible — du tilpasser dem ved at overstyre metoder (filtrering af queryset pr. bruger, styring af permissions, hook ind i create/update) og tilføje **custom actions** (`@action`) for endpoints ud over grundlæggende CRUD.

Forståelse af viewsets og routers, hvordan de genererer endpoints, hvordan man tilpasser dem, og **hvornår man bruger dem** (konventionelle REST-ressourcer) versus mere eksplicitte generiske views eller APIView (custom/ikke-standard endpoints) er vigtig praktisk viden for DRF-udvikling.

Da opbygning af REST API'er er en primær brug af Django i dag, og viewsets+routers er den idiomatiske, mest produktive måde at gøre det på for standard-ressourcer, er de en hyppigt brugt, vigtig del af DRF-værktøjskassen, der gør det muligt for udviklere at bygge robuste API'er med minimal kode, samtidig med at de bevarer fleksibiliteten til at håndtere brugerdefinerede krav.