一、Django的请求生命周期
1.wsgi,它就是socket的服务端，用于接收用户请求并将请求进行初次封装，然后讲求交给(Flask,Django)进行二次封装。
2.中间件，帮助我们对请求进行校验或在请求对象中添加其他相关数据，例如：csrf、request.session
3.路由匹配
4.视图函数，在视图函数中进行业务逻辑的处理，可能涉及到：ORM、templates ==>>渲染
5.中间件，对响应的数据进行处理。
6.wsgi，将响应的内容发给浏览器。
Django的流程图：
二、什么是wsgi?
web服务网关接口，wsgi是一个协议，实现该写一个的模块：
- wsgiref
- werkzeug
实现其协议的模块本质上就是socket服务端用于接收用户请求，并处理。
一般web框架基于wsgi实现，这样实现关注点分离。
wsgiref示例： from wsgiref.simple_server import make_server def run_server(environ, start_response): start_response('200 OK', [('Content-Type', 'text/html')]) return [bytes('<h1>Hello, web!</h1>', encoding='utf-8'), ] if __name__ == '__main__': httpd = make_server('127.0.0.1', 8000, run_server) httpd.serve_forever() werkzeug示例： from werkzeug.wrappers import Response from werkzeug.serving import run_simple def run_server(environ, start_response): response = Response('hello') return response(environ, start_response) if __name__ == '__main__': run_simple('127.0.0.1', 8000, run_server)
三、什么是HTTP协议？
HTTP协议就是一种传输数据的格式，是基于TCP的之上的。原来学习django框架，是从socket服务端开始学起。
自己创造一个socket服务器来充当网站，浏览器充当socket客户端。
更能够明白http协议到底是什么：
----- 请求头 请求体
----- 响应头 响应体
一次请求响应后，断开链接。（无状态，短连接）
四、常见的请求头
- Content-Type
- User-Agent: 值得不同，返回不同的页面。(根据设备)
- referer： 可以做图片防盗链。
- Host： 当前域名
- cookies： 携带在请求头里面
五、常见的请求体？
Form表单提交：
POST /index http1.1
host:www.luffycity.com...
username=alex&password=123&...
Ajax请求：
POST /index http1.1
host:www.luffycity.com...
username=alex&password=123&...
POST /index http1.1
host:www.luffycity.com...
{“username”:"alex","password":123}
补充：django中获取请求体
- request.POST 只能获取这种可是的(nusername=alex&password=123)
- request.body 能够获得 ({“username”:"alex","password":123})
常见的请求方法：
GET/POST/DELETE/PUT/PATCH/OPTIONS
六、中间件
中间件有五种方法：
process_request(self,request)
process_view(self, request, callback, callback_args, callback_kwargs)
process_template_response(self,request,response)
process_exception(self, request, exception)
process_response(self, request, response
中间件的应用场景：
1.登录认证，不再需要在每个函数中添加装饰器。
2.权限，当用户登录的时候获得当前用户的所有权限并放入session，然后再次访问其他页面，获取当前url并在session中进行匹配。如果没有匹配成功，则在中间件返回“无权访问”
3.跨域
4.使用中间件做过什么？
(1)内置 csrf sesson
(2)自定义 登录认证 权限 cors
七、为什么会有跨域？
浏览器具有同源策略才出现跨域。
同源策略：
开放：src
禁止：ajax
解决跨域的两种方法：
1、jsonp:在客户端动态的创建一个script标签
(1) 客户端：创建一个
<script src='http://www.jxntv.cn/data/jmd-jxtv2.html'></script>
<script>
function func(arg){
alert(arg);
}
</script>
(2) 服务端：接收到请求并处理返回值"func('success')"相当于：
<script>
func('success')
</script>
必须与上边一致，而且jsonp只能发送GET请求
2、cors:设置响应头
(1)简单请求
(2)复杂请求
options 请求做预检
PUT/POST
应用：本地测试前后端分离时使用。
在Django中的解决方案：
1、中间件中设置响应头
2、Django中的一个第三方组件：cors
补充Ajax：
jQuery Ajax：
$.ajax({
...
})
原生Ajax：XMLHttpRequest对象：
var xhr = new XMLHttpRequest()
xhr.onreadystatechange = function(){
if(xhr.readyState == 4){
// 已经接收到全部响应数据，执行以下操作
var data = xhr.responseText;
console.log(data);
}
};
xhr.open('POST', "/test/", true);
// 设置请求头
xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset- UTF-8');
// 发送请求
xhr.send('n1=1;n2=2;');
八、视图
在本质的上FBV和CBV是一样的
区别：
FBV：url----->函数（自己定义）
CBV: url----->view (继承的类)
继承的类：
class View(object):
class APIView(View):
class GenericAPIView(views.APIView):
class GenericViewSet(ViewSetMixin, generics.GenericAPIView)
class ModelViewSet(mixins.CreateModelMixin,
mixins.RetrieveModelMixin,
mixins.UpdateModelMixin,
mixins.DestroyModelMixin,
mixins.ListModelMixin,
GenericViewSet):
九、restful规范
restful是一个规范，规定API如何编写，通过它可以让我们api更加简洁方便维护。
例如，最直观的：
method: get/post/put/delete
原来都是在url中设置的。
除此之外还有：
(1) api
(2)版本
(3)名词(面向资源编程)
(4)条件
(5)响应式设置状态码
(6)返回值
GET: 所有列表
{
code: 10000,
data: [
{'id':1,'title':'xx'},
{'id':1,'title':'yy'},
{'id':1,'title':'zzz'},
]
}
POST: 返回新增的数据
{'id':1,'title':'xx'}
https://www.luffycity.com/api/v2/salary/1/
GET: 获取单条数据
{'id':1,'title':'xx'}
PUT：更新
{'id':1,'title':'xx'}
PATCH: 局部更新
{'id':1,'title':'xx'}
DELETE：删除
(7)错误信息
(8)hypermedia link
什么是接口？
URL
约束：约束继承（实现）了它的类中必须含有的方法
十、django rest framework 框架
作用：快速搭建基于restful规定的接口
1、路由
（1）可以通过as_view传参数，根据请求方式不同执行相应的方法
（2）可以在url中设置一个结尾，类似于：.json
2、视图
帮助了开发者提供了一些类，并在类中提供了多个方法以供我们使用
3、版本
在url中设置version参数，用户请求时候传入参数。在request.version中获取版本，根据版本不同做不同处理
4、认证
写一个类并注册到认证类，在类的authtocate方法中编写认证逻辑
认证成功（user,auth）
raise AuthticateFaild(....)
None
5、权限
写一个类并注册到权限类，在类的的has_permission方法中编写认证逻辑。
True
False
6、访问频率的限制
- 访问频率控制原理：
匿名：
1.1.1.1:[时间,时间,时间,时间,]
登录：
user:[时间,时间,时间,时间,]
默认将访问记录放在缓存中：redis/memcached
写一个类并注册到频率类，在类的的 allow_request/wait 方法中编写认证逻辑。
allow_request
True
False 如果返回False，那么就要执行wait
7、解析器
根据ContentType请求头，选择不同解析器对 请求体中的数据进行解析。
POST /index/ http1.1.
host:11.11.11.11
Content-Type:url-formendo....
user=alex&age=123
POST /index/ http1.1.
host:11.11.11.11
Content-Type:application/json
{....}
8、序列化
对queryset序列化以及对请求数据格式校验。
from rest_framework.serializers import Serializer
class XX(Serializer):
pass
ser =XX(queryset,many=True) # ListSerializer对象
ser =XX(obj, many=False) # XX对象
- 列表生成式
- 根据字符串的形式，自动导入模块并使用反射找到模块中的类【参考：s9day108】。
9、分页
对从数据库中获取到的数据进行分页处理: SQL -> limit offset
根据页码：http://www.luffycity.com/api/v1/student/?page=1&size=10
根据索引：http://www.luffycity.com/api/v1/student/?offset=60&limit=10
根据加密：http://www.luffycity.com/api/v1/student/?page=erd8
页码越大速度越慢，为什么以及如何解决？
原因：页码越大向后需要扫描的行数越多，因为每次都是从0开始扫描。
解决：
限制显示的页数
记录当前页数据ID最大值和最小值，再次分页时，根据ID现行筛选，然后再分页。
10、渲染器
根据URL中传入的后缀，决定在数据如何渲染到到页面上。
十一、ORM的补充
a. 需求: 只取某n列
queryset=[ {},{}]
models.User.objects.all().values( 'id','name')
queryset=[ (),()]
models.User.objects.all().values_list( 'id','name')
queryset=[ obj,obj]
b. - only
result = models.User.objects.all().only('id','name','age')
c. - defer
# result = models.User.objects.all().defer('id','name','age')
for item in reuslt:
print(item.id,item.name,item.age)
示例：
class Depart(models.Model): 5个部门
title = models.CharField(...)
class User(models.Model): 10个用户
name = models.CharField(...)
email = models.CharField(...)
dp = models.FK(Depart)
1.之前：11次单表查询
result = User.objects.all()
for item in result:
print(item.name,item.dp.title)
2. seleted_related，主动做连表查询（1次链表）
result = User.objects.all().seleted_related('dp')
for item in result:
print(item.name,item.dp.title)
问题：如果链表多，性能越来越差。
3. prefetch_related：2次单表查询
# select * from user ;
# 通过python代码获取：dp_id = [1,2]
# select * from depart where id in dp_id
result = User.objects.all().prefetch_related('dp')
for item in result:
print(item.name,item.dp.title)
注：数据量比较大，不会使用FK，允许出现数据冗余。
- select_related,连表操作，相当于主动做join
- prefeth_related,多次单表操作，先查询想要的数据，然后构造条件,如：id=[1,2,3]，再次查询其他表根据id做条件。
- only
- defer
- F 更新数据库字段
- Q 构造复杂条件
- 通过ORM写偏原生SQL：
- extra
Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])
- raw
# 执行原生SQL
models.UserInfo.objects.raw('select * from userinfo')
# 如果SQL是其他表时，必须将名字设置为当前UserInfo对象的主键列名
models.UserInfo.objects.raw('select id as nid from 其他表')
# 为原生SQL设置参数
models.UserInfo.objects.raw('select id as nid from userinfo where nid>%s', params=[12,])
name_map = {'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'}
Person.objects.raw('SELECT * FROM some_other_table', translations=name_map)
- 原生SQL
from django.db import connection, connections
cursor = connection.cursor() # cursor = connections['default'].cursor()
cursor.execute("""SELECT * from auth_user where id = %s""", [1])
row = cursor.fetchone() # fetchall()/fetchmany(..)
PS: 选择数据库
queryset = models.Course.objects.using('default').all()