Generic View

제너릭 뷰(Generic Views)는 Django REST Framework에서 제공하는 기본적인 CRUD(Create, Retrieve, Update, Delete) 작업을 수행하는 뷰를 손쉽게 만들 수 있도록 도와주는 클래스입니다. 이들은 APIView를 상속받아 특정 작업을 자동으로 처리해주는 뷰 클래스를 제공합니다.

제너릭 뷰의 장점

• 간편함: CRUD 작업을 수행하는 뷰를 간단하게 생성할 수 있습니다.
• 일관성: 코드를 간결하고 일관성 있게 유지할 수 있습니다.
• 재사용성: 공통 기능을 손쉽게 재사용할 수 있습니다.

---

📝 실습

1. ListAPIView

from django.db.models import Q
from rest_framework.generics import ListAPIView, RetrieveAPIView
from rest_framework.permissions import IsAuthenticatedOrReadOnly

from blog.models import Blog
from blog.serializers import BlogSerializer

class BlogListAPIView(ListAPIView):
    queryset = Blog.objects.all()
    serializer_class = BlogSerializer
    permission_classes = [IsAuthenticatedOrReadOnly]
    
    def get_queryset(self):
    	queryset=super().get_queryset()
        # 함수를 이렇게 선언해서 넣어야 datetime.now가 그 발생시간에 선언된다. 클래스내에서 만들면 그클래스가 처음에 선언 됬을때 의시간으로 생성됨
        return queryset.filter(
        	Q(published_at__isnull=True) |
            Q(published_at__gte=timezone.now())
        ).order_by('-created_at').select_related('author')

# blog/urls/generics_urls.py
from django.urls import path, include
from blog.views import generics_views

app_name ='generics_api'
# blog/urls/api_urls.py
urlpatterns = [
    path('blog', generics_views.BlogListAPIView.as_view(), name='blog_list'),
]

2. DetailView, RetrieveAPIView ListView와 동일

class BlogRetrieveAPIView(BlogQuerySetMixin, RetrieveAPIView):
    model = Blog
        queryset = Blog.objects.all()
        serializer_class = BlogSerializer
        permission_classes = [IsAuthenticatedOrReadOnly]
    
        def get_queryset(self): 
            queryset = super().get_queryset()
            return queryset.filter(
                Q(published_at__isnull=True) |
                Q(published_at__gte=timezone.now())
            ).order_by('-created_at').select_related('author')
    
    # blog/urls/generics_urls.py
    from django.urls import path, include
    from blog.views import generics_views
    
    app_name ='generics_api'
    # blog/urls/api_urls.py
    urlpatterns = [
        path('blog/<int:pk>', generics_views.BlogRetrieveAPIView.as_view(), name='blog_detail'),
    ]

3. 상속시켜 제작해보자

class BlogQuerySetMixin:
    serializer_class = BlogSerializer
    queryset = Blog.objects.all()
    permission_classes = [IsAuthenticatedOrReadOnly]
    def get_queryset(self):
        return self.queryset.filter(
            Q(published_at__isnull=True) |
            Q(published_at__gte=timezone.now())
        ).order_by('-created_at').select_related('author')
class BlogListAPIView(BlogQuerySetMixin, ListAPIView):
    pass

class BlogRetrieveAPIView(BlogQuerySetMixin, RetrieveAPIView):
    pass

📝 POST, UPDATE, DESTROY

class BlogQuerySetMixin:
    serializer_class = BlogSerializer
    queryset = Blog.objects.all()
    permission_classes = [IsAuthenticatedOrReadOnly]
    def get_queryset(self):
        
        return self.queryset.filter(
            Q(published_at__isnull=True) |
            Q(published_at__gte=timezone.now())
        ).order_by('-created_at').select_related('author')
class BlogListAPIView(BlogQuerySetMixin, ListCreateAPIView):
    pass

class BlogRetrieveAPIView(BlogQuerySetMixin, RetrieveUpdateDestroyAPIView):
    pass

1. postman으로 쏴보면 author 아 없어서 안됨
2. command + 클릭해서 -> create 또 들어가보면 해당 클래스 살펴보면 serializer.save(author=request..) 뭐 이런식 이걸 불러와서 오버라이딩 해주자 -> 잘됨

class BlogListAPIView(BlogQuerySetMixin, ListCreateAPIView):
    def perform_create(self, serializer):
        serializer.save(author=self.request.user)

3. 업데이트는 작성자만 가능하게 permission을 업데이트 해주자 만들어놓은 걸로

from permissions import IsAuthorOrReadOnly
class BlogRetrieveAPIView(BlogQuerySetMixin, RetrieveUpdateDestroyAPIView):
    permission_classes = [IsAuthorOrReadOnly]

# utils/permissions.py
from rest_framework import permissions

class IsAuthorOrReadOnly(permissions.BasePermission):
    def has_pers(self, request, view):
        if request.method in permissions.SAFE_METHODS:
            return True
        try:
            obj = view.get_object(request, *view.args, **view.kwargs)
        except TypeError:
            # get_object 가 다름 
            obj = view.get_object()
        return obj.author == request.user

📌 fields에 드가는 단어 오버라이딩 하는 방법 SerializerMethodField()

class BlogSerializer(serializers.ModelSerializer):
    author = UserSerializer(many=False, read_only=True)
    # read_only => 해당필드를 클라이언트가 수정할 수 없게 해놓는 것
    # foreignkey 연결된것 연결하는것 serialzer 로 해놓은것 이렇게 사용가능
    # 이렇게 쓰면 꼭 까먹지말고 views 에서 select_related 등록하기
    # BlogSerializer를 사용하면 author가 자동으로 불러와짐

    comment_count = serializers.SerializerMethodField()  # 이렇게 쓰면 상페이지에서 댓글 숫자를 확인할수있음
    # SerializerMethodField 메소드는 변수 앞에 get_ 을 붙여 함수로 만들면 변수를 Meta에서 사용하게 해주는 메소드이다
    author_name = serializers.SerializerMethodField()
    def get_comment_count(self, obj):
        return obj.comment_set.count()
    def get_author_name(self, obj):
        return obj.author.username
    # 만든것 꼭 feild에 넣어야 보임    
    # author의 name 만 보면 되어서 이제 author 를 빼도 author를 확인할 수 있다.
    class Meta:
        model = Blog
        fields = ['title', 'content', 'author', 'published_at', 'created_at', 
                  'updated_at', 'comment_count','author_name']

📝 Comment 모델, generics CRUD 제작

# models.py
class Comment(TimestampModel) :
    blog = models.ForeignKey(Blog, on_delete=models.CASCADE)
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    content = models.TextField('본문')

    class Meta:
        verbose_name = '댓글'
        verbose_name_plural ='댓글 목록'
        ordering = ('-created_at', '-id')

# serializers.py
class CommentSerializer(serializers.ModelSerializer):
    blog = BlogSerializer(many=False, read_only=True)
    author = UserSerializer(many=False, read_only=True)
    class Meta:
        model = Comment
        fields = ['id', 'blog', 'author', 'content', ]

# generics_views.py
class CommentListCreateAPIView(ListCreateAPIView):
    queryset = Comment.objects.all()
    serializer_class = CommentSerializer
    permission_classes = [IsAuthenticatedOrReadOnly]

    def perform_create(self, serializer):
        blog=self.get_blog_object()
        serializer.save(author=self.request.user, blog = blog)

    def get_queryset(self):
        queryset = super().get_queryset()
        blog = self.get_blog_object()
        return queryset.filter(blog=blog)

    def get_blog_object(self):
        return get_object_or_404(Blog, pk=self.kwargs.get('blog_pk'))
# generics_urls.py
path('comment/<int:blog_pk>', generics_views.CommentListCreateAPIView.as_view(), name='comment_list_create'),

# DELETE,UPDATE
# 상세페이지가 없기에 이렇게 상속받는게 적절함
class CommentUpdateDestroyAPIView(UpdateAPIView,  DestroyAPIView):
    queryset = Comment.objects.all()
    serializer_class = CommentBlogSerializer
    permission_classes = [IsAuthorOrReadOnly]
# serializers.py
class CommentBlogSerializer(serializers.ModelSerializer):
    author = UserSerializer(many=False, read_only=True)
    blog = BlogSerializer(many=False, read_only=True)
    class Meta:
        model = Comment
        fields = ['id', 'author', 'content','blog' ]

🚀 super().get_queryset()을 사용하는 이유 - 더 깊이 이해하기

📌 1️⃣ 기본적인 동작 방식 정리

Django REST Framework(DRF)의 ListAPIView는 기본적으로 get_queryset()을 호출해서 데이터를 가져옵니다.

class ListAPIView(GenericAPIView, mixins.ListModelMixin):
    def get_queryset(self):
        assert self.queryset is not None, (
            f"{self.__class__.__name__} should either include a `queryset` attribute, "
            "or override the `get_queryset()` method."
        )
        return self.queryset.all()

✔ 즉, ListAPIView는 기본적으로 self.queryset을 사용해서 queryset.all()을 실행한 결과를 반환합니다.
✔ 만약 우리가 queryset을 정의하지 않으면 오류가 발생합니다.

---

📌 2️⃣ queryset을 다시 설정하는 이유

✅ 1. 부모 클래스의 기본 동작을 유지하면서 확장하기 위해

📌 잘못된 방식 (부모의 기능을 무시하고 직접 queryset 설정)

class BlogListAPIView(ListAPIView):
    serializer_class = BlogSerializer

    def get_queryset(self):
        return Blog.objects.filter(published_at__lte=timezone.now()).order_by("-created_at")

🚨 문제점

• ListAPIView는 기본적으로 self.queryset을 활용하는 구조인데, 이렇게 하면 부모 클래스(ListAPIView)의 queryset을 아예 무시함.
• 이렇게 하면 다른 클래스에서 BlogListAPIView를 상속받아서 확장할 때 부모의 get_queryset()을 재사용할 수 없음.

📌 올바른 방식 (부모의 기능을 유지하면서 필터링 추가)

class BlogListAPIView(ListAPIView):
    queryset = Blog.objects.all()  # 기본 QuerySet 설정
    serializer_class = BlogSerializer

    def get_queryset(self):
        queryset = super().get_queryset()  # 부모 클래스의 get_queryset() 실행
        return queryset.filter(published_at__lte=timezone.now()).order_by("-created_at")

✅ 이 방식이 좋은 이유
1. super().get_queryset()을 호출하면 부모 클래스(ListAPIView)에서 설정한 QuerySet을 먼저 가져온 후, 추가적인 필터링을 적용할 수 있음.
2. 이렇게 하면 만약 다른 곳에서 queryset을 동적으로 변경해도 get_queryset()을 수정하지 않아도 됨.
3. super().get_queryset()을 사용하면 추후 BlogListAPIView를 상속받아 사용할 경우, get_queryset()의 동작을 유지하면서 추가적인 필터링을 적용할 수 있음.

---

📌 3️⃣ 상속을 활용하는 이유

✅ 부모 클래스를 확장하면서도 유연한 설계를 하기 위해

ListAPIView를 상속받으면 기본적인 기능(ListModelMixin의 기능 포함)을 사용할 수 있습니다.
하지만 프로젝트 요구사항에 맞춰 쿼리셋을 수정하고 싶을 때 get_queryset()을 오버라이딩하는 것이 일반적인 패턴입니다.

📌 이해를 돕기 위한 비유
✔ ListAPIView는 자동차의 기본 모델
✔ BlogListAPIView는 기본 모델을 기반으로 옵션(쿼리 필터링 등)을 추가한 스포츠카

🚗 자동차 기본 모델 (ListAPIView)

class Car:
    def drive(self):
        print("Driving a car")

🏎 상속을 활용한 확장 (BlogListAPIView)

class SportsCar(Car):
    def drive(self):
        print("Super speed mode activated!")
        super().drive()  # ✅ 부모 클래스의 기본 동작을 유지하면서 새로운 기능을 추가

🚀 결과

my_car = SportsCar()
my_car.drive()

📌 출력:

Super speed mode activated!
Driving a car

✅ 즉, 부모의 기능을 유지하면서도 새로운 기능을 추가하는 것이 핵심!

---

📌 4️⃣ 결론

질문	설명
부모 클래스에 queryset이 있는데 왜 get_queryset()에서 또 설정하는가?	부모 클래스의 기본 동작을 유지하면서 특정 필터를 추가하기 위해
부모의 queryset을 직접 사용하면 안 되는가?	가능하지만, super().get_queryset()을 사용하면 유지보수와 확장성이 더 좋아짐
그럼 queryset을 설정하고 get_queryset()을 오버라이딩하면 왜 super()를 호출하는가?	다른 곳에서 queryset이 변경될 가능성이 있기 때문. super().get_queryset()을 사용하면 동적으로 변경된 부모의 queryset을 활용할 수 있음

🔥 즉, super().get_queryset()을 사용하면 부모의 queryset을 기반으로 필터링을 추가할 수 있어서 더 유연하고 확장성이 높아진다! 🚀