resful规范

1.简介

什么是resful

resful是一个规范，说白了就是面向资源编程，把网络中所有的东西，想象成资源

2.规范

10条规范

1）API与用户的通信协议，总是用HTTPS协议：HTTPS比http安全

2）域名

https://api.example.com  尽量将API部署在专用域名（会存在跨域问题）https://example.org/api/  API很简单例如写一个查询所有图书的api接口:https://api.example.com/books                        https://127.0.0.1/api/books

3）版本

-版本:每个接口都应该有版本   URL，如：https://api.example.com/v1/    https://127.0.0.1/api/v2/books(推荐用这种)   请求头 跨域时，引发发送多次请求

4）路径

-路径，视网络上任何东西都是资源，均使用名词表示（可复数）   https://api.example.com/v1/books   https://api.example.com/v1/animals   https://api.example.com/v1/employees   不能这么写:      -获取所有图书:https://127.0.0.1/api/get_all_books      -新增一本书:https://127.0.0.1/api/add_book   同一都用这个:   https://api.example.com/v1/books

5）method

-method   GET      ：从服务器取出资源（一项或多项）   POST    ：在服务器新建一个资源   PUT      ：在服务器更新资源（客户端提供改变后的完整资源）   PATCH  ：在服务器更新资源（客户端提供改变的属性）   DELETE ：从服务器删除资源谈到请求方法，这里需要提到一下幂等性幂等性：就是用户对于同一操作发起的一次请求或者多次请求的结果是一致的，不会因为多次点击而产生了副作用。举个最简单的例子，那就是支付，用户购买商品使用支付，支付扣款成功，但是返回结果的时候网络异常，此时钱已经扣了，用户再次点击按钮，此时会进行第二次扣款，返回结果成功，用户查询余额发现多扣钱了，流水记录也变成了两条。这里简单介绍一下__getattr__:如果属性查找在实例以及对应的勒种失败，那么会调用到类的__getattr__函数，如果没有定义这个函数，那么会抛出异常。可以把__getattr__的作用理解为属性查找的最后一步，兜底。与__getattr__相对应的，还有个__setattr__,对象在属性赋值时，会执行这个函数

class Student:
    name = 'lqz'

    def __init__(self, age):
        self.age = age

    def __getattr__(self, item):
        return '你煞笔啊,没有这个属性'

    def __setattr__(self, key, value):
        print('setattr方法')
        self.__dict__[key] = value

    def __getitem__(self, item):
        print('getitem方法')
        return self.__dict__[item]

    def __setitem__(self, key, value):
        print('setitem方法')
        self.__dict__[key] = value

#setattr,赋值时会进行调用
#getattr,取不到对象的attr时会调用
#__getitem__ 对象A，取值A['name’]会调用
#__setitem__ 对象A设定值A['male’]会调用

A = Student(18)
A.num = '#调用__setattr__方法
print(A.num)
print(A['num'])#调用__getitem__方法
A['sex']='MALE'#调用__setitem__方法
print(A['sex'])
print(A.haha)#调用__getattr__方法

6）过滤

-过滤，通过在url上传参的形式传递搜索条件   https://api.example.com/v1/zoos?limit=10：指定返回记录的数量

7）状态码

请求回去,需要有状态码自定义状态码status: 100表示成功      101表示用户名密码错误      102我也不知道什么错误

8）错误处理

-错误处理，应返回错误信息，error当做key。   -{status:100,error:'错误信息写上'}

9）返回结果

-返回结果，针对不同操作，服务器向用户返回的结果应该符合以下规范。   GET /books：返回资源对象的列表（数组）   GET /books/1：返回单个资源对象   POST /books：返回新生成的资源对象    -新增,传数据,一旦新增完成,把新的资源对象返回   PUT /books/1：返回完整的资源对象   PATCH /books/1：返回完整的资源对象   DELETE /books/1：返回一个空文档

10）Hypermedia API,resful API最好做到Hypermedia，即返回结果中提供链接，连向其他API

-Hypermedia API，RESTful API最好做到Hypermedia，即返回结果中提供链接，连向其他API             方法，使得用户不查文档，也知道下一步应该做什么。      {         status:100         msg:成功         url:127.0.0.1/books/1      }   核心:返回结果中提供链接3.drf（django rest framework）框架（django的app）安装：djangorestframework它是一个app，要在咱的项目中用只是快速的构建resful规范的接口drf下request把原来的request包装进去了request.query_params这个是原来GET中的数据request.data是发方法，包装成了属性，前台传过来的body体重的数据，放在里面

from django.shortcuts import render,HttpResponse,redirect,reverse
from rest_framework.views import APIView
from app01 import models
from django.views import View
from django.http import JsonResponse

# Create your views here.

#写resful规范的接口，用fbv和cbv都可以

#这里使用rest_framework，是为了快速构建restful规范，即使不使用rest_framework,也是可以写的，只是麻烦一些

#不使用rest_framework版本
# class Books(View):
#     #获取所有图书
#     def get(self,request):
#         response={'status':100,'data':None}
#         books=models.Book.objects.all()
#         ll=[{'name':book.name,'price':book.price} for book in books]
#         response['data']=ll
#         return JsonResponse(response,safe=False)
#     def put(self,request,pk):
#         response={'status':100,'msg':'修改成功'}
#         #注意，django只处理了get和put，也就是只有这两个方法request.POST,request.GET能get到值
#         # name=request.POST.get('name')
#         # price=request.POST.get('price')
#         #这里无法get,所以直接去body体里去取
#
#         import json
#         data=json.loads(request.body.decode('utf-8'))
#         name=data.get('name')#相当于name=data['name'],不这么写只是我自己个人理解，防止万一没有值，程序崩溃
#         price=data.get('price')
#         ret=models.Book.objects.filter(pk=pk).update(name=name,price=price)
#         #按照resful规范这里需要返回一个改变后的完整的资源，但是resful是一个规范，是建议
#         #可以不按它的建议来，自己定义返回的结果
#         return JsonResponse(response,safe=False)

#使用restful的APIView类
class Books(APIView):
    #request.data是个方法，包装成了属性，前台传过来body体中的数据，放在里面
    #request.query_params 这个是原来GET中的数据

    #现在的request对象，已经不是原来django中的request对象了，它是rest_framework.request下的Request
    def put(self,request,pk):
        response={'status':100,'msg':'修改成功'}
        #以后再取数据，直接从request.data中取
        #前端传来json格式：
        #前端传来格式x-www-form-urlencoded格式：传来结果是<QueryDict: {'name': ['金瓶'], 'price': ['250']}>，type是<class 'django.http.request.QueryDict'>
        #这里应该是rest_framework内部进行了一些处理，将其转化了格式
        #前端传来格式json格式，传来结果是{'name': 'alex', 'price': '250'}，type是<class 'dict'>
        #request.data不同编码格式过来，它可能是不同类的对象,但是用法都是一样的，可以用get
        print(request.data)
        print(type(request.data))
        return JsonResponse(response)

4.序列化django提供的序列化组件（不可控）

from django.core import serializers
    def get(self,request):
        response={'status':100,'data':None}
        books=models.Book.objects.all()
        #
        ret=serializers.serialize('json',books)
        print(ret)
        response['data']=ret
        return JsonResponse(response,safe=False)

drf提供的序列化组件

#drf序列化组件的使用
#1.导入drf的序列化类
from rest_framework.serializers import Serializer
from rest_framework import serializers
#2.写一个类继承它
class BookSerializer(Serializer):
    name=serializers.CharField()
    price=serializers.CharField()

    def get(self,request):
        books=models.Book.objects.all()
        # 第三步，实例化产生对象
        #instance=books是要序列化的queryset对象，many=True表示序列化多条
        #instance可以不写，按位置传.many=True一定要传
        # ser=BookSerializer(instance=books,many=True)
        ser=BookSerializer(books,many=True)
        #只序列化一个book对象的话,book也可以是单个对象，不是queryset对象
        # book=models.Book.objects.all().first()
        # ser=BookSerializer(book,many=False)
        #注意加上safa=False，拿到的是序列化之后的字典，里面有可能套了列表
        return JsonResponse(ser.data,safe=False)

5.规范使用序列化

在app中创建一个py文件，例如mySer.py

from rest_framework import serializers
from rest_framework.serializers import Serializer
from app01 import models

class AuthorSerializer(Serializer):
    name=serializers.CharField()
    sex=serializers.CharField()

class BookSerializer(Serializer):#BookSerializer这里在定义阶段，就要想好关联哪个表序列化哪些对象。
    #进到这个表里，将当做自己已经拿到了book对象，想要取哪个字段，直接在source里取
    #将对象返回实例化时，如果要修改字段名，可以在前面修改，后面再写上source='name'，表示关联的字段
    xxx=serializers.CharField(source='name')
    #不指定字段名的话，这里前面的名字必须和models表里的字段名一样
    price=serializers.CharField()

    #这里publish在models里面是做了外键关联的，在Book表里存的是对象。所以这里返回的是Publish object。
    #如果要它返回出版社名字，方式一：可以在models下Publish表里自己定义str方法
    # publish=serializers.CharField()
    #方式二：
    # publish=serializers.CharField(source='publish.name')
    #Publish下的test函数也能被查出来，显示的是函数的执行结果,没什么卵用.
    test=serializers.CharField(source='publish.test')
    #SerializerMethodField可以指定一个方法
    #方法名：叫get_字段名，要传参数，参数是：当前的book对象
    publish=serializers.SerializerMethodField()
    def get_publish(self,obj):
        #obj是当前的book对象
        dic={'name':obj.publish.name,'email':obj.publish.email,'addr':obj.publish.addr}
        return dic
    #取这本书的所有作者
    #这样显示的是queryset对象，不太好，弃用
    # author=serializers.CharField(source='authors.all')

    authors=serializers.SerializerMethodField()
    def get_authors(self,book):
        aus=book.authors.all()
        #可以继续用序列化类，来处理
        auth_ser=AuthorSerializer(aus,many=True)
        return auth_ser.data

其中有个ModelSerlializer

from app01.models import Book
class BookSerializer(serializers.ModelSerializer):
    #必须写一个内部类，名字叫sMeta
    class Meta:
        model=Book#指定表
        fields='__all__'#指定字段
        #指定深度，可以理解为指定跨几张表。不推荐使用，特别影响效率，可控性查
        # depth=1
        #exclude=['publish']排除掉哪个字段
        #fields跟exclude不能连用
    #这时查到的一些关联外键的字段是数字，可以重写属性
    publish=serializers.CharField(source='publish.name')
    authors=serializers.SerializerMethodField()
    def get_authors(self,book):
        aus=book.authors.all()
        auth_ser=AuthorSerializer(aus,many=True)
        return auth_ser.data