Django4.0 基于类的视图-在基于类的视图中使用混入

Django 内置的基于类的视图提供了很多功能，但你可能想单独使用有些功能。例如，你可能想写一个渲染一个模板来生成 HTTP 响应的视图，但你不能使用 ​TemplateView ​；也许你只需要在 POST 时渲染一个模板，用 GET 来处理其他所有事。虽然你可以直接使用 ​TemplateResponse​，但这很可能会导致重复代码。

因此 Django 也提供了很多混入，它们提供了更多的离散功能。比如模板渲染，被封装在 ​TemplateResponseMixin ​中。

上下文和模板响应

提供了两个重要的混入，它们有助于在基于类的视图中使用模板时提供一个一致的接口。

TemplateResponseMixin

每个返回 ​TemplateResponse的内置视图都将调用 ​TemplateResponseMixin提供的 ​render_to_response() 方法。大多数时候，这个方法会被你调用（例如，它被 ​TemplateView​和 ​DetailView​共同实现的 ​get()方法调用）；同样，你也不太可能需要覆盖它，但如果你想让你的响应返回一些没有通过 Django 模板渲染的东西，那么你会想要这样做。

ContextMixin

每个需要上下文数据的内置视图，比如为了渲染一个模板（包括上面的 ​TemplateResponseMixin​），都应该将他们想确定传入的数据作为关键字参数传入 ​get_context_data()

调用。​get_context_data()返回一个字典；在 ​ContextMixin​中它返回它的关键字参数，但通常覆盖此项来增加更多成员到字典中。你也可以使用 ​extra_context属性。

构造 Django 基于类的通用视图

让我们看看 Django 的两个基于类的通用视图是如何由提供离散功能的混入构建的。我们将考虑 ​DetailView ​，它渲染一个对象的 “详情” 视图，以及 ​ListView ​，它渲染一个对象列表，通常来自一个查询集，并可选择将它们分页。这里将介绍四个混入，无论是在处理单个 Django 对象还是多个对象时，它们都提供了有用的功能。
通用编辑视图（ ​FormView​，和模型专用的视图 ​CreateView​，​UpdateView ​和 ​DeleteView ​），以及基于日期的通用视图中也涉及到混入

DetailView ：使用单个 Django 对象

要显示一个对象的详情，我们基本上需要做两件事：我们需要查询对象，然后将该对象作为上下文，用一个合适的模板生成一个 ​TemplateResponse ​。
为了得到对象，​DetailView ​依赖于 ​SingleObjectMixin ​，它提供一个 ​get_object()​ 方法，该方法根据请求的 URL 来找出对象（它查找 ​URLconf ​中声明的 ​pk ​和 ​slug ​关键字参数，并从视图上的 ​model ​属性查找对象，或者从提供的 ​queryset ​属性中查找）。​SingleObjectMixin ​还覆盖了 ​get_context_data()​ ，它被用于所有 Django 内置的基于类的视图，为模板渲染提供上下文数据。
然后为了生成一个 ​TemplateResponse​， ​DetailView ​使用了 ​SingleObjectTemplateResponseMixin​，它扩展了 ​TemplateResponseMixin​，如上所述的覆盖了 ​get_template_names()​。它实际上提供了一组相当复杂的选项，但大多数人都会使用的主要选项是 ​<app_label>/<model_name> _detail.html​。​_detail​ 部分可以通过在子类上设置 ​template_name_suffix ​来改变。（例如 通用编辑视图 的创建和更新视图使用 ​_form​，删除视图使用 ​_confirm_delete​。）

ListView ：使用多个 Django 对象

对象列表大致遵循相同的模式：我们需要一个（可能是分页的）对象列表，通常是 ​QuerySet ​，然后根据这个对象列表使用合适的模板生成 ​TemplateResponse ​。
为了得到对象，​ListView ​使用了 ​MultipleObjectMixin ​，它同时提供 ​get_queryset()​ 和 ​paginate_queryset()​ 。与 ​SingleObjectMixin ​不同的是，不需要使用部分 URL 来找出要使用的查询集，所以默认使用视图类上的 ​queryset ​或 ​model ​属性。在这里覆盖 ​get_queryset()​ 的常见原因是为了动态变化的对象，比如根据当前用户的情况，或者为了排除博客未来的文章。
​MultipleObjectMixin ​还覆盖了 ​get_context_data()​，为分页加入了适当的上下文变量（如果分页被禁用，则提供虚假分页）。它依赖于 ​ListView ​作为关键字参数传入的 ​object_list​。
要生成一个 ​TemplateResponse ​，​ListView ​则使用 ​MultipleObjectTemplateResponseMixin ​；和上面的 ​SingleObjectTemplateResponseMixin ​一样，它覆盖 ​get_template_names()​ 来提供一系列选项，最常用的 ​<app_label>/<model_name>_list.html ​，​_list​ 部分同样从 ​template_name_suffix ​属性中获取。（基于日期的通用视图使用诸如 ​_archive​ 、​_archive_year​ 等后缀来为各种专门的基于日期的列表视图使用不同的模板。）

使用 Django 的基于类的视图混入

现在我们已经知道 Django 的基于类的通用视图如何使用所提供的混入，让我们看看使用它们的其他方式。我们仍然会将它们与内置的基于类的视图，或者其他通用的基于类的视图结合起来，但是，有一系列比 Django 开箱即用所提供的更罕见的问题可以被解决。

注意：不是所有的混入都可以一起使用，并且不是所有的基于类的通用视图能和所有其他的混入一起使用。这里我们介绍一些有用的例子；如果你想把其他功能汇集在一起，那么你就必须考虑你正在使用的不同类之间重叠的属性和方法之间的相互作用，以及 ​method resolution order​ 将如何影响哪些版本的方法将以何种顺序被调用。

如果有问题，最好还是退而求其次，以 ​View ​或 ​TemplateView ​为基础，或许可以用 ​SingleObjectMixin​ 和 ​MultipleObjectMixin ​。虽然你最终可能会写出更多的代码，但对于以后再来的人来说，更有可能清楚地理解，并且由于需要担心的交互较少，你可以省去一些思考。

在视图中使用 SingleObjectMixin

如果我们想编写一个只响应 POST 的基于类的视图，我们将子类化 View 并且在子类中编写一个 post() 方法。但是如果想让我们的程序在一个从 URL 中识别出来特定的对象上工作，我们就需要 ​SingleObjectMixin ​提供的功能。

我们将使用我们在基于类的通用视图介绍中使用的 Author 模型来演示这一点。

from django.http import HttpResponseForbidden, HttpResponseRedirect
from django.urls import reverse
from django.views import View
from django.views.generic.detail import SingleObjectMixin
from books.models import Author

class RecordInterestView(SingleObjectMixin, View):
    """Records the current user's interest in an author."""
    model = Author

    def post(self, request, *args, **kwargs):
        if not request.user.is_authenticated:
            return HttpResponseForbidden()

        # Look up the author we're interested in.
        self.object = self.get_object()
        # Actually record interest somehow here!

        return HttpResponseRedirect(reverse('author-detail', kwargs={'pk': self.object.pk}))

在实际操作中，你可能会希望把兴趣记录在一个键值存储中，而不是关系数据库中，所以我们把关于数据库的省略了。视图在使用 ​SingleObjectMixin ​时，我们唯一需要担心的地方是想要查找我们感兴趣的作者，它通过调用​ self.get_object() ​来实现。其他的一切都由混入替我们处理。

我们可以很简单的将它挂接在我们的 URLs 中：

from django.urls import path
from books.views import RecordInterestView

urlpatterns = [
    #...
    path('author/<int:pk>/interest/', RecordInterestView.as_view(), name='author-interest'),
]

注意 ​pk ​命名的组，​get_object()​ 用它来查找 ​Author ​实例。你也可以使用 ​slug​，或者 ​SingleObjectMixin ​的任何其他功能。

在 ListView 中使用 SingleObjectMixin

​ListView ​提供了内置的分页功能，但你可能想将一个对象列表分页，而这些对象都是通过一个外键链接到另一个对象的。在我们的出版示例中，你可能想对某一出版商的所有书籍进行分页。
一种方法是将 ​ListView ​和 ​SingleObjectMixin ​结合起来，这样一来，用于图书分页列表的查询集就可以脱离作为单个对象找到的出版商对象。 为此，我们需要两个不同的查询集：
​ListView ​使用的 Book 查询集

由于我们已经得到了我们所想要书籍列表的 Publisher ，我们只需覆盖 ​get_queryset()​ 并使用的 ​Publisher ​的 反向外键管理器。

​get_object()​ 使用的 ​Publisher ​查询集

我们将依赖 ​get_object()​ 的默认实现来获取正确的 ​Publisher ​对象。然而，我们需要显式地传递一个 ​queryset ​参数，因为 ​get_object() ​的默认实现会调用 ​get_queryset()​ ，我们已经覆盖了它并返回了 Book 对象而不是 Publisher 对象。

注解：我们必须认真考虑 ​get_context_data()​。由于 ​SingleObjectMixin ​和 ​ListView ​会将上下文数据放在 ​context_object_name​ 的值下（如果它已设置），我们要明确确保 ​Publisher ​在上下文数据中。​ListView ​将为我们添加合适的 ​page_obj ​和 ​paginator​，只要我们记得调用 ​super()​。

现在我们可以编写一个新的 ​PublisherDetailView​：

from django.views.generic import ListView
from django.views.generic.detail import SingleObjectMixin
from books.models import Publisher

class PublisherDetailView(SingleObjectMixin, ListView):
    paginate_by = 2
    template_name = "books/publisher_detail.html"

    def get(self, request, *args, **kwargs):
        self.object = self.get_object(queryset=Publisher.objects.all())
        return super().get(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['publisher'] = self.object
        return context

    def get_queryset(self):
        return self.object.book_set.all()

注意看我们如何在 ​get()​ 中设置 ​self.object​ ，这样我们可以在后面的 ​get_context_data()​ 和 ​get_queryset()​ 中再次使用它。如果你没有设置 ​template_name ​，模板将为正常 ​ListView ​的默认选项，在这个例子里是 "​books/book_list.html​" ，因为它是书籍的列表；​ListView ​对 ​SingleObjectMixin ​一无所知，因此这个视图和 ​Publisher ​没有任何关系。
在这个例子中，​paginate_by ​被刻意地缩小了，所以你不需要创建很多书就能看到分页的效果。这里是你要使用的模板：

{% extends "base.html" %}

{% block content %}
    <h2>Publisher {{ publisher.name }}</h2>

    <ol>
      {% for book in page_obj %}
        <li>{{ book.title }}</li>
      {% endfor %}
    </ol>

    <div class="pagination">
        <span class="step-links">
            {% if page_obj.has_previous %}
                <a href="?page={{ page_obj.previous_page_number }}">previous</a>
            {% endif %}

            <span class="current">
                Page {{ page_obj.number }} of {{ paginator.num_pages }}.
            </span>

            {% if page_obj.has_next %}
                <a href="?page={{ page_obj.next_page_number }}">next</a>
            {% endif %}
        </span>
    </div>
{% endblock %}

避免过度复杂的事情

一般来说，你可以在需要的时候使用 ​TemplateResponseMixin ​和 ​SingleObjectMixin ​的功能。如上所示，只要稍加注意，你甚至可以将 ​SingleObjectMixin ​和 ​ListView ​结合起来。然而当你尝试这样做时，事情会变得越来越复杂，一个好的经验法则是：

提示：你的每个视图应该只使用混入或者来自一个通用基于类的视图的组里视图： 详情，列表，编辑 和日期。例如，将 ​TemplateView ​（内置视图）和 ​MultipleObjectMixin ​（通用列表）结合起来，但你可能会在 ​SingleObjectMixin ​（通用详情）和 ​MultipleObjectMixin ​（通用列表）结合时遇到问题。

为了说明当您尝试变得更复杂时会发生什么，我们展示了一个示例，该示例在有更简单的解决方案时会牺牲可读性和可维护性。 首先，让我们看一个将 ​DetailView ​与 ​FormMixin ​结合起来的天真的尝试，使我们能够将 Django 表单发布到与使用 ​DetailView ​显示对象相同的 URL。

DetailView 和 FormMixin 一起使用

回想一下我们之前使用 ​View ​和 ​SingleObjectMixin ​一起使用的例子。我们当时记录的是一个用户对某个作者的兴趣；比如说现在我们想让他们留言说为什么喜欢他们。同样，我们假设我们不打算把这个存储在关系型数据库中，而是存储在更深奥的东西中，我们在这里就不关心了。
这时自然而然就会用到一个 ​Form ​来封装从用户浏览器发送到 Django 的信息。又比如说我们在 ​REST ​上投入了大量的精力，所以我们希望用同样的 URL 来显示作者和捕捉用户的信息。让我们重写我们的 ​AuthorDetailView ​来实现这个目标。
我们将保留 ​DetailView ​中的 ​GET ​处理，尽管我们必须在上下文数据中添加一个 ​Form​，这样我们就可以在模板中渲染它。我们还要从 ​FormMixin ​中调入表单处理，并写一点代码，这样在 ​POST​时，表单会被适当地调用。

注解：我们使用 ​FormMixin ​并自己实现 ​post()​，而不是尝试将 ​DetailView ​与 ​FormView ​混合（它已经提供了合适的 ​post()​），因为两个视图都实现了 ​get()​，事情会变得更加混乱。

我们新的 ​AuthorDetailView ​如下所示：

# CAUTION: you almost certainly do not want to do this.
# It is provided as part of a discussion of problems you can
# run into when combining different generic class-based view
# functionality that is not designed to be used together.

from django import forms
from django.http import HttpResponseForbidden
from django.urls import reverse
from django.views.generic import DetailView
from django.views.generic.edit import FormMixin
from books.models import Author

class AuthorInterestForm(forms.Form):
    message = forms.CharField()

class AuthorDetailView(FormMixin, DetailView):
    model = Author
    form_class = AuthorInterestForm

    def get_success_url(self):
        return reverse('author-detail', kwargs={'pk': self.object.pk})

    def post(self, request, *args, **kwargs):
        if not request.user.is_authenticated:
            return HttpResponseForbidden()
        self.object = self.get_object()
        form = self.get_form()
        if form.is_valid():
            return self.form_valid(form)
        else:
            return self.form_invalid(form)

    def form_valid(self, form):
        # Here, we would record the user's interest using the message
        # passed in form.cleaned_data['message']
        return super().form_valid(form)

​get_success_url()​ 提供了重定向的去处，它在 ​form_valid()​ 的默认实现中使用。如前所述，我们需要提供自己的 ​post()​ 。

更好的解决方案

​FormMixin ​和 ​DetailView ​之间微妙交互已经在测试我们管理事务的能力了。你不太可能想写这样的类。
在这个例子里，你可以编写 ​post()​ 让 ​DetailView ​作为唯一的通用功能，尽管编写 ​Form ​的处理代码会涉及到很多重复的地方。
或者，使用单独的视图来处理表单仍然比上述方法工作量小，它可以使用 ​FormView ​，而不必担心任何问题。

另一种更好的解决方案

我们在这里真正想做的是使用来自同一个 URL 的两个不同的基于类的视图。 那么为什么不这样做呢？ 我们这里有一个非常明确的划分：​GET ​请求应该获取 ​DetailView​（将 ​Form ​添加到上下文数据中），​POST ​请求应该获取 ​FormView​。 让我们先设置这些视图。

​AuthorDetailView ​视图与我们第一次介绍 ​AuthorDetailView ​时几乎相同； 我们必须编写自己的 ​get_context_data()​ 以使 ​AuthorInterestForm ​可用于模板。 为了清楚起见，我们将跳过之前的 ​get_object()​ 覆盖：

from django import forms
from django.views.generic import DetailView
from books.models import Author

class AuthorInterestForm(forms.Form):
    message = forms.CharField()

class AuthorDetailView(DetailView):
    model = Author

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['form'] = AuthorInterestForm()
        return context

那么​AuthorInterestForm​是一个​FormView​，但是我们必须引入​SingleObjectMixin​，这样我们才能找到我们正在谈论的作者，并且我们必须记住设置​template_name​以确保表单错误会呈现与​AuthorDetailView​在GET上使用的模板相同的模板 ：

from django.http import HttpResponseForbidden
from django.urls import reverse
from django.views.generic import FormView
from django.views.generic.detail import SingleObjectMixin

class AuthorInterestFormView(SingleObjectMixin, FormView):
    template_name = 'books/author_detail.html'
    form_class = AuthorInterestForm
    model = Author

    def post(self, request, *args, **kwargs):
        if not request.user.is_authenticated:
            return HttpResponseForbidden()
        self.object = self.get_object()
        return super().post(request, *args, **kwargs)

    def get_success_url(self):
        return reverse('author-detail', kwargs={'pk': self.object.pk})

最后，我们将它们放在一个新的 ​AuthorView ​视图中。 我们已经知道，在基于类的视图上调用 ​as_view()​ 会给我们一些行为与基于函数的视图完全相同的东西，因此我们可以在两个子视图之间进行选择时这样做。

您可以像在 ​URLconf ​中一样将关键字参数传递给 ​as_view()​，例如，如果您希望 ​AuthorInterestFormView​ 行为也出现在另一个 URL 上，但使用不同的模板：

from django.views import View

class AuthorView(View):

    def get(self, request, *args, **kwargs):
        view = AuthorDetailView.as_view()
        return view(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        view = AuthorInterestFormView.as_view()
        return view(request, *args, **kwargs)

这个方式也可以被任何其他通用基于类的视图，或你自己实现的直接继承自 ​View ​或 ​TemplateView ​的基于类的视图使用，因为它使不同视图尽可能分离。

不仅仅是HTML

基于类的视图的优势是你可以多次执行相同操作。假设你正在编写 API，那么每个视图应该返回 JSON，而不是渲染 HTML。

我们可以创建一个混入类来在所有视图里使用，用它来进行一次转换到 JSON。

比如，一个 JSON 混入可以是这样：

from django.http import JsonResponse

class JSONResponseMixin:
    """
    A mixin that can be used to render a JSON response.
    """
    def render_to_json_response(self, context, **response_kwargs):
        """
        Returns a JSON response, transforming 'context' to make the payload.
        """
        return JsonResponse(
            self.get_data(context),
            **response_kwargs
        )

    def get_data(self, context):
        """
        Returns an object that will be serialized as JSON by json.dumps().
        """
        # Note: This is *EXTREMELY* naive; in reality, you'll need
        # to do much more complex handling to ensure that arbitrary
        # objects -- such as Django model instances or querysets
        # -- can be serialized as JSON.
        return context

混入提供了 ​render_to_json_response()​ 方法，其签名与 ​render_to_response() ​相同。为了使用它，我们需要把它混入一个 ​TemplateView ​里，并且重写 ​render_to_response()​ 来调用 ​render_to_json_response()​ ：

from django.views.generic import TemplateView

class JSONView(JSONResponseMixin, TemplateView):
    def render_to_response(self, context, **response_kwargs):
        return self.render_to_json_response(context, **response_kwargs)

同样，我们可以将我们的 ​mixin ​与通用视图之一一起使用。 我们可以通过将 ​JSONResponseMixin ​与 ​BaseDetailView ​混合来制作我们自己的 ​DetailView ​版本——（模板渲染行为之前的 ​DetailView ​已被混合）：

from django.views.generic.detail import BaseDetailView

class JSONDetailView(JSONResponseMixin, BaseDetailView):
    def render_to_response(self, context, **response_kwargs):
        return self.render_to_json_response(context, **response_kwargs)

然后可以以与任何其他 ​DetailView ​相同的方式部署此视图，具有完全相同的行为——除了响应的格式。

您甚至可以混合一个能够返回 HTML 和 JSON 内容的 ​DetailView ​子类，具体取决于 HTTP 请求的某些属性，例如查询参数或 HTTP 表头。 混合 ​JSONResponseMixin ​和 ​SingleObjectTemplateResponseMixin​，并覆盖 ​render_to_response()​ 的实现，以根据用户请求的响应类型推迟到适当的呈现方法：

from django.views.generic.detail import SingleObjectTemplateResponseMixin

class HybridDetailView(JSONResponseMixin, SingleObjectTemplateResponseMixin, BaseDetailView):
    def render_to_response(self, context):
        # Look for a 'format=json' GET argument
        if self.request.GET.get('format') == 'json':
            return self.render_to_json_response(context)
        else:
            return super().render_to_response(context)

由于 Python 解析方法重载的方式，对 ​super().render_to_response(context)​ 的调用最终会调用 ​TemplateResponseMixin ​的 ​render_to_response()​ 实现。