缓存，设置缓存，操作缓存，强缓存，协商缓存，中间件，中间件的创建和使用

缓存
定义：是一类可以更快的读取数据的介质统称，也指其他可以加快数据读取的存储方式。一般用来存储临时数据，常用介质是读取速度很快的内存
意义：视图渲染有一定成本，数据库的频繁查询过高；所以对于低频变动的页面可以考虑使用缓存技术，减少实际渲染次数；用户拿到响应的时间成本会更低。
设置缓存
将缓存的数据存储到数据库中
说明：假如A表中有100w条数据，对其进行查询是很消耗时间的，所以将其从的查询结果重新放到一个数据库表当中，每次当要使用这些查询结果时，就去这个新表中去简单的查询就可以找到想要的数据了。
设置方法：

CACHES = {
    'default': {
        "BACKEND": 'django.core.cache.backends.db.DatabaseCache',# 引擎的名称
        'LOCATION': 'my_cache_table',# 缓存保存到数据库中的表的名称
        'TIMEOUT': 300,# 缓存保存的时间 单位为秒，默认为300秒
        'OPTIONS': {
            'MAX_ENTRIES': 300,# 缓存的最大数据条数
            'CULL_FREQUENCY': 2# 缓存条数达到最大值是 删除1/x的缓存数据
        }
    }
}

上面的新的数据库的表的是需要手动创建的，在命令行中执行下面的命令，既可创建一个名称为my_cache_table的数据库表

python manage.py createcachetable my_cache_table

Django中使用缓存
1.在视图函数中导入相应的包

from django.views.decorators.cache import cache_page

@cache_page(30) # 单位是秒
def my_view(request):
	...

2.在路由中导入相应的包

from django.views.decorators.cache import cache_page
urlpatterns=[
	path('foo/',cache_page(30)(my_view))
]

局部缓存
对缓存进行操作
先引入cache对象
方式1：使用caches[‘CACHE配置key’]导入具体对象

from django.core.cache import caches

cache1 = caches['default'] # 拿到settings中配置的caches内的default对象
cache2 = caches['mylias_2']

方式2：

from django.core.cache import cache

相当于直接引用CACHES配置中的default项
操作
1.存储缓存

cache.set(key,value,timeout)
key：缓存的key，字符串类型
value：Python对象
timeout：缓存存储的时间，默认为settings中的TIMEOUT值
返回值：None

In [1]: cache.set('username','zhangsan',100)

2.获取缓存

cache.get(key)
key：缓存的key
返回值：存在为key对应的内容，不存在就返回None

In [2]: cache.get('username')
Out[2]: 'zhangsan'

3.在key不存在的时候存储缓存

cache.add(key,value)
返回值：True,或False，表示存储成功或失败

In [3]: cache.add('password','123')
Out[3]: True# 当key不存在的时候添加返回True

In [4]: cache.add('password','123')
Out[4]: False # 再次添加的时候就会返回False

4.先get，未get到就set一下

cache.get_or_set(key,value,timeout)
返回值：value

In [5]: cache.get_or_set('password','123',80)
Out[5]: '123'# 当缓存失效时，就无法get到对象，所以就重新set了一个数据

In [5]: cache.get_or_set('password','456',80)
Out[5]: '123'# 因为添加了数据，所以这次是可以get到，就返回对应的上次存储的value

5.批量存储

cache.set_many(dict,timeout)
dict：为Python中的字典
返回值：插入不成功的key数组

In [24]: dic = {'username':'张三',
    ...: 'age': 105,
    ...: 'password':123}

In [25]: cache.set_many(dic,100)
Out[25]: []# 全部插入成功即返回一个空字符串

6.批量获取

cache.get_many(key_list)
key_list：想获取数据的key组成的list
返回值：取回到的key和value组成的字典

In [29]: key_list = ['username','age','password']

In [30]: cache.get_many(key_list)
Out[30]: {'age': 105, 'password': 123, 'username': '张三'}

7.删除缓存

cache.delete(key)
返回值：None

8.批量删除

cache.delete_many(key_list)
返回值：None

浏览器缓存
浏览器对数据也进行缓存，当访问同一条数据多次时，浏览器会将其进行缓存到电脑中的一个区域，就不会想服务器进行发送请求了，默认会从浏览器缓存中拿取数据
强缓存
1.响应头-Expires

定义：缓存过期时间，用来指定资源到期的时间，是服务器端的具体的时间点 Expires: Sun, 26 Sep 2021 12:53:20 GMT

2.响应头-Cache-Control

在HTTP/1.1中，Cache-Control主要用于控制网页缓存。
Cache-Control: max-age=30

说明：服务器会带着这两个请求头同时响应给浏览器，浏览器优先使用Cache-Control

协商缓存
图片这种大数据，比较费带宽且不易变化的数据，强缓存时间到期后，浏览器会跟服务器协商，当前缓存是否可用，如果可用，服务器不必返回数据，浏览器继续使用原来的缓存数据，如果文件不可用，则返回最新数据

1.响应头-Last-Modified

文件最近修改时间，浏览器第一次请求静态文件时，服务器如果返回Last-Modified响应头，则代表该资源为协商的缓存。

2.响应头-If-Modified-Science

当缓存到期后，浏览器将获取到Last-Modified值做为请求头If-Modified-Science的值，与服务器发生请求协商，服务端返回304响应码[响应体为空],代表缓存继续使用，200响应码代表缓存不可用[响应体为最新资源]

3.响应头ETag

Last-Modified对文件的修改判定会出现误差，则引用一个新的判定方法计算文件的hash值，当文件发生改变的时候对应的文件编码的hash值会发生剧烈的变化，这样就可以精准的对文件是否进行修改进行判定了

中间件
浏览器和Django框架之间联系的中间处理框架，属于轻量级、低级的插件系统，用于全局改变Django的输入和输出
中间件以类的形式出现
编写中间件

中间件必须继承自
django.utils.deprecation.MiddlewareMixin
中间件类要实现下列五个方法中的一个或多个：

1.process_request(self,request):

执行路由之前被调用，在每个请求之前调用
返回None，或者HttpResponse对象

2.process_view(self,request,callback,callback_args,callback_kwargs):

调用视图之前被调用，在每个请求上调用
返回None，或者HttpResponse对象

3.process_response(self,request,response)：

所有响应返回浏览器被调用，在每个请求上调用
返回HttpResponse对象

4.process_exception(self,request,exception):

当处理过程中抛出异常时调用
返回HttpResponse对象

5.process_template_response(self,request,response):

视图函数执行完毕，并且返回对象中包含render方法时被调用
返回实现了render方法的响应对象

注：中间件中大多数方法在返回None时表示忽略当前操作进入下一项事件，当返回HttpResponse对象时表示此请求结束，直接返回给客户端

注册中间件
在settings中有一个MIDDLEWARE列表，在其中插入自己创建的中间件类即可
一般将中间件的类写在一个文件夹中
在项目的子文件夹中创建一个叫Middleware的文件夹，再创建一个Python文件，在文件中创建中间件类

# 开发时间 2021/9/26 21:48
from django.utils.deprecation import MiddlewareMixin


class MyMw(MiddlewareMixin):# 中间件的类要继承这个包

    def process_request(self,request):

        print('MyMw process_request do ---')

    def process_view(self,request,callback,callback_args,callback_kwargs):
        
        print('Mymw process_views do --')

    def process_respose(self,request,response):
        
        print('MyMw process_response do --')
        

然后再setting中添加对应的创建的中间件的相对位置即可

MIDDLEWARE = [
    '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',
    'Middleware.mymiddleware.MyMw'# 这个就自定义的中间件类
]

当运行views中间的函数时，就会执行中间件中响应的函数

注意：配置为数组，中间件被调用是以先上到下，再由下到上的顺序调用
即视图函数的进行是先上到下，从视图函数中出来是先下到上