DRF之入门规范

在开发Web应用中，有两种应用模式

1.1前后端不分离

1.2 前后端分离

目前主流网站都是这种模式 比如：web，桌面应用，移动端app，ios，小程序都可以使用同一套后端

二 API接口

api接口是什么

为了在团队内部形成共识，防止个人习惯差异引起的混乱，我们需要找到一种大家都觉得很好的接口实现规范，而其这种规范能够让后端写的接口，用途一目了然，减少双方之间合作的成本，api接口规定了前后台信息交互的url链接，也就是前后端信息交互的媒介，

比如 127.0.0.1:8080/login/

api接口需要有的东西

1.url：url链接

2.请求方式：get,post,put等请求方式

3.请求参数：json或xml格式的key-value类型的数据

4.相应结果：json或xml格式的数据

三 接口测试工具-Postman

postman是一个能够模拟发送请求发送http请求的软件

Postman可以直接从官网：https://www.getpostman.com/downloads/下载获得，然后进行傻瓜式安装。

四 RESTful API规范

restful是什么

REST全称是Representational State Transfer，表征性状态转移，Web API接口的设计风格，尤其适用于前后端分离的应用模式中

RESTful API规范有哪些

1.数据的安全保障：url链接一般都采用https协议进行传输

https是：http+ssl 安全的超文本传输协议

2.接口特征表现：在API地址中带接口标识，咱们一般放在地址栏中(放在域名中)

 https://api.baidu.com
 https://www.baidu.com/api

3.多版本共存：在url链接中带版本标识

https://api.weibo.com/2/
https://api.weibo.com/v2/
https://api.weibo.com/?version=2
https://api.weibo.com/v1/login  --->需要的参数name和pwd
https://api.weibo.com/v2/login --->需要的参数name和pwd和code

4.数据即是资源，均使用名词（可复数）：前后端交互的数据我们称之为资源

接口一般都是完成前后台数据的交互，交互的数据我们称之为资源

https://127.0.0.1/api/v1/users

5.资源操作由请求方式决定（method）   

获取资源用get，新增资源用post，修改资源用put，删除资源用delete

    https://api.baidu.com/books      - get请求：获取所有书
    https://api.baidu.com/books/1    - get请求：获取主键为1的书
    https://api.baidu.com/books      - post请求：新增一本书书
    https://api.baidu.com/books/1    - put请求：整体修改主键为1的书
    https://api.baidu.com/books/1    - patch请求：局部修改主键为1的书
    https://api.baidu.com/books/1    -delete请求：删除主键为1的书

6.url中带搜索或过滤条件

https://api.example.com/v1/zoos?name=猴子 get请求

7.响应状态码

http响应状态码：1xx，2xx，3xx，4xx，5xx

自己的状态码（用的多）： 100成功，看公司自己

8.返回中带错误信息

	{code:100,msg:成功}
    "Message": "send success",

9.返回结果，符合以下规范

	GET /collection：返回资源对象的列表（数组）       [{name:xx,age:19},{name:xx,age:19},{}]
    GET /collection/resource：返回单个资源对象        {name:xx,age:19}
    POST /collection：返回新生成的资源对象             {name:yy,age:19}
    PUT /collection/resource：返回完整的资源对象       {name:xx,age:20}
    PATCH /collection/resource：返回完整的资源对象     {name:xx,age:20}
    DELETE /collection/resource：返回一个空文档   

10 返回数据中带url链接

      "url": "http://blog.sina.com.cn/zaku"

五 序列化和反序列化

api接口开发，最核心最常见的一个过程就是序列化，所谓序列化就是把数据转换格式，序列化可以分两个阶段：

序列化： 把我们识别的数据转换成指定的格式提供给别人。

例如：我们在django中获取到的数据默认是模型对象，但是模型对象数据无法直接提供给前端或别的平台使用，所以我们需要把数据进行序列化，变成字符串或者json数据，提供给别人。

反序列化：把别人提供的数据转换/还原成我们需要的格式。

例如：前端js提供过来的json数据，对于python而言就是字符串，我们需要进行反序列化换成模型类对象，这样我们才能把数据保存到数据库中。

六 Django REST framework快速使用

有个book表单，我们对这个表进行增删改查，我们来用原生django来实现

6.1使用原生django实现五个接口

模型类

class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.IntegerField()

路由

path('books/', views.BookView.as_view()),
path('books/', views.BookDetailView.as_view()),

视图类

from django.views import View
from .models import Book
from django.http import JsonResponse
import json


class BookView(View):
    def get(self, request):
        # 获取所有图书
        book_list = Book.objects.all()

        # Object of type QuerySet is not JSON serializable  Queryset对象不允许用json序列化
        # json能序列化什么数据类型？
        '''
         +---------------+-------------------+
        | JSON          | Python            |
        +===============+===================+
        | object        | dict              |
        +---------------+-------------------+
        | array         | list              |
        +---------------+-------------------+
        | string        | str               |
        +---------------+-------------------+
        | number (int)  | int               |
        +---------------+-------------------+
        | number (real) | float             |
        +---------------+-------------------+
        | true          | True              |
        +---------------+-------------------+
        | false         | False             |
        +---------------+-------------------+
        | null          | None              |
        +---------------+-------------------+
        '''
        # 把qs [对象1，对象2]  对象转成  [{}，{}]
        l = []
        for book in book_list:
            l.append({'name': book.name, 'price': book.price})
        return JsonResponse({'code': 100, 'msg': '查询成功', 'results': l})

    def post(self, request):
        # 前端编码格式：urlencoded，json（规定）
        data = json.loads(request.body)  # 反序列化   # request.body bytes格式，json格式的 不是字符串
        # 在 Book表中插入一条记录
        book = Book.objects.create(**data)
        return JsonResponse({'code': 100, 'msg': '新增成功', 'results': {'name': book.name, 'price': book.price}})


修改一条  查询一条   删除一条 路由跟上面不一样，单独再写在一个视图类中

class BookDetailView(View):
    def get(self, request, pk):
        pass

    def delete(self, request, pk):
        pass

    def put(self, request, pk):
        pass

6.2使用drf实现五个接口

路由

from rest_framework.routers import SimpleRouter
router = SimpleRouter()
router.register('books', views.BookView, 'books')
urlpatterns = [
]
urlpatterns += router.urls

视图类

from .models import Book
from .serializer import BookSerializer
from rest_framework.viewsets import ModelViewSet
class BookView(ModelViewSet):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

序列化类

from rest_framework import serializers
from .models import Book
class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = '__all__'

七 CBV源码分析

#1 请求来了---》执行 ---》views.BookView.as_view()(request)--->执行View类中as_view类方法中得 闭包函数 view
@classonlymethod
def as_view(cls, **initkwargs):
     def view(request, *args, **kwargs):
        self = cls(**initkwargs) # BookView类实例化得到对象
        self.dispatch(request, *args, **kwargs) # BookView类的dispatch
        
# 2 BookView类的dispatch没有---》View的dispatch
	# 根据请求方式，通过反射去视图类中【BookView】反射出跟请求方式同名的方法，执行
    def dispatch(self, 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
        return handler(request, *args, **kwargs)
    
    
    
# 3 以什么请求方式访问---》就会执行视图类中 跟请求方式同名的方法
	比如：http://127.0.0.1:8000/books/  get请求
    执行BookView类中get方法

八 APIView执行流程源码分析

以后使用drf写符合restful规范的接口---》都继承 APIView

# 1 在路由中：path('books/', views.BookView.as_view()),请求来了
# 2 先看 as_view()---->APIView的 as_view---》as_view执行结果跟之前一样，去除了csrf认证
    @classmethod
    def as_view(cls, **initkwargs):
        view = super().as_view(**initkwargs) # 调用父类的 as_view，view还是View的as_view
        # 以后所有请求，都不会做csrf认证了
        return csrf_exempt(view)
    
# 3 请求来了执行 views.BookView.as_view()(request)--->view(request)--->csrf_exempt(view)(request)--->内部核心---》return self.dispatch(request)
# 4 self 是 APIView类的对象---》APIView没有dispatch---》APIView的dispatch，核心代码如下
    def dispatch(self, request, *args, **kwargs):
        # 后续的request都是 initialize_request 返回结果--》新的request--》drf的Requet类的对象
        request = self.initialize_request(request, *args, **kwargs)
        # 新的request放到了 self.request中---》self是BookView类的对象
        # 后续视图类的方法中 可以直接 self.request取出 当次请求的request对象
        self.request = request

        try:
            # 执行了三大认证：
            '''
            self.perform_authentication(request)
            self.check_permissions(request)
            self.check_throttles(request)
            '''
            self.initial(request, *args, **kwargs)

            ###### 通过反射，去视图类中：BookView中执行跟请求方式同名的方法
            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
		   # request是新的Request类的对象了  get方法的第一个参数request也是新的
            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
    
    
# 5 看self.initialize_request 是APIView的
    def initialize_request(self, request, *args, **kwargs):
        # 类实例化得到对象，传入一些参数
        # Request类--》drf提供的类
        from rest_framework.request import Request
        return Request(
            request,
            parsers=self.get_parsers(),
            authenticators=self.get_authenticators(),
            negotiator=self.get_content_negotiator(),
            parser_context=parser_context
        )
    

# 只要继承APIView，以后方法中得request都变了，成了 rest_framework.request.Request 的对象了
	但是用起来，跟之前的一模一样
# 原来的是：django.core.handlers.wsgi.WSGIRequest 类的对象

总结：
    1 以后视图类方法中得request对象，变成了新的request，它是rest_framework.request.Request 的对象了，但是用起来跟之前一样
    2 把新的request对象，同时放到了 视图类的对象中  self.request = request  后续从视图类中可以直接通过 self.request取出来
    3 在执行视图类的方法之前，执行了三大认证
    4 如果三大认证或视图类的方法执行出错，会有全局异常处理
    5 以后所有的接口都去除了csrf认证

九 Request对象分析

# 分析APIVIew时，分析出，以后request都是新的request了，是drf提供的Request的对象
	from rest_framework.request import Request
    
    
# 源码解析之 __init__--->老的request在新的内部---》request._request：
	-先看 __init__--->类实例化得到对象时，对对象进行初始化，往对象中放数据
    def __init__(self, request, parsers=None, authenticators=None,negotiator=None, parser_context=None):
        # 传入的request是老的，django原生的request
        # 放到了self._request,self 是新的request类的对象
        self._request = request
        self._data = Empty
        self._files = Empty
    -什么时候调用的 __init__？
    	新的                                老的
    	-request = self.initialize_request(request, *args, **kwargs)
        				  老的
        	return Request(request)
        
        
# 以后用新的跟用老的一样,为什么？
	新的  requet.method
    新的   request.path
# 魔法方法：
	在类内部，以 __开头  __结尾的方法， 在某种情况下会自动调用，他们称之为魔法方法
    学过：__init__:  类名() 自动触发
          __str__:   print(对象)  自动触发
        
    还有哪些？ 很多---》所有类都继承object类---》它都在object类中
    # 今天要学的 __getattr__ 
    	-对象.属性 ，属性不存在会触发
        
# 回头看  新的 requet.method用的时候，如果method不存在就会触发 Request类的 __getattr__
# 源码解析之 __getattr__
	-逻辑肯定是：从老的request中取出，你想要的东西
    
    def __getattr__(self, attr):
        try:
            # 通过反射，去老的中取，能取到就返回，取不到，执行except代码，再取不到就报错
            return getattr(self._request, attr)
        except AttributeError:
            return self.__getattribute__(attr)
        
        
        
# 以后新的request中多了个属性 data---》前端post，put提交的请求体中得数据，都会放在request.data中，无论何种编码格式，它都是字典

总结：
    - 1 原生django--》post--》提交数据，只能处理urlencoded和form-data编码，从request.POST中取
    - 2 原生djagno--》put--》提交数据，处理不了，需要我们自己从body中取出来处理---》分不同编码格式：
            urlencoded ---》name=lqz&age=19-->字符串切割
            json----》{"xxz":"xx","yyz":"yyy"}---》json.loads
            
   -3 原生django不能处理json提交的数据，需要自己做（put，post）
         json----》body中：{"xxz":"xx","yyz":"yyy"}---》json.loads
    
   -4 新的request解决了所有问题
        request.data