Как описывал представления в Django?

Представления (Views) в Django

Представления (views) — это функции или классы, которые обрабатывают запросы пользователя и возвращают ответ. Есть два основных подхода.

1. Function-Based Views (FBV) — простой способ

Просто функции, которые получают request и возвращают response:

# views.py
from django.shortcuts import render, get_object_or_404
from django.http import HttpResponse, JsonResponse
from django.contrib.auth.decorators import login_required
from .models import Post, Comment

# Простое представление
def index(request):
    posts = Post.objects.all()
    return render(request, 'blog/index.html', {'posts': posts})

# Представление с параметром
def post_detail(request, post_id):
    post = get_object_or_404(Post, id=post_id)
    comments = post.comments.all()
    return render(request, 'blog/post_detail.html', {
        'post': post,
        'comments': comments
    })

# Представление с POST запросом
def create_comment(request, post_id):
    if request.method == 'POST':
        post = get_object_or_404(Post, id=post_id)
        text = request.POST.get('text')
        
        comment = Comment.objects.create(
            post=post,
            text=text,
            author=request.user
        )
        
        return HttpResponse('Комментарий добавлен')
    
    return HttpResponse('Только POST', status=405)

# API представление (JSON)
def api_posts(request):
    posts = Post.objects.values('id', 'title', 'created_at')
    return JsonResponse({
        'posts': list(posts),
        'count': posts.count()
    })

# Представление с декоратором (требует логин)
@login_required(login_url='login')
def user_dashboard(request):
    user_posts = Post.objects.filter(author=request.user)
    return render(request, 'user/dashboard.html', {
        'posts': user_posts
    })

URL маршруты:

# urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),
    path('posts/<int:post_id>/', views.post_detail, name='post_detail'),
    path('posts/<int:post_id>/comments/', views.create_comment, name='create_comment'),
    path('api/posts/', views.api_posts, name='api_posts'),
    path('dashboard/', views.user_dashboard, name='dashboard'),
]

2. Class-Based Views (CBV) — более мощный подход

ОО способ с наследованием и миксинами:

# views.py
from django.views import View
from django.views.generic import ListView, DetailView, CreateView, UpdateView, DeleteView
from django.contrib.auth.mixins import LoginRequiredMixin
from django.urls import reverse_lazy
from django.shortcuts import get_object_or_404
from .models import Post, Comment
from .forms import CommentForm

# Простой View
class IndexView(View):
    def get(self, request):
        posts = Post.objects.all()
        return render(request, 'blog/index.html', {'posts': posts})

# ListView для отображения списка объектов
class PostListView(ListView):
    model = Post
    template_name = 'blog/post_list.html'
    context_object_name = 'posts'
    paginate_by = 10
    
    def get_queryset(self):
        """Фильтруем только опубликованные посты"""
        return Post.objects.filter(published=True).order_by('-created_at')
    
    def get_context_data(self, **kwargs):
        """Добавляем дополнительный контекст"""
        context = super().get_context_data(**kwargs)
        context['total_posts'] = Post.objects.count()
        return context

# DetailView для отображения одного объекта
class PostDetailView(DetailView):
    model = Post
    template_name = 'blog/post_detail.html'
    context_object_name = 'post'
    pk_url_kwarg = 'post_id'
    
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['comments'] = self.object.comments.all()
        context['form'] = CommentForm()
        return context

# CreateView для создания новых объектов
class PostCreateView(LoginRequiredMixin, CreateView):
    model = Post
    fields = ['title', 'content']
    template_name = 'blog/post_form.html'
    login_url = 'login'
    
    def form_valid(self, form):
        """Вызывается когда форма валидна"""
        form.instance.author = self.request.user
        return super().form_valid(form)
    
    def get_success_url(self):
        """Куда перенаправить после успешного создания"""
        return reverse_lazy('post_detail', kwargs={'post_id': self.object.id})

# UpdateView для редактирования
class PostUpdateView(LoginRequiredMixin, UpdateView):
    model = Post
    fields = ['title', 'content']
    template_name = 'blog/post_form.html'
    pk_url_kwarg = 'post_id'
    
    def get_queryset(self):
        """Пользователь может редактировать только свои посты"""
        return Post.objects.filter(author=self.request.user)
    
    def get_success_url(self):
        return reverse_lazy('post_detail', kwargs={'post_id': self.object.id})

# DeleteView для удаления
class PostDeleteView(LoginRequiredMixin, DeleteView):
    model = Post
    template_name = 'blog/post_confirm_delete.html'
    pk_url_kwarg = 'post_id'
    success_url = reverse_lazy('index')
    
    def get_queryset(self):
        return Post.objects.filter(author=self.request.user)

# Кастомный View
class UserDashboardView(LoginRequiredMixin, View):
    login_url = 'login'
    
    def get(self, request):
        user_posts = Post.objects.filter(author=request.user)
        stats = {
            'total_posts': user_posts.count(),
            'total_comments': Comment.objects.filter(post__author=request.user).count(),
        }
        return render(request, 'user/dashboard.html', {
            'posts': user_posts,
            'stats': stats
        })

URL маршруты:

# urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('', views.IndexView.as_view(), name='index'),
    path('posts/', views.PostListView.as_view(), name='post_list'),
    path('posts/<int:post_id>/', views.PostDetailView.as_view(), name='post_detail'),
    path('posts/create/', views.PostCreateView.as_view(), name='post_create'),
    path('posts/<int:post_id>/edit/', views.PostUpdateView.as_view(), name='post_update'),
    path('posts/<int:post_id>/delete/', views.PostDeleteView.as_view(), name='post_delete'),
    path('dashboard/', views.UserDashboardView.as_view(), name='dashboard'),
]

Сравнение FBV и CBV

Миксины для повторной используемости

from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin

# Миксин для проверки прав
class IsAuthorMixin(UserPassesTestMixin):
    def test_func(self):
        obj = self.get_object()
        return obj.author == self.request.user
    
    def handle_no_permission(self):
        return HttpResponseForbidden('Вы не автор этого поста')

# Использование
class PostUpdateView(LoginRequiredMixin, IsAuthorMixin, UpdateView):
    model = Post
    fields = ['title', 'content']
    pk_url_kwarg = 'post_id'

Django REST Framework для API

from rest_framework import viewsets, status
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated
from .models import Post, Comment
from .serializers import PostSerializer, CommentSerializer

class PostViewSet(viewsets.ModelViewSet):
    queryset = Post.objects.all()
    serializer_class = PostSerializer
    permission_classes = [IsAuthenticated]
    
    def get_queryset(self):
        """Пользователь видит только опубликованные посты"""
        if self.request.user.is_staff:
            return Post.objects.all()  # Администратор видит все
        return Post.objects.filter(published=True)
    
    def perform_create(self, serializer):
        serializer.save(author=self.request.user)
    
    @action(detail=True, methods=['post'])
    def like(self, request, pk=None):
        """Пользовательское действие: лайк на пост"""
        post = self.get_object()
        if request.user in post.likes.all():
            post.likes.remove(request.user)
            return Response({'status': 'unlike'})
        else:
            post.likes.add(request.user)
            return Response({'status': 'like'})
    
    @action(detail=True, methods=['get'])
    def comments(self, request, pk=None):
        """Пользовательское действие: комментарии поста"""
        post = self.get_object()
        comments = post.comments.all()
        serializer = CommentSerializer(comments, many=True)
        return Response(serializer.data)

# Регистрация ViewSet в URL
from rest_framework.routers import DefaultRouter

router = DefaultRouter()
router.register(r'posts', PostViewSet)

urlpatterns = [
    path('api/', include(router.urls)),
]

Лучшие практики

✓ Тонкие представления

# Хорошо: логика в models.py
class PostListView(ListView):
    queryset = Post.objects.published()

✗ Толстые представления

# Плохо: вся логика в view
class PostListView(ListView):
    def get_queryset(self):
        posts = Post.objects.all()
        # 100 строк логики здесь
        return posts

✓ DRY принцип

# Хорошо: используем миксины
class MyListView(LoginRequiredMixin, ListView):
    pass

✗ Повторение кода

# Плохо: один и тот же код в каждом view
def view1(request):
    if not request.user.is_authenticated:
        return redirect('login')

def view2(request):
    if not request.user.is_authenticated:
        return redirect('login')

Итог

Выбор между FBV и CBV:

• FBV: для простых представлений, микросервисов, новичков
• CBV: для больших проектов с повторяющимся кодом
• DRF ViewSet: для API

Сочетание всех трёх подходов — лучшее решение для сложных приложений.