restful规范 序列化反序列化 基于Django原生编写5个接口 drf介绍及快速使用 cbv源码分析

目录

• restful规范
  • 概念
  • 10个规范
• 序列化和反序列化
  • 序列化：把我们识别的数据转换成指定的格式提供给别人 read
  • 反序列化：把别人提供的数据转换成/还原成我们需要的格式 write
• 基于Django原生编写5个接口
• drf介绍和快速使用
  • 使用drf编写5个接口
• cbv源码分析

restful规范

概念

REST全称是Representational State Tranesfer，中文意思是表述：表征性状态转移，它首次出现在2000年RoyFielding的博士论文中。

RESTful是一种定义Web API接口的设计风格，尤其适用于前后端分离的应用模式中

10个规范

1.数据的安全保障，通常使用https(http+ssl/tsl)协议

URL链接一般都采用https协议进行传输，采用回https协议，可以提高数据交互过程中的安全性

2.接口中带api标识

https://api.wyf.com/books
https:///www.wyf.com/api/books 这个我们较为常用

3.多版本共存，路径中带版本信息

https://api.wyf.com/v1/login
https://www.wyf.com/api/v2/login

4.数据即使资源，均使用名词，尽量不出现动词(最核心的)

接口一般都是完成前后端数据的交互，交互的数据我们称之为资源
接口形式如下：
	https://api.baidu.com/user
  https://api.baidu.com/books
特殊的接口可以出现动词，因为这些接口一般没有一个明确的资源，或是动词就是接口的核心含义
	https://api.baidu.com/login

5.资源操作有请求方式决定的(method)

操作资源一般都会设计到增删改查，我们提供请求方式来标识增删改查动作
	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/book/1	delete请求：删除主键为1的书

6.在请求地址中带过滤条件

https://api.baidu.com/books?name=西游记&price=99

7.响应中状态码：两套

http响应状态码：
  1xx：请求正在处理
  2xx：成功响应
  3xx：重定向
  4xx：客户端错误
  5xx：服务端错误
  https://blog.csdn.net/li_chunlong/article/details/120787872
公司内部规定的响应状态码，放在响应体中
	{code:0} 后期咱们一般使用100 101 102这种

8.返回数据中带错误信息

{
  code:0
  msg: "ok/用户名错误"
}

9.返回的结应该符合以下规范，但好多公司都不遵循

GET 获取所有的数据：返回资源对象的列表(数组):[{name:红楼梦, price: 99} ,{name:西游记, price:88}, {name:西游记, price:66}]
GET 单个对象：返回单个资源对象:{name: 西游记, price: 89}
POST 新增对象：返回新生成的资源对象：{name:西游记, price:89}
PUT 修改对象：返回完整的资源对象：{name:西游记, price: 100}
DELETE 删除：返回一个空文档

10.响应数据中带链接

序列化和反序列化

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

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

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

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

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

基于Django原生编写5个接口

以后写的接口，基本上都是5个接口及其变形
	查询所有
  查询单个
  新增一个
  修改一个
  删除一个
基于books单表为例，写5个接口
	创建book表
  class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.CharField(max_length=32)
    publish = models.CharField(max_length=32)
  	表迁移
    录入假数据：可以直接录或者后台管理
   
# view中 使用cbv
	  1.查询所有
    2.新增一个数据
    3.查询一个
    4.修改一个：put提交的数据，不能从request.POST中取
    5.删除一个
from .models import Book
from django.views import View
import json
from django.http import JsonResponse


class BookView(View):
    # 查询所有数据
    def get(self, request):
        books = Book.objects.filter()
        book_list = []
        for book in books:
            book_list.append({'name': book.name, 'price': book.price, 'publish': book.publish})
        # return HttpResponse(json.dumps(book_list, ensure_ascii=False))
        return JsonResponse(book_list, safe=False, json_dumps_params={'ensure_ascii': False})

    # 新增一个 这里编码不能使用json格式编码 得使用urlencoded或者form_data格式编码 因为json格式的编码 在取值时从request.POST.get是取不到值的 是none，得从body中取值
    def post(self, request):
        name = request.POST.get('name')
        price = request.POST.get('price')
        publish = request.POST.get('publish')
        book = Book.objects.create(name=name, price=price, publish=publish)
        return JsonResponse({'name': book.name, 'price': book.price, 'publish': book.publish}, safe=False,
                            json_dumps_params={'ensure_ascii': False})


class BookDetail(View):
    # 查询单条数据
    def get(self, request, pk):
        obj = Book.objects.filter(pk=pk).first()
        return JsonResponse({'id': obj.id, 'name': obj.name, 'price': obj.price, 'publish': obj.publish})

    # 修改数据 这里用的put 而在reqeust.POST只能是在urlencoded与form-data编码格式获取到数据 所以得从body中获取数据
    def put(self, request, pk):
        book = Book.objects.filter(pk=pk).first()
        book_dict = json.loads(request.body)
        book.name = book_dict.get('name')
        book.price = book_dict.get('price')
        book.publish = book_dict.get('publish')
        book.save()
        return JsonResponse({'id': book.id, 'name': book.name, 'price': book.price, 'publish': book.publish})
		# 删除数据
    def delete(self, request, pk):
        Book.objects.filter(pk=pk).delete()
        return JsonResponse(data={})
      
# url中  --->>遵循restful规范 
    path('api/v1/books/', views.BookView.as_view()),
    path('api/v1/books/<int:pk>/', views.BookDetail.as_view()),
    

put请求方式form-data携带参数

urlencode携带

raw源方式为json格式字符串

drf介绍和快速使用

# djangorestframework: 简称drf 帮助我们快速的实现符合restful规范的接口

# Django 最新 4.x 一般都会用最新版的上一版3.x
# drf最新支持到Django 3.x，最新不支持2.x
安装drf
pip3.8 install djangorestframework -i https://pypi.tuna.tsinghua.edu.cn/simple/
  # 由于你是Django2.x 它发现它不支持，它会自动下载Django，安装最新的Django 4.x(可以手动将最新的Django4.x卸载 再下载Django 2.2.2)

使用drf编写5个接口

views中

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

创建serializer.py

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

urls中

from rest_framework.routers import SimpleRouter
router = SimpleRouter()
router.register('books', views.BookView, 'books')

urlpatterns = [
    path('admin/', admin.site.urls),
]
# 两个列表相加  [1,2,4] +  [6,7,8]=
urlpatterns += router.urls

settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app01.apps.App01Config',
    'rest_framework'   #别忘了注册rest——framework   app
]

cbv源码分析

以后写的cbv,都是基于类的视图

cbv写好后，路由配置如下
path('api/v1/books/',views.BookView.as_view())

	第一个参数是路径，第二个参数是视图函数的内存地址(视图执行as_view这个类方法，把它执行完，结果放在第二个参数上：我们猜测执行完的结果是个函数内存地址,无论是cbv还是fbv放的都是函数的内存地址)
  去找as_view,去BookView类中找，找不到，没有，去父类View中
          @classonlymethod
        def as_view(cls, **initkwargs):
            def view(request, *args, **kwargs):
                return self.dispatch(request, *args, **kwargs)
            return view
	当请求来了，路由匹配成功，会执行view(request)--->>本质执行self.dispatch(request,*args,**kwargs)
  去View中找到了dispatch
		 def dispatch(self, request, *args, **kwargs):
            # 请求方式转成小写，假设 get 请求，符合if条件
            if request.method.lower() in self.http_method_names:
                # 反射 getattr(对象,'字符串','默认值')
                # self是BookView的对象
                # handler 就是BookView类的get方法
                handler = getattr(self, 'get', self.http_method_not_allowed)
            else:
                handler = self.http_method_not_allowed
                # BookView的get方法，加括号，传入request
            return handler(request, *args, **kwargs)  # get(request)

1. cbv路由写法：
path('test/', views.BookView.as_view())
2. path的第二个参数实际是函数内存地址
3. as_view()执行完，实际是闭包函数view的内存地址
4. 当请求来了，路由匹配成功，会执行view(request)，传入当次请求的request对象
5. view函数的返回值：return self.dispatch(request, *args, **kwargs)
6. View类中找dispatch
7. 如果是get请求就会执行视图类中的get方法，如果是post请求，就会执行视图类的post方法


# as_view 类的绑定方法--->View类的方法-->@classonlymethod
# dispatch核心代码--->getattr反射--->从当前对象(视图类的对象)--->如果是get请求-->会拿到get方法--->handler就是get方法--->handler(request)本质就是--->get(request)
handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
return handler(request, *args, **kwargs)

# 通过描述符自己写装饰器来装饰类---》完成类似于property，classmethod。