contenttype组件、Django缓存机制以及跨域请求

1 昨日回顾
版本控制 ***
（1）url=127.0.0.1/course/?version=v100000
1 versioning_class=QueryParameterVersioning
‘VERSION_PARAM‘:‘version‘,
‘DEFAULT_VERSION‘:‘v2‘,
‘ALLOWED_VERSIONS‘:[‘v1‘,‘v2‘]

2 配置成全局：在setting里：QueryParameterVersioning

（2）重要（以后建议用这种）：127.0.0.1/v1/course/
1 路由改写：(?P<version>[v1|v2|v3]+)/version/
2 versioning_class=URLPathVersioning
‘VERSION_PARAM‘:‘version‘,
‘DEFAULT_VERSION‘:‘v2‘,
‘ALLOWED_VERSIONS‘:[‘v1‘,‘v2‘]

2 配置成全局：再setting里：URLPathVersioning
（其他）1 v1.baidu.com/course/
2 放在头里
3 名称空间的

分页 ***
1 简单分页
PageNumberPagination
1 再试图类里 生成一个PageNumberPagination对象
2 对象.属性=xxx：修改属性
3 ret=models.Book.objects.all()
data_list=对象.paginate_queryset(ret,request,self)
4 序列化 instance，反序列化：data
5 my_page.get_paginated_response(ser.data)

2 偏移分页
就第二部不一样

3 加密分页
就第二部不一样：ordering

响应（渲染）器 *
局部：JSONRenderer,BrowsableAPIRenderer
全局：配置在settings里的rest_framework

2 路飞学城项目分析
-主站
课程系列：
-所有课程（专题课，学位课）
-课程详情
-视频播放
-课程章节
-课程评论
-课程价格策略
-加入购物车
-支付中心
-去支付（调支付宝支付）
首页
轻课
个人中心：
登陆
注册
个人中心

-管理员后台

-导师后台

3 ContentType组件
解决什么问题：表的id和数据id，来唯一确定一条数据
用：
插入数据：
models：content_obj = GenericForeignKey(‘table_id‘, ‘course_id‘)
存：models.PricePolicy.objects.create(period=5, price=18000, content_obj=degree)

查询数据：
1 通过课程查价格策略：
policy = GenericRelation(‘PricePolicy‘, object_id_field=‘course_id‘, content_type_field=‘table_id‘)
course.policy.all() 拿出所有价格策略
2 通过价格策略查课程
content_obj = GenericForeignKey(‘table_id‘, ‘course_id‘)
price.content_obj 拿到的就是课程对象

models层

 1 from django.db import models
 2
 3 from django.contrib.contenttypes.models import ContentType
 4 from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
 5
 6
 7 class Course(models.Model):
 8     title = models.CharField(max_length=32)
 9     # 不会在数据库中生成字段，只用于数据库操作
10     # policy = GenericRelation(‘PricePolicy‘,object_id_field=‘object_id‘,content_type_field=‘contentType‘)
11
12
13 class DegreeCourse(models.Model):
14     title = models.CharField(max_length=32)
15
16
17 class PricePolicy(models.Model):
18     # 跟ContentType表做外键关联
19     contentType = models.ForeignKey(to=ContentType)
20     # 正数
21     object_id = models.PositiveIntegerField()
22
23     # 引入一个字段，不会在数据库中创建，只用来做数据库操作
24     # content_obj = GenericForeignKey(‘contentType‘, ‘object_id‘)
25
26     period = models.CharField(max_length=32)
27     price = models.FloatField()

views层

 1 from app01 import models
 2 def test(request):
 3     import json
 4     # 方式一插入价格规则
 5     # ret=models.ContentType.objects.filter(model=‘course‘).first()
 6     # course=models.Course.objects.filter(pk=1).first()
 7     # print(ret.id)
 8     # models.PricePolicy.objects.create(period=‘30‘,price=100,object_id=course.id,contentType_id=ret.id)
 9
10     # 方式二插入价格规则
11     # course=models.Course.objects.filter(pk=1).first()
12     # # content_obj=course  会自动的把课程id放到object_id上，并且去ContentType表中查询课程表的id，放到contentType上
13     # models.PricePolicy.objects.create(period=‘60‘,price=800,content_obj=course)
14     # 增加学位课，价格规则
15     # degreecourse = models.DegreeCourse.objects.filter(pk=1).first()
16     # models.PricePolicy.objects.create(period=‘60‘, price=800, content_obj=degreecourse)
17
18     # 查询所有价格策略，并且显示对应的课程名称
19     # ret=models.PricePolicy.objects.all()
20     # for i in ret:
21     #     print(i.price)
22     #     print(i.period)
23     #     # content_obj 就是代指关联的课程，或者学位课程的那个对象
24     #     print(type(i.content_obj))
25     #     print(i.content_obj.title)
26
27     # 通过课程id，获取课程信息和价格策略
28     course=models.Course.objects.filter(pk=1).first()
29     print(course.policy.all())
30
31
32
33
34     return render(request,‘test.html‘)

4 Django缓存机制
三个粒度：有粗粒度和细粒度，这里不做研究

缓存是放在最外层的中间件里，第一次请求经过多个中间件过滤，请求到数据，返回的时候数据缓存到最外层，再次请求可以直接在最外层拿到（缓存有时间限制）

1 全站缓存 在中间件做缓存 全局缓存是所有的类和函数都要遵守规定的。

用中间件： 注意：这里第一个中间件是处理请求过来的信息request，最后一个中间件是处理response。
MIDDLEWARE = [
# ‘django.middleware.cache.UpdateCacheMiddleware‘,
‘django.middleware.security.SecurityMiddleware‘,
。。。。。。
# ‘django.middleware.cache.FetchFromCacheMiddleware‘

]
# CACHE_MIDDLEWARE_SECONDS=10  在settings里设置缓存失效时间。在设置的时间内缓存是一直存在的。
2 单视图：
用装饰器
from django.views.decorators.cache import cache_page
# @cache_page(24*60*60)  导入cache_page 传入缓存时间，只有加了装饰器的才会有缓存。有缓存的在一段时间数据是不会变化的，没缓存的数据实时变化。
3 局部页面：  这个一般是前端处理，在前端页面导入cache模块，{%cache 5 ‘test‘%} 这里的cache是一个函数，需要传参。
{% load cache %}
{% cache 5 ‘test‘ %} 两个参数：5是时间，test是唯一标识 
{{ ctime }}
{% endcache %}

5 跨域请求
1 浏览器的同源策略

同源策略（Same origin policy）是一种约定，它是浏览器最核心也最基本的安全功能，如果缺少了同源策略，则浏览器的正常功能可能都会受到影响。可以说Web是构建在同源策略基础之上的，浏览器只是针对同源策略的一种实现

请求的url地址,必须与浏览器上的url地址处于同域上,也就是域名,端口,协议相同.

请求的信息来到服务器，服务器做出响应，只是响应来到浏览器被浏览器拒绝。

2 简单请求：发一次请求
response[‘Access-Control-Allow-Origin‘] = ‘*‘   * 代表所有的访问ip+port来源
response[‘Access-Control-Allow-Origin‘] = ‘http://127.0.0.1:8008,http://127.0.0.1:8009‘
2 非简单请求：发两次，一次预检（OPTIONS），第二次是真正的请求
if request.method==‘OPTIONS‘:  通过一个简单的判断
response[‘Access-Control-Allow-Methods‘]=‘PUT,DELETE‘
response[‘Access-Control-Allow-Headers‘]=‘Content-Type‘
建议写在中间件里
注释：里面尽量不要写（*），都支持（*）  这里尽量不要写* 虽然都支持，默认规定。

跨域请求写在中间件里：定义后记得加在中间件里。需要写中间件要注意一点：不会写的时候可以仿照中间件源码。

 1 from django.utils.deprecation import MiddlewareMixin
 2
 3 class MyMiddle(MiddlewareMixin):
 4     def process_response(self, request, response):
 5         if request.method==‘OPTIONS‘:
 6             response[‘Access-Control-Allow-Methods‘]=‘*‘
 7             response[‘Access-Control-Allow-Headers‘]=‘*‘
 8
 9         response[‘Access-Control-Allow-Origin‘] = ‘*‘
10         return response

作业：https://www.cnblogs.com/liuqingzheng/articles/9794285.html

原文地址：https://www.cnblogs.com/Roc-Atlantis/p/9846050.html

时间： 2024-10-11 14:35:02

contenttype组件、Django缓存机制以及跨域请求的相关文章

django 实现全局支持跨域请求

Django 允许跨域请求 一.django 实现支持跨域请求,本人所了解到的方法有两种: 1.视图中进行配置,只实现当前视图支持跨域请求 2.进行全局配置,实现所有视图均支持跨域请求 这里对第二种方法进行一下说明: 1.安装django-cors-headers pip install django-cors-headers 2.配置settings.py文件 INSTALLED_APPS = [ ... 'corsheaders', ... ] MIDDLEWARE_CLASSES = (

Django前后端分离跨域请求问题

一.问题背景 之前使用django+vue进行前后端分离碰到跨域请求问题,跨域(域名或者端口不同)请求问题的本质是由于浏览器的同源策略导致的,当请求的响应不是处于同一个域名和端口下,浏览器不会接受响应,同源策略也是浏览器针对请求的安全问题所作出的一种保护行为.针对跨域问题,可以有下面的解决方式: JSONP方式 自定义中间件,设置响应头 使用django-cors-headers包 二.解决方式 (一)自定义中间件 JSONP本质上是利用html的一些不受同源策略影响的标签属性src,例如:<a

django中配置允许跨域请求

对于django 安装django-cors-headers,详情请看官方文档 pip install django-cors-headers 配置settings.py文件 a.在INSTALLED_APPS里添加"corsheaders" INSTALLED_APPS = [ ... 'corsheaders', ... ] b.在MIDDLEWARE_CLASSES添加 'corsheaders.middleware.CorsMiddleware', 'django.middle

Jsonp的js实现，跨域请求，同源策略机制

Jsonp的js实现,跨域请求,同源策略机制1.跨域请求:请求URL的协议,域名,端口三者之间任意一个与当前页面地址不同即为跨域 存在跨域的情况: 网络协议不同,端口不通,域名不同,子域名不同,域名和域名对应IP不同2.同源策略机制:(相对情况,保护隐私不被泄露) 同源策略概念(Same-Origin Policy) 同源指:域名,协议,端口相同.不同源的客户端脚本(Javascript,ActionScript)在 没明确授权的情况下,不能读写对方的资源.3.Jsonp的js实现: Jsonp

Django框架基础之跨域

由于浏览器存在同源策略机制,同源策略阻止从一个源加载的文档或脚本获取或设置另一个源加载的文档的属性. 特别的:由于同源策略是浏览器的限制,所以请求的发送和响应是可以进行,只不过浏览器不接受罢了. 浏览器同源策略并不是对所有的请求均制约: 制约: XmlHttpRequest 不约束: img.iframe.script等具有src属性的标签 开发需求:向其他网站发http请求         -- 浏览器直接发送请求(考虑同源)                         --制造含有src

Django框架 之 跨域请求伪造

浏览目录 同源策略与Jsonp 同源策略 Jsonp jQuery对JSONP的实现 CORS 简介 两种请求 同源策略与Jsonp 同源策略 同源策略(Same origin policy)是一种约定,它是浏览器最核心也最基本的安全功能,如果缺少了同源策略,则浏览器的正常功能可能都会受到影响.可以说Web是构建在同源策略基础之上的,浏览器只是针对同源策略的一种实现. 同源策略,它是由Netscape提出的一个著名的安全策略.现在所有支持JavaScript 的浏览器都会使用这个策略.所谓同源是

Django跨域请求CSRF的方法示例

web跨域请求 1.为什么要有跨域限制 举个例子: 1.用户登录了自己的银行页面 http://mybank.com,http://mybank.com向用户的cookie中添加用户标识. 2.用户浏览了恶意页面 http://evil.com.执行了页面中的恶意AJAX请求代码. 3.http://evil.com向http://mybank.com发起AJAX HTTP请求,请求会默认把http://mybank.com对应cookie也同时发送过去. 4.银行页面从发送的cookie中提取

【Django】实现跨域请求

目录 JsonP实现跨域 在Django中间件中添加响应头 @ *** CORS 即 Cross Origin Resource Sharing 跨域资源共享. 跨域请求分两种:简单请求.复杂请求. 简单请求 简单请求必须满足下述条件. HTTP方法为这三种方法之一:HEAD.GET.POST · HTTP头消息不超出以下字段: Accept.Accept-Language.Content-Language.Last-Event-ID · 且Content-Type只能为下列类型中的某一个: a

Django中解决跨域请求问题

目录 解决办法 1. 新建一个中间件,路径为:Django项目/your_app/core.py, 2. 在 项目/setting.py中, 新增 解决办法 通过django中间件进行添加跨域头 1. 新建一个中间件,路径为:Django项目/your_app/core.py, 内容如下 from django.middleware.common import CommonMiddleware class MiddlewareMixin: def __init__(self, get_respo