Hva er DRF viewsets og routers?

Question

Accepted Answer

I Django REST Framework grupperer **viewsets** logikken for et sett med relaterte API-endepunkter (CRUD-operasjonene for en ressurs) inn i en enkelt klasse, og **routers** genererer automatisk URL-rutingen for dem. Sammen reduserer de dramatisk boilerplate ved bygging av RESTful API-er.

## ModelViewSet — fullstendig 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` tilbyr automatisk det **komplette settet med RESTful CRUD-endepunkter** for en modell — list, create, retrieve, update, partial update, og delete — fra bare en queryset og serializer. Ingen grunn til å 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** kartlegger en viewset til et fullstendig sett med standard RESTful URL-er automatisk — registrering av en viewset genererer alle de konvensjonelle endepunktene med riktige HTTP-metoder, og eliminerer manuell URL-konfigurasjon.

## Tilpasse 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 å overstyre metoder (`get_queryset`, `perform_create`), sette tillatelser, og legge til **egendefinerte handlinger** (`@action`) for endepunkter utover 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 betyr noe

Viewsets og routers er en kraftig DRF-funksjon for å bygge RESTful API-er effektivt — de representerer det høyeste abstraksjonnivået for det ekstremt vanlige tilfellet med å eksponere en modell som en fullstendig REST-ressurs, og å forstå dem er verdifullt for produktiv API-utvikling.

Hovedfordelen er dramatisk **reduksjon av boilerplate**: en `ModelViewSet` pluss en router gir deg et komplett, konvensjonelt REST API for en ressurs (alle CRUD-endepunkter med riktige HTTP-metoder og URL-er) fra bare en queryset og serializer — som erstatter det som ellers ville vært mange separate views og manuelle URL-mønstre.

Dette gjør bygging av standard REST API-er bemerkelsesverdig rask samtidig som det sikrer at **RESTful-konvensjoner** (konsistent URL-struktur og HTTP-metodesemantikk) følges automatisk.

Viewsets forblir fleksible — du tilpasser dem ved å overstyre metoder (filtrering av queryset per bruker, kontroll av tillatelser, innfesting i create/update) og legge til **egendefinerte handlinger** (`@action`) for endepunkter utover grunnleggende CRUD.

Å forstå viewsets og routers, hvordan de genererer endepunkter, hvordan du tilpasser dem, og **når du skal bruke dem** (konvensjonelle REST-ressurser) versus mer eksplisitte generiske views eller APIView (tilpassede/ikke-standard endepunkter) er viktig praktisk kunnskap for DRF-utvikling.

Siden bygging av REST API-er er en primær bruk av Django i dag, og viewsets+routers er den idiomatiske, mest-produktive måten å gjøre det på for standard ressurser, er de en hyppig brukt, viktig del av DRF-verktøysetet som lar utviklere bygge robuste API-er med minimal kode samtidig som de beholder fleksibiliteten til å håndtere tilpassede krav.