Bài 6.1: Generic Views & ViewSets - Phần 1 - Generic Views

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

Mục Tiêu Bài 6.1

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

✅ Hiểu DRF view hierarchy (APIView → GenericAPIView → Concrete Views)
✅ Master các Mixin classes
✅ Sử dụng Concrete Generic Views
✅ Customize queryset và serializer_class
✅ Override methods hiệu quả
✅ Apply pagination, filtering, ordering
✅ Handle permissions và authentication

View Hierarchy trong DRF

From Django to DRF

Evolution of Views:

Django Function View    ↓Django Class-Based View (View)    ↓DRF APIView    ↓DRF GenericAPIView    ↓DRF Mixins + GenericAPIView    ↓DRF Concrete Generic Views    ↓DRF ViewSets

Why Generic Views?

Problem với APIView:

# APIView: Lots of boilerplateclass ArticleList(APIView):    def get(self, request):        articles = Article.objects.all()        serializer = ArticleSerializer(articles, many=True)        return Response(serializer.data)        def post(self, request):        serializer = ArticleSerializer(data=request.data)        if serializer.is_valid():            serializer.save()            return Response(serializer.data, status=201)        return Response(serializer.errors, status=400) # 20+ lines for basic CRUD!

Solution với Generic Views:

# Generic View: Minimal codefrom rest_framework import generics class ArticleList(generics.ListCreateAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer # 3 lines for same functionality! 🎉

Benefits:

✅ Less boilerplate code
✅ Built-in functionality (pagination, filtering, permissions)
✅ Consistent patterns
✅ Easy to maintain
✅ Highly customizable

APIView Review

Basic APIView

Foundation of all DRF views:

from rest_framework.views import APIViewfrom rest_framework.response import Responsefrom rest_framework import status class ArticleList(APIView):    """    List all articles or create new article    """        def get(self, request):        """List all articles"""        articles = Article.objects.all()        serializer = ArticleSerializer(articles, many=True)        return Response(serializer.data)        def post(self, request):        """Create new article"""        serializer = ArticleSerializer(data=request.data)                if serializer.is_valid():            serializer.save(author=request.user)            return Response(serializer.data, status=status.HTTP_201_CREATED)                return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

When to use APIView:

Custom logic that doesn't fit patterns
Non-model endpoints
Complex request handling
Need full control

GenericAPIView

What is GenericAPIView?

GenericAPIView = APIView + common functionality for model-based views.

Base class for all generic views.

Basic Structure

from rest_framework import generics class ArticleList(generics.GenericAPIView):    """    Base generic view with common attributes    """    # Required attributes    queryset = Article.objects.all()    serializer_class = ArticleSerializer        # Optional attributes    lookup_field = 'pk'  # URL kwarg for single object    pagination_class = PageNumberPagination    filter_backends = [SearchFilter, OrderingFilter]        def get(self, request):        # Use built-in methods        queryset = self.get_queryset()        serializer = self.get_serializer(queryset, many=True)        return Response(serializer.data)

Key Attributes

1. queryset:

class ArticleList(generics.GenericAPIView):    # Static queryset    queryset = Article.objects.all()        # Or with filtering    queryset = Article.objects.filter(status='published')        # Or with select_related    queryset = Article.objects.select_related('author').all()

2. serializer_class:

class ArticleList(generics.GenericAPIView):    serializer_class = ArticleSerializer        # Or dynamic    def get_serializer_class(self):        if self.request.user.is_staff:            return ArticleDetailSerializer        return ArticleListSerializer

3. lookup_field:

class ArticleDetail(generics.GenericAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    lookup_field = 'slug'  # Use slug instead of pk        # URL: /articles/<slug>/

Key Methods

1. get_queryset():

class ArticleList(generics.GenericAPIView):    serializer_class = ArticleSerializer        def get_queryset(self):        """Override to customize queryset"""        # Filter by user        if self.request.user.is_staff:            return Article.objects.all()                return Article.objects.filter(author=self.request.user)

2. get_serializer_class():

class ArticleView(generics.GenericAPIView):    def get_serializer_class(self):        """Dynamic serializer based on action"""        if self.request.method == 'GET':            return ArticleListSerializer        return ArticleCreateSerializer

3. get_object():

class ArticleDetail(generics.GenericAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        def get_object(self):        """Get single object with custom logic"""        obj = super().get_object()                # Check permissions        self.check_object_permissions(self.request, obj)                # Track view count        obj.views += 1        obj.save(update_fields=['views'])                return obj

4. get_serializer():

class ArticleList(generics.GenericAPIView):    def get(self, request):        queryset = self.get_queryset()                # Get serializer instance        serializer = self.get_serializer(queryset, many=True)                return Response(serializer.data)

Mixins

What are Mixins?

Mixins = Small classes providing specific functionality.

DRF provides 5 mixins:

ListModelMixin - List objects
CreateModelMixin - Create object
RetrieveModelMixin - Get single object
UpdateModelMixin - Update object
DestroyModelMixin - Delete object

ListModelMixin

List collection of objects:

from rest_framework import mixins, generics class ArticleList(mixins.ListModelMixin, generics.GenericAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        def get(self, request, *args, **kwargs):        return self.list(request, *args, **kwargs) # GET /articles/ → Returns list

What ListModelMixin provides:

def list(self, request, *args, **kwargs):    queryset = self.filter_queryset(self.get_queryset())        page = self.paginate_queryset(queryset)    if page is not None:        serializer = self.get_serializer(page, many=True)        return self.get_paginated_response(serializer.data)        serializer = self.get_serializer(queryset, many=True)    return Response(serializer.data)

CreateModelMixin

Create new object:

class ArticleList(mixins.CreateModelMixin, generics.GenericAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        def post(self, request, *args, **kwargs):        return self.create(request, *args, **kwargs) # POST /articles/ → Creates article

What CreateModelMixin provides:

def create(self, request, *args, **kwargs):    serializer = self.get_serializer(data=request.data)    serializer.is_valid(raise_exception=True)    self.perform_create(serializer)    headers = self.get_success_headers(serializer.data)    return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers) def perform_create(self, serializer):    serializer.save()

Override perform_create:

class ArticleList(mixins.CreateModelMixin, generics.GenericAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        def perform_create(self, serializer):        # Add author automatically        serializer.save(author=self.request.user)

RetrieveModelMixin

Retrieve single object:

class ArticleDetail(mixins.RetrieveModelMixin, generics.GenericAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        def get(self, request, *args, **kwargs):        return self.retrieve(request, *args, **kwargs) # GET /articles/1/ → Returns article #1

UpdateModelMixin

Update existing object:

class ArticleDetail(mixins.UpdateModelMixin, generics.GenericAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        def put(self, request, *args, **kwargs):        return self.update(request, *args, **kwargs)        def patch(self, request, *args, **kwargs):        return self.partial_update(request, *args, **kwargs) # PUT /articles/1/ → Full update# PATCH /articles/1/ → Partial update

Override perform_update:

class ArticleDetail(mixins.UpdateModelMixin, generics.GenericAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        def perform_update(self, serializer):        # Track last modified by        serializer.save(modified_by=self.request.user)

DestroyModelMixin

Delete object:

class ArticleDetail(mixins.DestroyModelMixin, generics.GenericAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        def delete(self, request, *args, **kwargs):        return self.destroy(request, *args, **kwargs) # DELETE /articles/1/ → Deletes article #1

Override perform_destroy:

class ArticleDetail(mixins.DestroyModelMixin, generics.GenericAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        def perform_destroy(self, instance):        # Soft delete        instance.is_deleted = True        instance.deleted_at = timezone.now()        instance.save()                # Or hard delete        # instance.delete()

Combining Mixins

Multiple operations in one view:

class ArticleList(mixins.ListModelMixin,                  mixins.CreateModelMixin,                  generics.GenericAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        def get(self, request, *args, **kwargs):        return self.list(request, *args, **kwargs)        def post(self, request, *args, **kwargs):        return self.create(request, *args, **kwargs) # GET /articles/ → List# POST /articles/ → Create

Concrete Generic Views

What are Concrete Views?

Concrete views = GenericAPIView + Mixins + HTTP method handlers.

Pre-built views for common patterns.

Available Concrete Views

1. CreateAPIView = Create only
2. ListAPIView = List only
3. RetrieveAPIView = Retrieve only
4. DestroyAPIView = Delete only
5. UpdateAPIView = Update only
6. ListCreateAPIView = List + Create
7. RetrieveUpdateAPIView = Retrieve + Update
8. RetrieveDestroyAPIView = Retrieve + Delete
9. RetrieveUpdateDestroyAPIView = Retrieve + Update + Delete

CreateAPIView

Create new objects:

from rest_framework import generics class ArticleCreate(generics.CreateAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    permission_classes = [IsAuthenticated]        def perform_create(self, serializer):        serializer.save(author=self.request.user) # POST /articles/ → Create

Use case:

Separate create endpoint
Registration forms
Upload endpoints

ListAPIView

List collection (read-only):

class ArticleList(generics.ListAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    pagination_class = PageNumberPagination    filter_backends = [SearchFilter, OrderingFilter]    search_fields = ['title', 'content']    ordering_fields = ['created_at', 'title'] # GET /articles/ → List all articles# GET /articles/?search=django → Search# GET /articles/?ordering=-created_at → Sort by newest

Use case:

Public read-only lists
Search endpoints
Feed/timeline views

RetrieveAPIView

Get single object (read-only):

class ArticleDetail(generics.RetrieveAPIView):    queryset = Article.objects.all()    serializer_class = ArticleDetailSerializer    lookup_field = 'slug' # GET /articles/django-tutorial/ → Get by slug

Use case:

Public detail pages
Profile views
Read-only resources

DestroyAPIView

Delete only:

class ArticleDelete(generics.DestroyAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    permission_classes = [IsAuthenticated, IsOwnerOrAdmin] # DELETE /articles/1/ → Delete

UpdateAPIView

Update only (PUT + PATCH):

class ArticleUpdate(generics.UpdateAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    permission_classes = [IsAuthenticated, IsOwner] # PUT /articles/1/ → Full update# PATCH /articles/1/ → Partial update

ListCreateAPIView

Most common pattern: List + Create:

class ArticleList(generics.ListCreateAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    permission_classes = [IsAuthenticatedOrReadOnly]        def get_queryset(self):        # Public: only published        if not self.request.user.is_authenticated:            return Article.objects.filter(status='published')                # Authenticated: own articles + published        return Article.objects.filter(            Q(author=self.request.user) | Q(status='published')        )        def perform_create(self, serializer):        serializer.save(author=self.request.user) # GET /articles/ → List# POST /articles/ → Create

Use case:

Blog posts
Comments
Todo items
Most collection endpoints

RetrieveUpdateDestroyAPIView

Full CRUD for single object:

class ArticleDetail(generics.RetrieveUpdateDestroyAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    permission_classes = [IsAuthenticatedOrReadOnly, IsOwnerOrReadOnly]        def perform_update(self, serializer):        serializer.save(modified_by=self.request.user)        def perform_destroy(self, instance):        # Soft delete        instance.is_deleted = True        instance.save() # GET /articles/1/ → Retrieve# PUT /articles/1/ → Update (full)# PATCH /articles/1/ → Update (partial)# DELETE /articles/1/ → Delete

Use case:

Resource detail endpoints
Most detail views
RESTful APIs

Customizing Generic Views

Override get_queryset()

Dynamic querysets:

class ArticleList(generics.ListAPIView):    serializer_class = ArticleSerializer        def get_queryset(self):        # Filter by query params        queryset = Article.objects.all()                # Filter by status        status = self.request.query_params.get('status')        if status:            queryset = queryset.filter(status=status)                # Filter by author        author_id = self.request.query_params.get('author')        if author_id:            queryset = queryset.filter(author_id=author_id)                # Filter by date range        start_date = self.request.query_params.get('start_date')        if start_date:            queryset = queryset.filter(created_at__gte=start_date)                return queryset # GET /articles/?status=published&author=5

Override get_serializer_class()

Dynamic serializers:

class ArticleView(generics.RetrieveUpdateDestroyAPIView):    queryset = Article.objects.all()        def get_serializer_class(self):        # Different serializer for different methods        if self.request.method == 'GET':            return ArticleDetailSerializer        return ArticleUpdateSerializer

Override get_object()

Custom object retrieval:

class ArticleDetail(generics.RetrieveAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        def get_object(self):        obj = super().get_object()                # Increment view count        obj.views += 1        obj.save(update_fields=['views'])                # Check custom permission        if obj.status == 'draft' and obj.author != self.request.user:            raise PermissionDenied('Cannot view draft articles')                return obj

Override perform_create()

Custom creation logic:

class ArticleCreate(generics.CreateAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        def perform_create(self, serializer):        # Set author        article = serializer.save(author=self.request.user)                # Send notification        notify_followers(article)                # Log activity        ActivityLog.objects.create(            user=self.request.user,            action='created_article',            object_id=article.id        )

Override perform_update()

Custom update logic:

class ArticleUpdate(generics.UpdateAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        def perform_update(self, serializer):        # Track changes        old_status = self.get_object().status        article = serializer.save(modified_by=self.request.user)        new_status = article.status                # Send notification if published        if old_status != 'published' and new_status == 'published':            notify_publication(article)

Override perform_destroy()

Custom deletion logic:

class ArticleDelete(generics.DestroyAPIView):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        def perform_destroy(self, instance):        # Check if can delete        if instance.comments.exists():            raise ValidationError('Cannot delete article with comments')                # Soft delete        instance.is_deleted = True        instance.deleted_at = timezone.now()        instance.deleted_by = self.request.user        instance.save()                # Or hard delete        # instance.delete()

Complete CRUD 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')    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)    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):    """Minimal serializer for list views"""    author_name = serializers.CharField(source='author.username', read_only=True)        class Meta:        model = Article        fields = ['id', 'title', 'slug', 'excerpt', 'author_name', 'status', 'created_at', 'views'] class ArticleDetailSerializer(serializers.ModelSerializer):    """Full serializer for detail views"""    author_name = serializers.CharField(source='author.username', read_only=True)        class Meta:        model = Article        fields = ['id', 'title', 'slug', 'content', 'excerpt', 'status',                   'author', 'author_name', 'created_at', 'updated_at', 'views']        read_only_fields = ['author', 'created_at', 'updated_at', 'views'] class ArticleCreateUpdateSerializer(serializers.ModelSerializer):    """Serializer for create/update"""    class Meta:        model = Article        fields = ['title', 'slug', 'content', 'excerpt', 'status']        def validate_slug(self, value):        # Check slug uniqueness on update        if self.instance and self.instance.slug != value:            if Article.objects.filter(slug=value).exists():                raise serializers.ValidationError('Slug already exists')        return value

Views

# views.pyfrom rest_framework import generics, filtersfrom rest_framework.permissions import IsAuthenticatedOrReadOnlyfrom django.db.models import Qfrom .models import Articlefrom .serializers import (    ArticleListSerializer,    ArticleDetailSerializer,    ArticleCreateUpdateSerializer)from .permissions import IsOwnerOrReadOnly class ArticleList(generics.ListCreateAPIView):    """    GET: List articles    POST: Create new article    """    permission_classes = [IsAuthenticatedOrReadOnly]    filter_backends = [filters.SearchFilter, filters.OrderingFilter]    search_fields = ['title', 'content']    ordering_fields = ['created_at', 'title', 'views']    ordering = ['-created_at']        def get_queryset(self):        queryset = Article.objects.select_related('author').all()                # 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')        )        def get_serializer_class(self):        if self.request.method == 'POST':            return ArticleCreateUpdateSerializer        return ArticleListSerializer        def perform_create(self, serializer):        serializer.save(author=self.request.user) class ArticleDetail(generics.RetrieveUpdateDestroyAPIView):    """    GET: Retrieve article    PUT/PATCH: Update article    DELETE: Delete article    """    queryset = Article.objects.select_related('author').all()    permission_classes = [IsAuthenticatedOrReadOnly, IsOwnerOrReadOnly]    lookup_field = 'slug'        def get_serializer_class(self):        if self.request.method in ['PUT', 'PATCH']:            return ArticleCreateUpdateSerializer        return ArticleDetailSerializer        def get_object(self):        obj = super().get_object()                # Increment views for GET only        if self.request.method == 'GET':            obj.views += 1            obj.save(update_fields=['views'])                return obj        def perform_destroy(self, instance):        # Soft delete        instance.status = 'archived'        instance.save()

URLs

# urls.pyfrom django.urls import pathfrom .views import ArticleList, ArticleDetail urlpatterns = [    path('articles/', ArticleList.as_view(), name='article-list'),    path('articles/<slug:slug>/', ArticleDetail.as_view(), name='article-detail'),]

Tóm Tắt Bài 6.1

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

✅ View Hierarchy:

Evolution: APIView → GenericAPIView → Mixins → Concrete Views
Why use generic views (less code, consistency)

✅ GenericAPIView:

Key attributes (queryset, serializer_class, lookup_field)
Key methods (get_queryset, get_serializer_class, get_object)

✅ Mixins:

5 mixins: List, Create, Retrieve, Update, Destroy
Combining mixins for custom views
Override perform_* methods

✅ Concrete Generic Views:

9 pre-built views for common patterns
ListCreateAPIView (most common)
RetrieveUpdateDestroyAPIView (full CRUD)

✅ Customization:

Override get_queryset() for filtering
Override get_serializer_class() for dynamic serializers
Override get_object() for custom retrieval
Override perform_create/update/destroy for custom logic

✅ Complete Example:

Models, serializers, views, URLs
Real-world patterns
Permissions and filtering

Next Steps

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

ViewSets và ModelViewSet
Routers (automatic URL routing)
Custom actions (@action decorator)
ViewSet lifecycle methods
Nested routes

Navigation:

#createapiview

Generic Views & ViewSets - Phần 1 - Generic Views