django中的缓存 跨域问题（同源策略）

django缓存机制

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

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

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

django中的6中缓存方式

开发调试缓存　　没有缓存

内存缓存

文件缓存

数据库缓存

缓存到redis

Memcache缓存（使用python-memcache模块）

Memcache缓存（使用pylibmc模块）

经常使用的有文件缓存和Mencache缓存

缓存配置

settings中配置缓存位置的配置（settings中配置，BACKEND不同，缓存的位置不同） 必须要配置

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

    }
}

缓存粒度

　　全站缓存

　　单页面缓存

　　局部缓存

文件缓存（把缓存数据存储在文件中）

使用：

　　settings文件，把cache配置进去

单页面缓存：在视图函数上加一个装饰器

from django.views.decorators.cache import cache_page

@cache_page(5)    5 代表缓存时间

例子

fbv加局部缓存装饰器

import time
from django.views.decorators.cache import cache_page  局部缓存装饰器
# #局部缓存
@cache_page(5)
def index(request):
    ctime = time.time()
    return render(request,'index.html',{'ctime':ctime})

cbv加装饰器

from django.utils.decorators import method_decorator

django的bug，不能直接对类进行装饰，必须使用 method_decorator,把装饰器当作参数传进去。

@method_decorator(wrapper, name="post")

#PS:CBV中添加装饰器

def wrapper(func):

    def inner(*args,**kwargs):

        return func(*args,**kwargs)

    return inner

#1.指定方法上添加装饰器

class Foo(View):

    @method_decorator(wrapper)

    def get(self,request):

        pass

    def post(self,request):

        pass

#2.在类上添加

@method_decorator(wrapper,name='dispatch')

class Foo(View):

    def get(self,request):
        pass

    def post(self,request):

        pass

局部缓存

{% load cache %}

{% cache 5 'test'}   <!--第一个参数表示缓存时间，第二个参数是key值（取缓存的时候，需要根据key值取）-->

    当前时间：{{ ctime }}
{% endcache %}

视图函数

from django.views.decorators.cache import cache_page
import time
from .models import *
def index(request):
     cttime=time.time()      #获取当前时间
     bookList=Book.objects.all()
     return render(request,"index.html",locals())

全站缓存

既然是全站缓存,当然要使用Django中的中间件.

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

当返回给用户之前,判断缓存中是否已经存在,如果不存在,则UpdateCacheMiddleware会将缓存保存至Django的缓存之中,以实现全站缓存

#缓存整个站点，是最简单的缓存方法
#在MIDDLEWARE_CLASSES 中加入 "update"和"fetch"中间件

MIDDLEWARE_CLASSES = (
    ‘django.middleware.cache.UpdateCacheMiddleware’, #第一
    'django.middleware.common.CommonMiddleware',
    ‘django.middleware.cache.FetchFromCacheMiddleware’, #最后
)

#"update"必须配置在第一个
#"fetch" 必须配置在最后一个

需要改settings.py配置文件

MIDDLEWARE = [
    'django.middleware.cache.UpdateCacheMiddleware',    #全局控制 内部有process_response　　响应HTTPResponse中设置几个headers
    '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'  #全局控制 内部有process_request 用来缓存通过GET和HEAD方法获取的状态码为200的响应
]

CACHE_MIDDLEWARE_SECONDS=5      #去局配置缓存 过期时间

视图函数

import time

def index(request):
    ctime = time.time()
    return render(request,'index.html',{'time':ctime})

模板

{{ time }}

其余代码不变，刷新浏览器5秒，页面上的时间变化一次，这样就实现了全站缓存

高级用法

　　前后端分离项目 

　　from django.core.cache import cache　　

　　cache.set　　cache.get

设置值跟取值：
         cache.set('test_data',{'name':'lqz','age':18},5)
         cache.get('test_data')

　　自定义Response对response再次进行封装

from rest_framework.response import Response

class MyResponse():
    def __init__(self):
        self.code = 100
        self.msg = None

    def get_response(self):
        return Response(self.__dict__)  #返回名称空间

使用

from app01.utils import  MyResponse #自定义Response封装
from rest_framework.views import APIView
class Test(APIView):
    def get(self,request):
        response = MyResponse()
        response.data = {'name':'llxbl','age':18}
        response.code = 200
        response.msg = '查询成功'
        return response.get_response()

开发调试（此模式为开发调试使用，实例上不执行任何操作）

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）
  },
 }
}

第二种

# 此为开始调试用，实际内部不做任何操作
# 配置：
    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）
            },
            'KEY_PREFIX': '',                                             # 缓存key的前缀（默认空）
            'VERSION': 1,                                                 # 缓存key的版本（默认1）
            'KEY_FUNCTION': 函数名                                         # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
        }
    }


# 自定义key
def default_key_func(key, key_prefix, version):
    """
    Default function to generate keys.

    Constructs the key used by all other methods. By default it prepends
    the `key_prefix'. KEY_FUNCTION can be used to specify an alternate
    function with custom key making behavior.
    """
    return '%s:%s:%s' % (key_prefix, version, key)

def get_key_func(key_func):
    """
    Function to decide which key function to use.

    Defaults to ``default_key_func``.
    """
    if key_func is not None:
        if callable(key_func):
            return key_func
        else:
            return import_string(key_func)
    return default_key_func

内存缓存（将缓存内容保存至内存区域中）

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

第二种

# 此缓存使用python-memcached模块连接memcache

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': '127.0.0.1:11211',
    }
}

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': 'unix:/tmp/memcached.sock',
    }
}   

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': [
            '172.19.26.240:11211',
            '172.19.26.242:11211',
            # 设置权重，memcache模块做的
            ('172.19.26.240:11211',1)
            ('172.19.26.242:11211',10)
        ]
    }
}

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一般与其他缓存配合使用

第二种

# 此缓存使用pylibmc模块连接memcache
    
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
        'LOCATION': '127.0.0.1:11211',
    }
}

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
        'LOCATION': '/tmp/memcached.sock',
    }
}   

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
        'LOCATION': [
            '172.19.26.240:11211',
            '172.19.26.242:11211',
        ]
    }
}

跨域问题（同源策略）

浏览器的：同源策略，浏览器拒绝不是当前域返回的数据

ip地址和端口号都相同才是同一个域

比如:我在本地上的域名是127.0.0.1:8000,请求另外一个域名：127.0.0.1:8001一段数据

浏览器上就会报错，个就是同源策略的保护,如果浏览器对javascript没有同源策略的保护,那么一些重要的机密网站将会很危险

已拦截跨源请求：同源策略禁止读取位于 http://127.0.0.1:8001/SendAjax/ 的远程资源。（原因：CORS 头缺少 'Access-Control-Allow-Origin'）。

但是注意，项目2中的访问已经发生了，说明是浏览器对非同源请求返回的结果做了拦截

如何解决：

　　CORS:跨域资源共享

　　简单请求：发一次请求

　　非简单请求：非简单请求是发送了两次请求，第一次是预检请求（OPTIONS请求），当预检通过，允许我发请求，再发送真实的请求

　　

 简单请求需要满足两大条件

（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

 凡是不同时满足上面两个条件，就属于非简单请求。

 浏览器对这两种请求的处理，是不一样的。

* 简单请求和非简单请求的区别？

   简单请求：一次请求
   非简单请求：两次请求，在发送数据之前会先发一次请求用于做“预检”，只有“预检”通过后才再发送一次请求用于数据传输。
* 关于“预检”

- 请求方式：OPTIONS
- “预检”其实做检查，检查如果通过则允许传输数据，检查不通过则不再发送真正想要发送的消息
- 如何“预检”
     => 如果复杂请求是PUT等请求，则服务端需要设置允许某请求，否则“预检”不通过
        Access-Control-Request-Method
     => 如果复杂请求设置了请求头，则服务端需要设置允许某请求头，否则“预检”不通过
        Access-Control-Request-Headers

支持跨域，简单请求

服务器设置响应头：Access-Control-Allow-Origin = '域名' 或 '*'

支持跨域，复杂请求

由于复杂请求时，首先会发送“预检”请求，如果“预检”成功，则发送真实数据。

• “预检”请求时，允许请求方式则需服务器设置响应头：Access-Control-Request-Method
• “预检”请求时，允许请求头则需服务器设置响应头：Access-Control-Request-Headers

  $('button').click(function () {
        alert('111');
        $.ajax({
            url:'http://127.0.0.1:8001/index/',
            type:'post',
            contentType:'application/json',
            data:{'name':'lqz'},
            success:function (data) {
                console.log(data)
            }
        })
    })

被请求站点

def index(request):

    obj = HttpResponse('11111111')
    if request.method == 'OPTIONS':
    #     #允许它
        obj['Access-Control-Allow-Headers']='Content-Type'
    #     # obj['Access-Control-Allow-Headers'] = '*'
    #
    #
    # # obj['Access-Control-Allow-Origin'] = '*'
    obj['Access-Control-Allow-Origin'] = 'http://127.0.0.1:8000'
    print(obj)
    return obj

 

 解决跨域问题：（写好一个中间件配置一下）　　被请求站点

from django.utils.deprecation import MiddlewareMixin

class MyCorsMiddle(MiddlewareMixin):
    def process_response(self, request, response):
        if request.method == 'OPTIONS':
            #允许它
            response['Access-Control-Allow-Headers'] = 'Content-type'
            #response['Access-Control-Allow-Headers'] = '*'

        # response['Access-Control-Allow-Origin'] = 'http://127.0.0.1:8000'
        # 允许的请求站点
        response['Access-Control-Allow-Origin'] = '*'
        return response

MIDDLEWARE = [
    'app01.MyMiddle.MyCorsMiddle',  #跨域问题
    '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',
]