DRF viewsets மற்றும் routers என்றால் என்ன?

Question

Accepted Answer

Django REST Framework இல், **viewsets** ஒரு பொதுவான API endpoints களின் தொடர்புடைய தர্க்கத்தை (একটি வளத்திற்கான CRUD செயல்பாடுகள்) ஒரே வகுப்பாகத் தொகுக்கிறது, மேலும் **routers** அவர்களுக்கான URL routing ஐ தானாகவே உருவாக்குகிறது. ஒன்றாகவே 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 ஐ standard RESTful URLs இன் முழு தொகுப்புடன் தானாகவே map செய்கிறது — ஒரு viewset ஐ பதிவு செய்வது சரியான HTTP methods உடன் அனைத்து வழக்கமான endpoints ஐ உருவாக்குகிறது, manual URL configuration ஐ நீக்குகிறது.

## 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 methods ஐ override செய்வதன் மூலம் தனிப்பயனாக்கப்படுகிறது (`get_queryset`, `perform_create`), permissions ஐ அமைப்பதன் மூலம், மற்றும் standard CRUD க்கு அப்பாற்பட்ட endpoints க்கான **custom actions** (`@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 ஐ திறமையாகவே கட்டுவதற்கான ஒரு சக்திशalী DRF feature ஆகும் — அவை ஒரு மாதிரியை ஒரு முழு REST வளமாக வெளிப்படுத்துவதற்கான மிகவும் பொதுவான case க்கான abstraction இன் மிக உயர்ந்த நிலையை குறிக்கிறது, மற்றும் அவற்றைப் புரிந்துகொள்வது productive API development க்கு மதிப்பளிக்கப்படுகிறது.

முக்கிய benefit dramatic **boilerplate reduction** ஆகும்: ஒரு `ModelViewSet` மற்றும் router வெறுமனே queryset மற்றும் serializer இலிருந்து ஒரு வளத்திற்கான ஒரு முழு, வழக்கமான REST API (சரியான HTTP methods மற்றும் URLs உடன் அனைத்து CRUD endpoints) வழங்குகிறது — இதை வேறுவிதமாக பல separate views மற்றும் manual URL patterns ஆக இருக்கும்.

இது standard REST APIs ஐ கட்டுவதை குறிப்பாக வேகமாக்குகிறது **RESTful conventions** (consistent URL structure மற்றும் HTTP method semantics) தானாகவே பின்பற்றப்படுவதை உறுதிசெய்கிறது.

Viewsets நমনীய தன்மையாகவே இருக்கிறது — நீங்கள் methods ஐ override செய்வதன் மூலம் அவற்றை தனிப்பயனாக்குகிறீர்கள் (user இன் படி queryset ஐ filter செய்தல், permissions ஐ கட்டுப்படுத்துதல், create/update ஐ hook செய்தல்) மற்றும் basic CRUD க்கு அப்பாற்பட்ட endpoints க்கான **custom actions** (`@action`) சேர்ப்பது.

Viewsets மற்றும் routers ஐ புரிந்துகொள்வது, அவை endpoints ஐ எவ்வாறு உருவாக்குகிறது, அவற்றை எவ்வாறு தனிப்பயனாக்குவது, மற்றும் **எப்போது அவற்றைப் பயன்படுத்துவது** (வழக்கமான REST வளங்கள்) மற்றும் மேலும் explicit generic views அல்லது APIView (custom/non-standard endpoints) DRF development க்கான பயிற்சிபெற்ற practical அறிவாகும்.

REST APIs ஐ கட்டுவது இன்று Django இன் ஒரு முதன்மை பயன்பாடாக இருப்பதால், மற்றும் viewsets+routers standard வளங்களுக்கு idiomatic, மிக-productive வழி இருப்பதால், அவை developers ஐ custom requirements ஐ கையாளுவதற்கான நমனீயத்தை தக்கவைத்துக்கொள்ளும் போது minimal code உடன் robust APIs ஐ கட்ட அனுமதிக்கும் DRF toolkit இன் frequently-used, முக்கியமான பகுதி ஆகும்.