Bài 6.2: Generic Views & ViewSets - Phần 2 - ViewSets & Routers

**Series Navigation:** - [Bài 6.1: Generic Views](/django-advance/generic-views-viewsets-phan-1) - **Bài 6.2 (bài này): ViewSets & Routers** 👈 - [Bài 6.3: Custom Actions & Advanced Patterns](/django-advance/generic-views-viewsets-phan-3)

Mục Tiêu Bài 6.2

Sau khi hoàn thành Bài 6.2 này, bạn sẽ:

✅ Hiểu ViewSets và lợi ích so với Generic Views
✅ Master ModelViewSet cho complete CRUD
✅ Sử dụng ReadOnlyModelViewSet
✅ Configure Routers (SimpleRouter, DefaultRouter)
✅ Create custom actions với @action decorator
✅ Handle multiple actions per ViewSet
✅ Apply permissions per action
✅ Optimize querysets trong ViewSets

ViewSets Overview

What are ViewSets?

ViewSet = Collection of related views grouped into single class.

Comparison:

# Generic Views: 2 classes for CRUDclass ArticleList(generics.ListCreateAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer class ArticleDetail(generics.RetrieveUpdateDestroyAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer # URLsurlpatterns = [    path('articles/', ArticleList.as_view()),    path('articles/<int:pk>/', ArticleDetail.as_view()),]

# ViewSet: 1 class for CRUDfrom rest_framework import viewsets class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer # URLs (with Router)from rest_framework.routers import DefaultRouter router = DefaultRouter()router.register(r'articles', ArticleViewSet)urlpatterns = router.urls

Benefits:

✅ Less code duplication
✅ Automatic URL routing
✅ Grouped logic for related operations
✅ Easy to add custom actions
✅ Consistent API structure

ViewSet Types

DRF provides 4 ViewSet types:

ViewSet - Base class, manual implementation
GenericViewSet - Base + common functionality
ModelViewSet - Full CRUD operations
ReadOnlyModelViewSet - List + Retrieve only

When to Use ViewSets?

Use ViewSets when:

✅ Standard CRUD operations
✅ Multiple related actions
✅ RESTful API design
✅ Want automatic routing

Use Generic Views when:

✅ Non-standard operations
✅ Single-purpose endpoints
✅ Need fine-grained control
✅ Complex URL patterns

Base ViewSet

ViewSet Class

Most basic ViewSet:

from rest_framework import viewsetsfrom rest_framework.response import Response class ArticleViewSet(viewsets.ViewSet):    """    Manually implement all actions    """        def list(self, request):        """GET /articles/"""        articles = Article.objects.all()        serializer = ArticleSerializer(articles, many=True)        return Response(serializer.data)        def create(self, request):        """POST /articles/"""        serializer = ArticleSerializer(data=request.data)        serializer.is_valid(raise_exception=True)        serializer.save()        return Response(serializer.data, status=201)        def retrieve(self, request, pk=None):        """GET /articles/{pk}/"""        article = get_object_or_404(Article, pk=pk)        serializer = ArticleSerializer(article)        return Response(serializer.data)        def update(self, request, pk=None):        """PUT /articles/{pk}/"""        article = get_object_or_404(Article, pk=pk)        serializer = ArticleSerializer(article, data=request.data)        serializer.is_valid(raise_exception=True)        serializer.save()        return Response(serializer.data)        def partial_update(self, request, pk=None):        """PATCH /articles/{pk}/"""        article = get_object_or_404(Article, pk=pk)        serializer = ArticleSerializer(article, data=request.data, partial=True)        serializer.is_valid(raise_exception=True)        serializer.save()        return Response(serializer.data)        def destroy(self, request, pk=None):        """DELETE /articles/{pk}/"""        article = get_object_or_404(Article, pk=pk)        article.delete()        return Response(status=204)

When to use:

Non-model endpoints
Custom logic for all actions
Complete control needed

GenericViewSet

ViewSet + GenericAPIView:

from rest_framework import viewsets, mixins class ArticleViewSet(mixins.ListModelMixin,                     mixins.CreateModelMixin,                     mixins.RetrieveModelMixin,                     mixins.UpdateModelMixin,                     mixins.DestroyModelMixin,                     viewsets.GenericViewSet):    """    Use mixins for standard operations    """    queryset = Article.objects.all()    serializer_class = ArticleSerializer    permission_classes = [IsAuthenticatedOrReadOnly]        def perform_create(self, serializer):        serializer.save(author=self.request.user)

When to use:

Want GenericAPIView features
Mix standard + custom actions
Need customization

ModelViewSet

Complete CRUD ViewSet

Most commonly used ViewSet:

from rest_framework import viewsets class ArticleViewSet(viewsets.ModelViewSet):    """    Provides list(), create(), retrieve(), update(), partial_update(), destroy()    """    queryset = Article.objects.all()    serializer_class = ArticleSerializer    permission_classes = [IsAuthenticatedOrReadOnly]        def perform_create(self, serializer):        serializer.save(author=self.request.user)

Equivalent to:

# 5 mixins + GenericViewSetclass ArticleViewSet(mixins.CreateModelMixin,                     mixins.RetrieveModelMixin,                     mixins.UpdateModelMixin,                     mixins.DestroyModelMixin,                     mixins.ListModelMixin,                     viewsets.GenericViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer

Auto-generated URLs:

GET    /articles/           → list()POST   /articles/           → create()GET    /articles/{pk}/      → retrieve()PUT    /articles/{pk}/      → update()PATCH  /articles/{pk}/      → partial_update()DELETE /articles/{pk}/      → destroy()

ModelViewSet Methods

Standard methods:

class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        def list(self, request):        """Override list behavior"""        queryset = self.filter_queryset(self.get_queryset())        serializer = self.get_serializer(queryset, many=True)        return Response(serializer.data)        def create(self, request):        """Override create behavior"""        serializer = self.get_serializer(data=request.data)        serializer.is_valid(raise_exception=True)        self.perform_create(serializer)        return Response(serializer.data, status=201)        def retrieve(self, request, pk=None):        """Override retrieve behavior"""        instance = self.get_object()        serializer = self.get_serializer(instance)        return Response(serializer.data)        def update(self, request, pk=None):        """Override update behavior"""        instance = self.get_object()        serializer = self.get_serializer(instance, data=request.data)        serializer.is_valid(raise_exception=True)        self.perform_update(serializer)        return Response(serializer.data)        def destroy(self, request, pk=None):        """Override destroy behavior"""        instance = self.get_object()        self.perform_destroy(instance)        return Response(status=204)

Customizing ModelViewSet

Override get_queryset:

class ArticleViewSet(viewsets.ModelViewSet):    serializer_class = ArticleSerializer    permission_classes = [IsAuthenticatedOrReadOnly]        def get_queryset(self):        """Filter based on user and action"""        queryset = Article.objects.select_related('author').all()                # List action: different filtering        if self.action == 'list':            # Public: only published            if not self.request.user.is_authenticated:                return queryset.filter(status='published')                        # Authenticated: own + published            return queryset.filter(                Q(author=self.request.user) | Q(status='published')            )                # Detail actions: all articles (permissions will handle access)        return queryset        def perform_create(self, serializer):        serializer.save(author=self.request.user)        def perform_destroy(self, instance):        # Soft delete        instance.is_deleted = True        instance.save()

Dynamic serializers:

class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()        def get_serializer_class(self):        """Different serializers per action"""        if self.action == 'list':            return ArticleListSerializer        elif self.action == 'retrieve':            return ArticleDetailSerializer        elif self.action in ['create', 'update', 'partial_update']:            return ArticleCreateUpdateSerializer        return ArticleSerializer

Action-based permissions:

class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        def get_permissions(self):        """Different permissions per action"""        if self.action in ['create', 'update', 'partial_update', 'destroy']:            permission_classes = [IsAuthenticated, IsOwnerOrAdmin]        else:            permission_classes = [AllowAny]        return [permission() for permission in permission_classes]

ReadOnlyModelViewSet

Read-Only Operations

List + Retrieve only:

from rest_framework import viewsets class ArticleViewSet(viewsets.ReadOnlyModelViewSet):    """    Provides list() and retrieve() only    No create, update, delete    """    queryset = Article.objects.filter(status='published')    serializer_class = ArticleSerializer    permission_classes = [AllowAny] # Generated URLs:# GET /articles/        → list()# GET /articles/{pk}/   → retrieve()

Use cases:

Public read-only APIs
Archive/historical data
Reference data
Public documentation

Equivalent to:

class ArticleViewSet(mixins.RetrieveModelMixin,                     mixins.ListModelMixin,                     viewsets.GenericViewSet):    queryset = Article.objects.filter(status='published')    serializer_class = ArticleSerializer

Routers

What are Routers?

Routers = Automatic URL configuration for ViewSets.

Benefits:

✅ No manual URL patterns
✅ Consistent URL structure
✅ Auto-generate URL names
✅ Support custom actions

SimpleRouter

Basic router:

# urls.pyfrom rest_framework.routers import SimpleRouterfrom .views import ArticleViewSet router = SimpleRouter()router.register(r'articles', ArticleViewSet) urlpatterns = router.urls

Generated URLs:

GET    /articles/           → list()          (name: article-list)POST   /articles/           → create()        (name: article-list)GET    /articles/{pk}/      → retrieve()      (name: article-detail)PUT    /articles/{pk}/      → update()        (name: article-detail)PATCH  /articles/{pk}/      → partial_update()(name: article-detail)DELETE /articles/{pk}/      → destroy()       (name: article-detail)

DefaultRouter

Router with API root view:

from rest_framework.routers import DefaultRouter router = DefaultRouter()router.register(r'articles', ArticleViewSet, basename='article')router.register(r'comments', CommentViewSet, basename='comment') urlpatterns = router.urls

Generated URLs:

GET /                   → API root (lists all endpoints)GET /articles/          → list()GET /articles/{pk}/     → retrieve()...GET /comments/          → list()GET /comments/{pk}/     → retrieve()...

API Root response:

{    "articles": "http://localhost:8000/api/articles/",    "comments": "http://localhost:8000/api/comments/"}

Router Configuration

Include in main URLs:

# project/urls.pyfrom django.urls import path, includefrom rest_framework.routers import DefaultRouterfrom articles.views import ArticleViewSetfrom comments.views import CommentViewSet router = DefaultRouter()router.register(r'articles', ArticleViewSet)router.register(r'comments', CommentViewSet) urlpatterns = [    path('api/', include(router.urls)),]

Per-app routers:

# articles/urls.pyfrom rest_framework.routers import DefaultRouterfrom .views import ArticleViewSet router = DefaultRouter()router.register(r'articles', ArticleViewSet) # project/urls.pyurlpatterns = [    path('api/', include('articles.urls')),]

basename Parameter

Auto-generated from queryset:

# basename automatically set to 'article' from Article modelrouter.register(r'articles', ArticleViewSet)

Manual basename (when no queryset attribute):

class ArticleViewSet(viewsets.ViewSet):    # No queryset attribute - must provide basename    def list(self, request):        # custom logic        pass router.register(r'articles', ArticleViewSet, basename='article')

Custom Actions

@action Decorator

Add custom endpoints to ViewSet:

from rest_framework import viewsetsfrom rest_framework.decorators import actionfrom rest_framework.response import Response class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        @action(detail=False, methods=['get'])    def published(self, request):        """        GET /articles/published/        List published articles        """        articles = self.get_queryset().filter(status='published')        serializer = self.get_serializer(articles, many=True)        return Response(serializer.data)        @action(detail=True, methods=['post'])    def publish(self, request, pk=None):        """        POST /articles/{pk}/publish/        Publish an article        """        article = self.get_object()        article.status = 'published'        article.save()        return Response({'status': 'article published'})        @action(detail=True, methods=['get'])    def comments(self, request, pk=None):        """        GET /articles/{pk}/comments/        Get article comments        """        article = self.get_object()        comments = article.comments.all()        serializer = CommentSerializer(comments, many=True)        return Response(serializer.data)

@action parameters:

detail=True → URL: /articles/{pk}/action/
detail=False → URL: /articles/action/
methods → HTTP methods (default: ['get'])
url_path → Custom URL segment
url_name → Custom URL name
permission_classes → Action-specific permissions
serializer_class → Action-specific serializer

Collection Actions (detail=False)

Actions on collection:

class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        @action(detail=False, methods=['get'])    def recent(self, request):        """GET /articles/recent/"""        recent = self.get_queryset().order_by('-created_at')[:10]        serializer = self.get_serializer(recent, many=True)        return Response(serializer.data)        @action(detail=False, methods=['get'])    def popular(self, request):        """GET /articles/popular/"""        popular = self.get_queryset().order_by('-views')[:10]        serializer = self.get_serializer(popular, many=True)        return Response(serializer.data)        @action(detail=False, methods=['get'])    def trending(self, request):        """GET /articles/trending/"""        # Articles with most views in last 7 days        from django.utils import timezone        from datetime import timedelta                week_ago = timezone.now() - timedelta(days=7)        trending = self.get_queryset().filter(            created_at__gte=week_ago        ).order_by('-views')[:10]                serializer = self.get_serializer(trending, many=True)        return Response(serializer.data)        @action(detail=False, methods=['post'], permission_classes=[IsAdminUser])    def bulk_delete(self, request):        """POST /articles/bulk_delete/"""        ids = request.data.get('ids', [])        deleted = Article.objects.filter(id__in=ids).delete()        return Response({'deleted': deleted[0]})

Instance Actions (detail=True)

Actions on single object:

class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        @action(detail=True, methods=['post'])    def publish(self, request, pk=None):        """POST /articles/{pk}/publish/"""        article = self.get_object()        article.status = 'published'        article.published_at = timezone.now()        article.save()        serializer = self.get_serializer(article)        return Response(serializer.data)        @action(detail=True, methods=['post'])    def unpublish(self, request, pk=None):        """POST /articles/{pk}/unpublish/"""        article = self.get_object()        article.status = 'draft'        article.save()        return Response({'status': 'unpublished'})        @action(detail=True, methods=['post'])    def archive(self, request, pk=None):        """POST /articles/{pk}/archive/"""        article = self.get_object()        article.status = 'archived'        article.archived_at = timezone.now()        article.save()        return Response({'status': 'archived'})        @action(detail=True, methods=['get'])    def stats(self, request, pk=None):        """GET /articles/{pk}/stats/"""        article = self.get_object()        return Response({            'views': article.views,            'comments': article.comments.count(),            'likes': article.likes.count(),            'shares': article.shares.count(),        })        @action(detail=True, methods=['post'], permission_classes=[IsAuthenticated])    def like(self, request, pk=None):        """POST /articles/{pk}/like/"""        article = self.get_object()        user = request.user                # Toggle like        if article.likes.filter(user=user).exists():            article.likes.filter(user=user).delete()            return Response({'status': 'unliked'})        else:            article.likes.create(user=user)            return Response({'status': 'liked'})

Custom URL Paths

Override default URL:

class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        @action(detail=True, methods=['post'], url_path='set-featured')    def set_featured(self, request, pk=None):        """        POST /articles/{pk}/set-featured/        Note: URL uses dash instead of underscore        """        article = self.get_object()        article.is_featured = True        article.save()        return Response({'status': 'featured'})        @action(detail=False, methods=['get'], url_path='by-tag/(?P<tag>[^/.]+)')    def by_tag(self, request, tag=None):        """        GET /articles/by-tag/{tag}/        Custom regex pattern in URL        """        articles = self.get_queryset().filter(tags__name=tag)        serializer = self.get_serializer(articles, many=True)        return Response(serializer.data)

Action-Specific Configuration

Different serializers per action:

class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        @action(detail=False, methods=['get'], serializer_class=ArticleListSerializer)    def recent(self, request):        """Uses ArticleListSerializer"""        recent = self.get_queryset().order_by('-created_at')[:10]        serializer = self.get_serializer(recent, many=True)        return Response(serializer.data)        @action(detail=True, methods=['post'],             permission_classes=[IsAuthenticated, IsOwner],            serializer_class=ArticlePublishSerializer)    def publish(self, request, pk=None):        """Uses ArticlePublishSerializer and custom permissions"""        article = self.get_object()        serializer = self.get_serializer(article, data=request.data)        serializer.is_valid(raise_exception=True)        serializer.save(status='published')        return Response(serializer.data)

Complete ViewSet Example

Models

# models.pyfrom django.db import modelsfrom django.contrib.auth.models import User class Article(models.Model):    STATUS_CHOICES = [        ('draft', 'Draft'),        ('published', 'Published'),        ('archived', 'Archived'),    ]        title = models.CharField(max_length=200)    slug = models.SlugField(unique=True)    content = models.TextField()    excerpt = models.TextField(blank=True)    status = models.CharField(max_length=20, choices=STATUS_CHOICES, default='draft')    is_featured = models.BooleanField(default=False)    author = models.ForeignKey(User, on_delete=models.CASCADE, related_name='articles')    created_at = models.DateTimeField(auto_now_add=True)    updated_at = models.DateTimeField(auto_now=True)    published_at = models.DateTimeField(null=True, blank=True)    views = models.IntegerField(default=0)        class Meta:        ordering = ['-created_at']        def __str__(self):        return self.title

Serializers

# serializers.pyfrom rest_framework import serializersfrom .models import Article class ArticleListSerializer(serializers.ModelSerializer):    author_name = serializers.CharField(source='author.username', read_only=True)        class Meta:        model = Article        fields = ['id', 'title', 'slug', 'excerpt', 'status',                   'author_name', 'created_at', 'views', 'is_featured'] class ArticleDetailSerializer(serializers.ModelSerializer):    author_name = serializers.CharField(source='author.username', read_only=True)        class Meta:        model = Article        fields = ['id', 'title', 'slug', 'content', 'excerpt', 'status',                  'is_featured', 'author', 'author_name', 'created_at',                   'updated_at', 'published_at', 'views']        read_only_fields = ['author', 'created_at', 'updated_at',                            'published_at', 'views'] class ArticleCreateUpdateSerializer(serializers.ModelSerializer):    class Meta:        model = Article        fields = ['title', 'slug', 'content', 'excerpt', 'status']

ViewSet

# views.pyfrom rest_framework import viewsets, filtersfrom rest_framework.decorators import actionfrom rest_framework.response import Responsefrom rest_framework.permissions import IsAuthenticatedOrReadOnly, IsAuthenticatedfrom django.utils import timezonefrom django.db.models import Qfrom .models import Articlefrom .serializers import (    ArticleListSerializer,    ArticleDetailSerializer,    ArticleCreateUpdateSerializer)from .permissions import IsOwnerOrReadOnly class ArticleViewSet(viewsets.ModelViewSet):    """    ViewSet for Article CRUD + custom actions    """    queryset = Article.objects.select_related('author').all()    permission_classes = [IsAuthenticatedOrReadOnly, IsOwnerOrReadOnly]    filter_backends = [filters.SearchFilter, filters.OrderingFilter]    search_fields = ['title', 'content']    ordering_fields = ['created_at', 'views', 'title']    ordering = ['-created_at']    lookup_field = 'slug'        def get_queryset(self):        """Filter based on action and user"""        queryset = super().get_queryset()                if self.action == 'list':            # Public: only published            if not self.request.user.is_authenticated:                return queryset.filter(status='published')                        # Authenticated: own + published            return queryset.filter(                Q(author=self.request.user) | Q(status='published')            )                return queryset        def get_serializer_class(self):        """Different serializers per action"""        if self.action == 'list':            return ArticleListSerializer        elif self.action == 'retrieve':            return ArticleDetailSerializer        elif self.action in ['create', 'update', 'partial_update']:            return ArticleCreateUpdateSerializer        return ArticleDetailSerializer        def perform_create(self, serializer):        """Set author on create"""        serializer.save(author=self.request.user)        def retrieve(self, request, *args, **kwargs):        """Increment views on retrieve"""        instance = self.get_object()        instance.views += 1        instance.save(update_fields=['views'])        serializer = self.get_serializer(instance)        return Response(serializer.data)        # Custom collection actions    @action(detail=False, methods=['get'])    def published(self, request):        """GET /articles/published/"""        articles = self.get_queryset().filter(status='published')        page = self.paginate_queryset(articles)        serializer = self.get_serializer(page, many=True)        return self.get_paginated_response(serializer.data)        @action(detail=False, methods=['get'])    def featured(self, request):        """GET /articles/featured/"""        articles = self.get_queryset().filter(            status='published',            is_featured=True        )        serializer = self.get_serializer(articles, many=True)        return Response(serializer.data)        @action(detail=False, methods=['get'])    def recent(self, request):        """GET /articles/recent/"""        articles = self.get_queryset().filter(            status='published'        ).order_by('-published_at')[:10]        serializer = self.get_serializer(articles, many=True)        return Response(serializer.data)        # Custom instance actions    @action(detail=True, methods=['post'], permission_classes=[IsAuthenticated])    def publish(self, request, slug=None):        """POST /articles/{slug}/publish/"""        article = self.get_object()                # Check permission        if article.author != request.user and not request.user.is_staff:            return Response({'error': 'Permission denied'}, status=403)                article.status = 'published'        article.published_at = timezone.now()        article.save()                serializer = self.get_serializer(article)        return Response(serializer.data)        @action(detail=True, methods=['post'], permission_classes=[IsAuthenticated])    def unpublish(self, request, slug=None):        """POST /articles/{slug}/unpublish/"""        article = self.get_object()                if article.author != request.user and not request.user.is_staff:            return Response({'error': 'Permission denied'}, status=403)                article.status = 'draft'        article.save()        return Response({'status': 'unpublished'})        @action(detail=True, methods=['get'])    def stats(self, request, slug=None):        """GET /articles/{slug}/stats/"""        article = self.get_object()        return Response({            'views': article.views,            'author': article.author.username,            'created_at': article.created_at,            'status': article.status,        })

URLs

# urls.pyfrom django.urls import path, includefrom rest_framework.routers import DefaultRouterfrom .views import ArticleViewSet router = DefaultRouter()router.register(r'articles', ArticleViewSet, basename='article') urlpatterns = [    path('', include(router.urls)),]

Generated URLs:

GET    /articles/                  → listPOST   /articles/                  → createGET    /articles/published/        → published (custom)GET    /articles/featured/         → featured (custom)GET    /articles/recent/           → recent (custom)GET    /articles/{slug}/           → retrievePUT    /articles/{slug}/           → updatePATCH  /articles/{slug}/           → partial_updateDELETE /articles/{slug}/           → destroyPOST   /articles/{slug}/publish/   → publish (custom)POST   /articles/{slug}/unpublish/ → unpublish (custom)GET    /articles/{slug}/stats/     → stats (custom)

Tóm Tắt Bài 6.2

Trong Bài 6.2 này, bạn đã học:

✅ ViewSets Overview:

ViewSet benefits (less code, automatic routing)
ViewSet types (ViewSet, GenericViewSet, ModelViewSet, ReadOnlyModelViewSet)
When to use ViewSets vs Generic Views

✅ ModelViewSet:

Complete CRUD operations
Standard methods (list, create, retrieve, update, destroy)
Customization (get_queryset, get_serializer_class, perform_*)

✅ ReadOnlyModelViewSet:

List + Retrieve only
Use cases for read-only APIs

✅ Routers:

SimpleRouter vs DefaultRouter
Automatic URL generation
Router configuration and basename

✅ Custom Actions:

@action decorator
Collection actions (detail=False)
Instance actions (detail=True)
Custom URL paths
Action-specific configuration

✅ Complete Example:

Real-world ViewSet with CRUD + custom actions
Multiple serializers per action
Permission handling
Router configuration

Next Steps

Trong Bài 6.3, bạn sẽ học:

Advanced ViewSet patterns
Nested routes và nested ViewSets
Mixins customization
Pagination strategies
Filtering và search
Ordering patterns
Performance optimization
Testing ViewSets

Navigation:

← Bài 6.1: Generic Views
Bài 6.2: ViewSets & Routers (current)
Bài 6.3: Custom Actions & Advanced Patterns →

#routers

Generic Views & ViewSets - Phần 2 - ViewSets & Routers