11. 常用的Web应用程序

Django为开发者提供了常见的Web应用程序,
如会话控制, 缓存机制, CSRF防护, 消息框架, 分页功能, 国际化和本地化, 单元测试和自定义中间件.
内置的Web应用程序大大优化了网站性能, 并且完善了安全防护机制, 同时也提高了开发者的开发效率.

11.1 会话控制

Django内置的会话控制简称为Session, 可以为用户提供基础的数据存储.
数据主要存储在服务器上, 并且网站的任意站点都能使用会话数据.

当用户第一次访问网站时, 网站的服务器将自动创建一个Session对象, 
该Session对象相当于该用户在网站的一个身份凭证, 而且Session能存储该用户的数据信息.

当用户在网站的页面之间跳转时, 存储在Session对象中的数据不会丢失,
只有Session过期或被清理时, 服务器才将Session中存储的数据清空并终止该Session.

11.1.1 会话的配置与操作

在4.2.3小节已讲述过Session和Cookie的关系, 本节将简单回顾两者的关系, 说明如下:
● Session存储在服务器端, Cookie存储在客户端, 所以Session的安全性比Cookie高.
● 当获取某用户的Session数据时, 首先从用户传递的Cookie里获取sessionid, 然后根据sessionid在网站服务器找到相应的Session.
● Session存放在服务器的内存中, Session的数据不断增加会造成服务器的负担, 因此存放在Session中的数据不能过于庞大.

在创建Django项目时, Django已默认启用Session功能, 
每个用户的Session通过Django的中间件MIDDLEWARE接收和调度处理, 可以在配置文件settings.py中找到相关信息, 如图11-1所示.

图11-1　Session功能配置

当访问网站时, 所有的HTTP请求都经过中间件处理,
而会话中间件SessionMiddleware会判断当前请求的用户身份是否存在, 并根据判断结果执行相应的程序处理.

会话中间件SessionMiddleware相当于HTTP请求接收器, 根据请求信息做出相应的调度,
而程序的执行则由settings.py的配置属性INSTALLED_APPS的django.contrib.sessions完成, 其配置信息如图11-2所示.

图11-2　Session的处理程序

django.contrib.sessions实现了Session的创建和操作处理, 如创建或存储用户的Session对象, 管理Session的生命周期等.
它默认使用数据库存储Session信息, 执行数据迁移后, 在数据库中可以看到数据表django_session, 如图11-3所示.

图11-3　数据表django_session

以10.6节的MyDjango项目为例, 我们将通过例子来讲述Session运行机制.
首先清除浏览器的历史记录, 确保以游客身份访问MyDjango, 即用户在未登录状态下访问Django.
在浏览器打开开发者工具并访问: 127.0.0.1:8000, 从开发者工具的Network标签的All选项里找到127.0.0.1:8000的请求信息,
若当前Cookie没有生成sessionid, 则说明一般情况下, Django不会为游客身份创建Session, 如图11-4所示.

图11-4　Cookie信息

访问用户登录页面(127.0.0.1:8000/login.html)并完成用户登录, 打开用户中心页面的请求信息,
可以看到Cookie生成带有sessionid的数据, 并且数据表django_session记录了当前sessionid的信息, 如图11-5所示.

图11-5　Cookie的sessionid信息

在登录状态下再次访问网站, 浏览器将Cookie信息发送到MyDjango, 
Django从Cookie获取sessionid并与数据表django_session的session_key进行匹配验证, 
从而确定当前访问的用户信息, 保证每个用户的数据信息不会杂乱无章.
Session的数据存储默认使用数据库保存, 如果想变更Session的保存方式, 
那么可以在settings.py中添加配置信息SESSION_ENGINE, 该配置可以指定Session的保存方式.
Django提供了5种Session的保存方式, 分别如下:

# 1. 数据库保存方式
# Django默认的保存方式, 使用该方法无须在settings.py中设置
SESSION_ENGINE = 'django.contrib.sessions.backends.db'

# 2. 以文件形式保存
SESSION_ENGINE = 'django.contrib.sessions.backends.file'
# 使用文本保存可设置文件保存路径
# /MyDjango代表将文本保存在项目MyDjango的根目录
SESSION_FILE_PATH = '/MyDjango'

# 3. 以缓存形式保存
SESSION_ENGINE = 'django.contrib.sessions.backends.cache'
# 设置缓存名, 默认是内存缓存方式, 此处的设置与缓存机制的设置相关
SESSION_CACHE_ALIAS = 'default'

# 4. 以数据库+缓存形式保存
SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'

# 5. 以Cookie形式保存
SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies'

SESSION_ENGINE用于配置服务器Session的保存方式, 而浏览器的Cookie用于记录数据表django_session的session_key,
Session还可以设置相关的配置信息, 如生命周期, 传输方式和保存路径等, 只需在settings.py中添加配置属性即可, 说明如下:
● SESSION_COOKIE_NAME = "sessionid": 浏览器的Cookie以键值对的形式保存数据表django_session的session_key,
  该配置是设置session_key的键, 默认值为sessionid.
● SESSION_COOKIE_PATH = "/": 设置浏览器的Cookie生效路径, 默认值为'/', 即127.0.0.1:8000.
● SESSION_COOKIE_DOMAIN = None: 设置浏览器的Cookie生效域名.
● SESSION_COOKIE_SECURE = False: 设置传输方式, 若为False, 则使用HTTP, 否则使用HTTPS.
● SESSION_COOKIE_HTTPONLY = True: 是否只能使用HTTP协议传输.
● SESSION_COOKIE_AGE = 1209600: 设置Cookie的有效期, 默认时间为两周.
● SESSION_EXPIRE_AT_BROWSER_CLOSE = False: 是否关闭浏览器使得Cookie过期, 默认值为False.
● SESSION_SAVE_EVERY_REQUEST = False: 是否每次发送后保存Cookie, 默认值为False.

了解Session的运行原理和相关配置后, 最后讲解Session的读写操作, Session的数据类型可理解为Python的字典类型,
主要在视图函数中执行读写操作, 并且从用户请求对象中获取, 即来自视图函数的参数request.
Session的读写如下:

# request为视图函数的参数request
# 获取存储在Session的数据k1, 若k1不存在, 则会报错
request.session['k1']
# 获取存储在Session的数据k1, 若k1不存在, 则为空值
# get和setdefault实现的功能是一致的
request.session.get('k1', '')
request.session.setdefault('k1', '')
# 设置Session的数据, 键为k1, 值为123
request.session['k1'] = 123
# 删除Session中k1的数据
del request.session['k1']
# 删除整个Session
request.session.clear()
# 获取Session的键
request.session.keys()
# 获取Session的值
request.session.values()
# 获取Session的session_key
# 即数据表django_session的字段session_key
request.session.session_key

11.1.2 使用会话实现商品抢购

本节将通过实例来讲述如何使用Session实现商品抢购功能.
以MyDjango为例, 创建项目应用index, 在index中创建路由文件urls.py,
然后在MyDjango的根目录创建静态资源文件夹static和模板文件夹templates, 
分别放置静态资源和模板文件index.html和order.html.
项目的目录结构如图11-6所示.

图11-6　MyDjango的目录结构

在index的models.py中定义模型Product, 该模型设有6个字段, 其作用是记录商品信息, 在商城首页生成商品列表.
模型Product的定义过程如下:

# index 的 models.py
from django.db import models


class Product(models.Model):
    id = models.AutoField('序号', primary_key=True)
    name = models.CharField('名称', max_length=50)
    picture = models.CharField('图片', max_length=50)
    configure = models.CharField('配置', max_length=50)
    price = models.IntegerField('价格')

    # 打印对象展示名称信息
    def __str__(self):
        return self.name

将已定义的模型Product执行数据迁移.

PS D:\MyDjango> python manage.py makemigrations
Migrations for 'index':
  index\migrations\0001_initial.py
    - Create model Product
PS D:\MyDjango> python manage.py migrate

在MyDjango的数据库文件db.sqlite3中创建数据表, 并在数据表index_product中添加商品信息, 如图11-7所示.

图11-7　数据表index_product

-- sql语句:
INSERT INTO "main"."index_product" ("id", "name", "picture", "configure", "price") 
VALUES (1, 'HUAWEI Mate 60 RS', 'img/1.png', '16 GB RAM + 512 GB ROM', 11999);
INSERT INTO "main"."index_product" ("id", "name", "picture", "configure", "price") 
VALUES (2, 'HUAWEI Mate X5', 'img/2.png', '16 GB RAM + 512 GB ROM', 14999);
INSERT INTO "main"."index_product" ("id", "name", "picture", "configure", "price") 
VALUES (3, 'HUAWEI Pura 70 Pro+', 'img/3.png', '16 GB RAM + 512 GB ROM', 7999);
INSERT INTO "main"."index_product" ("id", "name", "picture", "configure", "price") 
VALUES (4, 'HUAWEI Pocket 2', 'img/4.png', '12GB RAM +1TB ROM', 8999);

# 配置静态文件
STATIC_URL = '/static/'
STATICFILES_DIRS = [BASE_DIR / 'static']

完成MyDjango的环境搭建后, 下一步开发商品抢购功能, 首先定义Admin后台系统, 商城首页和订单页面的路由信息.
Admin后台系统主要为用户提供登录页面; 商城首页和订单页面实现商品抢购功能.
MyDjango的urls.py和index的urls.py的路由定义如下:

# MyDjango 的 urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include(('index.urls', 'index'), namespace='index'))
]

# index 的 urls.py
from django.urls import path
from .views import *

urlpatterns = [
    # 网站首页
    path('', index, name=index),
    # 订单页面
    path('orser.html', order_view, name='order'),
]

在index的views.py中分别定义视图函数index和order_view.
视图函数index实现商品列表的展示和抢购功能; 视图函数order_view将用户抢购的商品进行结算处理并生成订单信息.
视图函数index和order_view的代码如下:

# index 的 views.py
from django.shortcuts import render, redirect
from .models import Product
from django.contrib.auth.decorators import login_required


@login_required(login_url='/admin/login')
def index(request):
    # 获取GET请求参数
    pk = request.GET.get('id', '')
    if pk:
        # 获取存储在Session的id_list
        # 若Session中没有id_list, 则返回一个空列表
        id_list = request.session.get('id_list', [])
        # 首次范围首页会创建空列表, 后续点击抢购会携带id访问首页
        # 判断当前请求参数是否已存储在Session中
        if pk not in id_list:
            # 将商品的主键id存储在id_list中
            id_list.append(pk)
        # 更新Session的id_list
        request.session['id_list'] = id_list
        print(id_list)
        return redirect('/')  # 刷新页面

    # 查询所有商品信息
    products = Product.objects.all()
    return render(request, 'index.html', locals())


def order_view(request):
    # 获取存储在Session的id_list
    # 若Session不存在id_list, 则返回一个空列表
    id_list = request.session.get('id_list', [])
    # 获取GET请求参数, 如果没有请求参数, 就返回空值
    del_id = request.GET.get('id', '')
    # 判断是否为空, 若费控, 则删除session里的商品信息
    if del_id in id_list:
        # 删除session里某个商品的质检
        id_list.remove(del_id)
        # 将删除后的数据覆盖原来的session
        request.session['id_list'] = id_list

    # 根据id_list查询商品所有信息
    print(id_list)
    products = Product.objects.filter(id__in=id_list)
    return render(request, 'order.html', locals())

(index首页视图中, 点击"立刻抢购"是为id_list列表添加商品id, 
order_view订单视图中先通过id_list列表的id获取商品数据并展示, 点击"移除商品"是从id_list列表移除商品id.
可以在视图中打印id_list查询id_list列表的变化.)

从视图函数index和order_view的功能实现过程中发现, 两者对Session的处理有相似的地方.
首先从Session中获取id_list的数据内容, 然后对id_list的数据进行读写处理, 最后将处理后的id_list重新写入Session.

当视图函数完成用户请求的处理后, 再由模板文件生成相应的网页返回给用户, 我们分别对模板文件index.html和order.html编写网页代码.
index.html的模板上下文products是将所有商品信息以列表形式展示;
order.html的模板上下文products是将已抢购的商品以列表形式展示.
模板文件index.html和order.html的代码如下:

<!-- template 的 index.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>商城首页</title>
    {% load static %}
    <link rel="stylesheet" href="{% static "css/hw_index.css" %}">
</head>
<body>
<div id="top_main">
    <div class="lf" id="my_hw">
        当前用户: {{ user.username }}
    </div>

    <div class="lf" id="settle_up">
        <a href="{% url 'index:order' %}">订单信息</a>
    </div>
</div>

<section id="main">
    <div class="layout">
        <div class="fl u-4-3 lf">
            <ul style="margin-top: 30px">
                {% for p in products %}
                    <li class="channel-pro-item">
                        <div class="p-img">
                            <img src="{% static p.picture %}" alt="手机图片">
                        </div>
                        <div class="p-name">
                            <a href="#">{{ p.name }}</a>
                        </div>
                        <div class="p-shining">
                            <div class="p-promotions">{{ p.configure }}</div>
                        </div>
                        <div class="p-price">
                            <em>¥</em><span>{{ p.price }}</span>
                        </div>
                        <div class="p-button lf">
                            <a href="{% url 'index:index' %}?id={{ p.id }}">立刻抢购</a>
                        </div>
                    </li>
                    {% if forloop.counter == 2 %}
                        <div class="hr-2"></div>
                    {% endif %}
                {% endfor %}
            </ul>
        </div>
    </div>
</section>
</body>
</html>

<!-- template 的 index.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>订单信息</title>
    {% load static %}
    <link rel="stylesheet" href="{% static "css/reset.css" %}">
    <link rel="stylesheet" href="{% static "css/carts.css" %}">
    <script src="{% static "js/jquery.min.js" %}"></script>
    <script src="{% static "js/carts.js" %}"></script>
</head>
<body>
<section class="cartMain">
    <div class="cartMain_hd">
        <ul class="order_lists cartTop">
            <li class="list_chk">
                <input type="checkbox" id="all" class="whole_check">
                <label for="all"></label>
                全选
            </li>
            <li class="list_con">商品信息</li>
            <li class="list_price">单价</li>
            <li class="list_amount">数量</li>
            <li class="list_sum">金额</li>
            <li class="list_op">操作</li>
            <li class="list_op">
                <a href="{% url 'index:index' %}">返回首页</a>
            </li>
        </ul>
    </div>

    <div class="cartBox">
        <div class="shop_info">
            <div class="all_check">
                <!-- 店铺全选 -->
                <label for="shop_b" class="shop"></label>
                <input type="checkbox" id="shop_b" class="shopChoice">
            </div>
            <div class="shop_name">
                店铺: <a href="javascript:;">MyDjango</a>
            </div>
        </div>

        <div class="order_content">
            {% for p in products %}
                <ul class="order_lists">
                    <li class="list_chk">
                        <label for="checkbox_4"></label>
                        <input type="checkbox" id="checkbox_4" class="son_check">
                    <li class="list_con">
                        <div class="list_text">
                            <a href="javascript:;">{{ p.name }}</a>
                        </div>
                    </li>
                    <li class="list_price">
                        <p class="price">￥{{ p.price }}</p>

                    </li>
                    <li class="list_amount">
                        <div class="amount_box">
                            <a href="javascript:;" class="reduce reSty">-</a>
                            <input type="text" value="1" class="sum">
                            <a href="javascript:;" class="plus">+</a>
                        </div>

                    </li>
                    <li class="list_sum">
                        <p class="sum_price">￥{{ p.price }}</p>
                    </li>
                    <li class="list_op">
                        <p class="del">
                            <a href="{% url "index:order" %}?id={{ p.id }}" class="delBtn">移除商品</a>
                        </p>
                    </li>
                    </li>
                </ul>
            {% endfor %}
        </div>
    </div>
    <!-- 底部 -->
    <div class="bar-wrapper">
        <div class="bar-right">
            <div class="piece">已选商品
                <strong class="piece_num">0</strong>件
            </div>
            <div class="totalMoney">共计:
                <strong class="total_text">0.0 </strong>
            </div>
            <div class="calBtn">
                <a href="javascript:;">结算</a>
            </div>
        </div>
    </div>
</section>
</body>
</html>

# 创建超级用户
PS D:\MyDjango> python manage.py createsuperuser
Username (leave blank to use 'blue'): admin
Email address:
Password: 123456
Password (again): 123456
This password is too short. It must contain at least 8 characters.
This password is too common.
This password is entirely numeric.
Bypass password validation and create user anyway? [y/N]: y
Superuser created successfully.

至此, 我们已完成商品抢购功能的开发.
为了验证功能是否正常运行, 在PyCharm里使用Django内置指令创建超级管理员, 
因为视图函数index设置了装饰器login_required, 所以只有已登录的用户才能访问商城首页, 这样才能确保视图函数index能够读写Session.
运行MyDjango并访问: 127.0.0.1:8000 , 若当前用户尚未登录, 则跳转到Admin后台系统的登录页面, 完成用户登录后就自动跳转到商城首页, 并在商城首页显示当前用户名, 如图11-8所示.

图11-8　商城首页

在商城首页单击某个商品的'立即抢购'按钮就会自动刷新商城首页, 页面刷新过程向Django发送了两次GET请求,
第一次请求带有请求参数id, 视图函数index将请求参数id写入当前用户的Session并重定向到商城首页, 如图11-9所示.
第二次请求是视图函数中更新id值到id_list列表中后使用redirect('/')函数重定向到商城首页.

图11-9　抢购商品

在商城首页可以单击多个商品的'立即抢购'按钮, 同一商品的'立即抢购'按钮可以重复单击, 但用户的Session不会重复记录同一商品的主键id.
单击'订单信息'就能进入订单页面, 如图11-10所示.

图11-10　订单页面

订单页面根据用户的Session所存储的数据生成商品列表, 单击某商品的'移除商品'按钮就会自动刷新订单页面,
页面刷新机制与商城首页的刷新机制相同, 只不过订单页面的刷新机制是删除当前用户Session的商品主键id.
订单页面只实现商品的展示和移除功能, 其他功能皆由前端的JavaScript实现, 如商品勾选, 数量与金额的计算等.

综上所述, 整个MyDjango项目主要实现商城首页和订单信息页, 两个页面之间的数据传递由Session实现, 详细说明如下:
● 商城首页实现Session的读取和写入.
  首先获取Session的id_list, 如果当前请求存在请求参数id, 就判断Session的id_list是否存在请求参数id的值,
  若不存在, 则将请求参数id的值写入Session的id_list.
● 订单信息页实现Session的读取和删除.
  首先获取Session的idList, 如果当前请求存在请求参数id, 就判断Session的id_list是否存在请求参数id的值,
  若存在, 则从Session的id_list删除请求参数id的值.

11.2 缓存机制

现在的网站都以动态网站为主, 当网站访问量过大时, 网站的响应速度必然大大降低, 这就有可能出现卡死的情况.
为了解决网站访问量过大的问题, 可以在网站上使用缓存机制.

11.2.1 缓存的类型与配置

缓存是将一个请求的响应内容保存到内存, 数据库, 文件或者高速缓存系统(Memcache)中,
若某个时间内再次接收同一个请求, 则不再执行该请求的响应过程, 而是直接从内存或者高速缓存系统中获取该请求的响应内容返回给用户.

Django提供5种不同的缓存方式, 每种缓存方式说明如下:
● Memcached: 一个高性能的分布式内存对象缓存系统, 用于动态网站, 以减轻数据库负载.
  通过在内存中缓存数据和对象来减少读取数据库的次数, 从而提高网站的响应速度.
  使用Memcached需要安装Memcached系统服务器, Django通过python-memcached或pylibmc模块调用Memcached系统服务器,
  实现缓存读写操作, 适合超大型网站使用.
● 数据库缓存: 缓存信息存储在网站数据库的缓存表中, 缓存表可以在项目的配置文件中配置, 适合大中型网站使用.
● 文件系统缓存: 缓存信息以文本文件格式保存, 适合中小型网站使用.
● 本地内存缓存: Django默认的缓存保存方式, 将缓存存放在计算机的内存中, 只适用于项目开发测试.
● 虚拟缓存: Django内置的虚拟缓存, 实际上只提供缓存接口, 不能存储缓存数据, 只适用于项目开发测试.

每种缓存方式都有一定的适用范围, 因此选择缓存方式需要结合网站的实际情况而定.
若在项目中使用缓存机制, 则首先在配置文件settings.py中设置缓存的相关配置. 每种缓存方式的配置如下:

# Memcached配置
# BACKEND用于配置缓存引擎, LOCATION是Memcached服务器的IP地址
# django.core.cache.backends.memcached.MemcacheCache
# 使用python模块连接Memcached
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        # 'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
        'LOCATION': [
            '172.19.26.240:11211',
            '172.19.26.242:11211',
        ]
    }
}

# 数据库缓存配置
# BACKEND用于配置缓存引擎, LOCATION是数据表的命名
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
        'LOCATION': 'my_cache_table',
    }
}

# 文件系统缓存
# BACKEND用于配置缓存引擎, LOCATION是文件的绝对路径
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
        'LOCATION': 'D:/django_cache',
    }
}

# 本地内存缓存
# BACKEND用于配置缓存引擎, LOCATION对存储器命名, 用于识别单个存储器
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
        'LOCATION': 'unique-snowflake',
    }
}

# 虚拟缓存
# BACKEND用于配置缓存引擎
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.dummy.DummyCache',
    }
}

上述缓存配置仅仅是基本配置, 也就是说缓存配置的参数BACKEND和LOCATION是必选参数, 其余的配置参数可自行选择.
我们以数据库缓存配置为例, 完整的缓存配置如下:

# settings.py
# 数据库缓存设置
# BACKEND用于配置缓存引擎, LOCATION是数据表的命名
CACHES = {
    # 默认缓存数据表
    'default': {
        'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
        'LOCATION': 'my_cache_table',
        # TIMEOUT设置缓存的生命周期, 以秒为单位, 若为None, 则永不过期
        'TIMEOUT': 60,
        'OPTIONS': {
            # MAX_ENTRIES代码最大缓存的记录
            'MAX_ENTRIES': 1000,
            # 当缓存达到最大数量之后, 设置剔除缓存的数量
            'CULL_FREQUENCY': 3
        },
    },
    
    # 设置多个缓存数据表
    'MyDjango': {
        'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
        'LOCATION': 'MyDjango_cache_table',
    }
}

Django允许同时配置和使用多种不同类型的缓存方式, 配置方法与多数据库的配置方法相似.
上述配置是在同一个数据库中使用不同的数据表存储缓存信息, 使用数据库缓存需要根据缓存配置来创建缓存数据表.
缓存数据表的创建依赖于settings.py的数据库配置DATABASES, 
如果DATABASES配置多个数据库, 缓存数据表就默认在DATABASES的default的数据库中生成.
在PyCharm的Terminal中输入: python manage.py createcachetable 指令创建缓存数据表, 
然后在数据库中查看缓存数据表, 如图11-11所示.

图11-11　缓存数据表

11.2.2 缓存的使用

完成数据库缓存配置以及缓存数据表的创建后, 下一步在项目功能中使用缓存机制.
缓存的使用方式有4种, 主要根据不同的使用对象进行划分, 具体说明如下:
● 全站缓存: 将缓存作用于整个网站的全部页面.
  一般情况下不采用这种方式实现, 如果网站规模较大, 缓存数据相应增多, 就会对数据库或Memcached造成极大的压力.
● 视图缓存: 当用户发送请求时, 若该请求的视图函数已生成缓存数据, 
  则以缓存数据作为响应内容, 这样可省去视图函数处理请求的时间和资源.
● 路由缓存: 其作用与视图缓存相同, 但两者是有区别的, 例如两个路由指向同一个视图函数, 分别访问这两个路由地址时,
  路由缓存会判断路由地址是否已生成缓存而决定是否执行视图函数.
● 模板缓存: 对模板某部分的数据设置缓存, 常用于模板内容变动较少的情况,
  如HTML的<head>标签, 设置缓存能省去模板引擎解析生成HTML页面的时间.

11.2.2.1 全站缓存

全站缓存作用于整个网站, 当用户向网站发送请求时, 首先经过Django的中间件进行处理.
因此, 使用全站缓存应在Django的中间件中配置, 配置信息如下:

# MyDjango的settings.py
MIDDLEWARE = [
    # 配置全站缓存
    'django.middleware.cache.UpdateCacheMiddleware',  # 更新缓存
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    # 添加本地化中间件LocaleMiddleware
    'django.middleware.locale.LocaleMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    # 配置全站缓存
    'django.middleware.cache.FetchFromCacheMiddleware',  # 从缓存中获取数据
]

# 设置缓存的生命周期
CACHE_MIDDLEWARE_SECONDS = 15
# 设置缓存数据保存在数据表my_cache_table中
# 属性值default来自于缓存配置CACHES的default
CACHE_MIDDLEWARE_ALIAS = 'default'
# 设置缓存表字段cache_key的值
# 用于同一个Django项目多个站点之间的共享缓存
CACHE_MIDDLEWARE_KEY_PREFIX = 'MyDjango'

全局缓存是使用Django内置中间件cache实现的, 上述配置的说明如下:
● 在配置属性MIDDLEWARE的首位元素和末位元素时分别添加cache中间件UpdateCacheMiddleware和FetchFromCacheMiddleware.
  FetchFromCacheMiddleware中间件: 用于从缓存中获取已经缓存的HTTP响应.
  当一个请求到达时, 它会首先检查缓存中是否有对应的响应, 如果有, 则直接返回缓存的响应, 而不是重新生成响应.
  这样可以提高网站的响应速度, 减轻服务器的压力.
  UpdateCacheMiddleware中间件用于更新缓存中的HTTP响应.
  当一个请求被处理并生成响应后, 这个中间件会将响应存储到缓存中, 以便下次请求时可以直接从缓存中获取.
  这样可以避免重复生成相同的响应, 提高网站的性能.
● CACHE_MIDDLEWARE_SECONDS设置缓存的生命周期. 
  若在视图, 路由和模板中使用缓存并设置生命周期属性TIMEOUT, 则优先选择CACHE_MIDDLEWARE_SECONDS.
● CACHE_MIDDLEWARE_ALIAS设置缓存的保存路径, 默认为default.
   如果缓存配置CACHES中设置多种缓存方式, 没有设置缓存的保存路径, 就默认保存在缓存配置CACHES的default的配置信息中.
● CACHE_MIDDLEWARE_KEY_PREFIX指定某个Django站点的名称.
  在一些大型网站中都会采用分布式站点实现负载均衡, 这是将同一个Django项目部署在多个服务器上, 
  当网站访问量过大的时候, 可以将访问量分散到各个服务器, 提高网站的整体性能.
  如果多个服务器使用共享缓存, 那么该属性是为了区分各个服务器的缓存数据, 这样每个服务器只能使用自己的缓存数据.

以11.2.1小节的MyDjango项目为例, 将上述配置信息写入配置文件settings.py中,
然后启动MyDjango, 在浏览器上访问任意页面都会在缓存数据表my_cache_table上生成相应的缓存信息, 如图11-12所示.

图11-12　缓存数据表my_cache_table

11.2.2.2 视图缓存

视图缓存是在视图函数或视图类的执行过程中生成缓存数据, 视图使用装饰器生成, 并保存缓存数据.
装饰器cache_page设有参数timeout, cache和key_prefix, 参数timeout是必选参数,
其余两个参数是可选参数, 参数的作用与全局缓存的配置属性相同, 代码说明如下:

# index的views.py
from django.shortcuts import render
# 导入cache_page
from django.views.decorators.cache import cache_page


# 参数cache与配置属性CACHE_MIDDLEWARE_ALIAS相同
# 参数key_prefix与配置属性CACHE_MIDDLEWARE_KEY_PREFIX相同
# 参数timeout与配置属性CACHE_MIDDLEWARE_SECONDS相同
# CACHE_MIDDLEWARE_SECONDS的优先级高于参数timeout
@cache_page(timeout=10, cache='MyDjango', key_prefix='MyView')
def index(request):
    return render(request, 'index.html')

# index 的 urls.py
from django.urls import path
from .views import *

urlpatterns = [
    # 网站首页
    path('', index, name="index"),
]

<!-- templates 的 index.html-->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
</head>
<body>
    <h1>首页</h1>
</body>
</html>

上述配置是将视图缓存存放在缓存数据表MyDjango_cache_table中, 并且缓存数据的字段cache_key含有关键词MyView.
运行MyDjango, 在浏览器上访问127.0.0.1:8000, 打开数据库查看缓存数据表MyDjango_cache_table的视图缓存信息, 如图11-13所示.

图11-13　缓存数据表MyDjango_cache_table

11.2.2.3 路由缓存

cache_header: 这种类型的缓存主要用于对特定URL的响应进行缓存.
当使用cache_header装饰器时, Django会为每个请求的URL生成一个唯一的缓存键, 这样可以为每个URL的响应独立缓存.
缓存键通常包含URL的哈希值和其他相关信息, 以确保唯一性.

cache_page: 这种类型的缓存是针对整个页面的输出进行缓存.
当使用cache_page装饰器时, Django会根据请求的方法(如GET或POST)和URL来生成缓存键.
这种缓存适用于整个页面的内容, 而不仅仅是响应头. 

路由缓存是在路由文件urls.py中生成和保存的, 路由缓存也是使用缓存函数cache_page实现的.
我们在index的urls.py中设置路由index的缓存数据, 代码如下:

from django.urls import path
from .views import *
from django.views.decorators.cache import cache_page

urlpatterns = [
    # 网站首页设置路由缓存
    path('', cache_page(timeout=10, cache='MyDjango', key_prefix='MyURL')(index), name="index"),
]

在浏览器上访问网站首页, 打开数据库查看缓存数据表MyDjango_cache_table的路由缓存数据, 如图11-14所示.

图11-14　缓存数据表MyDjango_cache_table

11.2.2.4 模板缓存

模板缓存是通过Django的缓存标签实现的, 缓存标签可以设置缓存的生命周期, 
缓存的关键词和缓存数据表(函数cache_page的参数timeout, key_prefix和cache),
三者的设置顺序和代码格式是固定不变的, 以模板文件index.html为例实现模板缓存, 代码如下:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
</head>
<body>
<div>
    {# 设置模板缓存 #}
    {% load cache %}
    {# 10代表生命周期 #}
    {# MyTemp代表缓存数据的cachr_key字段 #}
    {# using="MyDjango" 代表缓存数据表 #}
    {% cache 10 MyTemp using="MyDjango" %}
        <div>Hello Django</div>
    {% endcache %}
</div>
</body>
</html>

重启MyDjango, 在浏览器上再次访问网站首页, 然后打开数据库查看缓存数据表MyDjango_cache_table的模板缓存数据, 如图11-15所示.

图11-15　缓存数据表MyDjango_cache_table

11.3 CSRF防护

CSRF(Cross-Site Request Forgery, 跨站请求伪造)也称为One Click Attack或者Session Riding, 
通常缩写为CSRF或者XSRF, 这是一种对网站的恶意利用, 窃取网站的用户信息来制造恶意请求.

Django为了防护这类攻击, 在用户提交表单时, 表单会自动加入csrfmiddlewaretoken隐藏控件, 
这个隐藏控件的值会与网站后台保存的csrfmiddlewaretoken进行匹配, 只有匹配成功, 网站才会处理表单数据.
这种防护机制称为CSRF防护, 原理如下:
(1) 在用户访问网站时, Django在网页表单中生成一个隐藏控件csrfmiddlewaretoken, 控件属性value的值是由Django随机生成的.
(2) 当用户提交表单时, Django校验表单的csrfmiddlewaretoken是否与自己保存的csrfmiddlewaretoken一致, 用来判断当前请求是否合法.
(3) 如果用户被CSRF攻击并从其他地方发送攻击请求, 由于其他地方不可能知道隐藏控件csrfmiddlewaretoken的值,
    因此导致网站后台校验csrfmiddlewaretoken失败, 攻击就被成功防御.
在Django中使用CSRF防护功能, 首先在配置文件settings.py中设置CSRF防护功能.
它是由settings.py的CSRF中间件CsrfViewMiddleware实现的, 在创建项目时已默认开启, 如图11-16所示.

(CSRF防止其他网站向自己的网站发送请求, 除非你得的随机生成的token值, 放到伪装的页面中.)

CSRF防御策略中使用随机令牌的基本步骤:
* 1. 生成令牌: 当服务器生成一个会话(如用户登录时), 它会生成一个随机的, 不可预测的令牌,
     并将其存储在用户的会话数据中(如服务器端的session cookie或浏览器的localStorage).
* 2. 将令牌发送到客户端: 服务器在发送HTML页面给客户端时, 会将令牌嵌入到页面中, 通常作为隐藏的表单字段或作为JavaScript变量.
* 3. 在请求中包含令牌: 当客户端向服务器发送请求时(如提交表单或执行AJAX请求), 它需要将令牌包含在请求中.
     这通常是通过在表单字段中添加一个额外的输入字段或将令牌作为请求头(如X-CSRF-Token)来实现的.
* 4. 验证令牌: 服务器在收到请求时, 会检查请求中是否包含令牌, 并且令牌是否与存储在服务器上的会话数据中的令牌匹配.
     如果令牌不存在或不匹配, 服务器将拒绝请求.

图11-16　设置CSRF防护功能

CSRF防护只适用于POST请求, 并不防护GET请求, 因为GET请求是以只读形式访问网站资源的, 一般情况下并不破坏和篡改网站数据.
以MyDjango为例, 在模板文件index.html的表单<form>标签中加入内置标签csrf_token即可实现CSRF防护, 代码如下:

<!-- templates的index.html -->
<html>
<body>
<form action="" method="post">
    {% csrf_token %}
    <div>用户名:</div>
    <input type="text" name='username'>
    <div>密 码:</div>
    <input type="password" name='password'>
    <div><button type="submit">确定</button></div>
</form>
</body>
</html>

启动运行MyDjango, 在浏览器中访问网站首页(127.0.0.1:8000), 然后打开浏览器的开发者工具, 
可以发现表单设有隐藏控件csrfmiddlewaretoken, 隐藏控件是由模板语法{% csrf_token %}生成的.
用户每次提交表单或刷新网页时, 隐藏控件csrfmiddlewaretoken的属性value都会随之变化, 如图11-17所示.

图11-17　隐藏控件csrfmiddlewaretoken

如果想要取消表单的CSRF防护, 那么可以在模板文件上删除{% csrf_token %},
并且在对应的视图函数中添加装饰器@csrf_exempt, 代码如下:

# index的views.py
from django.shortcuts import render
from django.views.decorators.csrf import csrf_exempt


# 取消CSRF防护
@csrf_exempt
def index(request):
    return render(request, 'index.html')

如果只在模板文件上删除{% csrf_token %}, 并没有在对应的视图函数中设置过滤器@csrf_exempt,
那么用户提交表单时, 程序会因CSRF验证失败而抛出403异常的页面, 如图11-18所示.

<!-- templates的index.html -->
<html>
<body>
<form action="" method="post">
    <div>用户名:</div>
    <input type="text" name='username'>
    <div>密 码:</div>
    <input type="password" name='password'>
    <div><button type="submit">确定</button></div>
</form>
</body>
</html>

图11-18　CSRF验证失败

如果想取消整个网站的CSRF防护, 那么可以在settings.py的MIDDLEWARE注释的CSRF中间件CsrfViewMiddleware.

但在整个网站没有CSRF防护的情况下, 又想对某些请求设置CSRF防护, 那么可以在模板文件上添加模板语法{% csrf_token %},
然后在对应的视图函数中添加装饰器@csrf_protect实现, 代码如下:

# index的views.py
from django.shortcuts import render
from django.views.decorators.csrf import csrf_protect


# 添加CSRF防护
@csrf_protect
def index(request):
    if request.method == 'POST':
        print(request.POST)
    return render(request, 'index.html')

启动Django项目, 访问: 127.0.0.1:8000 , 在模板页面中没有添加csrf控件的时候, 提交表单结果如下:

如果网页表单是使用前端的Ajax向Django提交表单数据的, Django设置了CSRF防护功能,
Ajax发送POST请求就必须设置请求参数csrfmiddlewaretoken, 否则Django会将当前请求视为恶意请求.
Ajax发送POST请求的功能代码如下:

<!-- templates的index.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
    {% load static %}
    <script src="{% static "js/jquery.min.js" %}"></script>
</head>
<body>
<form id="loginForm" action="" method="post">
    {% csrf_token %}
    <label for="id_username">用户名:</label>
    <input type="text" id="id_username" name='username'>
    <label for="id_password">密 码:</label>
    <input type="password" id="id_password" name='password'>
    <div>
        <button type="button" onclick="submitForm()">确定</button>
    </div>
</form>

<script>
    function submitForm() {
        var csrf = $('input[name="csrfmiddlewaretoken"]').val();
        var username = $('#id_username').val();
        var password = $('#id_password').val();

        $.ajax({
            url: '/',
            type: 'POST',
            data: {
                'csrfmiddlewaretoken': csrf,
                'username': username,
                'password': password
            },

            // success和error是两个重要的回调函数, 它们分别用于处理成功的HTTP响应和失败的HTTP响应.
            success: function (arg) {
                console.log(arg);

            },
            error: function(xhr, status, error) {
                console.error(xhr.responseText);
            }
        });
        // 阻止默认的表单提交行为
        return false;
    }
</script>
</body>
</html>

在HTML表单中, 如果使用了<button type="submit">或者没有指定type属性的<button>(默认就是type="submit"),
当用户点击这个按钮时, 浏览器会执行默认的表单提交行为, 这通常会导致页面跳转到表单的action属性所指定的URL.

然而, 如果想要使用AJAX来异步提交表单数据, 并且不想页面跳转或者刷新, 需要阻止这个默认的表单提交行为.
这可以通过在JavaScript的表单提交事件监听器中调用event.preventDefault()方法来实现.

除此之外, 还可以简单地返回false来达到同样的效果.
返回false实际上会同时调用event.preventDefault()和event.stopPropagation(),
这意味着它不仅阻止了表单的默认提交行为, 还阻止了事件向DOM树上级元素的冒泡.

不过, 在现代开发中, 更推荐使用event.preventDefault()来明确表明你的意图是阻止默认行为, 而不是阻止事件冒泡.

Ajax之所以被称为异步提交, 是因为它允许在不重新加载整个页面的情况下, 与服务器进行数据的交换并更新部分网页内容.
这种交换数据的方式是异步的, 意味着它不会阻塞用户的界面操作, 而是允许用户在等待服务器响应的同时继续与页面进行交互.

启动Django项目, 访问: 127.0.0.1:8000 , 提交表单结果如下:

11.4 消息框架

在网页应用中, 当用户完成某个功能操作时, 网站会有相应的消息提示.
Django内置的消息框架可以供开发者直接调用, 它允许开发者设置功能引擎, 消息类型和消息内容.

11.4.1 源码分析消息框架

消息框架由中间件SessionMiddleware(会话中间件), MessageMiddleware(消息中间件)
和INSTALLED_APPS的django.contrib.sessions(会话框架), django.contrib.messages(消息框架)共同实现.
在创建Django项目时, 消息框架已默认开启, 如图11-19所示.

图11-19　消息框架的配置信息

消息框架必须依赖会话中间件SessionMiddleware, 因为它的功能引擎默认使用FallbackStorage(备用存储),
而FallbackStorage是在Session的基础上实现的, 这说明中间件SessionMiddleware必须设置在MessageMiddleware的前面.

根据中间件MessageMiddleware的文件路径找到消息框架的源码文件,
为了更好地展示源码文件的目录结构, 我们在PyCharm里打开消息框架的源码文件, 如图11-20所示.
(Python38\Lib\site-packages\django\contrib\messages\storage)

图11-20　消息框架的目录结构

源码文件夹storage共有5个.py文件, 其中cookie.py, session.py和fallback.py, 
分别定义消息框架的功能引擎CookieStorage, SessionStorage和FallbackStorage, 每个功能引擎说明如下:
● CookieStorage(Cookie存储): 是将消息提示的数据存储在浏览器的Cookie中, 并且数据经过加密处理, 
  如果存储的数据超过2048字节, 就将之前存储在Cookie的消息销毁.
● SessionStorage(会话存储): 是将消息提示的数据存储在服务器的Session中,
  因此它依赖于INSTALLED_APPS的sessions和中间件SessionMiddleware.
● FallbackStorage(备用存储): 是将CookieStorage和SessionStorage结合使用, 
  这是Django默认使用的功能引擎, 它根据数据大小选择合适的存储方式, 优先选择CookieStorage存储.
  
然后分析源码文件constants.py, 它一共定义了5种消息类型, 每种类型设置了不同的级别, 每种消息类型说明如表11-1所示.

表11-1　Django内置的5种消息类型

最后分析源码文件api.pym该文件定义消息框架的使用方法, 一共定义9个函数, 每个函数的说明如下:
● add_message(): 为用户添加消息提示.
  参数request代表当前用户的请求对象; 参数level是消息类型或级别; 参数message为消息内容;
  参数extra_tags是自定义消息提示的标记, 可在模板里生成上下文; 
  参数fail_silently在禁用中间件MessageMiddleware的情况下还能添加消息提示, 一般情况下使用默认值即可.

● debug(): 添加消息类型为debug的消息提示.
● info(): 添加消息类型为info的消息提示.
● success(): 添加消息类型为success的消息提示.
● warning(): 添加消息类型为warning的消息提示.
● error(): 添加消息类型为error的消息提示.

● get_messages(): 获取用户的消息提示. 
  参数request代表当前用户的请求对象.
  
● get_level(): 获取用户所有消息提示最低级别的值.
  参数request代表当前用户的请求对象.
  
● set_level(): 对不同类型的消息提示进行筛选处理.
  参数request代表当前用户的请求对象;
  参数level是消息类型或级别, 从用户的消息提示筛选并保留比参数level级别高的消息提示.

11.4.2 消息框架的使用

在开发过程中, 我们在视图里使用消息框架为用户添加消息提示, 
然后将消息提示传递给模板, 再由模板引擎解析上下文, 最后生成相应的HTML网页.
也就是说, 消息框架主要在视图和模板里使用, 而且消息框架在视图函数和视图类中有着不一样的使用方式.
以MyDjango为例, 在配置文件settings.py中设置消息框架的功能引擎, 3种功能引擎的设置方式如下:

# MyDjango的settings.py
# 设置消息框架的功能引擎(设置消息存储使用的方式)
# MESSAGE_STORAGE = 'django.contrib.messages.storage.cookie.CookieStorage'
# MESSAGE_STORAGE = 'django.contrib.messages.storage.session.SessionStorage'
# FallbackStorage是默认使用的, 无须设置
MESSAGE_STORAGE = 'django.contrib.messages.storage.fallback.FallbackStorage'

在MyDjango的urls.py和项目应用index的urls.py中分别定义路由index, success和create.
路由index和create分别指向视图函数index和视图类MyCreateView, 
路由success用于设置视图类MyCreateView的属性success_url(意思是MyCreateView中数据创建成功后, 重定向到success路由).
MyDjango的路由信息如下:

# MyDjango的urls.py
from django.urls import path, include

urlpatterns = [
    path('', include(('index.urls', 'index'), namespace='index')),
]

# index的urls.py
from django.urls import path
from .views import *

urlpatterns = [
    path('', index, name='index'),
    path('success', success, name='success'),
    path('create', MyCreateView.as_view(), name='create'),
]

下一步在index的views.py中定义视图函数index, success和视图类MyCreateView, 三者的代码如下:

# index的views.py
from django.shortcuts import render
from .models import PersonInfo
from django.contrib import messages
# from django.template import RequestContext
from django.contrib.messages.views import SuccessMessageMixin
from django.views.generic.edit import CreateView


# 视图函数使用消息框架
def index(request):
    # 筛选并保留比messages.WARNING级别高的消息提示
    # set_level必须在添加信息提示之前使用，否则无法筛选
    # messages.set_level(request, messages.WARNING)
    # 消息添加方法一
    messages.debug(request, 'debug类型')
    messages.info(request, 'info类型', 'MyInfo')
    messages.success(request, 'success类型')
    messages.warning(request, 'warning类型')
    messages.error(request, 'error类型')
    # 消息添加方法二
    messages.add_message(request, messages.INFO, 'info类型2')
    # 自定义消息类型
    # request代表参数request
    # 66代表参数level
    # 自定义类型代表参数message
    # MyDefine代表参数extra_tags
    messages.add_message(request, 66, '自定义类型', 'MyDefine')
    # 获取所以消息提示的最低级别
    current_level = messages.get_level(request)
    print(current_level)
    # 获取当前用户的消息提示对象
    mg = messages.get_messages(request)
    print(mg)
    return render(request, 'index.html', locals())
    # return render(request, 'index.html', locals(), RequestContext(request))
    # 新版本设置RequestContext会导致模板页面乱码


def success(request):
    return render(request, 'index.html', locals())


# 视图类使用消息框架
class MyCreateView(SuccessMessageMixin, CreateView):
    model = PersonInfo  # 使用的模型
    fields = ['name', 'age']  # 展示的字段
    template_name = 'create.html'  # 使用的模板
    success_url = '/success'  # 例被成功创建后, 用户将被重定向到这个URL
    success_message = 'created successfully'
    # 从SuccessMessageMixin继承的属性. 当对象被成功创建后, 这个消息会被添加到下一个响应的上下文中, 可以在模板中显示给用户.
   

视图函数index列举了9个函数的使用方法, 这是整个消息框架的使用方法, 
-- 视图函数的返回值必须设置RequestContext(request), 这是Django的上下文处理器, 确保消息提示对象messages能在模板中使用. --
( 使用RequestContext(request)后会导致模板页面乱码!!!, 不设置这个返回值也可以使用消息提示!!!
在Django 1.8及以后的版本中, render函数已经默认使用RequestContext(或类似的机制), 所以不需要显式地传递RequestContext.
然而, 如果你需要确保使用RequestContext(或只是出于某种原因想要这样做),
可以手动创建一个RequestContext实例并将其与模板一起传递给render_to_response函数(注意, 不是render函数).
但是, 通常建议使用 render 函数. )

视图类iClass继承父类SuccessMessageMixin和CreateView, 父类的继承顺序是固定不变的, 否则无法生成消息提示.
SuccessMessageMixin由消息框架定义, CreateView是数据新增视图类.
视图类iClass的类属性success_message来自SuccessMessageMixin, 其他的类属性均来自CreateView.
消息框架定义的SuccessMessageMixin只能用于数据操作视图, 
也就是说只能与视图类FormView, CreateView, UpdateView和DeleteView结合使用.
(SuccessMessageMixin不应与不涉及表单处理或数据库操作的视图一起使用, 例如:
TemplateView: 仅用于渲染模板, 不涉及表单处理或数据库操作.
RedirectView: 仅用于重定向到另一个URL, 不涉及表单处理或数据库操作.
DetailView: 用于显示数据库对象的详细信息, 但不涉及表单处理或数据库对象的修改. )

由于视图函数index使用模板文件index.html, 视图类MyCreateView使用模型PersonInfo和模板文件create.html,
因此在index的models.py中定义模型PersonInfo, 然后在模板文件夹templates中创建index.html和create.html,
最后分别在index的models.py, 模板文件index.html和create.html中编写以下代码:

# index的models.py
from django.db import models


class PersonInfo(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=20, verbose_name='姓名')
    age = models.IntegerField(verbose_name='年龄')
    

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>消息提示</title>
</head>
<body>
    {% if messages %}
        <ul>
            {% for m in messages %}
                <li>消息内容: {{ m.message }}</li>
                <div>消息类型: {{ m.level }}</div>
                <div>消息级别: {{ m.level_tag }}</div>
                <div>参数extra_tags的值: {{ m.extra_tags }}</div>
                <div>extra_tags和level_tag组合值: {{ m.tags }}</div>
            {% endfor %}
        </ul>
    {% else %}
        <script>alert('暂无消息!');</script>
    {% endif %}
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>数据新增</title>
</head>
<body>
    <h3>数据新增</h3>
    <form action="" method="post">
        {% csrf_token %}
        {{ form.as_p }}
        <input type="submit" value="确定">
    </form>
</body>
</html>

模板文件index.html将消息提示对象messages进行遍历访问, 每次遍历获取某条消息提示, 
并将当前消息提示的所有属性进行列举说明, 通过这些属性可以控制消息提示的输出和CSS样式设置等操作.

在运行MyDjango之前, 记得执行数据迁移, 让模型PersonInfo在数据库中生成数据表,
否则视图类iClass无法正常使用模型PersonInfo.

# 数据库迁移
D:\MyDjango> python manage.py makemigrations
Migrations for 'index':
  index\migrations\0002_auto_20240512_1826.py
    - Create model PersonInfo
    - Delete model Product

D:\MyDjango> python manage.py migrate
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, index, sessions
Running migrations:
  Applying index.0002_auto_20240512_1826... OK

最后运行MyDjango, 在浏览器上访问: 127.0.0.1:8000 , 可以看到每条消息提示的属性内容, 如图11-21所示.

图11-21　消息提示

如果想要使用DEBUG级别的消息, 可以手动将消息的级别设置可以在Django的设置文件中添加如下代码

# MyDajgno 的 settings.py
MESSAGE_LEVEL = 10  # 设置等级为dubug级别

在浏览器上访问: 127.0.0.1:8000/create 并在网页表单中输入数据, 然后单击'确定'按钮, 即可在数据表index_personinfo中新增数据.
在新增数据的过程中, 视图类MyCreateView创建消息提示对象messages, 并将对象messages传递给视图函数success,
再由视图函数success传递给模板文件index.html, 最终生成相应的消息提示, 如图11-22所示.

图11-22　消息提示

11.5 分页功能

在网页上浏览数据的时候, 数据列表的下方能够看到翻页功能, 而且每一页的数据各不相同.
比如在淘宝上搜索某商品的关键字, 淘宝会根据用户提供的关键字返回符合条件的商品信息,
并且对这些商品信息进行分页处理, 用户可以在商品信息的下方单击相应的页数按钮查看.

11.5.1 源码分析分页功能

Django已为开发者提供了内置的分页功能, 开发者无须自己实现数据分页功能, 只需调用Django内置分页功能的函数即可实现.
实现数据的分页功能需要考虑多方面的因素, 分别说明如下:
● 当前用户访问的页数是否存在上(下)一页.
● 访问的页数是否超出页数上限.
● 数据如何按页截取, 如何设置每页的数据量.
对于上述考虑因素, Django内置的分页功能已提供解决方法, 而且代码的实现方式相对固定, 便于开发者理解和使用.
分页功能由Paginator类实现, 我们在PyCharm里查看该类的定义过程, 如图11-23所示.

图11-23　源码文件paginator.py

Paginator类一共定义了4个初始化参数和8个类方法, 每个初始化参数和类方法的说明如下:
● object_list: 必选参数, 代表需要进行分页处理的数据, 参数值可以为列表, 元组或ORM查询的数据对象等.
● per_page: 必选参数, 设置每一页的数据量, 参数值必须为整型.
● orphans: 可选参数, 如果最后一页的数据量小于或等于参数orphans的值, 就将最后一页的数据合并到前一页的数据.
  比如有23行数据, 若参数per_page=10, orphans=5, 则数据分页后的总页数为2, 第一页显示10行数据, 第二页显示13行数据.
● allow_empty_first_page: 可选参数, 是否允许第一页为空.
  如果参数值为False并且参数object_list为空列表, 就会引发EmptyPage错误.
● validate_number(): 验证当前页数是否大于或等于1.
● get_page(): 调用validate_number()验证当前页数是否有效, 函数返回值调用page().
● page(): 根据当前页数对参数object_list进行切片处理, 获取页数所对应的数据信息, 函数返回值调用_get_page().
● _get_page(): 调用Page类, 并将当前页数和页数所对应的数据信息传递给Page类, 创建当前页数的数据对象.
● count(): 获取参数object_list的数据长度.
● num_pages(): 获取分页后的总页数.
● page_range(): 将分页后的总页数生成可循环对象.
● _check_object_list_is_ordered(): 如果参数object_list是ORM查询的数据对象, 
  并且该数据对象的数据是无序排列的, 就提示警告信息.
从Paginator类定义的get_page(), page()和_get_page()得知, 三者之间存在调用关系,
我们将它们的调用关系以流程图的形式表示, 如图11-24所示.

图11-24　函数的调用关系

从图11-24得知, 我们将Paginator类实例化之后, 再由实例化对象调用get_page()即可得到Page类的实例化对象.
在源码文件paginator.py中可以找到Page类的定义过程, 它一共定义了3个初始化参数和7个类方法, 每个初始化参数和类方法的说明如下:
● object_list: 必选参数, 代表已切片处理的数据对象.
● number: 必选参数, 代表用户传递的页数.
● paginator: 必选参数, 代表Paginator类的实例化对象.
● has_next(): 判断当前页数是否存在下一页.
● has_previous(): 判断当前页数是否存在上一页.
● has_other_pages(): 判断当前页数是否存在上一页或者下一页.
● next_page_number(): 如果当前页数存在下一页, 就输出下一页的页数, 否则抛出EmptyPage异常.
● previous_page_number(): 如果当前页数存在上一页, 就输出上一页的页数, 否则抛出EmptyPage异常.
● start_index(): 输出当前页数的第一行数据在整个数据列表的位置, 数据位置从1开始计算.
● end_index(): 输出当前页数的最后一行数据在整个数据列表的位置, 数据位置从1开始计算.

上述是从源码的角度剖析分页功能的参数和方法, 下一步在PyCharm的Terminal中开启Django的Shell模式, 
简单地讲述如何使用分页功能, 代码如下:

D:\MyDjango> python manage.py shell
# 导入分页功能模块
>>> from django.core.paginator import Paginator
# 生成数据列表(将数字转换为字母a-j)
>>> objects = [chr(x) for x in range(97, 107)]
>>> objects
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
# 将数据列表以每3个元素分为一页
>>> p = Paginator(objects, 3)
# 输出全部数据, 即整个数据列表
>>> p.object_list
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
# 获取数据列表的长度
>>> p.count
10
# 分页后的总页数
>>> p.num_pages
4
# 将页数转换成range循环对象
>>> p.page_range
range(1, 5)
# 获取第二页的数据信息
>>> page2 = p.get_page(2)
# 判断第二页是否存在上一页
>>> page2.has_previous()
True
# 如果当前页存在上一页, 就输出上一页的页数
# 否则抛出EmptyPage异常
>>> page2.previous_page_number()
1
# 判断第二页是否存在下一页
>>> page2.has_next()
True
# 如果当前页存在下一页, 就输出下一页的页数
# 否则抛出EmptyPage异常
>>> page2.next_page_number()
3
# 判断当前页是否存在上一页或者下一页
>>> page2.has_other_pages()
True
# 输出第二页所对应的数据内容
>>> page2.object_list
['d', 'e', 'f']
# 输出第二页的第一行数据在整个数据列表的位置
# 数据位置从1开始计算
>>> page2.start_index()
4
# 输出第二页的最后一行数据在整个数据列表的位置
# 数据位置从1开始计算
>>> page2.end_index()

11.5.2 分页功能的使用

我们对Django的分页功能已经深入地分析过了, 并初步掌握了使用方式, 本节将以项目的形式来讲述如何在开发过程中使用分页功能.
以MyDjango为例, 首先在index的models.py中定义模型PersonInfo, 模型的定义过程如下:

# index的models.py
from django.db import models


class PersonInfo(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=20)
    age = models.IntegerField()

下一步对模型PersonInfo执行数据迁移, 在数据库中创建相应的数据表.
完成数据迁移后, 使用数据库可视化工具(Navicat Premium)连接MyDjango的db.sqlite3文件,
查看数据表index_personinfo, 并在数据表中添加数据信息, 如图11-25所示.

# 进行数据迁移
PS D:\MyDjango> Python manage.py makemigrations
Migrations for 'index':
  index\migrations\0001_initial.py
    - Create model PersonInfo
PS D:\MyDjango> python manage.py migrate

图11-25　数据表index_personinfo

完成项目的数据搭建后, 我们将进入数据页面进行开发.
在MyDjango的urls.py和index的urls.py中定义数据页面的路由信息, 代码如下:

# MyDjango 的 urls.py
from django.urls import path, include

urlpatterns = [
    path('', include(('index.urls', 'index'), namespace='index')),
]

# index的urls.py
from django.urls import path
from .views import *

urlpatterns = [
    path('<page>/', index, name='index'),
]

在index的views.py中定义视图函数index, 视图函数查询模型PersonInfo的所有数据并对数据执行分页处理, 实现的代码如下:

from django.shortcuts import render
from django.core.paginator import Paginator  # 分页器
from django.core.paginator import EmptyPage  # 空白页
from django.core.paginator import PageNotAnInteger  # 页面不是整数, 异常类
from .models import PersonInfo


# page参数是当前访问的页码
def index(request, page):
    # 获取模型PersonInfo的全部数据(按年龄倒序)
    person_info = PersonInfo.objects.all().ordered_by('-age')
    # 设置每一页的数据量为2, 最后一页小于等于1合并到前面一页
    p = Paginator(person_info, 2, 1)
    try:
        pages = p.get_page(page)  # 访问第n页
    except PageNotAnInteger:
        # 如果参数page的数据不是整数, 就返回第一页的数据
        pages = p.get_page(1)
    except EmptyPage:
        # 若用户访问的页数大于实际页数, 则返回最后一页的数据
        pages = p.get_page(p.num_pages)
    return render(request, 'index.html', locals())

7条数据, 两条为一页展示, 7 // 2 = 3 ... 1 , 设置最后一页的记录小于等于3合并到前一页展示.
p.num_pages查看总页数是3.

视图函数index设有参数page, 参数page来自路由变量page; 变量person_info用于查询模型PersonInfo的数据对象, 
数据查询过程使用order_by对数据进行排序, 否则在执行分页处理时将会提示警告信息, 如图11-26所示.

图11-26　提示警告信息

(对未排序的QuerySet进行分页时, 如果数据库中的数据有所变动(例如, 有新的数据插入或旧的数据被删除),
那么相同的页码可能会显示不同的数据, 因为数据库在返回结果时可能会选择不同的顺序.
这可能会导致用户体验不一致, 或者在某些情况下, 甚至可能导致数据安全问题.

Django的Paginator类在创建分页对象时, 会检查QuerySet是否使用了order_by()方法.
如果没有, Django就会发出UnorderedObjectListWarning警告, 以提醒你注意这个问题.

这个警告通常是通过Django的内部检查机制触发的, 这个机制会检查传递给Paginator的QuerySet是否包含了一个显式的排序. 
具体来说, Django会查看QuerySet的query属性, 该属性是一个Query对象, 它包含了查询的详细信息, 包括是否使用了ORDER BY子句.)

参数page和变量person都是为分页功能提供数据信息, 
使用分页功能实现数据分页是在视图函数index的try...except代码里实现的, 实现过程如下:
(1) 实例化Paginator类, 参数object_list为变量person, 参数per_page设为2, 参数orphans设为1,
    这是对变量person的数据进行分页处理, 每页的数据量为2, 若最后一页的数据量小于或等于1, 则将最后一页的数据合并到前一页的数据.
(2) 由对象p调用函数get_page, 并传入参数page; 函数get_page将参数page传入Page类执行实例化, 生成实例化对象pages.
(3) 参数page传入Page类执行实例化的过程中可能出现3种情况.
① 第一种是参数page的值在总页数的范围内, 根据参数page的值获取对应页数的数据信息.
② 第二种是参数page的数据类型不是整型, 这时将触发PageNotAnInteger异常, 异常处理是返回第一页的数据信息.
③ 第三种是参数page的值超出总页数的范围, 这时触发EmptyPage异常, 异常处理是返回最后一页的数据信息.

在MyDjango项目目录下添加static目录, 并settings.py中配置静态文件地址.

# settings.py
STATIC_URL = '/static/'
STATICFILES_DIRS = [BASE_DIR, 'static']

最后在模板文件index.html中实现数据列表和分页功能的展示, 这两个功能是由视图函数index的变量pages实现的, 详细代码如下:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    {% load static %}
    <link rel="stylesheet" href="{% static "css/base.css" %}">
    <link rel="stylesheet" href="{% static "css/lists.css" %}">
</head>
<body class="app-route model-hkrouteinfo change-list">
<div id="container">
    <div id="content" class="flex">
        <h1>分页功能</h1>
        <div id="content-main">
            <div class="model filtered" id="changelist">
                <form action="" method="post">
                    <div class="results">
                        <table id="result_list">
                            <thead>
                            <tr>
                                <th class="action-checkbox-column">
                                    <div class="text">
                                        <span><input type="checkbox"></span>
                                    </div>
                                </th>
                                <th>
                                    <div class="text">姓名</div>
                                </th>
                                <th>
                                    <div class="text">年龄</div>
                                </th>
                            </tr>
                            </thead>
                            <tbody>
                            {% for p in pages %}
                                <tr>
                                    <td class="action-checkbox">
                                        <input type="checkbox" class="action-select">
                                    </td>
                                    <td>{{ p.name }}</td>
                                    <td>{{ p.age }}</td>
                                </tr>
                            {% endfor %}
                            </tbody>
                        </table>
                    </div>
                    <p class="paginator">
                        {# 上一页的路由地址 #}
                        {% if pages.has_previous %}
                            <a href="{% url "index:index" pages.previous_page_number %}">上一页</a>
                        {% endif %}
                        {# 列出所有的路由 #}
                        {% for n in pages.paginator.page_range %}
                            {% if n == pages.number %}
                                <span class="this-page">{{ pages.number }}</span>
                            {% else %}
                                <a href="{% url "index:index" n %}">{{ n }}</a>
                            {% endif %}
                        {% endfor %}
                        {# 下一页的路由地址 #}
                        {% if pages.has_next %}
                            <a href="{% url "index:index" pages.next_page_number %}">下一页</a>
                        {% endif %}
                    </p>
                </form>
            </div>
        </div>
    </div>
</div>

</body>
</html>

综上所述, 整个MyDjango项目的分页功能已开发完成, 
运行MyDjango, 在浏览器上访问: 127.0.0.1:8000/1 即可看到第一页的数据信息,
单击下方的翻页功能可以切换相应的页数和数据信息, 运行结果如图11-27所示.

图11-27 运行结果

我在主程序中加了一行: print(pages.number, page) 想看看pages.number当前页码的值. 

查看get_page方法内部源码已经实现了返回有效页面的代码, number的值就是当前页面的页码, 也就是page参数.

运行时查看终端, 发现视图函数执行了两次, 原因如下是获取图标也执行index视图函数.
然而, 获取图标虽然执行了视图函数, 但是他不会改变页面的显示, 只针对网站图标区域.

11.6 国际化和本地化

国际化和本地化是指使用不同语言的用户在访问同一个网页时能够看到符合其自身语言的网页内容.
国际化: 是指在Django的路由, 视图, 模板, 模型和表单里使用内置函数配置翻译功能.
本地化: 是根据国际化的配置内容进行翻译处理.
简单来说, 国际化和本地化是让整个网站的每个网页具有多种语言的切换方式.

(在Django中, 国际化(i18n)和本地化(l10n)是两个重要的概念, 用于支持多语言和多地区的环境.

* 1. 国际化(Internationalization, i18n): 国际化是指使软件产品(如Django项目)能够支持多种语言和文化的过程.
     在Django中. 国际化通常涉及以下步骤:
     1. 标记可翻译字符串: 在Django的模板, 视图, 模型和表单中, 使用gettext(通常简写为_())
        或django.utils.translation模块中的其他函数来标记需要翻译的字符串.
     2. 提取可翻译字符串: 使用Django的makemessages命令从源代码中提取这些标记的字符串,
        并生成.po(Portable Object)文件. 这些文件包含了待翻译的原始字符串和它们的上下文.
     3. 翻译字符串: 翻译人员使用诸如Poedit等工具编辑.po文件, 为每种目标语言提供翻译.
        这会产生.mo(Machine Object)文件, 这是Django用于查找翻译的文件.
     4. 配置语言和地区: 在Django的设置中, 配置LANGUAGES和LANGUAGE_CODE来指定项目支持的语言和默认语言.
     
* 2. 本地化(Localization, l10n): 本地化是指根据特定地区或国家的语言和文化习惯来调整国际化后的软件产品的过程.
     在Django中, 本地化通常涉及以下方面:
     1. 使用翻译: 当Django处理一个请求时, 它会根据用户的语言设置(通常通过HTTP头中的Accept-Language字段或URL中的语言代码)
        查找相应的.mo文件, 并使用其中的翻译来替换标记的字符串.
     2. 日期, 时间和数字格式: Django允许您为每种语言配置不同的日期, 时间和数字格式.
        这包括日期和时间的表示方式, 数字的千位分隔符和货币符号等.
     3. 时区支持: Django支持时区感知的日期和时间, 允许您根据用户的时区显示时间.
     4. 本地化的模板和表单: 在模板和表单中, 可以使用Django的模板标签和表单字段来自动显示本地化后的内容.
        例如, 可以使用{% localize %}模板标签来在模板中启用本地化,
        或者使用forms.DateField和forms.TimeField等表单字段来显示和验证日期和时间.

* 3. 总结: 国际化使软件能够支持多种语言, 而本地化则根据特定地区或国家的文化和习惯来调整软件.
     在Django中, 国际化涉及标记和提取可翻译字符串以及配置语言和地区,
     而本地化则涉及使用翻译, 配置日期, 时间和数字格式以及支持时区等.
     通过结合使用国际化和本地化功能, 可以轻松地创建支持多种语言和文化的Django项目.)

11.6.1 环境搭建与配置

Django的国际化和本地化是默认开启的, 如果不需要使用此功能, 那么在配置文件settings.py中设置USE_I18N = False即可,
Django在运行时将执行某些优化, 不再加载国际化和本地化机制.

国际化和本地化需要依赖GNU Gettext工具, 不同的操作系统, GNU Gettext的安装方式有所不同.
以Windows系统为例, 在浏览器上访问: mlocati.github.io/articles/gettext-iconv-windows.html,
根据计算机的位数下载相应的.exe安装包即可, 如图11-28所示.

图11-28　GNU Gettext安装包

GNU Gettext安装成功后, 接着配置Django的国际化和本地化功能.
以MyDjango为例, 在根目录下创建文件夹language, 然后在配置文件settings.py的MIDDLEWARE中添加中间件LocaleMiddleware,
新增配置属性LOCALE_PATHS和LANGUAGES, 代码如下:

# MyDjango的settings.py
# 中间件
MIDDLEWARE = [
   ......
   'django.contrib.sessions.middleware.SessionMiddleware',
   'django.middleware.locale.LocaleMiddleware',  # 本地化中间件
   'django.middleware.common.CommonMiddleware',
   ......
]


# 翻译文件路径
LOCALE_PATHS = (
   BASE_DIR / 'language',
)


# 可用语言
LANGUAGES = (
    ('en', 'English'),
    ('zh', '中文简体'),
)

在上述配置中, 中间件LocaleMiddleware, 新增配置属性LOCALE_PATHS和LANGUAGES的说明如下:
● 中间件LocaleMiddleware使用国际化和本地化功能.
● 新增配置属性LOCALE_PATHS指向MyDjango的language文件夹, 
  该文件夹用于存储语言文件, 实现路由, 视图, 模板, 模型和表单的数据翻译.
● 新增配置属性LANGUAGES用于定义Django支持翻译的语言, 每种语言的定义格式以元组表示,
  如('en', 'English'), 其中en和English可自行命名, 一般默认采用各国语言的缩写.

11.6.2 设置国际化

完成MyDjango的环境搭建与配置后, 我们将在路由, 视图和模板里使用国际化设置.
首先在MyDjango的urls.py中设置路由的国际化, 同一个路由可以根据配置属性LANGUAGES的值来创建不同语言的路由信息, 设置方式如下:

# MyDjango的urls.py
from django.urls import path, include
from django.conf.urls.i18n import i18n_patterns

urlpatterns = i18n_patterns(
    path('', include(('index.urls', 'index'), namespace='index')),
)

在Django的URL配置中, i18n_patterns是用于支持国际化i18n的URL模式的工具. 这允许你为应用程序创建多语言版本的URL.
urlpatterns = i18n_patterns(...): 这意味着以下的所有path或url模式都会支持国际化.
当Django使用i18n_patterns时, 它会自动为每一个URL添加语言前缀(例如/en/, /zh/等).
这些前缀基于Django的国际化设置和当前请求的Accept-Language头部来确定(后续说明).

# index的urls.py
from django.urls import path
from .views import *
urlpatterns = [
    path('', index, name='index'),
]

路由的国际化设置必须在MyDjango的urls.py里实现, 路由的定义方式不变, 只需在路由urlpatterns中使用函数i18n_patterns即可.
下一步在index的views.py中设置视图函数index的国际化, 代码如下:

# index的views.py
from django.shortcuts import render
from django.utils.translation import gettext  # 获取文本
# from django.utils.translation import gettext_lazy  # 惰性获取文本


def index(request):
    if request.LANGUAGE_CODE == 'zh':
        language = gettext('Chinese')
        # language = gettext_lazy('Chinese')
    else:
        language = gettext('English')
        # language = gettext_lazy('English')
    print(language)
    return render(request, 'index.html', locals())

视图函数index根据当前请求的语言类型来设置变量language的值, 说明如下:
(1) 请求对象request的属性LANGUAGE_CODE由中间件LocaleMiddleware生成(后续有说明),
    通过判断该属性的值可以得知当前用户选择的语言类型.
(2) 变量language调用内置函数gettext或gettext_lazy设置变量值.
    若当前用户选择中文模式, 则变量值为Chinese; 否则为英文类型, 变量值为English.

最后在模板文件index.html中实现数据展示, 数据展示分为中文和英文模式, 当选择某个语言模式后, 
浏览器跳转到相应的路由地址并将数据转换成相应的语言模式, 代码如下:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    {% load i18n %}
    <title>{% trans "Choice languages" %}</title>

</head>
<body>
<div>
    {# 列举配置数据 LANGUAGES, 显示网站支持的语言 #}
    {% get_available_languages as languages %}
    {% trans "Choice languages" %}
    {% for lang_code, lang_name in languages %}
        {% language lang_code %}
            <a href="{% url 'index:index' %}">{{ lang_name }}</a>
        {% endlanguage %}
    {% endfor %}

</div>
<br>
<div>
    {% blocktrans %}
        The languages is {{ language }}
    {% endblocktrans %}
</div>
</body>
</html>

模板文件index.html导入Django内置文件i18n.py, 该文件用于定义国际化的模板标签.
上述代码使用内置标签trans, get_available_languages, language和blocktrans, 每个标签的说明如下:
● trans: 使标签里的数据可支持语言转换, 标签里的数据可为模板上下文或字符串, 但两者不能组合使用,
  比如{% trans "Hello" value %}, "Hello"为字符串, value为模板上下文, 两者混合使用将提示TemplateSyntaxError异常.
● get_available_languages: 获取配置属性LANGUAGES的值.
● language: 在模板里生成语言选择的功能.
● blocktrans: 与标签trans的功能相同, 但支持模板上下文和字符串的组合使用.
除了上述的国际化函数与标签之外, Django还定义了许多国际化函数与标签, 本书不再详细讲述, 读者可在官方文档中自行查阅.

11.6.3 设置本地化

完成路由, 视图和模板的国际化设置后, 下一步执行本地化操作.
我们以管理员身份运行命令提示符窗口, 将命令提示符窗口的路径切换到MyDjango, 然后执行makemessages指令创建语言文件,
该指令设有两个参数: 第一个参数为-l (字母L的小写), 这是固定参数; 第二个参数为zh, 这来自配置属性LANGUAGES, 如图11-29所示.

C:\Users\blue\Desktop> D:

D:\>cd MyDjango

D:\MyDjango> python manage.py makemessages -l zh
processing locale zh

D:\MyDjango>

图11-29　执行makemessages指令创建语言文件

执行makemessages指令必须以管理员身份运行, 如果在PyCharm的Terminal中执行该指令, 
Django将提示CommandError异常信息, 如图11-30所示.
(我的电脑上权限不同, 创建成功了...)

图11-30　CommandError异常信息

makemessages指令执行完成后, 打开language文件夹可以看到新建的文件django.po,
该文件为路由, 视图, 模板, 模型或表单的国际化设置提供翻译内容.
打开django.po文件, 我们需要为视图函数index和模板文件index.html的国际化设置编写翻译内容, 如图11-31所示.

图11-31　编写翻译内容

从图11-31看到, 只要在视图, 模板, 模型或表单里使用了国际化函数, 我们都可以在django.po文件中看到相关信息.
在django.po文件中, 一个完整的信息包含3行数据, 以msgid "Chinese"为例, 说明如下:
● #: .\index\views.py:7 代表国际化设置的位置信息.
● msgid"Chinese"代表国际化设置的名称, 标记和区分每个国际化设置, 比如视图函数index设置的gettext('Chinese').
● msgstr代表国际化设置的翻译内容, 默认值为空, 需要翻译人员逐条填写.

(#: .\index\views.py:7 是一个注释, 它指示原始字符串"Chinese"在文件index\views.py的第7行中.
msgid "Chinese" 是原始字符串, 即软件中的英文标签或文本.
msgstr "简体中文" 是对msgid的翻译, 即"Chinese"被翻译为"简体中文".)