Django Views 심화: 고급 기능과 최적화 기법 마스터하기

Django 开发人员朋友们，大家好！今天我们将讨论默认值随后是 Django 您已经熟悉了基本的功能视图，但现在是时候更上一层楼，更高效地使用视图，让您的项目更加强大。准备好让 Django 技能更上一层楼了吗？让我们开始吧。

深入了解 Django 视图 - 基于类的视图 (CBV)

基于类的视图（CBV）是 Python-Django Web 开发框架提供的一项功能，它允许您以类的形式实现网页的功能，从而使您的代码更具可重用性和结构性。与基于函数的视图 (FBV) 相比，CBV 具有以下优点

优点

提供多种功能CBV 通过通用视图预先实现了各种功能，包括列表、明细、创建、修改、删除等。这使得开发人员可以很容易地继承他们需要的功能。
代码重用性CBV 允许您通过继承重复使用代码。例如，列表页面和详细页面有很多类似的功能，CBV 可以在父类中定义公共部分，然后只在每个页面上添加所需的功能，从而简化代码。
构建代码CBV 通过按功能划分类来轻松构建代码。这使得代码更易于理解和维护。

让我们来看一个简单的例子。

从 django.views 导入 View
from django.http import HttpResponse

类 HelloView(View)：
    def get(self, request)：
        return HttpResponse("Hello, it's a class-based view!")

代码说明

1. 从 django.views 导入 View
姜戈的 观点 在模块中 查看 去上课
查看 类是创建基于类的视图（CBV）时继承的基本类。
2. 从 django.http 导入 HttpResponse
姜戈的 http 在模块中 HttpResponse 去上课
HttpResponse 类用于生成 HTTP 响应。
3. 类 HelloView（视图）：
HelloView定义一个名为
该类实现了 查看 从类继承。
换句话说 HelloView将是一个基于类的视图。
4. def get(self, request)：
HelloView 班级内部 获取方法称为
获取 方法负责处理 HTTP GET 请求。
要求是保存客户端请求信息的对象。
5. return HttpResponse("Hello, it's a class-based view!")
HttpResponse 对象，并将字符串 "你好，这是一个基于类的视图！"作为参数传递给它。
该字符串会被放入 HTTP 响应的正文中，并发送给客户端。
返回 语句是一个 HttpResponse 反对

要将该视图链接到 URL，请这样做：在浏览器地址栏中输入 "主页地址/hello/"，HellowView 就会工作。

path('hello/', HelloView.as_view(), name='hello'), # 将 HelloView 连接到 URL "hello/"，并将其命名为 "hello

基于类的视图的优势在于，它们可以按 HTTP 方法轻松处理。

类 MyView（视图）：
    def get(self, request)：
        # 处理 GET 请求
        return HttpResponse("This is a GET request")

    def post(self, request)：
        # 处理 POST 请求
        return HttpResponse("This is a POST request")

代码评注

1. 类 MyView（视图）：
我的视图定义一个名为
该类实现了 Django 的 查看 从类继承。
换句话说 我的视图成为基于类别的视图（CBV）。
2. def get(self, request)：
我的视图 班级内部 获取方法称为
获取 方法负责处理 HTTP GET 请求。
客户端访问网页时，网络浏览器会向服务器发送 GET 请求。
要求是保存客户端请求信息的对象。
3. # GET 请求处理 :
注释。它们用于描述代码的功能。
4. return HttpResponse("This is a GET request")
HttpResponse 对象，并将字符串 "这是一个 GET 请求 "作为参数传递给它。
该字符串会被放入 HTTP 响应的正文中，并发送给客户端。
返回 语句是一个 HttpResponse 反对
5. def post(self, request)：
我的视图 班级内部 邮寄方法称为
邮寄 方法负责处理 HTTP POST 请求。
当客户端向服务器提交表单数据时，网络浏览器会向服务器发送 POST 请求。
要求是保存客户端请求信息的对象。
6. # POST 请求处理:
注释。它们用于描述代码的功能。
7. return HttpResponse("This is a POST request")
HttpResponse 对象，并将字符串 "This is a POST request"（这是一个 POST 请求）作为参数传递给它。
该字符串会被放入 HTTP 响应的正文中，并发送给客户端。
返回 语句是一个 HttpResponse 反对

深入了解 Django 视图--利用通用视图

Django 提供通用视图（Generic View），它是网络开发中常用模式的预置实现。使用通用视图可以帮助您减少重复代码的编写，并通过提高代码的可读性来提高开发效率。

通用视图的优势

代码重用性通用视图预先实现了常用功能，因此开发人员只需继承他们需要的功能即可。
代码简洁通用视图：通用视图减少了重复代码，因此你可以编写更简洁的代码。
代码可读性通用视图：通用视图按功能分隔类，使代码更易于理解和维护。

主要通用视图类型

删除视图视图：提供删除对象功能的视图

列表视图：显示对象列表的视图

详细查看显示特定对象详细信息的视图

创建查看视图：提供创建对象表单的视图

更新查看提供修改对象表单的视图

例如，如果您想创建一个显示对象列表的视图，就可以这样做。通过这段简单的代码，您就可以创建一个显示图书模型中所有对象列表的视图。

从 django.views.generic 导入 ListView
从 .models import Book

类 BookListView(ListView)：
    model = Book
    template_name = "book_list.html
    context_object_name = 'books' 上下文对象名称

代码评注

1. 从 django.views.generic 导入 ListView
姜戈的 视图.通用 在模块中 列表视图 去上课
列表视图是一种通用视图，可用于创建显示多个对象列表的网页。
2. 从 .models import Book
当前应用程序的 模型 在模块中 图书 导入模型
图书 模型是定义要存储在数据库中的图书信息的类。
3. 类 BookListView(ListView)：
图书列表视图定义一个名为
该类实现了 列表视图 从类继承。
换句话说 图书列表视图"(《世界人权宣言》) 列表视图创建图书列表页面。
4. 模型 = 图书
模型 属性是一个 列表视图指定要使用的模型。
在这里，我们将使用 图书 现在我们已经指定了一个模型、 图书列表视图"(《世界人权宣言》) 图书 创建一个页面，显示模型中存储的图书列表。
5. 模板名称 = 'book_list.html'
模板名称 属性指定模板文件的名称。
在这里，我们将使用 book_list.html 以该文件为模板，构建图书列表页面。
该模板文件名为 图书 它的作用是以 HTML 格式显示模型中的对象列表。
6. context_object_name = "书籍
上下文对象名称 属性指定模板中要使用的对象列表名称。
默认情况下 列表视图"(《世界人权宣言》) 对象列表的对象列表。
然而 上下文对象名称将其更改为您选择的名称。
在这里，我们将使用 书籍的对象列表，因此模板将传递一个名为 {{书籍 }}以同样的方式访问图书列表。

深入了解 Django 视图--使用混合素

在基于类的视图（CBV）中，混合元素是重复使用代码和扩展功能的有用工具。混合元素是一小部分执行特定功能的类，可以与其他类混合使用。

混合体的优势

代码重用性混合类：混合类允许在多个类中重复使用共同的功能，从而减少代码重复并提高可维护性。
代码可读性混合类：将功能分离到混合类中，可以更容易地看到类的功能，从而使代码更易读。
灵活性混合类：通过组合具有所需功能的混合类，您可以轻松创建具有不同功能的类。

通过混合组件，可以轻松地为视图添加额外的功能。例如，如果要创建一个需要登录的视图，可以这样做：此视图只有登录用户才能访问。

from django.contrib.auth.mixins import LoginRequiredMixin
从 django.views.generic 导入 DetailView
从 .models 导入 PrivateDocument

类 PrivateDocumentView(LoginRequiredMixin, DetailView)：
    model = PrivateDocument
    template_name = "private_document.html

代码评注

1. from django.contrib.auth.mixins import LoginRequiredMixin
姜戈的 contrib.auth.mixins 在模块中 登录所需的混音从
Mixin 是一个用于为类添加功能的类。
登录所需的混音增加了检查视图是否已登录的功能，这意味着只有已登录的用户才能访问该视图。
2. 从 django.views.generic 导入 DetailView
姜戈的 视图.通用 在模块中 详细查看从
详细查看是一种通用视图，可用于创建显示特定对象详细信息的网页。
3. 从 .models 导入 PrivateDocument
当前应用程序的 模型 在模块中 私人文档 导入模型
私人文档 模型是一个定义要存储在数据库中的个人文档信息的类。
4. 类 PrivateDocumentView（LoginRequiredMixin、DetailView）：
私有文档视图定义一个名为
该类实现了 登录所需的混音和 详细查看继承自
多重继承 私有文档视图将同时具有要求登录功能和详细页面查看功能。
继承顺序很重要。 登录所需的混音必先 详细查看将在登录确认后执行。
5. 模型 = PrivateDocument
模型 属性是一个 详细查看指定要使用的模型。
在这里，我们将使用 私人文档 现在我们已经指定了一个模型、 私有文档视图"(《世界人权宣言》) 私人文档 创建一个页面，显示模型中存储的特定个人文档的详细信息。
6. 模板名称 = 'private_document.html'
模板名称 属性指定模板文件的名称。
在这里，我们将使用 private_document.html 将该文件作为模板，配置您的个人文章详情页。
该模板文件名为 私人文档 它负责以 HTML 格式显示模型中的对象信息。

深入了解 Django 视图 - 创建自定义中间件

中间件是在处理网络请求和响应过程中执行特定功能的函数或类。在 Django 中，中间件在请求到达视图和响应发送到客户端之前运行。

中间件的作用

处理申请注意：你可以修改请求对象，或阻止不符合特定条件的请求。
处理答复您可以修改响应对象，或添加任何需要的标头。
处理全局功能:实施网络应用程序范围内的功能，如日志、安全、缓存等。

中间件允许你在请求/响应循环中加入额外的逻辑。让我们创建一个简单的日志中间件。下面的中间件记录所有请求和响应。

类 SimpleLoggingMiddleware：
    Def __init__(self, get_response)：
        self.get_response = get_response

    def __call__(self, request)：
        print(f "Request received: {request.path}")
        response = self.get_response(request)
        print(f "Response sent: {response.status_code}")
        返回响应

代码评注

1. 类 SimpleLoggingMiddleware：
简单记录中间件定义一个名为中间件的类。该类将充当中间件。
2. def __init__(self, get_response)：
启动 方法是类实例化时调用的构造函数。
获取响应是一个可调用对象，指向下一个中间件或视图函数。它负责将请求传递给 Django 中间件链中的下一步。
self.get_response = get_response是传入的 获取响应 函数作为类的属性。这样，您就可以将 __调用__ 方法可以调用下一级中间件或视图。
3. def __call__(self, request)：
__调用__ 方法是调用中间件时运行的方法；它们执行中间件的核心逻辑。
要求是一个 HTTP 请求对象。它包含有关请求的各种信息。
4. print(f "Request received: {request.path}")
收到请求时，请求路径 (request.path) 发送到控制台。我们使用了 f-string 来紧凑地处理字符串格式化。
5. response = self.get_response(request)
self.get_response(request)调用下一个中间件或视图函数，并将结果返回给 回应 变量。这是将请求传递到下一步的重要部分。
6. print(f "Response sent: {response.status_code}")
在向客户端发送响应之前，响应状态代码 (response.status_code)到控制台。
7. 返回响应
回应 对象。该对象可以是下一个中间件或视图生成的响应对象，也可以是后一个中间件修改过的响应对象。这就是最终将交付给客户端的响应。
一句话
简单记录中间件是一个简单的中间件，可在收到请求和发送响应时输出日志。 __调用__ 方法输出请求路径，调用下一级中间件或视图，并输出响应状态代码。该中间件称为 中间设备 您可以在 "设置 "中注册，启用记录所有请求和回复的功能。

深入了解 Django 视图--使用视图装饰器

装饰器是 Python 中的一种功能，您可以用它来封装函数或类，以添加或更改功能。视图装饰器可以轻松地将附加功能应用到视图函数中。

视图装饰器的优势

代码重用性:装饰器允许在多个视图中重复使用共同的功能，从而减少代码重复并提高可维护性。
代码可读性:装饰器将视图的核心逻辑与附加组件分离开来，使代码更具可读性。
灵活性:装饰器可以组合使用，轻松创建具有不同功能的视图。

装饰器可轻松为视图添加额外功能。例如，让我们创建一个可应用缓存的装饰器。

从 django.views.decorators.cache 导入 cache_page

@cache_page(60 * 15) # 缓存 15 分钟
def my_view(request)：
    # 视图逻辑
    return HttpResponse("This response is cached for 15 minutes")

代码评注

1. 从 django.views.decorators.cache 导入 cache_page
姜戈的 views.decorators.cache 在模块中 缓存页面 导入装饰器
缓存页面 装饰器提供了在指定时间内缓存视图结果的功能。
2. @cache_page(60 * 15) # 缓存 15 分钟
@cache_page(60 * 15)"(《世界人权宣言》) 我的视图 功能到 缓存页面 应用装饰器。
60 * 15是一个以秒为单位表示 15 分钟的值，这意味着视图结果将缓存 15 分钟。
# 缓存 15 分钟是注释，用于解释代码的含义。
3. def my_view(request)：
我的视图定义一个名为
该函数返回一个 HTTP 请求对象 (要求) 作为参数。
4. # 查看逻辑
注释，指明视图核心逻辑的位置。
实际视图执行的任务包括处理请求、查找数据库、渲染模板等。
5. return HttpResponse("This response is cached for 15 minutes")
HttpResponse 对象，并将字符串 "此响应缓存 15 分钟 "作为参数传递给它。
该字符串会被放入 HTTP 响应的正文中，并发送给客户端。
返回 语句是一个 HttpResponse 反对
摘要
上述代码相当于 我的视图 在视图功能中 缓存页面 应用装饰器将视图结果缓存 15 分钟。
这样，如果同一请求在 15 分钟内再次出现，就可以立即返回缓存结果，而不是重新运行视图函数，从而提高性能。

深入了解 Django 视图--使用异步视图

传统的同步视图无法在处理请求的同时执行其他任务，例如，无法在执行数据库查询的同时处理其他请求，从而造成瓶颈。

引入异步视图就是为了解决这些问题。异步视图允许你在等待 I/O 操作完成的同时执行其他任务。这样你就可以同时处理多个请求，从而提高整体吞吐量。

异步视图的优势

提高性能减少 I/O 绑定操作的瓶颈，提高整体吞吐量。
资源效率I/O：利用 I/O 操作的延迟，有效利用 CPU 和内存资源。
更快的响应时间I/O：用户无需等待 I/O 操作完成即可执行其他任务，缩短了响应时间。

Django 3.1 支持异步视图，这对 I/O 绑定操作特别有用。

导入 asyncio
从 django.http 导入 HttpResponse

async def async_view(request)：
    await asyncio.sleep(1) # 模拟异步 I/O 操作
    return HttpResponse("It's an async view!")

代码评注

1. 导入 asyncio
Python 的 异步 导入模块。 异步是异步编程的标准库。
2. 从 django.http 导入 HttpResponse
姜戈的 http 在模块中 HttpResponse 去上课 HttpResponse在生成 HTTP 响应对象时使用。
3. async def async_view(request)：
异步视图定义一个名为
异步 关键字表示该函数是一个 coroutine。例程是一种可以异步运行的函数。
要求是一个 HTTP 请求对象。它包含有关请求的各种信息。
4. await asyncio.sleep(1) # 模拟异步 I/O 操作
await asyncio.sleep(1)模拟停止一秒的异步操作。
asyncio.sleep(1)返回一个在一秒内完成的 Future 对象。
等 关键字会暂停执行 coroutine，直到 Future 对象完成。
注释 # 异步输入/输出操作模拟解释了代码的含义。
5. return HttpResponse("It's an asynchronous view!")
HttpResponse 对象，并将字符串 "这是一个异步视图！"作为参数传递给它。
该字符串会被放入 HTTP 响应的正文中，并发送给客户端。
返回 语句是一个 HttpResponse 反对
摘要
上述代码是一个异步视图函数，它模拟了停止一秒钟的异步操作 异步视图来定义
异步 关键字，使函数成为一个 coroutine、 等 关键字来等待异步操作。
该视图函数会返回一个 HTTP 响应，其中包含字符串 "This is an asynchronous view!"（这是一个异步视图！）。

性能优化技巧

Django 视图是网络应用程序中处理网络应用程序核心逻辑的部分，高效的视图编写可以显著提高性能。

1. `选择相关`和 `预取相关` 启用

问题是 在使用 ORM 查询相关对象时，可能会出现额外的数据库查询，从而导致性能下降。

解决方案 选择相关通过预先获取 1:1 或 N:1 关系中的相关对象，减少查询次数。 预取相关通过预先获取 N:N 关系中的相关对象来减少查询次数。

# 提前获取与作者相关的图书对象
books = Book.objects.select_related('author').all()

# 预取与出版商相关的图书对象（N:N 关系）
books = Book.objects.prefetch_related('publisher').all()

2. 利用 DB 索引

问题是 使用未编入索引的字段进行搜索会降低性能，因为必须搜索整个数据库。

解决方案 为经常查询的字段添加索引，以加快搜索速度。Django 使用 db_index=True 您可以通过添加选项来创建索引。

Pythonclass Book(models.Model): title = models.CharField(max_length=200, db_index=True) # ...

# 提前获取与作者相关的图书对象
books = Book.objects.select_related('author').all()

# 预取与出版商相关的图书对象（N:N 关系）
books = Book.objects.prefetch_related('publisher').all()

3. 缓存策略

问题是 每次从数据库中检索不经常变化的数据会浪费性能。

解决方案 不经常变化的数据可以存储在缓存中，以加快查找速度。Django 支持多种缓存后端，您可以使用视图装饰器或模板标签应用缓存。

类 Book(models.Model)：
    title = models.CharField(max_length=200, db_index=True)
    # ...

4. 分页

问题是 在一个页面上显示大量数据会增加加载时间，影响用户体验。
解决方案 使用分页功能将数据分割成多个页面。Django 使用 分页器 类可轻松实现分页。

5. 查询优化

问题是 低效查询会使数据库超载，导致性能下降。

解决方案 使用 QuerySet API 只检索所需的数据，减少不必要的查询或操作。

# 仅选择需要的字段
books = Book.objects.only('title', 'author').all()

# 仅筛选符合特定条件的数据
books = Book.objects.filter(author__name='John Doe').all()

总结

到目前为止，我们已经深入探讨了 Django 视图：基于类的视图、通用视图、中间件和性能优化技术。有了这些功能，您就能构建更强大、更高效的 Django 应用程序。

起初它们可能看起来很复杂，但当您逐一应用并掌握它们时，您的 Django 技能将得到显著提高。请不断尝试和练习。祝您在 Django 的道路上一帆风顺！

# 术语表

基于类别的视图（CBV）:如何使用类实现视图
通用观点预先实现常用视图模式的视图
混合体:为类提供附加功能的类
中间件处理请求和响应的中间层
装饰如何修改或扩展函数或方法的功能。
异步视图视图：行为异步的视图
ORM 优化主题：如何高效使用 Django ORM

我们希望您喜欢这篇深入了解 Django 视图的文章，并希望您的 Django 项目变得更加出色。加油吧！

深入了解 Django 视图 - 基于类的视图 (CBV)

优点

代码说明

1. 从 django.views 导入 View

2. 从 django.http 导入 HttpResponse

3. 类 HelloView（视图）：

4. def get(self, request)：

5. return HttpResponse("Hello, it's a class-based view!")

代码评注

1. 类 MyView（视图）：

2. def get(self, request)：

3. # GET 请求处理 :

4. return HttpResponse("This is a GET request")

5. def post(self, request)：

6. # POST 请求处理:

7. return HttpResponse("This is a POST request")

深入了解 Django 视图--利用通用视图

通用视图的优势

主要通用视图类型

代码评注

1. 从 django.views.generic 导入 ListView

2. 从 .models import Book

3. 类 BookListView(ListView)：

4. 模型 = 图书

5. 模板名称 = 'book_list.html'

6. context_object_name = "书籍

深入了解 Django 视图--使用混合素

混合体的优势

代码评注

1. from django.contrib.auth.mixins import LoginRequiredMixin

2. 从 django.views.generic 导入 DetailView

3. 从 .models 导入 PrivateDocument

4. 类 PrivateDocumentView（LoginRequiredMixin、DetailView）：

5. 模型 = PrivateDocument

6. 模板名称 = 'private_document.html'

深入了解 Django 视图 - 创建自定义中间件

中间件的作用

代码评注

1. 类 SimpleLoggingMiddleware：

2. def __init__(self, get_response)：

3. def __call__(self, request)：

4. print(f "Request received: {request.path}")

5. response = self.get_response(request)

6. print(f "Response sent: {response.status_code}")

7. 返回响应

深入了解 Django 视图--使用视图装饰器

视图装饰器的优势

代码评注

1. 从 django.views.decorators.cache 导入 cache_page

2. @cache_page(60 * 15) # 缓存 15 分钟

3. def my_view(request)：

4. # 查看逻辑

5. return HttpResponse("This response is cached for 15 minutes")

摘要

深入了解 Django 视图--使用异步视图

异步视图的优势

代码评注

1. 导入 asyncio

2. 从 django.http 导入 HttpResponse

3. async def async_view(request)：

4. await asyncio.sleep(1) # 模拟异步 I/O 操作

5. return HttpResponse("It's an asynchronous view!")

摘要

性能优化技巧

1. 选择相关和 预取相关 启用

2. 利用 DB 索引

3. 缓存策略

4. 分页

5. 查询优化

总结

# 术语表

类似文章

1. `从 django.views 导入 View`

2. `从 django.http 导入 HttpResponse`

3. `类 HelloView（视图）：`

4. `def get(self, request)：`

5. `return HttpResponse("Hello, it's a class-based view!")`

1. `类 MyView（视图）：`

2. `def get(self, request)：`

3. `# GET 请求处理` :

4. `return HttpResponse("This is a GET request")`

5. `def post(self, request)：`

6. `# POST 请求处理`:

7. `return HttpResponse("This is a POST request")`

1. `从 django.views.generic 导入 ListView`

2. `从 .models import Book`

3. `类 BookListView(ListView)：`

4. `模型 = 图书`

5. `模板名称 = 'book_list.html'`

6. `context_object_name = "书籍`

1. `from django.contrib.auth.mixins import LoginRequiredMixin`

2. `从 django.views.generic 导入 DetailView`

3. `从 .models 导入 PrivateDocument`

4. `类 PrivateDocumentView（LoginRequiredMixin、DetailView）：`

5. `模型 = PrivateDocument`

6. `模板名称 = 'private_document.html'`

1. `类 SimpleLoggingMiddleware：`

2. `def init(self, get_response)：`

3. `def call(self, request)：`

4. `print(f "Request received: {request.path}")`

5. `response = self.get_response(request)`

6. `print(f "Response sent: {response.status_code}")`

7. `返回响应`

1. `从 django.views.decorators.cache 导入 cache_page`

2. `@cache_page(60 * 15) # 缓存 15 分钟`

3. `def my_view(request)：`

4. `# 查看逻辑`

5. `return HttpResponse("This response is cached for 15 minutes")`

1. `导入 asyncio`

2. `从 django.http 导入 HttpResponse`

3. `async def async_view(request)：`

4. `await asyncio.sleep(1) # 模拟异步 I/O 操作`

5. `return HttpResponse("It's an asynchronous view!")`

1. `选择相关`和 `预取相关` 启用