djangorestful framework (三)学习

十、分页器

-简单分页：
			-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()
            def test_time(request):
                ctime=time.time()
                return HttpResponse(ctime)
        -全局缓存
            在中间件中加入：

            MIDDLEWARE = [
                # 相应的时候，放入缓存
                'django.middleware.cache.UpdateCacheMiddleware',
                。。。
                # 从缓存中取出页面
                'django.middleware.cache.FetchFromCacheMiddleware'
            ]
            CACHE_MIDDLEWARE_SECONDS=
        -模板层的缓存
            {%load cache %}
            {% cache  '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": }
                            # "PASSWORD": "",
                        }
                    }
                }

eg\

import time
from django.views.decorators.cache import cache_page
@cache_page()
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，

 contentType组件:
    路飞学成项目，有课程，学位课（不同的课程字段不一样），价格策略

    问题， 如何设计表结构，来表示这种规则
          　  为专题课，添加三个价格策略
               查询所有价格策略，并且显示对应的课程名称
               通过课程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=)

class Course(models.Model):
    title = models.CharField(max_length=)
    # 不会在数据库中生成字段，只用于数据库操作
    policy = GenericRelation('PricePolicy',object_id_field='course_id',content_type_field='table_id')

class PricePolicy(models.Model):
    period=models.CharField(max_length=)
    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=).first()

    table=models.ContentType.objects.filter(model='course').first()

    ret=models.PricePolicy.objects.create(price=,period='一个月',course_id=course.pk,table_id=table)
    ret=models.PricePolicy.objects.create(price=,period='三个月',course_id=course.pk,table_id=table)
    ret=models.PricePolicy.objects.create(price=,period='五个月',course_id=course.pk,table_id=table)
    第二种方式
    degreecourse=models.DrgeeCourse.objects.filter(pk=).first()

    #为django全站开发学位课，添加一个价格策略
    ret=models.PricePolicy.objects.create(price=,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=)
    # 第一种方案
    #  取出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')