一.REST
1.什么是编程？
数据结构和算法的结合
2.什么是REST？
首先我们回顾下我们之前的图书管理系统，我们设计了这样的URL，如下：
127.0.0.1:9001/books/ 127.0.0.1:9001/get_all_books/ 访问所有的数据 127.0.0.1:9001/books/{id}/ 127.0.0.1:9001/books/{id}?method=get 访问单条数据 127.0.0.1:9001/books/add/ 127.0.0.1:9001/books/?type=create 创建数据 127.0.0.1:9001/books/delete/ 127.0.0.1:9001/books/update/
分析：以上定义的url虽然也可以实现功能，但是因个人命名习惯的不同，同一个功能会产生五花八门的url，而且响应回去的数据（包括错误提示等）格式也没有统一的规范，这就造成了前后端交互上的困难。
因此，就产生了REST，REST下的url唯一代表资源，http请求方式来区分用户行为，下面就是符合REST下的url设计规范的示例：
url的设计规范： GET： 127.0.0.1:9001/books/ # 获取所有数据 GET: 127.0.0.1:9001/books/{id} # 获取单条数据 POST： 127.0.0.1:9001/books/ # 增加数据 DELETE: 127.0.0.1:9001/books/{id} # 删除数据 PUT: 127.0.0.1:9001/books/{id} # 修改数据 数据响应规范： GET： 127.0.0.1:9001/books/ # 返回[{}, {}, {}] GET: 127.0.0.1:9001/books/{id} # 返回单条数据{} POST： 127.0.0.1:9001/books/ # 返回添加成功的数据{} DELETE: 127.0.0.1:9001/books/{id} # 返回空"" PUT: 127.0.0.1:9001/books/{id} # 返回{} ，更新后完整的一条记录，注意并非一个字段 错误处理： { "error": "error_message" }
REST是只用软甲架构设计风格，不是标准，也不是技术实现，只是提供了一组设计原则和约束条件，是目前最流行的API 设计规范，用于web数据接口的设计。2000年，由Roy Fielding在他的博士论文中提出，Roy Fielding是HTTP规范的主要编写者之一。
RESTful参考链接：
那么，我们接下来要学的Django Rest Framework与REST有什么关系呢？
其实，DRF（Django REST Framework）是一套基于django开发的，帮助我们更好的设计符合REST规范的web应用的一个Django App，所以，本质上，它是要给Django App。
二、知识准备
学习新知识之前，先回顾以下几个知识点：
1、CBV（class based view）
django.views import View
class LoginView(View):
def get(self, request):
pass
def post(self, request):
pass
2、 类方法classmethod & classonlymethod
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
# 注意：Person类加载时，会执行装饰器函数classmethod(sleepping),并将结果赋给slepping
@classmethod # 相当于 sleepping = classmethod(sleepping)
def sleepping(cls):
print("Jihong is sleepping")
@classonlymethod
def guangjie(cls):
print("Jihong is shopping")
Person.sleepping() # 类直接调用类方法
Person.guangjie() # 类直接调用方法
jihong = Person("jihong", 20)
jihong.sleepping() # 对象可以调用类方法
jihong.guangjie() # 报错，对象不能调用由@classonlymethod装饰的方法
总结：
@classmethod装饰（python加的装饰器）的方法可以由对象和类调用；
@classonlymethod装饰（django加的装饰器）只能由类直接调用；
3、反射
getattr, hasattr, setattr
4、self定位
明确self指向谁 - 始终指向调用者
5、http请求协议
协议就是沟通双方约定俗称的规范，即解析数据的规则。
6、form表单的enctype属性中有三种请求协议
如果通过form表单提交用户数据，可以使用form表单的enctype属性来定义数据编码协议，该属性有三个值，代表三种数据编码协议：
- application/x-www-form-urlencoded：使用&符号连接多个键值对，键值对用等号拼接，默认；
- multipart/form-data：上传文件、图片时使用该方式；
- text/plain：空格转换为“+”号；
7、JavaScript中 object，例如： { name: "pizza"} <==> json 的相互转换方式
JSON.stringify(data) =相当于=> python json.dumps()
JSON.parse(data) =相当于=> python json.loads()
三、Django REST Framework（DRF）
为什么使用DRF?
从概念可以看出，有了这样的一个App，能够帮助我们更好的设计符合RESTful规范的web应用，实际上，没有它，我们也能自己设计符合规范的web应用，如下代码中，我们就手动实现了符合RESTful规范的web应用：
class CourseView(View):
def get(self, request):
course_list = list()
for course in Course.objects.all():
course = {
"course_name": course.course_name,
"description": course.description
}
course_list.append(course)
return HttpResponse(json.dumps(course_list, ensure_ascii=False))
如上代码所示，我们获取所有的课程数据，并根据REST规范，将所有资源通过列表返回给用户，可见，就算没有DRF，我们也能设计出符合RESTful规范的接口，甚至是整个App应用，但是，如果所有的接口都自定义，难免会出现重复代码，为了提高工作效率，我们建议使用优秀的工具，DRF就是这样一个优秀的工具，另外，它不仅能够帮助我们快速的设计符合REST规范的接口，还提供诸如认证、权限等等其他强大功能。
什么时候使用DRF?
前边提到，REST是目前最流行的API设计规范，如果使用Django开发你的web应用，那么请尽量使用DRF，如果使用的是Flask，可以使用Flask-RESRful。
DRF官方文档中有详细介绍，使用如下命令安装，首先安装Django，然后安装DRF：
|
1
2
|
>>> pip install django # 安装django，已经安装的可以直接下载DRF>>> pip install djangorestframework # 下载 |
安装完成之后，我们就可以开始使用DRF框架来实现我们的web应用了，这部分内容包括如下知识点：
- APIView - 解析器组件 - 序列化组件 - 视图组件 - 认证组件 - 权限组件 - 频率控制组件 - 分页组件 - 相应器组件 - url控制器
介绍DRF，必须介绍APIView，它是重中之重，是下面所有组件的基础，因为所有的请求都是通过它来分发的，至于它究竟是如何分发请求的？想要弄明白这个问题，就必须解读它的源码，而想要解读DRF APIView的源码，就必须先解读django中views.View类的源码，为什么使用视图类调用as_view()之后，请求就可以被不同的函数处理？
1、回顾CBV，View源码解读
# views.py中代码如下：
from django.views import View
class LoginView(View):
def get(self, request):
pass
def post(self, request):
pass
# urls.py中代码如下：
from django.urls import path, include, re_path
from classbasedView import views
urlpatterns = [
re_path("login/$", views.LoginView.as_view())
]
1）启动django项目：python manage.py runserver 127.0.0.1:8000后
2）开始加载settings配置文件
- 读取models.py
- 加载views.py
- 加载urls.py，执行as_view( )： views.LoginView.as_view()
LoginView中没有as_view，因此去执行父类View中as_view方法，父类View的相关源码如下：
class View:
http_method_names = [‘get‘, ‘post‘, ‘put‘, ...]
def __init__(self, **kwargs):
for key, value in kwargs.items():
setattr(self, key, value)
@classonlymethod
def as_view(cls, **initkwargs):
for key in initkwargs:
...
def view(request, *args, **kwargs):
# 实例化一个对象，对象名称为self，self是cls的对象，谁调用了as_view
# cls就是谁（当前调用as_view的是LoginView）
# 所以，此时的self就是LoginView的实例化对象
self = cls(**initkwargs)
if hasattr(self, ‘get‘) and not hasattr(self, ‘head‘):
self.head = self.get
self.request = request
self.args = args
self.kwargs = kwargs
return self.dispatch(request, *args, **kwargs)
view.view_class = cls
view.view_initkwargs = initkwargs
update_wrapper(view, cls, updated=())
update_wrapper(view, cls.dispatch, assigned=())
return view
def dispatch(self, request, *args, **kwargs):
if request.method.lower() in self.http_method_names:
# 通过getattr找到的属性，已和对象绑定，访问时不需要再指明对象了
# 即不需要再：self.handler，直接handler()执行
handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
else:
handler = self.http_method_not_allowed
return handler(request, *args, **kwargs)
上面源码中可以看出，as_view是一个类方法，并且方法中定义了view函数，且as_view将view函数返回，此时url与某一个函数的对应关系建立，并开始等待用户请求。
3）当用户发来请求（如get请求），开始执行url对应的view函数，并传入request对象，view函数的执行结果是返回self.dispatch(request, *args, **kwargs)的执行结果，这里的self是指LoginView的实例化对象，LoginView中没有dispatch方法，所以去执行父类View中的dispatch方法，View类中的dispatch函数中通过反射找到self（此时self指LoginView的实例对象）所属类（即LoginView）中的get方法，dispatch函数中的handler(request, *args, **kwargs)表示执行LoginView类中的get方法，其执行结果就是dispatch的执行结果，也就是请求url对应view函数的执行结果，最后将结果返回给用户。
2、APIView
使用：
# views.py中代码：
from rest_framework.views import APIView # 引入APIView
class LoginView(APIView): # LoginView继承APIView
def get(self, request):
pass
def post(self, request):
pass
# urls.py中用法同CBV一样，如下示例：
from django.urls import path, include, re_path
from classbasedView import views
urlpatterns = [
re_path("login/$", views.LoginView.as_view())
]
源码解读：
1）启动django项目：python manage.py runserver 127.0.0.1:8000后
2）开始加载settings配置文件
- 读取models.py
- 加载views.py
- 加载urls.py，执行as_view( )： views.LoginView.as_view()
LoginView中没有as_view，因此去执行父类APIView中as_view方法，父类APIView的相关源码如下：
class APIView(View):
...
# api_settings是APISettings类的实例化对象
parser_classes = api_settings.DEFAULT_PARSER_CLASSES
...
settings = api_settings
schema = DefaultSchema()
@classmethod
def as_view(cls, **initkwargs): # cls指LoginView
if isinstance(getattr(cls, ‘queryset‘, None), models.query.QuerySet):
...
# 下面一句表示去执行APIView父类（即View类）中的as_view方法
view = super(APIView, cls).as_view(**initkwargs)
view.cls = cls
view.initkwargs = initkwargs
return csrf_exempt(view)
def dispatch(self, request, *args, **kwargs):
...
request = self.initialize_request(request, *args, **kwargs)
...
try:
self.initial(request, *args, **kwargs)
if request.method.lower() in self.http_method_names:
handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
else:
handler = self.http_method_not_allowed
response = handler(request, *args, **kwargs)
except Exception as exc:
response = self.handle_exception(exc)
self.response = self.finalize_response(request, response, *args, **kwargs)
return self.response
参考View源码解读，我们知道View中的as_view方法返回view函数，此时url与view的对应关系已经建立，等待用户请求。
3）当用户发来请求（如get请求），开始执行url对应的view函数，并传入request对象，View类中view函数的执行结果是返回self.dispatch(request, *args, **kwargs)的执行结果，这里的self是指LoginView的实例化对象，LoginView中没有dispatch方法，所以去执行父类APIView中的dispatch方法，同样，APIView类中的dispatch函数中也是通过反射找到self（此时self指LoginView的实例对象）所属类（即LoginView）中的get方法，dispatch函数中的handler(request, *args, **kwargs)表示执行LoginView类中的get方法，其执行结果就是dispatch的执行结果，也就是请求url对应view函数的执行结果，最后将结果返回给用户。
四、补充知识点
1、若类中有装饰器函数，那么当类加载的时候，装饰器函数就会执行，如下代码：
class Person(object):
@classmethod # 相当于 sleepping = classmethod(sleepping)
def sleepping(cls):
print("Jihong is sleepping")
print(sleepping) # 加载类时执行，结果<classmethod object at 0x000001F2C29C8198>
注意：类中直接print语句会执行打印输出结果，而函数只有调用时才会执行，如下：
def func(): print(‘hello world‘) # 函数func加载不会执行打印，只有调用即func()才会执行打印
2、__dict__方法
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def sing(self):
print(‘I am singing‘)
p1 = Person(‘alex‘, 18)
print(p1.__dict__) # {‘name‘: ‘alex‘, ‘age‘: 18}
print(Person.__dict__)
# {‘__module__‘: ‘__main__‘, ‘__init__‘: <function Person.__init__ at 0x0000021E1A46A8C8>,
‘sing‘: <function Person.sing at 0x0000021E1A46A950>,
‘__dict__‘: <attribute ‘__dict__‘ of ‘Person‘ objects>,
‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Person‘ objects>,
‘__doc__‘: None}
总结：
对象.__dict__ 返回对象的所有成员字典；
类.__dict__ 返回类的所有成员字典；
我们可以通过（对象.name）取出成员，字典没有这种取值方式，使用对象.name的本质是执行类中的__getitem__方法。
3、现在有如下两个需求：
# 需求一：计算add函数的执行时间（不重写add函数的前提下） def add(x, y): return x+y
# 解决方式：装饰器 def outer(func): def inner(*args, **kwargs): import time start_time = time.time() ret = func(*args, **kwargs) end_time = time.time() print(end_time - start_time) return inner @outer def add(x, y): return x+y
# 需求二：扩展类中函数的功能（在不重写Father类的前提下） class Father(object): def show(self): print(‘father show is excuted‘)
father = Father() father.show()
# 解决方式：重新写一个类，继承Father类，重写show(),super()调用 class Son(Father): def show(self): print(‘son show is excuted‘) super().show()
son = Son() son.show()
总结：
面向过程的方式对程序进行功能扩展
- 装饰器
面向对象的方式对程序功能进行扩展
- 类的继承
- 方法重写
- super()
4、老师博客：https://pizzali.github.io/
