djangorestful framework (三)学习

10、分页器

-简单分页：
			-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

11、响应器

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

12、版本控制

一、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)

十3、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())

 

十4、跨域请求

 一、本质上是浏览器的安全策略，不一样的域，请求能够成功，可是被浏览器拦截了

-本质上是浏览器的安全策略，不一样的域，请求能够成功，可是被浏览器拦截了 -能够在服务器端处理 -简单请求和非简单请求 -简单请求：发一次请求 请求方法是如下三种方法之一： 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

二、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

十5、django操做redis

https://www.cnblogs.com/di2wu/p/10159594.html

十6、ContentType组件的使用

一、ContentType是django提供的关系查找表的组件，创建一个表存储django项目中全部的表model，

1 contentType组件: 路飞学成项目，有课程，学位课（不一样的课程字段不同），价格策略 问题，1 如何设计表结构，来表示这种规则 　 2 为专题课，添加三个价格策略 3 查询全部价格策略，而且显示对应的课程名称 4 经过课程id，获取课程信息和价格策略 

二、经过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)

三、反向查询，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')