十、分页器

-简单分页:
			-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')