O que são viewsets e routers do DRF?

Question

Accepted Answer

No Django REST Framework, **viewsets** agrupam a lógica para um conjunto de endpoints de API relacionados (as operações CRUD para um recurso) em uma única classe, e **routers** geram automaticamente o roteamento de URL para eles. Juntos, eles reduzem dramaticamente o boilerplate para construir APIs RESTful.

## ModelViewSet — CRUD completo em poucas linhas

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

Um `ModelViewSet` fornece automaticamente o **conjunto completo de endpoints RESTful CRUD** para um modelo — list, create, retrieve, update, partial update e delete — a partir apenas de um queryset e serializer. Não há necessidade de escrever cada view separadamente.

## Routers — geração automática de URL

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

Um **router** mapeia um viewset para um conjunto completo de URLs RESTful padrão automaticamente — registrar um viewset gera todos os endpoints convencionais com métodos HTTP corretos, eliminando a configuração manual de URL.

## Customizando 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 são customizados sobrescrevendo métodos (`get_queryset`, `perform_create`), definindo permissões e adicionando **ações customizadas** (`@action`) para endpoints além do CRUD padrão.

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

## Por que isso importa

Viewsets e routers são uma feature poderosa do DRF para construir APIs RESTful eficientemente — eles representam o nível mais alto de abstração para o caso extremamente comum de expor um modelo como um recurso REST completo, e entendê-los é valioso para desenvolvimento produtivo de API.

O benefício principal é a redução dramática de **boilerplate**: um `ModelViewSet` mais um router oferece uma API REST completa e convencional para um recurso (todos os endpoints CRUD com métodos HTTP e URLs corretos) a partir apenas de um queryset e serializer — substituindo o que seria muitas views separadas e padrões de URL manuais.

Isso torna a construção de APIs REST padrão notavelmente rápida, ao mesmo tempo em que garante que as **convenções RESTful** (estrutura de URL consistente e semântica de método HTTP) sejam seguidas automaticamente.

Viewsets permanecem flexíveis — você os customiza sobrescrevendo métodos (filtrando o queryset por usuário, controlando permissões, enganchar em create/update) e adicionando **ações customizadas** (`@action`) para endpoints além do CRUD básico.

Compreender viewsets e routers, como eles geram endpoints, como customizá-los e **quando usá-los** (recursos REST convencionais) versus views genéricas mais explícitas ou APIView (endpoints customizados/não-padrão) é conhecimento prático importante para desenvolvimento com DRF.

Como construir APIs REST é um uso primário do Django atualmente, e viewsets+routers são a forma idiomática e mais produtiva de fazer isso para recursos padrão, eles são uma parte frequentemente usada e importante do toolkit DRF que permite aos desenvolvedores construir APIs robustas com código mínimo, mantendo a flexibilidade para lidar com requisitos customizados.