django 之(一) --- DjangoRestFormwork

V2AS问路

django 之(一) --- DjangoRestFormwork

阅读原文时间：2023年07月10日阅读：3

IOP：面向接口编程，不再关注具体的实现；只关注输入、输出。

　　http://www.ruanyifeng.com/blog/2018/10/restful-api-best-practices.html

服务器返回数据类型：

　　网页数据html，为浏览器使用

　　Json数据，ajax javascript发请求的一种方式；也可以使用request的python请求方式

为移动端编写接口关注：

接口地址是什么：/xxx/yyy/zzz

　　接口需要什么参数：参数根据业务场景

　　返回什么格式的数据：大多数是json数据

RestfulAPI：

　一种软件架构风格、设计风格、而不是标准，只是提供了一组设计原则和约束条件。它主要用户客户端和服务器交互类的软件。

　　基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存机制等。REST全程是Representational State Transfer，表征性状态转移。

　　首次在2000年Roy Thomas Fielding的博士论文中出现，Fielding是一个非常重要的人，他是HTTP协议（1.0版和1.1版）的主要设计者，

　　Apache服务器软件的作者之一，Apache基金会的第一任主席。所以，他的这篇论文一经发表，就引起了广泛的关注。

**介绍：https://github.com/RockTeach/PythonCourse/blob/master/web/flask/restful.md**

　　要理解RESTful架构，最好的就是去理解它的单词 Representational State Transfer 到底是什么意思，它的每一个词到底要表达什么。

　　REST的释义，"(资源的)表现层状态转化"，其实这省略了主语。“表现层”其实指的是“资源(Resource)”的“表现层”。

状态码

　　服务器向用户返回的状态码和提示信息，常见的有以下一些地方

200：OK - [GET]：服务器成功返回用户请求的数据
201：CREATED -[POST/PUT/PATCH]：用户新建或修改数据成功
202：Accepted - [*] ：表示一个请求已经进入后台排队（异步任务）
204：NO CONTENT - [DELETE]：表示数据删除成功
400：INVALID REQUEST - [POST/PUT/PATCH]：用户发出的请求有错误
401：Unauthorized - [*] ：表示用户没有权限（令牌，用户名，密码错误）
403：Forbidden - [*]：表示用户得到授权，但是访问是被禁止的
404：NOT FOUND - [*]：用户发出的请求针对的是不存在的记录
406：Not Acceptable - [*]：用户请求格式不可得
410：Gone - [GET] ：用户请求的资源被永久移除，且不会再得到的
422：Unprocesable entity -[POST/PUT/PATCH]：当创建一个对象时，发生一个验证错误
500：INTERNAL SERVER EROR - [*] ：服务器内部发生错误

资源（Resource）

　　所谓“资源”，就是网络上的一个实体，或者说是网络上的一个具体信息。它可以是一段文本，一张图片，一首歌曲，一种服务，总之就是一个具体的实例。

　　你可以使用一个URI(统一资源定位符)指向它，每种资源对应一个特定的URI。要获取这个资源，访问它的URI就可以了，因此URI就成了每一个资源的地址或独一无二的识别符。

　　所谓“上网”就是与互联网上一系列的“资源”互动，调用它们的URI。

表现层（Representation）

　　“资源”是一种信息实体，它可以有多种外在表现形式。我们把“资源”具体呈现出来的形式，叫做它的”表现层“（Representation）。

　　URI只代表资源的实体，不代表它的形式。严格地说，有些网站最后的”.html“后缀名是不必要的，因为这个后缀表示格式，属于”表现层“范畴，而URI应该只代表”资源“的位置。

　　它的具体表现形式，应该在HTTP请求头的信息中使用Accept和Content-Type字段指定。

状态转换（State Transfer）

　　访问一个网站，就代表客户端和服务端的一个互动过程。在这个过程中，势必涉及到数据和状态的变化。

　　互联网通信协议HTTP协议，是一个无状态协议。这意味着，所有的状态都保存在服务端。

　　因此，如果客户端想要操作服务器，就必须通过某种手段，让服务器端发生”状态转换（State Transfer）“。

　　而这种转换是建立在表现层之上的，所以就是”表现层状态转化“。

　　客户端用到的手段，只能是HTTP协议。具体来说，就是HTTP协议中，四个表示操作方式的动词：GET，POST，PUT，DELETE。

　　它们分别对应四种基本操作：GET用来获取资源，POST用来新建资源（也可用于更新资源），PUT用来更新资源，DELETE用来删除资源

总结：

每一个URI代表一种资源
客户端和服务器之间，传递这种资源的某种表现层
客户端通过四个HTTP动词，对服务端资源进行操作，实现”表现层状态转换“
同一个url针对用户的不同的请求操作，表现出来的状态是不同的。表现出来的多种形式，就是表现层状态转换。

RESTful是软件架构设计思想。使用在CS，客户端和服务端这种架构模型中。
表现层状态转换
- 主语（资源）
- URI 每个URI代表一种资源
- 资源展现给我们的形式就叫做表现层
- 通过HTTP的请求谓词来实现表现层转换
重要概念
URI、HTTP请求谓词、JSON

注意：

　　postman/前端在向服务器提交json数据时，需要声明提交的类型。

　　在postman的请求的headers增加content-type：application/json。

　　flask 在确认请求数据是通过json提交后，会将json字符产转换成字典。保存在request.json中

　　函数视图：FBV(function base views)；　　类视图：CBV(class base views)

图示：

前后端统一开发

　　　　
前后端分离开发

FBV简单体验：由源码中的dispatch进行各请求分发

api/urls.py

from django.conf.urls import url
from API import views

urlpatterns = [
url(r'^books/$', views.books, name='books'),
url(r'^books/(?P\d+)/', views.book, name='book'),
]
api/models.py

from django.db import models

class Book(models.Model):
b_name = models.CharField(max_length=32)
b_price = models.FloatField(default=1)

def to_dict(self):
return {'id': self.id, 'b_name': self.b_name, 'b_price': self.b_price}
api/views.py [选中此文件，右键--> Refactor-->Convert To Python Package 将其变成一个包文件] [from .BookModel import Book 导入到在此包文件中的init.py文件]

from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from API.models import Book

@csrf_exempt # 进行csrf豁免
def books(request):
# get 获取书
if request.method == "GET":
book_list = Book.objects.all()
book_list_json = []
for book in book_list:
book_list_json.append(book.to_dict())
data = {
'status': 200,
'msg': 'ok',
'data': book_list_json
}
return JsonResponse(data=data)
# post 创建书
elif request.method == "POST":
b_name = request.POST.get('b_name')
b_price = request.POST.get('b_price')
book = Book()
book.b_name = b_name
book.b_price = b_price
book.save()
data = {
'status': 201,
'msg': 'add success',
'data': book.to_dict()
}
return JsonResponse(data=data, status=201)

注意：在pycahrm工具栏:Tools ---> HTTP Client ---> Test RESTful web server 进行模拟请求。亦可HTTPie和Postman

@csrf_exempt
def book(request, bookid):
# get 带参数获取某一本书
if request.method == "GET":
book_obj = Book.objects.get(pk=bookid)
data = {
'msg': 'ok',
'status': 200,
'data': book_obj.to_dict()
}
return JsonResponse(data=data)
# delete 带参数删除某一个书
elif request.method == "DELETE":
book_obj = Book.objects.get(pk=bookid)
book_obj.delete()
data = {
'msg': 'delete success',
'status': 204, # 前端看到的状态码
# 'data': {} 如果某个对象删除后没有数据了，有默认值就返回对应的数据类型格式，否则前端不知如何解析
}
return JsonResponse(data=data, # status=204) # status=204 设置真正的网络传输状态码204，舍弃响应体中的内容
books.html

BookList

CBV简单体验：由源码中的dispatch进行各请求分发

urls.py

from django.contrib import admin
from django.urls import path
from user.views import UserView, RegisterView

urlpatterns = [
path('admin/', admin.site.urls),
path('register/', RegisterView.as_view(), name='register'),
path('user/', UserView.as_view(), name='user'),
]

views.py

Create your views here.

from django.http import HttpResponse
from django.views import View

6 # 用FBV
7 def indexs(request):
8 return HttpResponse('基础流程')

用CRF: 实现登陆注册

class RegisterView(View):
# 用户登陆
def get(self, request):
pass
# 用户注册
def post(self, request):
pass

用CRF: get post put patch delete

class UserView(View):
# 请求get，获取信息
def get(self, request, uid):
pass
# 提交post，添加信息
def post(self, request, uid):
pass
# 修改put，全部修改
def put(self, request, uid):
pass
# 修改patch，差量修改
def patch(self, request, uid):
pass
# 删除delete，删除操作
def delete(self, request, uid):
pass

使用：

urls.py 只能接收已经存在的属性作为参数

from django.conf.urls import url
from CBV import views

urlpatterns = [
url(r'^hello/', views.HelloCBV.as_view(msg='Sleeping'), name='hello'),
　　　　**# as_view(msg)中的参数msg(变量名)，只能接收此路由对应的类视图中已经存在的属性作为参数
** ]
views.py

from django.http import HttpResponse
from django.views import View

class HelloCBV(View):

msg = None **# 类视图中只有设置了此msg属性，路由中as_view(msg)中的变量名msg才能接收到并生效(名字要对应好)
** def get(self, request):
return HttpResponse("hahaha %s" % self.msg)
def post(self, request):
return HttpResponse("POST 666")
def put(self, request):
return HttpResponse("PUT 666")

Api接口 CBV方式利用在模型中定义[对象转字典]的类方法来简单实现

urls.py

from django.contrib import admin
from django.urls import path
from user.views import UserView

urlpatterns = [
path('user/', UserView.as_view(), name='user'),
]

models.py

from django.db import models

class User(models.Model):
username = models.CharField(max_length=20, unique=True, verbose_name='用户名')
password = models.CharField(max_length=128, verbose_name='密码')

class Meta:
db_table = 'user'
verbose_name = '用户表'
verbose_name_plural = verbose_name

def __str__(self):
return self.username
def to_dict(self): # 在模型中定义类方法，实现模型对象的序列化，转为字典形式
return {'id': self.id, 'username': self.username, 'password': self.password}
views.py

from django.http import JsonResponse
from django.views import View
from user.models import User

class UserView(View):
def get(self, request, uid):
user = User.objects.get(pk=uid)
return JsonResponse({'status': 200, 'user': user.to_dict()})
　　　　　　 # 在模型中定义类方法，实现模型对象的序列化，转为字典形式

def post(self, request, uid):
username = request.POST.get('username')
password = request.POST.get('password')
repassword = request.POST.get('repassword')
if password == repassword:
user = User.objects.create(username=username, password=password)
if user:
return JsonResponse({'status': 200, 'msg': '注册成功'})
return JsonResponse({'status': 200, 'msg': '注册失败'})

安装配置****：

pip install djangorestframework 若使用序列化和类视图继承view或APIView，必须安装此行
添加：INSTALLED_APPS = ['user.apps.UserConfig', 'rest_framework', ]在settings.py文件中

初步体验：

urls.py 请求：某个http://127.0.0.1:8000/groups/2/ 或某组http://127.0.0.1:8000/groups

from django.conf.urls import url, include
from rest_framework.routers import DefaultRouter
from drf.views import UserViewSet, GroupViewSet

router做了路由注册

router = DefaultRouter()
router.register(r'users',UserViewSet)
router.register(r'groups',GroupViewSet)

urlpatterns = [
url(r'^',include(router.urls)),
]
drf/serializers.py

from django.contrib.auth.models import User, Group
from rest_framework import serializers

HyperlinkedModelSerializer 实现超链接

class UserSerializer(serializers.HyperlinkedModelSerializer):
class Meta:
model = User # 系统自带的user
fields = ('url', 'username', 'email', 'groups')

HyperlinkedModelSerializer 实现超链接

class GroupSerializer(serializers.HyperlinkedModelSerializer):
class Meta:
model = Group # 系统自带的group
fields = ('url', 'name')
drf/views.py

from django.contrib.auth.models import User, Group
from rest_framework import viewsets
from drf.serializers import UserSerializer, GroupSerializer

继承自：viewsets.ModelViewSet。对数据集合实现了：get、post

本身是一个CBV，也是一个视图集合。对单个集合实现了：get、post、delete、put、patch封装

class UserViewSet(viewsets.ModelViewSet):
queryset = User.objects.all()
serializer_class = UserSerializer

继承自：viewsets.ModelViewSet。对数据集合实现了：get、post

本身是一个CBV，也是一个视图集合。对单个集合实现了：get、post、delete、put、patch封装

class GroupViewSet(viewsets.ModelViewSet):
queryset = Group.objects.all()
serializer_class = GroupSerializer

　注意：一般不会用这种继承方式，不灵活

序列化器：

序列化：表示将对象转换成可以在IO[网络]中传输的格式如json
反序列化：将在IO[网络]中传输的格式[如json]转化为对象的形式。

基本使用1:

urls.py

from django.conf.urls import url, include

urlpatterns = [
url(r'^ser/', include('RestSerializers.urls')),
]
RestSerializers/urls.py

from django.conf.urls import url
from RestSerializers import views

urlpatterns = [
url(r'^persons/', views.PersonView.as_view()),
url(r'^students/', views.StudentView.as_view()),
url(r'^books/', views.books), # FBV
]
RestSerializers/models.py

from django.db import models

class Person(models.Model):
p_name = models.CharField(max_length=32)
p_age = models.IntegerField(default=1)
p_sex = models.BooleanField(default=False)

class Student(models.Model):
s_name = models.CharField(max_length=32)
s_age = models.IntegerField(default=1)
RestSerializers/serializers.py

from rest_framework import serializers
from RestSerializers.models import Person, Student, Book

serialization的子类

"""
模块serializers中
1。Serializer：手动原生序列化。有创建和更新两个功能
2。ModelSerializer：模型序列化。
3。HyperLinkedModelSerializer：带超链接的模型序列化工具
"""
class PersonSerializer(serializers.Serializer):
　　　　# 手动设置需要序列还的字段
id = serializers.IntegerField(read_only=True)
p_name = serializers.CharField(max_length=32)
p_age = serializers.IntegerField(default=1)
p_sex = serializers.BooleanField(default=False)

# 实现抽象方法，手动创建对象。validated_data验证过的数据
def create(self, validated_data):
return Person.objects.create(**validated_data)

# 实现抽象方法，手动更新对象。validated_data验证过的数据，instance实例
def update(self, instance, validated_data):
instance.p_name = validated_data.get('p_name', instance.p_name) # 没有获取到，给其原有值
instance.p_age = validated_data.get('p_age', instance.p_age)
instance.p_sex = validated_data.get('p_sex', instance.p_sex)
instance.save()
return instance

class StudentSerializer(serializers.ModelSerializer):
class Meta:
model = Student
fields = ('s_name', 's_age')
　　　　　　 # fields：包含什么字段；exclude：不包含什么字段
RestSerializers/views.py

from django.http import JsonResponse
from django.views import View
from rest_framework import status
from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework.views import APIView
from RestSerializers.models import Person, Student
from RestSerializers.serializers import PersonSerializer, StudentSerializer,

class PersonView(View):

def get(self, request):
persons = Person.objects.all()
# many=True 表示有多个需要序列化转化
person_serializer = PersonSerializer(persons, many=True)
return JsonResponse(person_serializer.data, safe=False)

def post(self, request):
p_name = request.POST.get("p_name")
p_age = request.POST.get("p_age")
person = Person()
person.p_name = p_name
person.p_age = p_age
person.save()
person_serializer = PersonSerializer(person)
return JsonResponse(person_serializer.data)

class StudentView(APIView):

def post(self, request):
s_name = request.POST.get('s_name')
s_age = request.POST.get('s_age')
student = Student()
student.s_name = s_name
student.s_age = s_age
student.save()
student_serializer = StudentSerializer(student)
# 只要类视图继承自APIView，request类型就变成了
print(type(request))
return JsonResponse(student_serializer.data)

基本使用2：

urls.py

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

urlpatterns = [
path('admin/', admin.site.urls),
path('oneuser/', views.UserViews.as_view(), name='user'),
path('twouser/', views.UserViewsSimple.as_view(), name='user'),
]
user/models.py

from django.db import models

class User(models.Model):
username = models.CharField(max_length=20, unique=True)
password = models.CharField(max_length=128)
phone = models.CharField(max_length=11)
add_time = models.DateTimeField(auto_now=True)

class Meta:
db_table = 'user' # 数据库中此模型的表名称

def __str__(self):
return self.username
user/serializers.py 在此文件内构件序列化类。继承自serializers.Serializer 和继承自serializers.ModelSerializer

from django.contrib.auth.hashers import make_password
from rest_framework import serializers
from user.models import User

UserSerializer class中的第一部分定义了有哪些字段需要被序列化/反序列化。

方法create()和方法update()部分定义了当调用serializer.save()方法时，serializer应该怎样构造实例

基础写法。建序列化类，继承自serializers.Serializer

class UserSerializer(serializers.Serializer):
id = serializers.IntegerField(read_only=True) # read_only=True 只读，不可修改
username = serializers.CharField(max_length=20, min_length=6, required=True) # required=True 必填项
password = serializers.CharField(max_length=128, required=True) # max_lenth = 128 最长是128
phone = serializers.CharField(max_length=11, min_length=11) # min_lenth = 11 最短是11

# -------------------------------------------------------------------------------------------------------#
# UserSerializerSimple继承自ModelSerializer；
# ModelSerializer继承自Serializer；ModelSerializer中重写了BaseSerializer父类中的create()方法
# Serializer继承自BaseSerializer。
# BaseSerializer有save()方法和create()方法。所以UserSerializerSimple就可以调用save()方法

# 简化写法。建序列化类，继承自serializers.ModelSerializer
class UserSerializerSimple(serializers.ModelSerializer):
# 新增需要验证的字段,且数据库中没有此字段。需要write_only=True表示只是在前端验证，不会进到模型中去
repassword = serializers.CharField(max_length=128, write_only=True)

 class Meta:  
     model = User  
     # fields = '\_\_all\_\_' 对所有字段进行校验  
     # exclude = ('id')   排除不想校验的字段  
     fields = \['id', 'username', 'password', 'phone','repassword'\]  # 需要序列化的字段有哪些

 # 重写父类方法 验证密码一致。重写父类中的validate进行全局验证。

　　　　# attrs是传递来的所有参数的字典形式。如果只验证一个参数,如验证密码长度可以直接把password当作参数
def validate(self, attrs):
if attrs['password'] != attrs['repassword']:
raise serializers.ValidationError('两次密码不相等')
return attrs

 # 重写父类方法 实现密码加密。重写父类中的create方法。validated\_data是  
 def create(self, validated\_data):  
     username = validated\_data\['username'\] # validated\_data父类中的  
     password = validated\_data\['password'\]  
     phone = validated\_data\['phone'\]  
     password = make\_password(password)  # 密码加密  
     user = User.objects.create(username=username, password=password, phone=phone)

     return user

user/views.py

from django.contrib.auth.hashers import make_password
from django.http import JsonResponse
from rest_framework.views import APIView
from user.models import User
from user.serializers import UserSerializer, UserSerializerSimple

基本实现序列化

class UserViews(APIView): # APIView是View的子类
# get请求
def get(self, request):
pass

# post请求用户注册。http://127.0.0.1:8000/oneuser/
def post(self, request):
username = request.POST.get('username')
password = request.POST.get('password')
phone = request.POST.get('phone')
```
 password = make\_password(password)  # 密码加密  
 # 1。创建并得到一个用户对象  
 user = User.objects.create(username=username, password=password, phone=phone)  
 # 2。放到UserSerializer类中得到一个用户序列化对象。  
 user\_serializer = UserSerializer(user)  
 # 3。将序列化的数据(json)返回出去。获取序列化中的数据的方法是：序列化类对象名.data(得到序列化之后的数据，打印是字典类型)  
 return JsonResponse({'status': 200, 'user': user\_serializer.data})
```

#----------------------------------------------------------------------------------------------------------------#
# 简化实现序列化
class UserViewsSimple(APIView): # APIView是View的子类
# get请求
def get(self, request):
pass
# post请求用户注册。http://127.0.0.1:8000/twouser/
def post(self, request):
# 1。将前端传递的数据送到Serializer中验证，获取序列化对象。只有在继承自APIView中的子类才可以使用request.data
user_serializer = UserSerializerSimple(data=request.data)
# 2。# 判断前端传来的数据时候是否符合models.py中定义的数据格式要求
if user_serializer.is_valid():
user_serializer.save()
return JsonResponse({'status': 200, 'user': user_serializer.data})
return JsonResponse({'status':400})

方法：

user_serializer.is_valid( )
* 序列化类对象.is_valid() ：此方法功能是判断传入的数据是否符合models中定义的数据格式要求
user_serializer.data
* 序列化类对象.data ：此方法功能是将序列化后的数据获取出来
user_serializer.save()
* 序列化类对象.save() : 此方法功能是将验证通过的数据存到数据库中
- user_serializer.save() 底层save()两个动作create,update
request.data
* request.data ：此方法功能是获取前端传递来的所有数据。只有类视图继承自APIView父类，才会有此方法
- data = JSONParser().parse(request)

注意：

ModelSerializer需要解决的两个问题：
- 某个字段不属于指定model，它是write_only，需要用户传进来，但我们不能对它进行save( )，因为ModelSerializer是基于Model，这个字段在Model中没有对应属性字段，这个时候我们需要重载validate！write_only与read_only对应。就是用户post过来的数据，后台服务器处理后不会再经过序列化后返回给客户端；最常见的就是我们在使用手机注册的验证码和填写的密码。required: 顾名思义，就是这个字段是否必填，例如要求：用户名，密码等是必须填写的；不填写就直接报错 allow_null/allow_blank：是否允许为NULL/空。  error_messages：出错时，信息提示。
* 某个字段属于指定model，它是read_only，read_only：True表示不允许用户自己上传，只能用于api的输出。如果某个字段设置了read_only=True，那么就不需要进行数据验证，只会在返回时，将这个字段序列化后返回，举个简单的例子：在用户进行购物的时候，用户post订单时，肯定会产生一个订单号，而这个订单号应该由后台逻辑完成，而不应该由用户post过来，如果不设置read_only=True，那么验证的时候就会报错。再例如，我们在网上购物时，支付时通常会产生支付状态，交易号，订单号，支付时间等字段，这些字段都应该设置为read_only=True，即这些字段都应该由后台产生然后返回给客户端；
- write_only：前端必须传递过来，但是序列化时不被序列化
- read_only：前端必须传递过来，但是序列化的时候会自动给出

补充：