drf-day2——restful规范、序列化反序列化、基于django编写五个原生接口、drf介绍和快速使用、cbv源码分析

目录

• 一、restful规范（重要，不难）
  • 概念
  • 十个规范
• 二、序列化反序列化
• 三、基于django原生编写5个接口
• 四、drf介绍和快速使用
  • 概念
  • 安装
  • 代码
• 五、cbv源码分析
• 六、作业
  • 1、使用ajax提交到后台数据
  • 2、django原生5个接口
  • 3、新增图书，三种编码格式都能增加成功

一、restful规范（重要，不难）

概念

REST全称是Representational State Transfer，中文意思是表述（编者注：通常译为表征性状态转移）。 它首次出现在2000年Roy Fielding的博士论文中。

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

这种风格的理念认为后端开发任务就是提供数据的，对外提供的是数据资源的访问接口，所以在定义接口时，客户端访问的URL路径就表示这种要操作的数据资源。

事实上，我们可以使用任何一个框架都可以实现符合restful规范的API接口。

十个规范

   -1 数据的安全保障，通常使用https（http+ssl/tsl）协议
        -url链接一般都采用https协议进行传输
        -采用https协议，可以提高数据交互过程中的安全性

   -2 接口中带api标识
		-https://api.lqz.com/books（可以写在域名中）
        -https://www.lqz.com/api/books（也可以写在路由中）    咱们用这个

   -3 多版本共存，路径中带版本信息
		-https://api.lqz.com/v1/login
        -https://api.lqz.com/v2/login
		-https://www.lqz.com/api/v1/login
        -https://www.lqz.com/api/v2/login

   -4 数据即是资源，均使用名词，尽量不出现动词(最核心的)
		-接口一般都是用于完成前后台数据的交互，交互的数据我们称之为资源
    	-接口形式如下
            https://api.baidu.com/users
            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/books/1  - patch请求：修改主键为1的书（局部修改一条）
        'ps：patch用的不多，一般用put即可'
        https://api.baidu.com/books/1  - delete请求：删除主键为1的书（删除一条）

   -6 在请求地址中带过滤条件
    https://api.example.com/v1/zoos?limit=10：指定返回记录的数量
    https://api.example.com/v1/zoos?offset=10：指定返回记录的开始位置
    https://api.example.com/v1/zoos?page=2&per_page=100：指定第几页，以及每页的记录数
    https://api.example.com/v1/zoos?sortby=name&order=asc：指定返回结果按照哪个属性排序，以及排序顺序
    https://api.example.com/v1/zoos?animal_type_id=1：指定筛选条件

   -7 响应中状态码：两套
		-http响应状态码：1xx：请求正在处理，2xx：成功响应，3xx：重定向，4xx：客户端错误，5xx：服务端错误
    '常见的需要记住'
    	响应状态码2XX		200:常规请求		201:创建成功
	 	响应状态码3XX		301:永久重定向	302:暂时重定向
	 	响应状态码4XX		403:请求无权限	404:请求路径不存在	405:请求方法不存在
	 	响应状态码5XX		500:服务器异常
    		-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：99}，{name:红楼梦，price：99}]
        GET 单个对象：返回单个资源对象：{name:红楼梦，price：99}
        POST 新增对象：返回新生成的资源对象：{name:西游记，price：99}
        PUT 修改对象：返回完整的资源对象 ：{name:西游记，price：100}
        DELETE 删除：返回一个空文档 

    -10 响应数据中带连接
    		# Hypermedia API，RESTful API最好做到Hypermedia，即返回结果中提供链接，连向其他API方法，使得用户不查文档，也知道下一步应该做什么
		{
		  	"status": 0,
		  	"msg": "ok",
		  	"results":[
		        {
		            "name":"肯德基(罗餐厅)",
		            "img": "https://image.baidu.com/kfc/001.png"
		        }
		      	...
				]
		}

	比较好的接口返回
		# 响应数据要有状态码、状态信息以及数据本身
		{
		  	"status": 0,
		  	"msg": "ok",
		  	"results":[
		        {
		            "name":"肯德基(罗餐厅)",
		            "location":{
		                "lat":31.415354,
		                "lng":121.357339
		            },
		            "address":"月罗路2380号",
		            "province":"上海市",
		            "city":"上海市",
		            "area":"宝山区",
		            "street_id":"339ed41ae1d6dc320a5cb37c",
		            "telephone":"(021)56761006",
		            "detail":1,
		            "uid":"339ed41ae1d6dc320a5cb37c"
		        }
		      	...
				]
		}

二、序列化反序列化

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

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

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

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

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

三、基于django原生编写5个接口

# 以后写的接口，基本上都是5个接口及其变形
	-查询所有
    -查询单个
    -新增一个
    -修改一个
    -删除一个

# 基于books单表为例，写5个接口
	-创建book表
    -表迁移
    -录入假数据：直接录，后台管理录
    -写查询所有接口---》遵循restful规范，使用cbv
    -新增一个数据---》
    -查询一个
    -修改一个：put提交的数据，不能从requets.POST中取
    -删除一个

models.py

from django.db import models

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

urls.py

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/v1/books/', views.BookView.as_view()),
    path('api/v1/books/<int:pk>', views.BookDetailView.as_view()),
]

views.py

from django.shortcuts import render, HttpResponse

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

import json

class BookView(View):
    # 查询所有
    def get(self, request):
        # 查询出所有图书,queryset对象，不能直接给前端
        books = Book.objects.all()
        # 转成json格式，给前端
        # 把queryset对象转成列表，然后再使用JsonResponse
        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)) # 指定ensure_ascii为false，前端就显示中文了
        return JsonResponse(book_list, safe=False, json_dumps_params={'ensure_ascii': False})  # JsonResponse只能放字典或列表

    # 新增一个(只能使用urlencoded或form-data编码，使用json形式编码不行，因为json格式编码提交的数据，不能从request.POST中取，从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})

class BookDetailView(View):
    # 获取单条
    def get(self, request, pk):
        book = Book.objects.filter(pk=pk).first()
        # book 模型对象转成字典，使用JsonResponse返回
        return JsonResponse({'id': book.id, 'name': book.name, 'price': book.price, 'publish': book.publish})

    def put(self, request, pk):  # request.POST只能取post提交的urlencoded或form-data编码数据，put提交的取不到
        # 查到要改的
        book = Book.objects.filter(pk=pk).first()
        # 取出前端传入的数据，修改完，保存-----》存在问题，因为put提交的取不到
        # book.name = request.POST.get('name')
        # book.price = request.POST.get('price')
        # book.publish = request.POST.get('publish')
        # book.save()

        # 前端使用json格式提交，自己保存
        print(request.body)
        book_dic=json.loads(request.body)
        book.name = book_dic.get('name')
        book.price = book_dic.get('price')
        book.publish = book_dic.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={})

四、drf介绍和快速使用

概念

核心思想: 缩减编写api接口的代码

Django REST framework是一个建立在Django基础之上的Web 应用开发框架，可以快速的开发REST API接口应用。在REST framework中，提供了序列化器Serialzier的定义，可以帮助我们简化序列化与反序列化的过程，不仅如此，还提供丰富的类视图、扩展类、视图集来简化视图的编写工作。REST framework还提供了认证、权限、限流、过滤、分页、接口文档等功能支持。REST framework提供了一个API 的Web可视化界面来方便查看测试接口。

官方文档：https://www.django-rest-framework.org/

github: https://github.com/encode/django-rest-framework/tree/master

特点（了解一下）

• 提供了定义序列化器Serializer的方法，可以快速根据 Django ORM 或者其它库自动序列化/反序列化；
• 提供了丰富的类视图、Mixin扩展类，简化视图的编写；
• 丰富的定制层级：函数视图、类视图、视图集合到自动生成 API，满足各种需要；
• 多种身份认证和权限认证方式的支持；[jwt]
• 内置了限流系统；
• 直观的 API web 界面；
• 可扩展性，插件丰富

安装

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

# django 最新 4.x ，一般都会用最新版的上一版3.x
# drf最新支持到djagno 3.x ，最新不支持2.x
# 安装drf
	pip3 install djangorestframework -i http://pypi.douban.com/simple/ --trusted-host pypi.douban.com/simple/
    # 由于你是django2.x 它发现它不支持，它会自动写在dajgno，安装最新的django 4.x

代码

ps:url的末尾必须要写斜杠符号，不然会报错

# 使用drf编写5个接口（听个响）

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

# serializer
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

		'''
		获取所有图书：Get 	http://127.0.0.1:8000/books/
		获取单个图书：Get 	http://127.0.0.1:8000/books/1/	加上ID号
		新增数据：	POST	http://127.0.0.1:8000/books/	Body内写入数据
		删除数据：	DeLETE	http://127.0.0.1:8000/books/1/	加上ID号
		修改数据：	PUT		http://127.0.0.1:8000/books/2/?name=你问我为什么&price=999&publish=在家出版社

		就是这么简单快速 五个接口就立马写好了 这是DRF的速度
		'''

五、cbv源码分析

# 1 路由中写的：path('api/v1/books/', views.BookView.as_view())，第二个参数无论是fbv还是cbv放的都是函数内存地址
	-当请求来了，匹配成功会执行，views.BookView.as_view()(request)
    -views.BookView.as_view()执行结果是View的类方法as_view返回的结果是内层函数view，是个函数内层地址
    -本身请求来了，匹配成功，会执行view(request)
    def view(request, *args, **kwargs):
        return self.dispatch(request, *args, **kwargs)

    -self.dispatch  View类的方法
   	def dispatch(self, request, *args, **kwargs):
        # request.method请求方式转成小写，必须在列表中才能往下走
        if request.method.lower() in self.http_method_names:
            # 反射，去self【视图类的对象：BookView】，去通过get字符串，反射出属性或方法
            # BookView的get方法
            handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
        else:
            handler = self.http_method_not_allowed
        # BookView的get方法，加括号，传入request
        return handler(request, *args, **kwargs)

话多一点的版本可以看这里：https://www.cnblogs.com/zhihuanzzh/p/16979250.html

六、作业

1、使用ajax提交到后台数据

    ajax    urlencoded
            form-data
            json
   django   request.body

这里我们在用ajax提交数据的时候json格式不能用request.POST获取，需要用request.body获取

urls.py

from django.contrib import admin
from django.urls import path
from app01 import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('home/', views.Home_fucn),
    path('home_post/', views.Home_func_post),
]

views.py

from django.shortcuts import render
from django.views import View
from django.http import JsonResponse
# Create your views here.
def Home_func_post(request):
    print('成功了')
    print('request.POST:', request.POST)
    print('request.body:', request.body)
    return JsonResponse({})

def Home_fucn(request):
    return render(request,'homePage.html')

homePage.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    {% load static %}
    <script src="{% static 'jquery-3.6.1.js' %}"></script>
    <link rel="stylesheet" href="{% static 'bootstrap-3.4.1-dist/css/bootstrap.css' %}">
    <script src="{% static 'bootstrap-3.4.1-dist/js/bootstrap.js' %}"></script>

</head>
<body>
<button id="subBtn">点击发送json数据</button>
<script>
    $('#subBtn').click(function () {
        $.ajax({
            url:'/home_post/',
            type:'post',
            data:JSON.stringify({'name':'zzh','age':'22'}),
            contentType:'application/json',
            success:function (args) {
                alert(args)
            }
        })
    })
</script>

</body>
</html>

结果

2、django原生5个接口

settings中的配置什么的就不说了，csrf那里需要注释掉。

1.models.py

模型层创建表，并执行数据库迁移

from django.db import models

# Create your models here.
class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.CharField(max_length=32)
    publish = models.CharField(max_length=32)

2.urls.py

添加路由，我们可以根据情况分析路由的写法，在查找所有的记录和增加记录的时候并不需要用到书籍信息的主键，但是在删改和查询一条记录中我们需要用到书籍的主键，因此我们把他们分成两条路由放在两个视图类中编写

from django.contrib import admin
from django.urls import path
from app01 import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('books/', views.Books_func.as_view()),
    path('books/<int:pk>/', views.Books_detail_view.as_view()),
]

3.views.py

编写五个接口的功能

import json

from django.shortcuts import render
from .models import Book
from django.views import View
from django.http import JsonResponse

# Create your views here.
class Books_func(View):
    # 查询所有
    def get(self, request):
        books = Book.objects.all()
        # 这里是换成了列表生成式
        # book_list = []
        # for book in books:
        #     book_list.append({'name': book.name, 'price': book.price, 'publish': book.publish})
        book_list = [{'name':book.name,'price':book.price,'publish':book.publish} for book in books]
        return JsonResponse(book_list, safe=False, json_dumps_params={'ensure_ascii': False})

    # 新增一个
    def post(self, request):

        # print(request.body)
        name = request.POST.get('name')
        # print(name)
        price = request.POST.get('price')
        # print(price)
        publish = request.POST.get('publish')
        # print(publish)

        if name == price == publish == None:
            book_dict = json.loads(request.body)
            name = book_dict.get('name')
            price = book_dict.get('price')
            publish = book_dict.get('publish')

        book = Book.objects.create(name=name, price=price, publish=publish)

        return JsonResponse({'name': book.name, 'price': book.price, 'publish': book.publish})

class Books_detail_view(View):
    # 获取单条数据
    def get(self, request, pk):
        book = Book.objects.filter(pk=pk).first()

        return JsonResponse({'id': book.id, 'name': book.name, 'price': book.price, 'publish': book.publish})
    # 修改一条记录
    def put(self, request, pk):
        book = Book.objects.filter(pk=pk).first()

        print(request.body)
        book_dic = json.loads(request.body)
        book.name = book_dic.get('name')
        book.price = book_dic.get('price')
        book.publish = book_dic.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={})

截图：

查询所有

添加（这里显示的是第三题的添加结果）

修改（第二条记录本来是红楼梦）

删除（这里是删除重复的那条记录）

查询一条记录

3、新增图书，三种编码格式都能增加成功

第三题写在第二题里面了，基本思路：

当用json格式传数据的时候数据存在与request.body中，因此这时候request.POST中获取到的信息都是空，当这些信息为空的时候用body中的数据进行替换，再创建记录到数据库中。