DRF viewsets और routers क्या हैं?

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 — कुछ ही पंक्तियों में पूर्ण CRUD

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

## यह महत्वपूर्ण क्यों है

Viewsets और routers RESTful APIs को कुशलतापूर्वक बनाने के लिए DRF की एक शक्तिशाली विशेषता हैं — वे एक मॉडल को पूर्ण REST संसाधन के रूप में उजागर करने के बेहद सामान्य मामले के लिए अमूर्ততन का सर्वोच्च स्तर प्रतिनिधित्व करते हैं, और उन्हें समझना उत्पादक API विकास के लिए मूल्यवान है।

मुख्य लाभ **boilerplate में नाटकीय कमी** है: एक `ModelViewSet` और एक router आपको एक संसाधन के लिए एक पूर्ण, पारंपरिक REST API देता है (सभी CRUD endpoints सही HTTP तरीकों और URLs के साथ) केवल एक queryset और serializer से — जो अन्यथा कई अलग views और manual URL patterns होते।

यह मानक REST APIs बनाना उल्लेखनीय रूप से तेज़ बनाता है जबकि **RESTful conventions** (सुसंगत URL संरचना और HTTP method semantics) को स्वचालित रूप से अनुसरण किया जाता है।

Viewsets लचीले रहते हैं — आप उन्हें methods को override करके (`get_queryset`, `perform_create`), permissions सेट करके, और मानक CRUD से परे endpoints के लिए **custom actions** (`@action`) जोड़कर कस्टमाइज़ करते हैं।

Viewsets और routers को समझना, वे कैसे endpoints उत्पन्न करते हैं, उन्हें कैसे कस्टमाइज़ करते हैं, और **उन्हें कब उपयोग करते हैं** (पारंपरिक REST resources) बनाम अधिक स्पष्ट generic views या APIView (custom/non-standard endpoints) — DRF विकास के लिए महत्वपूर्ण व्यावहारिक ज्ञान है।

चूंकि REST APIs बनाना आज Django का प्राथमिक उपयोग है, और viewsets+routers मानक संसाधनों के लिए मुहावरेदार, सबसे उत्पादक तरीका है, वे frequently-used, DRF toolkit का एक महत्वपूर्ण हिस्सा हैं जो developers को न्यूनतम कोड के साथ robust APIs बनाने देता है जबकि custom requirements को संभालने की लचीलापन बनाए रखता है।