Vad är DRF viewsets och routers?

Question

Accepted Answer

I Django REST Framework grupperar **viewsets** logiken för en uppsättning relaterade API-endpoints (CRUD-operationerna för en resurs) i en enda klass, och **routers** genererar automatiskt URL-routningen för dem. Tillsammans minskar de dramatiskt boilerplate-koden vid byggandet av RESTful API:er.

## ModelViewSet — fullständig CRUD på några rader

```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` tillhandahåller automatiskt den **kompletta uppsättningen RESTful CRUD-endpoints** för en modell — list, create, retrieve, update, partial update och delete — från bara en queryset och serializer. Du behöver inte skriva varje 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** mappar en viewset till en fullständig uppsättning standard RESTful-URL:er automatiskt — registreringen av en viewset genererar alla konventionella endpoints med rätt HTTP-metoder, vilket eliminerar manuell URL-konfiguration.

## Anpassning av 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 anpassas genom att åsidosätta metoder (`get_queryset`, `perform_create`), ställa in behörigheter och lägga till **anpassade åtgärder** (`@action`) för endpoints bortom standard CRUD.

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

## Varför det spelar roll

Viewsets och routers är en kraftfull DRF-funktion för att bygga RESTful API:er effektivt — de representerar den högsta abstraktionsnivån för det extremt vanliga fallet att exponera en modell som en fullständig REST-resurs, och att förstå dem är värdefullt för produktiv API-utveckling.

Huvudfördelens är dramatisk **minskning av boilerplate-kod**: en `ModelViewSet` plus en router ger dig ett fullständigt, konventionellt REST API för en resurs (alla CRUD-endpoints med rätt HTTP-metoder och URL:er) från bara en queryset och serializer — vilket ersätter det som annars skulle vara många separata views och manuella URL-mönster.

Detta gör byggandet av standard REST API:er anmärkningsvärt snabbt samtidigt som **RESTful-konventioner** (konsistent URL-struktur och HTTP-metodsemantik) följs automatiskt.

Viewsets förblir flexibla — du anpassar dem genom att åsidosätta metoder (filtrera queryset per användare, kontrollera behörigheter, koppla in i create/update) och lägga till **anpassade åtgärder** (`@action`) för endpoints bortom grundläggande CRUD.

Att förstå viewsets och routers, hur de genererar endpoints, hur man anpassar dem och **när man ska använda dem** (konventionella REST-resurser) kontra mer explicita generiska views eller APIView (anpassade/icke-standardiserade endpoints) är viktig praktisk kunskap för DRF-utveckling.

Eftersom byggandet av REST API:er är en primär användning av Django idag, och viewsets+routers är det idiomatiska, mest produktiva sättet att göra det för standard-resurser, utgör de en ofta använd, viktig del av DRF-verktygslådan som låter utvecklare bygga robusta API:er med minimal kod samtidigt som de behåller flexibiliteten att hantera anpassade krav.