DRF viewsets మరియు routers అంటే ఏమిటి?

Question

Accepted Answer

Django REST Framework లో, **viewsets** సంబంధిత API endpoints (సంపద కోసం CRUD కార్యకలాపాలు) సమితి కోసం లాజిక్‌ను ఒక్క క్లాస్‌లో సమూహపరుస్తాయి, మరియు **routers** వాటి కోసం URL రౌటింగ్‌ను స్వయంచాలకంగా ఉత్పత్తి చేస్తాయి. కలిసి అవి RESTful APIs నిర్మాణం కోసం boilerplate నాటకీయంగా తగ్గిస్తాయి.

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

ఒక `ModelViewSet` ఒక మోడల్ కోసం **పూర్తి RESTful CRUD endpoints సమితిని** స్వయంచాలకంగా అందిస్తుంది — list, create, retrieve, update, partial update, మరియు delete — కేవలం queryset మరియు serializer నుండి. ప్రతి view ను వేరుగా వ్రాయవలసిన అవసరం లేదు.

## Routers — స్వయంచాలక 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
```

ఒక **router** viewset ను పూర్తి ప్రమాణిత RESTful URLs సమితికి స్వయంచాలకంగా మ్యాప్ చేస్తుంది — ఒక viewset నమోదు చేయడం సరైన HTTP పద్ధతులతో అన్ని సంప్రదాయ endpoints ను ఉత్పత్తి చేస్తుంది, manual URL కాన్ఫిగరేషన్‌ను తొలగిస్తుంది.

## 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 పద్ధతులను ($get_queryset$, $perform_create$) override చేయడం ద్వారా కస్టమైజ్ చేయబడతాయి, అనుమతులను సెట్ చేయడం ద్వారా, మరియు ప్రమాణిత CRUD కు అతీతమైన endpoints కోసం **కస్టమ్ చర్యలు** ($@action$) జోడించడం ద్వారా.

## 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 ఇస్తుంది (సరైన HTTP పద్ధతులు మరియు URLలతో అన్ని CRUD endpoints) కేవలం queryset మరియు serializer నుండి — ఇది ఇతరత్రా చాలా వేర్వేరు views మరియు manual URL నమూనాలను భర్తీ చేస్తుంది.

ఇది ప్రామాణిక REST APIs నిర్మాణం చేయడానికి విశేషంగా వేగవంతమైనది చేస్తుంది **RESTful సంప్రదాయాలు** (సামర్థ్యవంతమైన URL నిర్మాణం మరియు HTTP పద్ధతి semantics) స్వయంచాలకంగా అనుసరించబడతాయి.

Viewsets నమ్యమైనవిగా ఉన్నాయి — పద్ధతులను override చేయడం ద్వారా వాటిని కస్టమైజ్ చేయండి (user కు queryset ను ఫిల్టర్ చేయడం, అనుమతులను నియంత్రించడం, create/update లో కనెక్ట్ చేయడం) మరియు ప్రమాణిత CRUD అతీతమైన endpoints కోసం **కస్టమ్ చర్యలను** ($@action$) జోడించండి.

Viewsets మరియు routers, endpoints ను ఎలా ఉత్పత్తి చేస్తాయి, వాటిని ఎలా కస్టమైజ్ చేయాలి, మరియు **ఎప్పుడు వాటిని ఉపయోగించాలి** (సంప్రదాయ REST సంపత్తులు) సందర్భంలో ఇతర స్పష్ట generic views లేదా APIView (కస్టమ్/ప్రామాణికం కాని endpoints) ను అర్థం చేసుకోవడం DRF అభివృద్ధి కోసం ముఖ్యమైన ఆచరణాత్మక జ్ఞానం.

REST APIs నిర్మాణం చేయడం ఇప్పుడు Django కి ప్రధాన ఉపయోగం కాబట్టి, మరియు viewsets+routers ప్రామాణిక సంపత్తుల కోసం సంబంధిత, చాలా-ఉత్పాదక మార్గం, అవి చిన్న నిమిషాన్ని ఉపయోగించి దృఢమైన APIs నిర్మించడానికి అనుమతించే DRF టూల్‌కిట్ యొక్క తరచుగా-ఉపయోగించిన, ముఖ్యమైన భాగం కస్టమ్ అవసరాలను నిర్వహించే సామర్థ్యాన్ని నిలిపివేయండి.