56 | ```
57 |
58 | ### 方案二
59 |
60 | 另一个种方法是不依赖 `contrib.staticfiles` ，手动给静态文件提供服务：
61 |
62 | ```python
63 | # settings.py
64 |
65 | INSTALLED_APPS = [
66 | ...
67 | # 注释掉它
68 | # 'django.contrib.staticfiles',
69 | ...
70 | ]
71 |
72 | DEBUG = True
73 |
74 | STATIC_URL = '/static/'
75 | STATIC_ROOT = os.path.join(BASE_DIR, 'static')
76 | # 注释掉它
77 | # STATICFILES_DIRS = [os.path.join(BASE_DIR, "static")]
78 | ```
79 |
80 | 所以此时你需要手动添加静态文件的路由解析：
81 |
82 | ```python
83 | # urls.py
84 |
85 | from django.conf import settings
86 | from django.conf.urls.static import static
87 |
88 | urlpatterns = [
89 | ...
90 | ]
91 | urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
92 | ```
93 |
94 | 这样子就可以了，也是同样的效果。
95 |
96 | > 这种方式的问题是后台 Admin 的静态文件都无法加载了，必须另外想办法手动管理起来，比如用部署时经常用到的 `collectstatic` 把相关文件收集起来，再配置路径。沿用了内置 admin 的同学还是尽量用第一种方案更方便。
97 |
98 | ## 部署阶段
99 |
100 | 部署阶段的套路就完全不同了，最主要的区别是这个东西：
101 |
102 | ```python
103 | # settings.py
104 |
105 | DEBUG = False
106 | ```
107 |
108 | 此时 Django 就不再管理静态文件了，哪怕你配置了路由也不行。这是因为静态文件由 Django 来管理的效率实在是太低了，应该交由更高效的网络服务管理起来，如 `Nginx` 等。
109 |
110 | 即所有静态文件的请求都由 `Nginx` 直接处理，完全不经过 Django 了，所以此时不管你怎么折腾 Django 的配置都是没用的了。
111 |
112 | 部署阶段的静态文件管理在我之前的文章 [《将博客部署到线上》](https://www.dusaiphoto.com/article/detail/71/) 有过详细探讨了，有兴趣的朋友可以参照。
--------------------------------------------------------------------------------
/md/150-批量上传图片.md:
--------------------------------------------------------------------------------
1 | 批量上传文件、图片都是一样的，**第一步就是要把前端表单写对**：
2 |
3 | ```html
4 |
14 | ```
15 |
16 | `enctype="multipart/form-data"` 允许表单提交文件，必须写这一项。`multiple="multiple"` 允许一次提交多个文件。
17 |
18 | 接下来配置文件路径：
19 |
20 | ```python
21 | # settings.py
22 |
23 | MEDIA_URL = '/media/'
24 | MEDIA_ROOT = os.path.join(BASE_DIR, 'media/')
25 | ```
26 |
27 | 注册到路由中去：
28 |
29 | ```python
30 | # urls.py
31 |
32 | from django.conf import settings
33 | from django.conf.urls.static import static
34 |
35 |
36 | urlpatterns = [
37 | ...
38 | ]
39 | urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
40 | ```
41 |
42 | 弄好了上面两步，Django 才知道去哪里找到上传的文件。
43 |
44 | > 不配置其实也是可以上传的，只不过读取这些文件需要自己配置路径。
45 |
46 | 接下来就是模型、视图、路由了：
47 |
48 | ```python
49 | # models.py
50 | class Image(models.Model):
51 | image = models.ImageField(upload_to='images/%Y%m%d')
52 |
53 | # ------------------
54 |
55 | # views.py
56 | def uploads_files(request):
57 | if request.method == 'POST':
58 | files = request.FILES.getlist('file_field')
59 | for f in files:
60 | file = Image(image=f)
61 | file.save()
62 | return ...
63 |
64 | # ------------------
65 |
66 | # app/urls.py
67 | path('uploads/', uploads_files, name='uploads')
68 | ```
69 |
70 | > `ImageField` 字段依赖三方库 `Pillow` ，请先将它安装到项目中。
71 |
72 | 就这么简单，提交的图片就批量保存好了。比如今天是2020年5月11日，那么照片就会保存在 `media/images/20200511/` 目录里面。并且即使你上传重名的文件也没关系，Django 会妥善的帮你处理好文件重命名的问题，保证不会引用错误或者互相覆盖。
73 |
74 | 这里给出的是最小实现。实际开发中你还需要对上传的图片做一些校验，比如是否真的是图片、限制图片尺寸等等，都可以在视图里扩展相关功能。
75 |
76 | 上传成功后，你可以在模板上下文中愉快的引用它们了：
77 |
78 | ```html
79 | 
80 | ```
81 |
82 | 文件的上传也是一样的，把 `ImageField` 改成 `FileField` 就行了。
83 |
84 | 最后提醒一句，当你在数据库中删除 `Image` 模型时，仅仅只是删除了模型对图片的引用，图片本体还是安然无恙的躺在你的硬盘中的。你需要写额外的代码，手动管理文件本体的去留。
85 |
86 | ### 在后台中预览图片
87 |
88 | 这个话题虽然不太相关，但在这里也一并说了。
89 |
90 | 首先将图片模型改成这样：
91 |
92 | ```python
93 | class Image(models.Model):
94 | image = models.ImageField(upload_to='images/%Y%m%d')
95 |
96 | def admin_image(self):
97 | return '58 | 您已经访问本页面：{{ count }} 次. 59 |
60 | {% endblock %} 61 | ``` 62 | 63 | Session 的默认保存时间为 2 周，如果你想手动删除也可以： 64 | 65 | ```python 66 | del request.session['xxx'] 67 | ``` 68 | 69 | 通常情况下对 session 的修改会自动保存。但如果你存的是某种嵌套结构（比如字典），那么需要手动保存： 70 | 71 | ```python 72 | def some_view(request): 73 | ... 74 | # session 保存字典数据 75 | if request.session.get('deeper_count'): 76 | num = request.session['deeper_count']['num'] 77 | # 此时 session 并未更新，因为更新的仅仅是字典中的数据 78 | request.session['deeper_count']['num'] = num + 1 79 | # 通知会话已修改 80 | request.session.modified = True 81 | else: 82 | num = 1 83 | request.session['deeper_count'] = {'num': num} 84 | return ... 85 | ``` 86 | 87 | > 关联文档：[How to use sessions](https://docs.djangoproject.com/en/3.0/topics/http/sessions/) -------------------------------------------------------------------------------- /md/230-Middleware中间件.md: -------------------------------------------------------------------------------- 1 | **中间件**是 Django 处理请求和响应的**钩子框架**。它是一个轻量级的、低层级的“插件”系统，用于**全局**改变 Django 的输入或输出。如果你需要在响应请求时插入一个自定义功能、参数的时候特别有用。 2 | 3 | ### 自定义中间件 4 | 5 | 假设你有一个叫 `middleware` 的 app 。在 app 中创建文件 `middlewares.py`，一会儿在这里面自定义中间件。 6 | 7 | 来看一下 Django 官方推荐的中间件写法是什么样子的： 8 | 9 | ```python 10 | # middleware/middlewares.py 11 | 12 | class Md1: 13 | def __init__(self, get_response): 14 | self.get_response = get_response 15 | # (0) 参数的配置与初始化。初始化只执行一次。 16 | 17 | def __call__(self, request): 18 | 19 | # (1) 这里写实际视图执行之前的逻辑 20 | print('Md1 视图执行前..') 21 | 22 | # (2) get_response 是下一个中间件或视图函数的处理程序 23 | response = self.get_response(request) 24 | 25 | # (3) 这里写实际视图执行之后的逻辑 26 | print('Md1 视图执行后..') 27 | 28 | return response 29 | ``` 30 | 31 | 这个类 `Md1` 就是一个最简单的中间件了，它最核心的部分就是实现了 `__call__` 方法，使得类变成可调用对象： 32 | 33 | - 方法里的 `request` 就是视图函数中传入的那个 `request` 。 34 | - `get_response` 是可调用对象，它处理的内容可以是下一个中间件，也可以是实际的视图函数，当前中间件并不关心。`request` 通过它传递到下一级，也就是说 `get_response` 到达的最底层就是视图函数了。 35 | - 因此，**序号(1)** 则是**请求到达视图前**需要自定义的逻辑，**序号(3)** 是**请求从视图出来后**需要自定义的逻辑。 36 | 37 | 来实际测试一下。 38 | 39 | 首先注册 app 和中间件： 40 | 41 | ```python 42 | # your_project/settings.py 43 | 44 | INSTALLED_APPS = [ 45 | ... 46 | 'middleware', 47 | ] 48 | 49 | MIDDLEWARE = [ 50 | # 这里是 Django 默认注册的中间件 51 | ... 52 | 53 | # 刚才自定义的中间件，注册规则：appName.fileName.className 54 | 'middleware.middlewares.Md1', 55 | ] 56 | ``` 57 | 58 | 在 app 中编写测试视图： 59 | 60 | ```python 61 | # middleware/views.py 62 | 63 | from django.http import HttpResponse 64 | 65 | def mid_test(request): 66 | print('--- 视图执行中...') 67 | return HttpResponse('中间件测试..') 68 | ``` 69 | 70 | 最后在项目根 `urls.py` 中添加路由： 71 | 72 | ```python 73 | # your_project/urls.py 74 | 75 | ... 76 | 77 | from middleware.views import mid_test 78 | 79 | urlpatterns = [ 80 | ... 81 | path('middleware/', mid_test), 82 | ] 83 | ``` 84 | 85 | 访问此路由，命令行打印结果如下： 86 | 87 | ```python 88 | Md1 视图执行前.. 89 | --- 视图执行中... 90 | Md1 视图执行后.. 91 | ``` 92 | 93 | 不仅视图 `mid_test`，项目中所有的请求都会执行中间件的代码，也就是说是**影响全局**的。 94 | 95 | ### 执行顺序 96 | 97 | Django 收到请求后，会根据配置文件中 `MIDDLEWARE` 列表挨个执行中间件，所以列表里中间件的**顺序就很重要**，有些是互相依赖的，比如 Django 默认开启的 `SessionMiddleware` 和 `AuthenticationMiddleware` ，调换执行顺序后功能就会不正常。 98 | 99 | 为了直观表现调用次序，再添加两个自定义中间件： 100 | 101 | ```python 102 | # middleware/middlewares.py 103 | 104 | class Md1: 105 | def __init__(self, get_response): 106 | self.get_response = get_response 107 | 108 | def __call__(self, request): 109 | 110 | print('Md1 视图执行前..') 111 | response = self.get_response(request) 112 | print('Md1 视图执行后..') 113 | 114 | return response 115 | 116 | 117 | class Md2: 118 | def __init__(self, get_response): 119 | self.get_response = get_response 120 | 121 | def __call__(self, request): 122 | 123 | print('Md2 视图执行前..') 124 | response = self.get_response(request) 125 | print('Md2 视图执行后..') 126 | 127 | return response 128 | 129 | 130 | class Md3: 131 | def __init__(self, get_response): 132 | self.get_response = get_response 133 | 134 | def __call__(self, request): 135 | 136 | print('Md3 视图执行前..') 137 | response = self.get_response(request) 138 | print('Md3 视图执行后..') 139 | 140 | return response 141 | ``` 142 | 143 | 注册到配置中： 144 | 145 | ```python 146 | # your_project/settings.py 147 | 148 | MIDDLEWARE = [ 149 | ... 150 | 'middleware.middlewares.Md1', 151 | 'middleware.middlewares.Md2', 152 | 'middleware.middlewares.Md3', 153 | ] 154 | ``` 155 | 156 | 刷新页面后，命令行打印如下： 157 | 158 | ```python 159 | Md1 视图执行前.. 160 | Md2 视图执行前.. 161 | Md3 视图执行前.. 162 | --- 视图执行中... 163 | Md3 视图执行后.. 164 | Md2 视图执行后.. 165 | Md1 视图执行后.. 166 | ``` 167 | 168 | 非常神奇的是，中间件调用的 `get_response()` 方法**之前**的逻辑是按照注册列表**顺序**执行，而**之后**的逻辑是**逆序**执行的。 169 | 170 | > 也就是说，中间件在传递请求的阶段顺序执行，在返回响应的阶段逆序执行。 171 | 172 | 为什么会这样？让我们再看一眼 `__call__` 方法： 173 | 174 | ```python 175 | def __call__(self, request): 176 | 177 | # (1) 这里的逻辑按中间件注册列表顺序执行 178 | 179 | # (2) 下一个中间件或视图 180 | response = self.get_response(request) 181 | 182 | # (3) 这里逆序执行 183 | 184 | return response 185 | ``` 186 | 187 | 请求通过 `__call__` 方法，首先执行了 **序号(1) ** 位置的代码后，通过 `get_response(request)` 传递到下一个中间件里后，又执行下一个 **序号(1)** 位置的代码并继续传递，直到到达了视图函数。 188 | 189 | 视图函数返回了响应体 `response` 后，整个中间件的调用从 `get_response(request)` 的位置一层层的往回翻，直到回到最初始的位置，整个调用才宣告结束。 190 | 191 | 所以中间件的执行顺序，**就像洋葱一样，请求通过洋葱的每一层直到核心的视图函数，再带着响应从里面反着出来**。 192 | 193 | ### 短路 194 | 195 | 中间件有种比较常用的用法，即不调用 `get_response()` 方法，手动返回一个 http 响应体，像这样： 196 | 197 | ```python 198 | # middleware/middlewares.py 199 | 200 | from django.http import HttpResponse 201 | 202 | 203 | class Md1: 204 | ... 205 | 206 | 207 | class Md2: 208 | ... 209 | 210 | def __call__(self, request): 211 | print('Md2 视图执行前..') 212 | 213 | # 新增代码 214 | if True: 215 | print('Md2 引发短路') 216 | return HttpResponse('Md2 引发短路') 217 | 218 | response = self.get_response(request) 219 | print('Md2 视图执行后..') 220 | return response 221 | 222 | 223 | class Md3: 224 | ... 225 | ``` 226 | 227 | 刷新页面，命令行打印如下： 228 | 229 | ```python 230 | Md1 视图执行前.. 231 | Md2 视图执行前.. 232 | Md2 引发短路 233 | Md1 视图执行后.. 234 | ``` 235 | 236 | `if` 语句中直接返回了 `HttpResponse`响应体，从而中断了中间件向下一级传播，直接从 `return` 位置返回了，甚至请求也不会进入视图函数。这就是中间件的**短路**，比较常用在权限控制等功能中。 237 | 238 | ### 更多钩子 239 | 240 | 除了上述最基础的模式之外，中间件类还提供了另外三种钩子方法。 241 | 242 | #### process_view() 243 | 244 | - `process_view(request, view_func, view_args, view_kwargs)` 245 | 246 | `request` 是一个 `HttpRequest` 对象。`view_func` 是实际要执行的视图函数。 `view_args` 是传递给视图的位置参数列表，`view_kwargs` 是传递给视图的关键字参数字典。 247 | 248 | `process_view()` 在**所有中间件的基础模式后、视图执行前**被调用。它返回 `None` 或 `HttpResponse`对象： 249 | 250 | - 返回 `None` ，Django 将按照规则处理这个请求并顺序执行接下来的中间件。 251 | - 返回 `HttpResponse` 对象，则 Django 不调用实际的视图，而是从已经调用的中间件开始逐层返回。 252 | 253 | #### process_exception() 254 | 255 | - `process_exception(request, exception)` 256 | 257 | `exception` 是视图函数引发的 `Exception` 对象。 258 | 259 | 当视图引发异常时，Django 会调用 `process_exception()`。它返回 `None` 或 `HttpResponse` 对象： 260 | 261 | - 如果返回 `HttpResponse`对象，中间件会直接将结果响应返回浏览器。 262 | - 否则就开始默认的异常处理。 263 | 264 | 也就是说，如果异常中间件返回一个响应，那么其他之后的中间件的 `process_exception` 方法将不会被调用。 265 | 266 | #### process_template_response() 267 | 268 | - `process_template_response(request, response)` 269 | 270 | `response` 是 `TemplateResponse` 对象。 271 | 272 | 它在视图被执行后调用，必须返回一个实现了 `render` 方法的响应对象。此钩子方法会在响应阶段按照相反的顺序运行。**也就是说，此方法仅当视图返回 `TemplateResponse` 对象才会被调用，通常用的 `render` 快捷方式不会触发它。** 273 | 274 | > 所有这些钩子方法组合到一起可以形成复杂的短路规则。推荐读者自行测试一下，印象会比较深刻。 275 | 276 | ### 案例 277 | 278 | #### 用户拦截 279 | 280 | 假设你有一个敏感路径，要求必须超级用户才能访问： 281 | 282 | ```python 283 | from django.http import HttpResponseForbidden 284 | 285 | class NormalUserBlock: 286 | def __init__(self, get_response): 287 | self.get_response = get_response 288 | 289 | def __call__(self, request): 290 | 291 | if (request.user.is_superuser != True) and (request.path == '/secret-url/'): 292 | return HttpResponseForbidden('超级用户方可访问此页面！
') 293 | 294 | response = self.get_response(request) 295 | 296 | return response 297 | ``` 298 | 299 | 此功能可以非常容易扩展为 IP 拦截：通过 `request.META['REMOTE_ADDR'] ` 获取请求的 IP 地址，比对数据库中的黑名单进行拦截。 300 | 301 | #### Debug 页面优化 302 | 303 | 假设你的博客部署到线上了，并且理所当然的配置了 `DEBUG = False` 。当引发 500 错误后，你想让超级用户仍然看到 DEBUG 页面，而普通用户看不到，可以这样： 304 | 305 | ```python 306 | import sys 307 | from django.views.debug import technical_500_response 308 | 309 | class DebugOnlySuperUser(): 310 | def __init__(self, get_response): 311 | self.get_response = get_response 312 | 313 | def __call__(self, request): 314 | response = self.get_response(request) 315 | return response 316 | 317 | def process_exception(self, request, exception): 318 | if request.user.is_superuser: 319 | return technical_500_response(request, *sys.exc_info()) 320 | ``` 321 | 322 | 这样调试起来就方便了不少。 323 | 324 | #### CSRF 验证 325 | 326 | `process_view()` 方法和基础用法的主要区别之一，就是它带有与请求相关的视图的信息。 327 | 328 | Django 自带的 CSRF 中间件就是很好的例子： 329 | 330 | ```python 331 | ... 332 | 333 | def process_view(self, request, callback, callback_args, callback_kwargs): 334 | ... 335 | 336 | if getattr(callback, 'csrf_exempt', False): 337 | return None 338 | 339 | ... 340 | ``` 341 | 342 | 如果请求的视图上存在 `csrf_exempt` 装饰器，则本次请求不会实施 CSRF 保护。 343 | 344 | #### 响应计时器 345 | 346 | 自定义中间件，记录从收到请求到完成响应所花费的时间： 347 | 348 | ```python 349 | from datetime import datetime 350 | 351 | class ResponseTimer: 352 | def __init__(self, get_response): 353 | self.get_response = get_response 354 | 355 | def __call__(self, request): 356 | request._request_time = datetime.now() 357 | response = self.get_response(request) 358 | return response 359 | 360 | def process_template_response(self, request, response): 361 | response_time = request._request_time - datetime.now() 362 | response.context_data['response_time'] = abs(response_time) 363 | return response 364 | ``` 365 | 366 | 有了这个中间件，所有的模板都可以获取到 `{{ response_time }}` 这个变量了。 367 | 368 | **再重复一次**，此方法仅当视图返回 `TemplateResponse` 对象才会被调用，通常用的 `render` 快捷方式不会触发它。它两的区别是，`TemplateResponse` 会延迟渲染，它包含了呈现模板之前的上下文数据，因此让中间件有机会去修改里面的变量。而 `render` 会立即呈现模板并返回 `HttpResponse` ，无法唤起此钩子方法： 369 | 370 | ```python 371 | from django.shortcuts import render 372 | from django.template.response import TemplateResponse 373 | 374 | # 无法调用 process_template_response() 375 | def mid_test(request): 376 | return render(request, '....html', context={}) 377 | 378 | # 返回 TemplateResponse 才可调用 379 | def mid_test(request): 380 | return TemplateResponse(request, '....html', context={}) 381 | ``` 382 | 383 | -------------------------------------------------------------------------------- /md/240-信号的运用.md: -------------------------------------------------------------------------------- 1 | 在任何项目中，我们或多或少都需要一种能力，即：**当某个事件发生时，另一个对象也能够知晓此事**。 2 | 3 | 拿博客举个栗子。我希望有**用户在博客留言时，博主收到通知**。按照比较容易想到的方式，那就是在保存评论数据时，显式执行发送通知相关的代码。 4 | 5 | 比如下面这样： 6 | 7 | ```python 8 | from django.db import models 9 | from somewhere import post_notification 10 | 11 | class Comment(models.Model): 12 | # ... 13 | 14 | def save(self, *args, **kwargs): 15 | 16 | # 发送通知 17 | post_notification() 18 | 19 | # ... 20 | ``` 21 | 22 | 这样做的缺点就在于把**评论模块**和**通知模块**耦合到一起了。如果哪天我改动甚至删除了**通知模块**的对应函数，搞不好**评论模块**也无法正常工作了。 23 | 24 | 当**很多模块都关心评论模块的保存事件**时，代码就有可能变成了这样： 25 | 26 | ```python 27 | class Comment(models.Model): 28 | def save(self, *args, **kwargs): 29 | # 以下函数分属不同模块 30 | post_notification() 31 | save_log() 32 | increase_count() 33 | do_this() 34 | do_that() 35 | blablabla() 36 | do_this_again() 37 | do_that_again() 38 | blablabla_again() 39 | #... 40 | ``` 41 | 42 | 模块之间还可以互相调用，搅在一起，动了其中一个可能就引出一堆报错，不利于功能的扩展。 43 | 44 | ## 信号的作用 45 | 46 | 因此，像这种**许多代码段对同一事件感兴趣时，信号就特别有用**。 47 | 48 | Django 内置了对**信号**这个概念的支持。信号允许**发送器**通知**接收器**某些事件已经发生。当事件发生时，”发送器“只负责发出一个”信号“，提醒”接收器“该执行了；至于接收器具体是什么、有多少个，发送器就不关心了。 49 | 50 | > 这就有点像村里的村长拿个大喇叭，站在村口喊：”长得帅的人该起床了！“至于到底哪些村民长得帅、喊出去的话有没有人听到、听到的到底起不起床，村长就完全不管了。 51 | 52 | 反过来讲，接收器在很多时候也并不关心到底是谁发出的信号，反正只要接收到唤醒自己的信号，直接执行就万事大吉了。 53 | 54 | 这种近似匿名的机制，再加之发送器、接收器都可以有多个，使得模块可以很轻松的解耦和功能扩展。 55 | 56 | ## 内置信号 57 | 58 | Django 内置了几种常见的信号，开箱即用。 59 | 60 | 比如每当一个 HTTP 请求发起、结束时的信号： 61 | 62 | ```python 63 | from django.core.signals import request_finished, request_started 64 | from django.dispatch import receiver 65 | 66 | @receiver(request_finished) 67 | def signal_callback(sender, **kwargs): 68 | print('信号已接收..') 69 | ``` 70 | 71 | 上面的代码会在每个请求结束时执行。装饰器 `@receiver` 将函数标注为接收器，其参数 `request_finished` 指定了具体的信号类型。 72 | 73 | > `request_finished` 就是其中一个内置信号，在 http 请求结束时发送。 74 | 75 | 任何想成为接收器的函数必须包含下面两个参数： 76 | 77 | - `sender` 参数是发出信号的发送器。 78 | - `**kwargs` 关键字参数。之所以必须有它，是因为参数可能在任意时刻被添加到信号中，而接收器必须能够处理这些新的参数。 79 | 80 | 如前面说的，同一个信号的接收器可以有多个： 81 | 82 | ```python 83 | # from ... 84 | 85 | @receiver(request_finished) 86 | def signal_callback(sender, **kwargs): 87 | print('信号已接收1..') 88 | 89 | @receiver(request_finished) 90 | def signal_callback_2(sender, **kwargs): 91 | print('信号已接收2..') 92 | ``` 93 | 94 | 同一个接收器的信号也可以有多个： 95 | 96 | ```python 97 | @receiver([request_finished, request_started]) 98 | def signal_callback(sender, **kwargs): 99 | print('信号已接收..') 100 | ``` 101 | 102 | 有些时候你可能只对某一类信号中的**子集**感兴趣。比如说我只想在 `BookModel` 保存前触发接收器，而在 `PersonModel` 保存前不触发。于是你就可以这样做： 103 | 104 | ```python 105 | from django.db.models.signals import pre_save 106 | from django.dispatch import receiver 107 | from myapp.models import BookModel 108 | 109 | @receiver(pre_save, sender=BookModel) 110 | def my_handler(sender, **kwargs): 111 | # ... 112 | ``` 113 | 114 | 装饰器中的 `sender=BookModel` 就表明了此接收器只响应 `BookModel` 的信号。 115 | 116 | > 与 `pre_save` 对应的还有内置的 `post_save` 信号。 117 | 118 | 还有一个问题是：信号注册的代码有可能无意间被多次执行。为了防止重复注册导致的信号重复，可以给装饰器传递一个唯一的标识符，像这样： 119 | 120 | ```python 121 | @receiver(my_signal, dispatch_uid="my_unique_identifier") 122 | def my_signal_handler(sender, **kwargs): 123 | # ... 124 | ``` 125 | 126 | 标识符通常是字符串，但其实任何可散列的对象都可以。 127 | 128 | 以上就是内置信号的基础用法了。 129 | 130 | 更多内置信号，请见[Django内置信号](https://docs.djangoproject.com/zh-hans/3.2/ref/signals/)。 131 | 132 | ## 自定义信号 133 | 134 | 有时候内置信号可能无法满足需求，Django 也允许你自定义信号。下面用一个例子看看自定义信号是如何实现的。 135 | 136 | 假设我的项目中有一个叫 `mySignal` 的 App。新建 `mySignal/signals.py` 文件，注册一个自定义信号： 137 | 138 | ```python 139 | # mySignal/signals.py 140 | 141 | import django.dispatch 142 | # 注册信号 143 | view_done = django.dispatch.Signal() 144 | ``` 145 | 146 | 然后新建 `mySignal/handlers.py` ，编写接收器并把它和信号连接起来： 147 | 148 | ```python 149 | # mySignal/handlers.py 150 | 151 | from django.dispatch import receiver 152 | from mySignal.signals import view_done 153 | 154 | @receiver(view_done, dispatch_uid="my_signal_receiver") 155 | def my_signal_handler(sender, **kwargs): 156 | print(sender) 157 | print(kwargs.get('arg_1'), kwargs.get('arg_2')) 158 | ``` 159 | 160 | 虽然已经有了信号和接收器，但是项目运行时并没有运行这两段代码。因此下面两步的作用是加载它们。 161 | 162 | 修改 `mySignal/__init__.py` ： 163 | 164 | ```python 165 | # mySignal/__init__.py 166 | 167 | default_app_config = "mySignal.apps.MysignalConfig" 168 | ``` 169 | 170 | 再修改 `mySignal/apps.py` ： 171 | 172 | ```python 173 | # mySignal/apps.py 174 | 175 | from django.apps import AppConfig 176 | 177 | class MysignalConfig(AppConfig): 178 | name = 'mySignal' 179 | 180 | def ready(self): 181 | import mySignal.handlers 182 | ``` 183 | 184 | 差不多快完成了。接下来就可以在任意位置发送这个信号了。比如像这样： 185 | 186 | ```python 187 | # mySignal/views.py 188 | 189 | from mySignal.signals import view_done 190 | 191 | def some_view(request): 192 | # 发送信号 193 | view_done.send( 194 | sender='View function...', 195 | arg_1='My signal...', 196 | arg_2='received...' 197 | ) 198 | 199 | # 其他代码... 200 | ``` 201 | 202 | 重启服务器，访问此视图后，控制台将输出如下字符： 203 | 204 | ```python 205 | View function... 206 | My signal... received... 207 | ``` 208 | 209 | 接收器成功唤醒了，并且正确接收到信号携带的信息。 210 | 211 | ## 总结 212 | 213 | 信号的优点是让模块之间**解耦**。当不同模块的代码片段对同一事物感兴趣时，就是信号非常适合的应用场景。信号的缺点是它是**隐式执行**的，这使得调试变得更困难。 214 | 215 | 事物都有两面性，是否使用信号还得根据实际需求进行判断。 -------------------------------------------------------------------------------- /md/250-Python装饰器入门：从理解到应用.md: -------------------------------------------------------------------------------- 1 | **装饰器（Decorator）**是 Python 非常重要的组成部分，它可以修改或扩展其他函数的功能，并让代码保持简短。 2 | 3 | 装饰器对初学者来说，理解起来有些困难。 4 | 5 | 因此，让我们从 Python 最基础的知识讲起。 6 | 7 | ## 一切皆对象 8 | 9 | 在 Python 中，**函数可以根据给定的参数返回一个值**： 10 | 11 | ```python 12 | def hello(name): 13 | return 'Hello ' + name 14 | 15 | print(hello('Bob')) 16 | 17 | # 输出: 18 | # Hello Bob 19 | ``` 20 | 21 | 与 Python 的其他对象（如字符串、整数、列表等）一样，**函数也是对象**，也可以赋值给一个变量： 22 | 23 | ```python 24 | def hello(name): 25 | return 'Hello ' + name 26 | 27 | h = hello 28 | 29 | print(hello) 30 | # 输出: 31 | #超级用户方可访问此页面！
') 33 | 34 | response = self.get_response(request) 35 | 36 | return response 37 | 38 | 39 | class DebugOnlySuperUser: 40 | 41 | def __init__(self, get_response): 42 | self.get_response = get_response 43 | 44 | def __call__(self, request): 45 | response = self.get_response(request) 46 | return response 47 | 48 | def process_exception(self, request, exception): 49 | if request.user.is_superuser: 50 | return technical_500_response(request, *sys.exc_info()) 51 | 52 | 53 | class Md1: 54 | def __init__(self, get_response): 55 | self.get_response = get_response 56 | # (0) 在这里进行某些自定义参数的初始化 57 | 58 | def __call__(self, request): 59 | # (1) 这里写实际视图执行之前的逻辑 60 | print('Md1 视图执行前..') 61 | 62 | # (2) response 是下一个中间件或视图函数的返回值 63 | response = self.get_response(request) 64 | 65 | # (3) 这里写实际视图执行之后的逻辑 66 | print('Md1 视图执行后..') 67 | 68 | return response 69 | 70 | 71 | class Md2: 72 | def __init__(self, get_response): 73 | self.get_response = get_response 74 | 75 | def __call__(self, request): 76 | print('Md2 视图执行前..') 77 | 78 | # if True: 79 | # print('Md2 引发短路') 80 | # return HttpResponse('Md2 引发短路') 81 | 82 | response = self.get_response(request) 83 | 84 | print('Md2 视图执行后..') 85 | 86 | return response 87 | 88 | 89 | class Md3: 90 | def __init__(self, get_response): 91 | self.get_response = get_response 92 | 93 | def __call__(self, request): 94 | print('Md3 视图执行前..') 95 | 96 | response = self.get_response(request) 97 | 98 | print('Md3 视图执行后..') 99 | 100 | return response 101 | -------------------------------------------------------------------------------- /middleware/migrations/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stacklens/django-knowledge-base/eed6eea3e667ff18cde1ff3382f58bf9f45ed7ca/middleware/migrations/__init__.py -------------------------------------------------------------------------------- /middleware/models.py: -------------------------------------------------------------------------------- 1 | from django.db import models 2 | 3 | # Create your models here. 4 | -------------------------------------------------------------------------------- /middleware/tests.py: -------------------------------------------------------------------------------- 1 | from django.test import TestCase 2 | 3 | # Create your tests here. 4 | -------------------------------------------------------------------------------- /middleware/views.py: -------------------------------------------------------------------------------- 1 | from django.shortcuts import render 2 | from django.http import HttpResponse 3 | from django.template.response import TemplateResponse 4 | 5 | # Create your views here. 6 | 7 | def mid_test(request): 8 | print('--- 视图执行中...') 9 | # raise None 10 | # return HttpResponse('中间件测试..') 11 | return TemplateResponse(request, 'midware_demo.html', context={}) 12 | 13 | -------------------------------------------------------------------------------- /mig/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stacklens/django-knowledge-base/eed6eea3e667ff18cde1ff3382f58bf9f45ed7ca/mig/__init__.py -------------------------------------------------------------------------------- /mig/admin.py: -------------------------------------------------------------------------------- 1 | from django.contrib import admin 2 | from .models import Pen 3 | 4 | # Register your models here. 5 | 6 | admin.site.register(Pen) -------------------------------------------------------------------------------- /mig/apps.py: -------------------------------------------------------------------------------- 1 | from django.apps import AppConfig 2 | 3 | 4 | class MigConfig(AppConfig): 5 | name = 'mig' 6 | -------------------------------------------------------------------------------- /mig/migrations/0001_initial.py: -------------------------------------------------------------------------------- 1 | # Generated by Django 3.0.5 on 2020-05-20 07:54 2 | 3 | from django.db import migrations, models 4 | import django.utils.timezone 5 | 6 | 7 | class Migration(migrations.Migration): 8 | 9 | initial = True 10 | 11 | dependencies = [ 12 | ] 13 | 14 | operations = [ 15 | migrations.CreateModel( 16 | name='Pen', 17 | fields=[ 18 | ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), 19 | ('price', models.DecimalField(decimal_places=2, max_digits=7)), 20 | ('color', models.CharField(default='black', max_length=20)), 21 | ('purchase_date', models.DateTimeField(default=django.utils.timezone.now)), 22 | ('length', models.IntegerField(default=10)), 23 | ], 24 | ), 25 | ] 26 | -------------------------------------------------------------------------------- /mig/migrations/0002_remove_pen_purchase_date.py: -------------------------------------------------------------------------------- 1 | # Generated by Django 3.0.5 on 2020-05-22 00:33 2 | 3 | from django.db import migrations 4 | 5 | 6 | class Migration(migrations.Migration): 7 | 8 | dependencies = [ 9 | ('mig', '0001_initial'), 10 | ] 11 | 12 | operations = [ 13 | migrations.RemoveField( 14 | model_name='pen', 15 | name='purchase_date', 16 | ), 17 | ] 18 | -------------------------------------------------------------------------------- /mig/migrations/0003_pen_purchase_date.py: -------------------------------------------------------------------------------- 1 | # Generated by Django 3.0.5 on 2020-05-22 00:33 2 | 3 | from django.db import migrations, models 4 | import django.utils.timezone 5 | 6 | 7 | class Migration(migrations.Migration): 8 | 9 | dependencies = [ 10 | ('mig', '0002_remove_pen_purchase_date'), 11 | ] 12 | 13 | operations = [ 14 | migrations.AddField( 15 | model_name='pen', 16 | name='purchase_date', 17 | field=models.DateTimeField(default=django.utils.timezone.now), 18 | ), 19 | ] 20 | -------------------------------------------------------------------------------- /mig/migrations/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stacklens/django-knowledge-base/eed6eea3e667ff18cde1ff3382f58bf9f45ed7ca/mig/migrations/__init__.py -------------------------------------------------------------------------------- /mig/models.py: -------------------------------------------------------------------------------- 1 | from django.db import models 2 | from django.utils import timezone 3 | 4 | 5 | class Pen(models.Model): 6 | price = models.DecimalField(max_digits=7, decimal_places=2) 7 | color = models.CharField(default='black', max_length=20) 8 | purchase_date = models.DateTimeField(default=timezone.now) 9 | # 手动删除 0003 文件后，添加此字段 10 | length = models.IntegerField(default=10) -------------------------------------------------------------------------------- /mig/tests.py: -------------------------------------------------------------------------------- 1 | from django.test import TestCase 2 | 3 | # Create your tests here. 4 | -------------------------------------------------------------------------------- /mig/views.py: -------------------------------------------------------------------------------- 1 | from django.shortcuts import render 2 | 3 | # Create your views here. 4 | -------------------------------------------------------------------------------- /mySignal/__init__.py: -------------------------------------------------------------------------------- 1 | default_app_config = "mySignal.apps.MysignalConfig" -------------------------------------------------------------------------------- /mySignal/admin.py: -------------------------------------------------------------------------------- 1 | from django.contrib import admin 2 | 3 | # Register your models here. 4 | -------------------------------------------------------------------------------- /mySignal/apps.py: -------------------------------------------------------------------------------- 1 | from django.apps import AppConfig 2 | 3 | 4 | class MysignalConfig(AppConfig): 5 | name = 'mySignal' 6 | 7 | def ready(self): 8 | import mySignal.handlers -------------------------------------------------------------------------------- /mySignal/handlers.py: -------------------------------------------------------------------------------- 1 | from django.dispatch import receiver 2 | from mySignal.signals import view_done 3 | 4 | 5 | @receiver(view_done, dispatch_uid="my_signal_receiver") 6 | def my_signal_handler(sender, **kwargs): 7 | print(sender) 8 | print(kwargs.get('arg_1'), kwargs.get('arg_2')) -------------------------------------------------------------------------------- /mySignal/migrations/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stacklens/django-knowledge-base/eed6eea3e667ff18cde1ff3382f58bf9f45ed7ca/mySignal/migrations/__init__.py -------------------------------------------------------------------------------- /mySignal/models.py: -------------------------------------------------------------------------------- 1 | from django.db import models 2 | 3 | # Create your models here. 4 | -------------------------------------------------------------------------------- /mySignal/signals.py: -------------------------------------------------------------------------------- 1 | import django.dispatch 2 | 3 | view_done = django.dispatch.Signal() -------------------------------------------------------------------------------- /mySignal/tests.py: -------------------------------------------------------------------------------- 1 | from django.test import TestCase 2 | 3 | # Create your tests here. 4 | -------------------------------------------------------------------------------- /mySignal/urls.py: -------------------------------------------------------------------------------- 1 | from django.urls import path 2 | from .views import some_view 3 | 4 | app_name = 'mySignal' 5 | 6 | urlpatterns = [ 7 | path('', some_view, name='some_view'), 8 | ] 9 | -------------------------------------------------------------------------------- /mySignal/views.py: -------------------------------------------------------------------------------- 1 | from django.http.response import HttpResponse 2 | from django.core.signals import request_finished, request_started 3 | from django.dispatch import receiver 4 | 5 | # @receiver([request_finished, request_started]) 6 | # def signal_callback(sender, **kwargs): 7 | # print('信号已接收..') 8 | # 9 | # 10 | # @receiver(request_finished) 11 | # def signal_callback_2(sender, **kwargs): 12 | # print('信号已接收2..') 13 | 14 | from mySignal.signals import view_done 15 | 16 | 17 | def some_view(request): 18 | 19 | view_done.send( 20 | sender='View function...', 21 | arg_1='My signal...', 22 | arg_2='received...' 23 | ) 24 | 25 | return HttpResponse('响应完毕..') 26 | -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | asgiref==3.2.10 2 | Django==3.0.5 3 | Pillow==7.1.2 4 | pytz==2019.3 5 | sqlparse==0.3.1 6 | -------------------------------------------------------------------------------- /static/test.css: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stacklens/django-knowledge-base/eed6eea3e667ff18cde1ff3382f58bf9f45ed7ca/static/test.css -------------------------------------------------------------------------------- /static/test.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stacklens/django-knowledge-base/eed6eea3e667ff18cde1ff3382f58bf9f45ed7ca/static/test.js -------------------------------------------------------------------------------- /templates/base.html: -------------------------------------------------------------------------------- 1 | {% load static %} 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 |
27 |
31 |
32 | {% block script %}{% endblock %}
33 |
34 |
35 |
36 |
37 |
--------------------------------------------------------------------------------
/templates/header.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
17 |
18 |
--------------------------------------------------------------------------------
/templates/home.html:
--------------------------------------------------------------------------------
1 | {% extends 'base.html' %}
2 |
3 | {% block content %}
4 |
5 |
6 |
28 | {% block content %}{% endblock %}
29 |
30 | reverse()
7 | 24 | 25 |redirect()
26 |
27 | {% for post in posts %}
28 |
33 |
34 |
29 | {{ post.title }}
30 |
31 | {% endfor %}
32 | path()
35 | 36 |
37 |
42 |
43 |
38 | 通过 path()
39 | 传递参数
40 |
41 | @property 与模型方法
44 | 45 |
46 |
49 |
50 | Full name: {{ name1 }}
47 | Full name: {{ name2 }}
48 | 批量上传文件
51 |
52 |
71 |
72 |
73 | Session
74 |
75 | Session记录
76 |
77 |
78 |
79 | 80 |
81 |
82 |
83 | {% endblock %} -------------------------------------------------------------------------------- /templates/midware_demo.html: -------------------------------------------------------------------------------- 1 | {% extends 'base.html' %} 2 | 3 | 4 | 5 | {% block content %} 6 |
7 | 本次请求处理时间： {{ response_time }}. 8 |
9 | {% endblock %} -------------------------------------------------------------------------------- /templates/path.html: -------------------------------------------------------------------------------- 1 | {% extends 'base.html' %} 2 | 3 | 4 | 5 | {% block content %} 6 |7 | {{ salute }} {{ first_name }} {{ last_name }}! 您已经访问本站：{{ count }} 次. 8 |
9 | {% endblock %} -------------------------------------------------------------------------------- /templates/post_detail.html: -------------------------------------------------------------------------------- 1 | {% extends 'base.html' %} 2 | 3 | {% block content %} 4 |{{ post.title }}
5 |
6 | 阅读量：{{ post.views }}
7 | 更新时间：{{ post.updated | date:"Y/m/d H:m:s" }}
8 | 作者：{{ owner.username }}
9 |
10 | {{ post.body }}
11 | {% endblock %}
--------------------------------------------------------------------------------
/templates/uploads_images.html:
--------------------------------------------------------------------------------
1 | {% extends 'base.html' %}
2 |
3 | {% block content %}
4 | {% for image in images %}
5 |
6 | 
7 |
9 | {% endfor %}
10 | {% endblock %}
--------------------------------------------------------------------------------
/templates/visits_count.html:
--------------------------------------------------------------------------------
1 | {% extends 'base.html' %}
2 |
3 |
4 | {% block content %}
5 |
7 | {{ image.image.url }}
8 |