rest_framework版本控制（接口提供版本号），Django缓存机制（三种粒度，六种缓存方式，六种缓存配置），Django缓存使用，跨域问题(cors)

rest_framework版本控制（接口提供版本号）

from rest_framework.versioning import QueryParameterVersioning, AcceptHeaderVersioning, NamespaceVersioning,URLPathVersioning
# 根据配置不同的类，前台携带版本信息的方式不同。    eg:配置信息里配置 URLPathVersioning 类，前台携带版本信息在路径里，http://127.0.0.1:8011/v1/users/ 

# 基于url的get传参方式：QueryParameterVersioning------>如：/users?version=v1            
# 基于url的正则方式：URLPathVersioning------>/v1/users/    * 根据rest_framework规范，推荐这种方式
# 基于 accept 请求头方式：AcceptHeaderVersioning------>Accept: application/json; version=1.0
# 基于主机名方法：HostNameVersioning------>v1.example.com
# 基于django路由系统的namespace：NamespaceVersioning------>example.com/v1/users/

版本控制全局控制 settings 里配置

REST_FRAMEWORK = {
    'DEFAULT_VERSIONING_CLASS': 'rest_framework.versioning.URLPathVersioning',   # 版本控制全局使用
    'DEFAULT_VERSION': 'v1',   # 默认版本(从request对象里取不到，显示的默认值)
    'ALLOWED_VERSIONS': ['v1', 'v2'],   # 允许的版本
    'VERSION_PARAM': 'version'   # URL中获取值的key
}

版本控制局部控制 CBV 里配置，版本信息可以在视图函数里 request.version 取出

from rest_framework.versioning import URLPathVersioning   # 根据不同的类携带版本信息的位置不同
from rest_framework.views import APIView

class Test(APIView):
　　 # versioning_class 变量名不能变
    versioning_class = QueryParameterVersioning  # 局部使用

    def get(self, request, *args, **kwargs):
        print(request.version)  # 视图里取前台带过来的版本号
        print(request.versioning_scheme)  # 指的是版本对象
        return HttpResponse("ok")

 

 

 

Django中的缓存机制

为了提高网站的并发量

三种力度

. 全站缓存
. 单页面缓存
. 页面的局部缓存

Django中6种缓存方式 ( 经常使用的有文件缓存和Mencache缓存 )

开发调试缓存
内存缓存
文件缓存 （settings里配置）
数据库缓存
Memcache缓存(使用python-memcached模块)
Memcache缓存(使用pylibmc模块)

 

前后端不分离使用缓存

 

Django中6种缓存配置

开发调试(此模式为开发调试使用,实际上不执行任何操作)

settings 文件里配置 

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.dummy.DummyCache',  # 缓存后台使用的引擎
        'TIMEOUT': 300,  # 缓存超时时间（默认300秒，None表示永不过期，0表示立即过期）
        'OPTIONS': {
            'MAX_ENTRIES': 300,  # 最大缓存记录的数量（默认300）
            'CULL_FREQUENCY': 3,  # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
        },
    }
}

 

内存缓存(将缓存内容保存至内存区域中)

settings 文件里配置 

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 文件里配置 

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

 

数据库缓存(把缓存数据存储在数据库中)

settings 文件里配置 

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.db.DatabaseCache',  # 指定缓存使用的引擎
        'LOCATION': 'cache_table',  # 数据库表    
        '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 文件里配置 

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': '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 文件里配置 

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缓存使用(前后端不分离)

单页面缓存（装饰器缓存）

import time
from django.views.decorators.cache import cache_page

@cache_page(5)   # 设置缓存超时时间为5秒，哪个页面需要缓存装饰器装饰一下
def test(request):
    ctime = time.time()
    return render(request, "index.html", locals())

局部缓存

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>

        <p>{{ ctime }}</p>
        _________________________________________

        {% load cache %}    # 页面的局部缓存先load 一个片段过来

        {% cache 2 "xx" %}    # 第一个参数为缓存超时时间，第二个参数为存到文件里的key值，必须要写上，否则下一次去取不知找哪一个缓存文件
            <h2>{{ ctime }}</h2>      # 在cache盒子里的代码局部缓存
        {% endcache %}
    </body>
</html>

全站缓存 ，settings里配置 ,注册两个存取缓存的中间件

MIDDLEWARE_CLASSES = (
    ‘django.middleware.cache.UpdateCacheMiddleware’,  # 这个中间件放只能最前面，表示响应回去再取
     'django.middleware.common.CommonMiddleware',
        ...
        ...
    ‘django.middleware.cache.FetchFromCacheMiddleware’,   # 这个中间件放只能最后，表示所有中间件走完在缓存起来
)

CACHE_MIDDLEWARE_SECONDS=10   # 设置全站缓存超时时间为10

 Django_rest_framework 使用缓存(前后端分离)

views视图层

from django.shortcuts import render
from django.http import JsonResponse
from django.core.cache import cache
# Create your views here.

def index(request):
    dic=cache.get("dic")         # 先去缓存里取
    if not dic:
        #去数据库查询
        print("第一次没有数据，取数据库取得")
        dic={'name':"lqz","age":18}
        cache.set("dic",dic)     # 存入缓存

    return JsonResponse(dic)

 settings里配置

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            "CONNECTION_POOL_KWARGS": {"max_connections": 100}
            # "PASSWORD": "密码",
        }
    }
}

 

 

 

 

跨域问题 :cors 跨域资源共享

同源策略:

. 浏览器自带安全策略问题
. 当前页面只能朝当前域发请求

同一个域:

ip + 端口号 + 协议号 三个都一样才是同一个域，否则都视为跨域

 

简单请求和给简单请求

简单请求：满足以下两种就是简单请求，发了一次请求，有一种不满足就不是简单请求，eg: 请求方法是GET，Content_Type: accept/json的格式，就是非简单请求

（1) 请求方法是以下三种方法之一：
    HEAD
    GET
    POST

（2）HTTP的头信息不超出以下几种字段：
    Accept
    Accept-Language
    Content-Language
    Last-Event-ID
    Content-Type：只限于三个值application/x-www-form-urlencoded、multipart/form-data、text/plain

非简单请求：发了两次请求，有一种不满足就是非简单请求

eg: Content-Type：accept/json   传json文件形式 就是非简单请求
eg: put | delete | update 请求就是非简单请求

 

处理 cors 跨域问题

根据简单与非简单请求处理跨域问题，写在自定义的中间件里，因为跨域问题还能够收到来的请求，响应回去的时候，浏览器同源策略给拦住了，所以写在响应回去的中间件里

class MyMiddleware(MiddlewareMixin):  
    def process_response(self,request,response):  # 表示响应回去的函数
        # 处理简单请求
        response['Access-Control-Allow-Origin'] = '*'
        # 处理非简单请求
        if request.method=='OPTIONS':   # 非简单请求先预检
            response['Access-Control-Allow-Headers']='*'  # 允许各种形式的编码
            # response['Access-Control-Allow-Methods']='PUT,PATCH'
            response['Access-Control-Allow-Methods']='*'   # 允许所有的请求方式

        return response

写好跨域中间件以后，要settings里注册 

MIDDLEWARE = [
    'django.middleware.cache.UpdateCacheMiddleware',  # 全站缓存中间件

    'app01.MiddlewareMixin_utile.MiddlewareMixin_response',   # 注册自定义的跨域中间件，
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    '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'  # 全站缓存中间件
]