Que sont les viewsets et routers de DRF?

Question

Accepted Answer

In Django REST Framework, **viewsets** group the logic for a set of related API endpoints (the CRUD operations for a resource) into a single class, and **routers** automatically generate the URL routing for them. Together they dramatically reduce boilerplate for building RESTful APIs.

## ModelViewSet — complete CRUD in a few lines

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

A `ModelViewSet` automatically provides the **complete set of RESTful CRUD endpoints** for a model — list, create, retrieve, update, partial update, and delete — from just a queryset and serializer. No need to write each view separately.

## Routers — automatic URL generation

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

A **router** maps a viewset to a full set of standard RESTful URLs automatically — registering one viewset generates all the conventional endpoints with correct HTTP methods, eliminating manual URL configuration.

## Customizing 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 are customized by overriding methods (`get_queryset`, `perform_create`), setting permissions, and adding **custom actions** (`@action`) for endpoints beyond standard CRUD.

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

## Pourquoi c'est important

Les viewsets et routers sont une fonctionnalité puissante de DRF pour construire des APIs RESTful efficacement — ils représentent le plus haut niveau d'abstraction pour le cas extrêmement courant d'exposer un modèle en tant que ressource REST complète, et les comprendre est précieux pour un développement d'API productif.

Le bénéfice principal est une réduction dramatique du **boilerplate**: un `ModelViewSet` plus un router vous donne une API REST complète et conventionnelle pour une ressource (tous les endpoints CRUD avec les bonnes méthodes HTTP et URLs) à partir d'une simple queryset et serializer — remplaçant ce qui serait autrement de nombreuses vues séparées et des patterns d'URL manuels.

Cela rend la construction d'APIs REST standards remarquablement rapide tout en garantissant que les **conventions RESTful** (structure d'URL cohérente et sémantique des méthodes HTTP) sont suivies automatiquement.

Les viewsets restent flexibles — vous les personnalisez en surchargeant les méthodes (filtrer la queryset par utilisateur, contrôler les permissions, se connecter à la création/mise à jour) et en ajoutant des **actions personnalisées** (`@action`) pour les endpoints au-delà du CRUD basique.

Comprendre les viewsets et routers, comment ils génèrent les endpoints, comment les personnaliser, et **quand les utiliser** (ressources REST conventionnelles) par rapport aux vues génériques plus explicites ou APIView (endpoints personnalisés/non-standards) est une connaissance pratique importante pour le développement avec DRF.

Comme la construction d'APIs REST est un usage principal de Django aujourd'hui, et viewsets+routers sont la façon idiomatique et la plus productive de le faire pour les ressources standards, ils sont une partie fréquemment utilisée et importante de la boîte à outils DRF qui permet aux développeurs de construire des APIs robustes avec un minimum de code tout en conservant la flexibilité de gérer les exigences personnalisées.