DRF初识

接口是连接两个物质的媒介介质。

web程序中：接口是联系前端页面与后端数据库的媒介
web接口组成部分：
    url ： 长得像返回数据的链接
    请求参数:前端按照指定的key提供数据给后台
    响应数据：后台与数据库交互后将数据返回前台

接口规范：就是为了采用不同的后台语言，也能使用接口获取数据。
两大部分
url
1) 用api关键字标识接口url
    api.baidu.com | www.baidu.com/api
    
2) 接口数据安全性决定优先选择https协议

3) 如果一个接口有多版本存在，需要在url中标识体现
    api.baidu.com/v1/... | api.baidu.com/v2/...
    
4) 接口操作的数据源称之为 资源，在url中一般采用资源复数形式，一个接口可以概括对该资源的多种操作方式
    api.baidu.com/books | api.baidu.com/books/(pk)
    
5) 请求方式有多种，用一个url处理如何保证不混乱 - 通过请求方式标识操作资源的方式
    /books        get            获取所有
    /books        post        增加一个(多个)
    /books/(pk)    delete        删除一个
    /books/(pk)    put            整体更新一个
    /books/(pk)    patch        局部更新一个

6) 资源往往涉及数据的各种操作方式 - 筛选、排序、限制
    api.baidu.com/books/?search=西&ordering=-price&limit=3



响应数据
1) http请求的响应会有响应状态码，接口用来返回操作的资源数据，可以拥有 操作数据结果的 状态码
    status  0(操作资源成功)  1(操作资源失败)  2(操作资源成功，但没匹配结果)
    注：资源状态码不像http状态码，一般都是后台与前台或是客户约定的
    
2) 资源的状态码文字提示
    status  ok    ‘账号有误‘  ‘密码有误‘  ‘用户锁定‘
    
3) 资源本身
    results
    注：删除资源成功不做任何数据返回(返回空字符串)
    
4) 不能直接放回的资源(子资源、图片、视频等资源)，返回该资源的url链接

from django.conf.urls import url, include
from django.contrib import admin


urlpatterns = [
    url(r‘^admin/‘, admin.site.urls),
    # 路由分发
    url(r‘^api/‘, include(‘api.urls‘))
]

from django.conf.urls import url

from . import views
urlpatterns = [
    url(r‘^books/‘, views.Book.as_view()),
    url(r‘^books/(?P<pk>.*)/$‘, views.Book.as_view()),
]

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=64)
    price = models.DecimalField(max_digits=5, decimal_places=2)

    class Meta:
        db_table = ‘old_boy_book‘
        verbose_name = ‘书籍‘
        verbose_name_plural = verbose_name

    def __str__(self):
        return ‘《%s》‘ % self.title

from django.contrib import admin

from . import models

admin.site.register(models.Book)

>: python manage.py makemigrations
>: python manage.py migrrate

>: python manage.py createsuperuser

from django.http import JsonResponse

from django.views import View
from . import models

六大基础接口：获取一个，获取所有，增加一个，删除一个，全局更新一个，局部更新一个



十大接口：群删，群增，整体改群改，局部改群改

class Book(View):
    def get(self, request, *args, **kwargs):
        pk = kwargs.get(‘pk‘)
        if not pk:  # 群查
            # 操作数据库
            book_obj_list = models.Book.objects.all()
            # 序列化过程
            book_list = []
            for obj in book_obj_list:
                dic = {}
                dic[‘title‘] = obj.title
                dic[‘price‘] = obj.price
                book_list.append(dic)
            # 响应数据
            return JsonResponse({
                ‘status‘: 0,
                ‘msg‘: ‘ok‘,
                ‘results‘: book_list
            }, json_dumps_params={‘ensure_ascii‘: False})
        else:  # 单查
            book_dic = models.Book.objects.filter(pk=pk).values(‘title‘, ‘price‘).first()
            if book_dic:
                return JsonResponse({
                    ‘status‘: 0,
                    ‘msg‘: ‘ok‘,
                    ‘results‘: book_dic
                }, json_dumps_params={‘ensure_ascii‘: False})
            return JsonResponse({
                ‘status‘: 2,
                ‘msg‘: ‘无结果‘,
            }, json_dumps_params={‘ensure_ascii‘: False})


    # postman可以完成不同方式的请求：get | post | put ...
    # postman发送数据包有三种方式：form-data | urlencoding | json
    # 原生django对urlencoding方式数据兼容最好
    def post(self, request, *args, **kwargs):
        # 前台通过urlencoding方式提交数据
        try:
            book_obj = models.Book.objects.create(**request.POST.dict())
            if book_obj:
                return JsonResponse({
                    ‘status‘: 0,
                    ‘msg‘: ‘ok‘,
                    ‘results‘: {‘title‘: book_obj.title, ‘price‘: book_obj.price}
                }, json_dumps_params={‘ensure_ascii‘: False})
        except:
            return JsonResponse({
                ‘status‘: 1,
                ‘msg‘: ‘参数有误‘,
            }, json_dumps_params={‘ensure_ascii‘: False})

        return JsonResponse({
            ‘status‘: 2,
            ‘msg‘: ‘新增失败‘,
        }, json_dumps_params={‘ensure_ascii‘: False})

>: pip3 install djangorestframework

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.request import Request
from rest_framework.serializers import Serializer
from rest_framework.settings import APISettings
from rest_framework.filters import SearchFilter
from rest_framework.pagination import PageNumberPagination
from rest_framework.authentication import TokenAuthentication
from rest_framework.permissions import IsAuthenticated
from rest_framework.throttling import SimpleRateThrottle

class Test(APIView):
    def get(self, request, *args, **kwargs):
        return Response(‘drf get ok‘)

1) 请求走的是APIView的as_view函数

2) 在APIView的as_view调用父类(django原生)的as_view，还禁用了 csrf 认证

3) 在父类的as_view中dispatch方法请求走的又是APIView的dispatch

4) 完成任务方法交给视图类的请求函数处理，得到请求的响应结果，返回给前台

# 二次封装得到def的request对象
request = self.initialize_request(request, *args, **kwargs) 点进去

# 在rest_framework.request.Request实例化方法中
self._request = request  将原生request作为新request的_request属性

# 在rest_framework.request.Request的__getattr__方法中
try:
    return getattr(self._request, attr)  # 访问属性完全兼容原生request
except AttributeError:
    return self.__getattribute__(attr)

drf对原生 rquest做了二次封装，request._request = 原生的request
原生的request对象和方法都可以被drf中的request对象直接访问或者兼容
所有的拼接数据都是放在query_params里面例如get，所有的数据包数据都是被解析到data中，如post。

class Test(APIView):
    def get(self, request, *args, **kwargs):
        # url拼接的参数
        print(request._request.GET)  # 二次封装方式
        print(request.GET) # 兼容
        print(request.query_params) # 拓展

        return Response(‘drf get ok‘)

    def post(self, request, *args, **kwargs):
        # 所有请求方式携带的数据包
        print(request._request.POST)  # 二次封装方式
        print(request.POST)  # 兼容
        print(request.data)  # 拓展，兼容性最强，三种数据方式都可以

        print(request.query_params)

        return Response(‘drf post ok‘)