Django框架深入了解_05 (Django中的缓存、Django解决跨域流程(非简单请求，简单请求)、自动生成接口文档)(一)

本文链接：https://blog.youkuaiyun.com/weixin_42625143/article/details/97127699

阅读目录

一、Django中的缓存：

前戏：
Django中的几种缓存方式：
Django中的缓存应用：
二、跨域：

跨域知识介绍：
CORS请求分类(简单请求和非简单请求)
示例：
三、自动生成接口文档

一、Django中的缓存：

前戏：
在动态网站中,用户所有的请求,服务器都会去数据库中进行相应的增,删,查,改,渲染模板,执行业务逻辑,最后生成用户看到的页面.

当一个网站的用户访问量很大的时候,每一次的的后台操作,都会消耗很多的服务端资源,所以必须使用缓存来减轻后端服务器的压力.

缓存是将一些常用的数据保存内存或者memcache中,在一定的时间内有人来访问这些数据时,则不再去执行数据库及渲染等操作,而是直接从内存或memcache的缓存中去取得数据,然后返回给用户.

Django中的几种缓存方式：

-开发调试阶段：没有缓存
-缓存到内存中：settings.py文件配置

--------------------------------------------------------------------
注：如果你对python感兴趣，我这有个学习Python基地，里面有很多学习资料，感兴趣的+Q群：895817687
--------------------------------------------------------------------

CACHES = {
 'default': {
  'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',  # 指定缓存使用的引擎
  'LOCATION': 'unique-snowflake',         # 写在内存中的变量的唯一值 
  'TIMEOUT':300,             # 缓存超时时间(默认为300秒,None表示永不过期)
  'OPTIONS':{
   'MAX_ENTRIES': 300,           # 最大缓存记录的数量（默认300）
   'CULL_FREQUENCY': 3,          # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  }  
 }
}

-缓存到数据库：settings.py文件配置

CACHES = {
 'default': {
  'BACKEND': 'django.core.cache.backends.db.DatabaseCache',  # 指定缓存使用的引擎
  'LOCATION': 'cache_table',          # 数据库表    
  'OPTIONS':{
   'MAX_ENTRIES': 300,           # 最大缓存记录的数量（默认300）
   'CULL_FREQUENCY': 3,          # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  }  
 }   
}

-缓存到文件：settings.py文件配置

CACHES = {
 'default': {
  'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache', #指定缓存使用的引擎
  'LOCATION': '/var/tmp/django_cache',        #指定缓存的路径
  'TIMEOUT':300,              #缓存超时时间(默认为300秒,None表示永不过期)
  'OPTIONS':{
   'MAX_ENTRIES': 300,            # 最大缓存记录的数量（默认300）
   'CULL_FREQUENCY': 3,           # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  }
 }   
}

注意,创建缓存的数据库表使用的语句:

python manage.py createcachetable

-Memcache缓存(使用python-memcached模块连接memcache)

Memcached是Django原生支持的缓存系统.要使用Memcached,需要下载Memcached的支持库python-memcached或pylibmc.

settings.py文件配置

CACHES = {
 'default': {
  'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', # 指定缓存使用的引擎
  'LOCATION': '192.168.10.100:11211',         # 指定Memcache缓存服务器的IP地址和端口
  'OPTIONS':{
   'MAX_ENTRIES': 300,            # 最大缓存记录的数量（默认300）
   'CULL_FREQUENCY': 3,           # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  }
 }
}
复制代码
LOCATION也可以配置成如下:

LOCATION也可以配置成如下:

'LOCATION': 'unix:/tmp/memcached.sock',   # 指定局域网内的主机名加socket套接字为Memcache缓存服务器
'LOCATION': [         # 指定一台或多台其他主机ip地址加端口为Memcache缓存服务器
 '192.168.10.100:11211',
 '192.168.10.101:11211',
 '192.168.10.102:11211',
]

-Memcache缓存(使用pylibmc模块连接memcache)

settings.py文件配置
 CACHES = {
  'default': {
   'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',  # 指定缓存使用的引擎
   'LOCATION':'192.168.10.100:11211',         # 指定本机的11211端口为Memcache缓存服务器
   'OPTIONS':{
    'MAX_ENTRIES': 300,            # 最大缓存记录的数量（默认300）
    'CULL_FREQUENCY': 3,           # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
   },  
  }
 }

LOCATION也可以配置成如下:

'LOCATION': '/tmp/memcached.sock',  # 指定某个路径为缓存目录
'LOCATION': [       # 分布式缓存,在多台服务器上运行Memcached进程,程序会把多台服务器当作一个单独的缓存,而不会在每台服务器上复制缓存值
 '192.168.10.100:11211',
 '192.168.10.101:11211',
 '192.168.10.102:11211',
]

Memcached是基于内存的缓存,数据存储在内存中.所以如果服务器死机的话,数据就会丢失,所以Memcached一般与其他缓存配合使用

Django中的缓存应用：

Django提供了不同粒度的缓存,可以缓存某个页面,可以只缓存一个页面的某个部分,甚至可以缓存整个网站.

缓存粒度：

单页面缓存：
在视图函数上加一个装饰器(基于FBV)

# urls.py

url(r'^show_time/', views.show_time),

# views.py

from django.shortcuts import render

# Create your views here.
from rest_framework.views import APIView
from django.views.decorators.cache import cache_page
import time

@cache_page(5)
def show_time(request):
    ctime = time.strftime('%Y-%m-%d %H:%M:%S')
    return render(request, 'show_time.html', {'ctime': ctime})

#  show_time.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>缓存测试</title>
</head>
<body>
{{ ctime }}
</body>
</html>

如果是CBV的化实现方法为：

from django.views.decorators.cache import cache_page
from django.utils.decorators import method_decorator
@method_decorator(cache_page(5), name='dispatch')
class ShowTime(APIView):
    def get(self, request):
        ctime = time.strftime('%Y-%m-%d %H:%M:%S')
        return render(request, 'show_time.html', {'ctime': ctime})

在这里插入图片描述
上面的例子是基于内存的缓存配置,基于文件的缓存该怎么配置呢??

更改settings.py的配置

CACHES = {
 'default': {
  'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache', # 指定缓存使用的引擎
  'LOCATION': 'E:\django_cache',          # 指定缓存的路径
  'TIMEOUT': 300,              # 缓存超时时间(默认为300秒,None表示永不过期)
  'OPTIONS': {
   'MAX_ENTRIES': 300,            # 最大缓存记录的数量（默认300）
   'CULL_FREQUENCY': 3,           # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  }
 }
}

然后再次刷新浏览器,可以看到在刚才配置的目录下生成的缓存文件

通过实验可以知道,Django会以自己的形式把缓存文件保存在配置文件中指定的目录中.

全站使用缓存：

使用方法：在Django中间件最上面和最下面添加2个中间件：

# 缓存全站：
# 在 MIDDLEWARE_CLASSES 中加入 “update” 和 “fetch” 中间件
# “update” 必须配置在第一个
# “fetch” 必须配置在最后一个


'django.middleware.cache.UpdateCacheMiddleware',     # process_response方法中更新缓存
    。。。。
'django.middleware.cache.FetchFromCacheMiddleware'   # process_request方法中获取缓存

同时在settings.py中再添加一个参数：

CACHE_MIDDLEWARE_SECONDS=10   # 缓存时间

用户的请求通过中间件,经过一系列的认证等操作,如果请求的内容在缓存中存在,则使用FetchFromCacheMiddleware获取内容并返回给用户，

(如果一开始还没有建立缓存，如果所有校验通过后，拿到数据，在请求走的时候，最上面中间件中要进行数据的缓存)

也就是请求走的时候，在最上面的中间件中进行判断缓存是否已经存在，如果不存在，就使用UpdateCacheMiddleware对该数据进行缓存。

局部使用缓存：

# 视图无需设置

def show_time(request):
    ctime = time.strftime('%Y-%m-%d %H:%M:%S')
    return render(request, 'show_time.html', {'ctime': ctime})

# 在页面文件中进行渲染
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>缓存测试</title>
</head>
<body>
<p>{{ ctime }}</p>
{% load cache %}
{% cache 5 'test' %}
    {{ ctime }}
{% endcache %}
</body>
</html>

tips：高级用法
-前后端分离项目
-设置值和取值：

    cache.set('test_data',{'name':'lqz','age':18},5)
    cache.get('test_data')