十、分页器
-简单分页： -from rest_framework.pagination import PageNumberPagination -生成一个对象 -调用对象的.page.paginate_queryset(books, request, view=self) -会有返回结果：把结果序列化，返回 -四个参数： 每页的大小 page_size = api_settings.PAGE_SIZE 查询第几页参数 page_query_param = 'page1' 可以指定每页的大小 page_size_query_param = None 每页最大显示多少 max_page_size = None -偏移分页 -from rest_framework.pagination import LimitOffsetPagination -生成一个对象 -调用对象的.page.paginate_queryset(books, request, view=self) -会有返回结果：把结果序列化，返回 -四个参数： 默认大小 default_limit = api_settings.PAGE_SIZE 查询的条数 limit_query_param = 'limit' 偏移的条数 offset_query_param = 'offset' 最多多少条 max_limit = None -加密分页： -from rest_framework.pagination import CursorPagination -生成一个对象 -调用对象的.page.paginate_queryset(books, request, view=self) -会有返回结果：把结果序列化，返回 -两个参数： 按什么排序 ordering = '-nid' page_size = 3
十一、响应器
1 原始的url
-url(r'^books/', views.Book.as_view()),
2 视图类继承ViewSetMixin（as_view中必须传参数，字典形式）
-url(r'^books/', views.Book.as_view(‘get':'get_all’)),
3 全自动路由（自动生成路由）
from rest_framework import routers
router=routers.DefaultRouter()
# 两个参数，一个是匹配的路由，一个是视图中写的CBV的类
router.register('book',views.Book)
url(r'', include(router.urls)),
十二、版本控制
1、eg，参考连接https://i.cnblogs.com/EditPosts.aspx?opt=1
from rest_framework.response import Response
from rest_framework.viewsets import ViewSetMixin
from rest_framework.versioning import QueryParameterVersioning,AcceptHeaderVersioning,NamespaceVersioning,URLPathVersioning
class Book(APIView):
versioning_class=URLPathVersioning
def get(self, request,*args,**kwargs):
response = MyResponse()
# print(request.GET.get('version'))
# print(request.query_params.get('version'))
print(request.version)
books = models.Book.objects.all()
ret = myserial.BookSer(instance=books, many=True)
response.msg = '查询成功'
response.data = ret.data
return Response(response.get_dic)
十三、django中的缓存
-单个视图缓存 from django.views.decorators.cache import cache_page @cache_page(5) def test_time(request): ctime=time.time() return HttpResponse(ctime) -全局缓存 在中间件中加入： MIDDLEWARE = [ # 相应的时候，放入缓存 'django.middleware.cache.UpdateCacheMiddleware', 。。。 # 从缓存中取出页面 'django.middleware.cache.FetchFromCacheMiddleware' ] CACHE_MIDDLEWARE_SECONDS=10 -模板层的缓存 {%load cache %} {% cache 5 'time'%} 应用缓存：{{ ctime }} {% endcache %} -缓存位置配置： -可以缓存到文件中 -可以缓存到内存中（默认就是内存） -可以缓存到redis中（需要安装django-redis模块） 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": "123", } } }
eg\
import time from django.views.decorators.cache import cache_page @cache_page(50) def test_time(request): ctime=time.time() # return HttpResponse(ctime) return render(request,'test.html',locals())
十四、跨域请求
1、本质上是浏览器的安全策略，不同的域，请求可以成功，但是被浏览器拦截了
-本质上是浏览器的安全策略，不同的域，请求可以成功，但是被浏览器拦截了 -可以在服务器端处理 -简单请求和非简单请求 -简单请求：发一次请求 请求方法是以下三种方法之一： HEAD GET POST HTTP的头信息只能出以下几种字段： Accept Accept-Language Content-Language Last-Event-ID Content-Type：只限于三个值application/x-www-form-urlencoded、multipart/form-data、text/plain -不符合上面的，是非简单请求，发两次请求，一次OPTIONS预检请求，然后发真实请求 -处理跨域： -写一个中间件（处理简单请求和非简单请求） class Mymiddleware(MiddlewareMixin): def process_response(self,request,response): if request.method == 'OPTIONS': response['Access-Control-Allow-Methods'] = 'PUT' response['Access-Control-Allow-Headers'] = '*' response['Access-Control-Allow-Origin'] = '*' return response
2、eg，新建一个mymiddle.py
from django.shortcuts import render,HttpResponse from django.utils.deprecation import MiddlewareMixin class Mymiddleware(MiddlewareMixin): def process_response(self,request,response): if request.method == 'OPTIONS': response['Access-Control-Allow-Methods'] = 'PUT' response['Access-Control-Allow-Headers'] = '*' response['Access-Control-Allow-Origin'] = '*' return response
setting.py:
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',
'app01.mymiddel.Mymiddleware'
]
# from django.middleware.clickjacking import XFrameOptionsMiddleware
# from app01.mymiddel import Mymiddleware
十五、django操作redis
https://www.cnblogs.com/di2wu/p/10159594.html
十六、ContentType组件的使用
1、ContentType是django提供的关系查找表的组件，建立一个表存储django项目中所有的表model，
1 contentType组件: 路飞学成项目，有课程，学位课（不同的课程字段不一样），价格策略 问题，1 如何设计表结构，来表示这种规则 2 为专题课，添加三个价格策略 3 查询所有价格策略，并且显示对应的课程名称 4 通过课程id，获取课程信息和价格策略
2、通过ContentType查找到Course、DrgeeCourse的model ID，然后方便建立关系,最终需要的是价格策略表
from django.db import models from django.contrib.contenttypes.models import ContentType from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation Create your models here.
class DrgeeCourse(models.Model): title=models.CharField(max_length=32) class Course(models.Model): title = models.CharField(max_length=32) # 不会在数据库中生成字段，只用于数据库操作 policy = GenericRelation('PricePolicy',object_id_field='course_id',content_type_field='table_id') class PricePolicy(models.Model): period=models.CharField(max_length=32) price=models.IntegerField() course_id=models.IntegerField() # table_id=models.IntegerField() # to 外部的表,不能用引号引起来 table_id=models.ForeignKey(to=ContentType,on_delete=models.CASCADE) # 这个字段,不会再数据库生成,只用来插入和查询,插入的时候, # 只需要传一个对象,他会自动把对象id赋给course_id,对象表模型的id,赋给table_id content_obj = GenericForeignKey('table_id', 'course_id')
eg.。。。。GenericForeignKey不会在数据库生成，创建时只需要给对象，不需要管它属于的表ID
from django.shortcuts import render,HttpResponse from django.http import JsonResponse # Create your views here. from api import models from django.contrib.contenttypes.models import ContentType from rest_framework.views import APIView def test(request): 为django专题课，添加三个价格策略 第一种方式 course=models.Course.objects.filter(pk=1).first() table=models.ContentType.objects.filter(model='course').first() ret=models.PricePolicy.objects.create(price=9,period='一个月',course_id=course.pk,table_id=table) ret=models.PricePolicy.objects.create(price=19,period='三个月',course_id=course.pk,table_id=table) ret=models.PricePolicy.objects.create(price=49,period='五个月',course_id=course.pk,table_id=table) 第二种方式 degreecourse=models.DrgeeCourse.objects.filter(pk=1).first() #为django全站开发学位课，添加一个价格策略 ret=models.PricePolicy.objects.create(price=9,period='一个月',content_obj=degreecourse) 查询所有价格策略，并且显示对应的课程名称 ret=models.PricePolicy.objects.all() for price in ret: print(type(price.content_obj)) # price.content_obj拿到的是?课程对象(可能是专题课,可能是学位课) print(price.content_obj.title)
3、反向查询，policy 其实就是存取PricePolicy表里的course_id
class Course(models.Model):
title = models.CharField(max_length=32)
# 不会在数据库中生成字段，只用于数据库操作
policy = GenericRelation('PricePolicy',object_id_field='course_id',content_type_field='table_id')
class PricePolicy(models.Model):
period=models.CharField(max_length=32)
price=models.IntegerField()
course_id=models.IntegerField()
# table_id=models.IntegerField()
# to 外部的表,不能用引号引起来
table_id=models.ForeignKey(to=ContentType,on_delete=models.CASCADE)
# 这个字段,不会再数据库生成,只用来插入和查询,插入的时候,
# 只需要传一个对象,他会自动把对象id赋给course_id,对象表模型的id,赋给table_id
content_obj = GenericForeignKey('table_id', 'course_id')
course=models.Course.objects.get(pk=1) # 第一种方案 # 取出course的id # 取出Couser这个表再contenttype表中对应的id # 去PricePolicy去查询数据 # 第二种方案,再course表中加入:policy = GenericRelation('PricePolicy',object_id_field='course_id',content_type_field='table_id') ret=course.policy.all() for policy in ret: print(policy.price) return HttpResponse('ok')
