django 之(一) --- DjangoRestFormwork

接口概念

　　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基金会的第一任主席。所以，他的这篇论文一经发表，就引起了广泛的关注。

理解Rest-Formwork

介绍：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用来删除资源

总结 ：

1. 每一个URI代表一种资源
2. 客户端和服务器之间，传递这种资源的某种表现层
3. 客户端通过四个HTTP动词，对服务端资源进行操作，实现”表现层状态转换“
4. 同一个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<bookid>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

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>BookList</title>
    <script type="text/javascript" src="/static/js/jquery.js"></script>
    <script type="text/javascript">
        $(function () {
           // $("button").click(function () {
                $.getJSON("/api/books/", function (data) {
                    console.log(data);
                    if (data['status'] === 200){
                        var $ul = $("ul");
                        var books = data['data'];
                        for(var i=0; i < books.length; i++){
                            var $li = $("<li></li>");
                            $li.html(books[i]['b_name']);
                            $li.appendTo($ul);
                        }
                    }
                })
          //  })
        })

    </script>
</head>

---

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/<int:uid>', UserView.as_view(), name='user'),
]

• views.py

# Create your views here.
from django.http import HttpResponse
from django.views import View

# 用FBV
def indexs(request):
    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/<int:uid>', 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': '注册失败'})

---

---

Django-Rest-Formwork

安装配置：

• 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类型就变成了<class 'rest_framework.request.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： 前端必须传递过来，但是序列化的时候会自动给出

补充：

• 新建的app包文件，需要调用models.py，生成迁移文件时，必须要将app包文件注册到settings.py文件中。
• 如果只是调用路由和视图函数文件，不需要models文件时，不注册新建的app包文件在settings.py也没关系