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 — few lines માં પૂર્ણ 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 પદ્ધતિ semantic) આપોઆપ અનુસરવામાં આવે છે.

Viewsets લવચક રહે છે — તમે તેમને પદ્ધતિઓ override કરીને કસ્ટમાઇઝ કરો છો (`get_queryset`, `perform_create`), permissions સેટ કરો છો, અને **custom actions** (`@action`) ઉમેરો છો મૂળભૂત CRUD તરફ endpoints માટે.

Viewsets અને routers, તેઓ કેવી રીતે endpoints જનરેટ કરે છે તે સમજવું, તેમને કેવી રીતે કસ્ટમાઇઝ કરવું, અને **તેમનો ઉપયોગ ક્યારે કરવો** (પરંપરાગત REST સંસાધનો) વર્સેસ વધુ સ્પષ્ટ generic views અથવા APIView (કસ્ટમ/બિન-માનક endpoints) — DRF વિકાસ માટે મહત્વપૂર્ણ વ્યવહારિક જ્ઞાન છે.

જોકે REST APIs બનાવવું આજે Django નો પ્રાથમિક ઉપયોગ છે, અને viewsets+routers પ્રમાણભૂત સંસાધનો માટે અર્થઘટક, સૌથી ઉત્પાદક રીત છે, તે વારંવાર ઉપયોગમાં આવતો, DRF toolkit નો મહત્વપૂર્ણ ભાગ છે જે ડેવલપર્સને લઘુતમ કોડ સાથે મજબૂત APIs બનાવવા દે છે જ્યારે કસ્ટમ આવશ્યકતાઓ સંભાળવવાની સુગમતા જાળવી રાખે છે.