版本控制，django缓存，跨域问题解决

复习

分页：

1. 简单分页

2. 偏移分页

3. 加密分页

解析器：客户处理前端提交来的数据

	urlencode: body体中的数据格式： key=value&

    formdata编码：为区分文件和数据，有固定格式的分隔

    json: {"name":"aaa"}

    -- 全局使用

    	from rest_framework import JSONParser,FormParser,MultiPartParser

版本控制

四种方式 -- 内置的四种类

1. 基于get传参的方式 : QueryParameterVersioning ----->/?version=v1

# views.py

from rest_framework.versioning import QueryParameterVersioning

from django.http import HttpResponse

from rest_framework.views import APIView

class VersionTest(APIView):

    versioning_class=QueryParameterVersioning

    def get(self,request):

        version = request.version

        obj = request.versioning_scheme  #是QueryParameterVersioning的一个对象

        print(version,obj)

        return HttpResponse('ok')

# settings.py REST_FRAMEWORK字典中： --- 全局使用

'DEFAULT_VERSION': 'v1',            # 默认版本(从request对象里取不到，显示的默认值)

'ALLOWED_VERSIONS': ['v1', 'v2'],   # 允许的版本

'VERSION_PARAM': 'version'          # URL中获取值的key

# 局部使用： 视图类中配置

versioning_class=QueryParameterVersioning

# ---------------------------------------------------------------------------

2. 基于url的正则方式： URLPathVersioning ---> /v1/users/

from rest_framework.versioning import URLPathVersioning

#　1. 视图类中：局部使用

versioning_class= URLPathVersioning

# settings.py 全局使用

'DEFAULT_VERSIONING_CLASS':'rest_framework.versioning.URLPathVersioning',

'DEFAULT_VERSION': 'v1',            # 默认版本(从request对象里取不到，显示的默认值)

'ALLOWED_VERSIONS': ['v1', 'v2'],   # 允许的版本

'VERSION_PARAM': 'version'          # URL中获取值的key

# 2.url配置 (视图函数由参数 *args, **kwargs)

url(r'^(?P<version>[v1|v2]+)/verdiontest/')

# -----------------------------------------------------------------------------

3. 基于accept 请求头方式： AcceptHeaderVersioning ---> Accept:application/json    version：1.0

    GET 请求，将以上两个键值对放在请求头中

from rest_framework.versioning import AcceptHeaderVersioning

#　视图类中：

versioning_class= AcceptHeaderVersioning

小结：

url 最常用，注意url ， 可以使用局部配置和全局配置两种方式，注意有名参数

Django 中的6种缓存

django缓存

-- 为了提高网站的并发量

-- 三种力度

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

-- 6中缓存方式

    开发调试缓存

    内存缓存

    文件缓存

    数据库缓存

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

    Memcache缓存(使用pylibmc模块)

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

Django 6中缓存的配置文件

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

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）

  },

 }

}

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

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）

  }

 }

}

1.2.3 文件缓存(把缓存数据存储在文件中)

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）

  }

 }

}

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

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

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

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

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',

]

1.2.6 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 中使用缓存



第一步： 在settings.py 文件中配置 -- 选择上面的配置文件

		location 中的路径进行配置

第二步：使用缓存

# 单页面缓存-- 视图函数中使用缓存

添加装饰器

from django.views.decorators.cache import cache_page

@cache_page(5)

def cache_test(request):

    ctime= time.time()

    return render(request,'index.html',locals())

html页面：  {{ ctime }}

#局部缓存： html页面中

{% load cache %}

# 参数： 超时时间，key值(自定义的名字，用来表示这个局部内容)

{% cache 5 'text'}

需要缓存的代码块： {{ ctime }}

{% endcache %}

# 全站缓存：配置中间件

两个中间件，一个存，一个取

存： 放在最上边-- 重新写process_response 方法

'django.middleware.cache.UpdateCacheMiddleware'

...

'django.middleware.cache.FetchFromCacheMiddleware'

取： 放在最下边-- 重写process_request方法

还要配置缓存时间

CACHE_MIDDLEWARE_SECONDS=10

跨域问题

浏览器的 同源策略：

-- 浏览器基本的安全策略

-- 当前页面只能给当前域的地址发送请求

-- ip + 端口 相同才是同源

--解决办法：

CORS跨域资源共享： 在服务端写东西允许其他域来访问

允许8000端口的访问--- 简单请求

def test(request):

    obj = JsonResponse({1:'sff'})

    obj['Access-Control-Allow-Origin']='127.0.0.1:8000'

    return obj

CORS请求分两类： 简单请求， 复杂请求

简单请求： 符合如下两条-- 只发一次请求

    1. 请求方式： get,post,head

    2. HTTP头信息不超过以下字段：

    Accept | Accept-Language | Content-Language| Last-Event-ID|

非简单请求：

-- 先发options 预检请求，预检请求同意，再发真实的请求

obj = JsonResponse({1:'sff'})

obj['Access-Control-Allow-Origin']='*'

if request == 'OPTIONS':

  obj['Access-Control-Allow-Header']='*'

  obj['Access-Control-Allow-Method']='PUT,PATCH' # *

! 以上部分可以在中间件中设置，重写process_response方法

总结： 解决跨域问题就是写一个中间件，允许不同源请求数据

'''自定义一个中间件的步骤！！！！ '''

1. myscrf.py 文件中写一个中间件：

from django.utils.deprecation import MiddlewareMixin

class MyMiddleware(MiddlewareMixin):

    def process_response(self,request):    # 响应回去的

        #处理简单请求

        response['Access-Control-Allow-Origin']='*'

        # 处理非简单请求

        if  request.method=='OPTIONS':

            response['Access-Control-Allow-Header']='*'

            response['Access-Control-Allow-Method']='PUT,PATCH' # *

        return response

2.在settings文件中配置

from app.myscrf import MyMiddleware

'app.myscrf.MyMiddleware'  # 注意放在中间，如果配置了全站缓存

解决跨域： 方法二

安装django-cors-headers模块

在settings.py中配置

# 注册app

INSTALLED_APPS = [

	...

	'corsheaders'

]

# 添加中间件

MIDDLEWARE = [

	...

	'corsheaders.middleware.CorsMiddleware'

]

# 允许跨域源

CORS_ORIGIN_ALLOW_ALL = False

# 配置指定跨域域名

CORS_ORIGIN_WHITELIST = [

	'http://127.0.0.1:8080',

	'http://localhost:8080',

]

巴特西