Cad iad viewsets agus routers DRF?

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 — complete CRUD in a few lines

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

## Cén fáth a bhíonn sé tábhachtach

Is gné chumhachtach de DRF a bhíonn i viewsets agus routers chun APIs RESTful a thógáil go héifeachtach — is ionann iad agus an leibhéal is airde abstraction don chás an-choitianta acmhainn a nochtadh mar fhíorfhoinse REST, agus bíonn sé luachmhar iad a thuiscint do fhorbairt API táirgiúil.

Is é an buntáiste príomhúil ná laghdú fíordramhaíoch ar **boilerplate**: tugann `ModelViewSet` agus router duit API REST iomlán agus ghnáth-oiriúnach d'acmhainn (na bendpointí CRUD go léir le modhanna HTTP agus URLs ceart) ó queryset agus serializer go simplí — agus é i gcomhpháirt do roinnt léargos ar leithligh agus patrúin URL a dhéantar de láimh.

Déanann sé seo tógáil APIs REST caighdeánach go hiontach tapa agus á chinntiú go leantar **coinbhinsiúin RESTful** (struchtúr URL comhsheasmhach agus séimeantaic mhodh HTTP) go foluain.

Fanann viewsets foluain — custamaítear iad trí mhodhanna a fhorscríobh (`get_queryset`, `perform_create`), ceadanna a shocrú, agus **gníomhartha saincheaptha** (`@action`) a chur leis do bhendpointí thar CRUD bunúsach.

Tá sé ríthábhachtach a thuiscint cad iad viewsets agus routers, conas a ghineann siad bendpointí, conas a chéimseatú iad, agus **cathain a úsáidtear iad** (acmhainní REST gnáth-oiriúnacha) i gcomparáid le léargos níos soiléire nó APIView (bendpointí saincheaptha/nach-caighdeánach) — is eolas praiticiúil tábhachtach é seo do fhorbairt DRF.

Os rud é go bhfuil tógáil APIs REST mar úsáid phríomhúil de Django inniu, agus gur iad viewsets+routers an bealach idiomatic agus is táirgiúla é a dhéanamh do acmhainní caighdeánach, tá siad ina gcuid ann go minic, tábhachtach den taiscéal DRF a ligeann do fhorbróirí APIs láidre a thógáil le barraicín de chód agus fós an solúbthacht a choimeád chun riachtanais saincheaptha a láimhseáil.