Rest Framework第一天-RESTful规范、APIView、序列化组件（上）

                                           RESTful规范         

一、什么是RESTful

• REST与技术无关，代表的是一种软件架构风格，REST是Representational State Transfer的简称，中文翻译为“表征状态转移”
• REST从资源的角度类审视整个网络，它将分布在网络中某个节点的资源通过URL进行标识，客户端应用通过URL来获取资源的表征，获得这些表征致使这些应用转变状态
• REST与技术无关，代表的是一种软件架构风格，REST是Representational State Transfer的简称，中文翻译为“表征状态转移”
• 所有的数据，不过是通过网络获取的还是操作（增删改查）的数据，都是资源，将一切数据视为资源是REST区别与其他架构风格的最本质属性
• 对于REST这种面向资源的架构风格，有人提出一种全新的结构理念，即：面向资源架构（ROA：Resource Oriented Architecture）

二  RESTful API设计

1. 协议
   API与用户的通信协议，总是使用HTTPs协议。
2. 域名
   应该尽量将API部署在专用域名之下。
       https://api.example.com
   如果确定API很简单，不会有进一步扩展，可以考虑放在主域名下
       https://example.org/api/
3. 版本（Versioning）
   应该将API的版本号放入URL。
       https://api.example.com/v1/
   另一种做法是，将版本号放在HTTP头信息中，但不如放入URL方便和直观。Github采用这种做法。
4. 路径（Endpoing）

   路径又称"终点"（endpoint），表示API的具体网址。

   在RESTful架构中，每个网址代表一种资源（resource），所以网址中不能有动词，只能有名词，而且所用的名词往往与数据库的表格名对应。一般来说，数据库中的表都是同种记录的"集合"（collection），所以API中的名词也应该使用复数。

   举例来说，有一个API提供动物园（zoo）的信息，还包括各种动物和雇员的信息，则它的路径应该设计成下面这样。

   • https://api.example.com/v1/zoos
   • https://api.example.com/v1/animals
   • https://api.example.com/v1/employees

5. HTTP动词
   对于资源的具体操作类型，由HTTP动词表示。

   常用的HTTP动词有下面五个（括号里是对应的SQL命令）。

   • GET（SELECT）：从服务器取出资源（一项或多项）。
   • POST（CREATE）：在服务器新建一个资源。
   • PUT（UPDATE）：在服务器更新资源（客户端提供改变后的完整资源）。
   • PATCH（UPDATE）：在服务器更新资源（客户端提供改变的属性）。
   • DELETE（DELETE）：从服务器删除资源。

   还有两个不常用的HTTP动词。

   • HEAD：获取资源的元数据。
   • OPTIONS：获取信息，关于资源的哪些属性是客户端可以改变的。

   下面是一些例子。

   • GET /zoos：列出所有动物园
   • POST /zoos：新建一个动物园
   • GET /zoos/ID：获取某个指定动物园的信息
   • PUT /zoos/ID：更新某个指定动物园的信息（提供该动物园的全部信息）
   • PATCH /zoos/ID：更新某个指定动物园的信息（提供该动物园的部分信息）
   • DELETE /zoos/ID：删除某个动物园
   • GET /zoos/ID/animals：列出某个指定动物园的所有动物
   • DELETE /zoos/ID/animals/ID：删除某个指定动物园的指定动物

6. 过滤信息（Filtering）

   如果记录数量很多，服务器不可能都将它们返回给用户。API应该提供参数，过滤返回结果。

   下面是一些常见的参数。

   • ?limit=10：指定返回记录的数量
   • ?offset=10：指定返回记录的开始位置。
   • ?page=2&per_page=100：指定第几页，以及每页的记录数。
   • ?sortby=name&order=asc：指定返回结果按照哪个属性排序，以及排序顺序。
   • ?animal_type_id=1：指定筛选条件

   参数的设计允许存在冗余，即允许API路径和URL参数偶尔有重复。比如，GET /zoo/ID/animals 与 GET /animals?zoo_id=ID 的含义是相同的。

7. 状态码（Status Codes）

   服务器向用户返回的状态码和提示信息，常见的有以下一些（方括号中是该状态码对应的HTTP动词）。

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

   状态码的完全列表参见这里。

8. 错误处理（Error handling）

   如果状态码是4xx，就应该向用户返回出错信息。一般来说，返回的信息中将error作为键名，出错信息作为键值即可。

   {
       error: "Invalid API key"
   }
   

9. 返回结果
   针对不同操作，服务器向用户返回的结果应该符合以下规范。

   • GET /collection：返回资源对象的列表（数组）
   • GET /collection/resource：返回单个资源对象
   • POST /collection：返回新生成的资源对象
   • PUT /collection/resource：返回完整的资源对象
   • PATCH /collection/resource：返回完整的资源对象
   • DELETE /collection/resource：返回一个空文档

10. Hypermedia API

    RESTful API最好做到Hypermedia，即返回结果中提供链接，连向其他API方法，使得用户不查文档，也知道下一步应该做什么。

    比如，当用户向api.example.com的根目录发出请求，会得到这样一个文档。

    {"link": {
      "rel":   "collection https://www.example.com/zoos",
      "href":  "https://api.example.com/zoos",
      "title": "List of zoos",
      "type":  "application/vnd.yourformat+json"
    }}
    

    上面代码表示，文档中有一个link属性，用户读取这个属性就知道下一步该调用什么API了。rel表示这个API与当前网址的关系（collection关系，并给出该collection的网址），href表示API的路径，title表示API的标题，type表示返回类型。

    Hypermedia API的设计被称为HATEOAS。Github的API就是这种设计，访问api.github.com会得到一个所有可用API的网址列表。

    {
      "current_user_url": "https://api.github.com/user",
      "authorizations_url": "https://api.github.com/authorizations",
      // ...
    }
    

    从上面可以看到，如果想获取当前用户的信息，应该去访问api.github.com/user，然后就得到了下面结果。

    {
      "message": "Requires authentication",
      "documentation_url": "https://developer.github.com/v3"
    }
    

    上面代码表示，服务器给出了提示信息，以及文档的网址。

11. 其他

    （1）API的身份认证应该使用OAuth 2.0框架。

    （2）服务器返回的数据格式，应该尽量使用JSON，避免使用XML。

    （完）

                                        rest-framework之APIView

一、安装djangorestframework

方式一：pip3 install djangorestframework

方式二：pycharm图形化界面安装

方式三：pycharm命令行下安装（装在当前工程所用的解释器下）

二、djangorestframework的APIView分析

as_view方法

@classmethod
    def as_view(cls, **initkwargs):
        """
        Store the original class on the view function.

        This allows us to discover information about the view when we do URL
        reverse lookups.  Used for breadcrumb generation.
        """
        if isinstance(getattr(cls, 'queryset', None), models.query.QuerySet):
            def force_evaluation():
                raise RuntimeError(
                    'Do not evaluate the `.queryset` attribute directly, '
                    'as the result will be cached and reused between requests. '
                    'Use `.all()` or call `.get_queryset()` instead.'
                )
            cls.queryset._fetch_all = force_evaluation

        view = super(APIView, cls).as_view(**initkwargs)
        view.cls = cls
        view.initkwargs = initkwargs

        # Note: session based authentication is explicitly CSRF validated,
        # all other authentication is CSRF exempt.
        return csrf_exempt(view)

dispatch

def dispatch(self, request, *args, **kwargs):
        """
        `.dispatch()` is pretty much the same as Django's regular dispatch,
        but with extra hooks for startup, finalize, and exception handling.
        """
        self.args = args
        self.kwargs = kwargs
        request = self.initialize_request(request, *args, **kwargs)
        self.request = request
        self.headers = self.default_response_headers  # deprecate?

        try:
            self.initial(request, *args, **kwargs)

            # Get the appropriate handler method
            if request.method.lower() in self.http_method_names:
                handler = getattr(self, request.method.lower(),
                                  self.http_method_not_allowed)
            else:
                handler = self.http_method_not_allowed

            response = handler(request, *args, **kwargs)

        except Exception as exc:
            response = self.handle_exception(exc)

        self.response = self.finalize_response(request, response, *args, **kwargs)
        return self.response

initialize_request

def initialize_request(self, request, *args, **kwargs):
        """
        Returns the initial request object.
        """
        parser_context = self.get_parser_context(request)

        return Request(
            request,
            parsers=self.get_parsers(),
            authenticators=self.get_authenticators(),
            negotiator=self.get_content_negotiator(),
            parser_context=parser_context
        )

initial方法（内部调用认证，权限和频率）

def initial(self, request, *args, **kwargs):
        """
        Runs anything that needs to occur prior to calling the method handler.
        """
        self.format_kwarg = self.get_format_suffix(**kwargs)

        # Perform content negotiation and store the accepted info on the request
        neg = self.perform_content_negotiation(request)
        request.accepted_renderer, request.accepted_media_type = neg

        # Determine the API version, if versioning is in use.
        version, scheme = self.determine_version(request, *args, **kwargs)
        request.version, request.versioning_scheme = version, scheme

        # Ensure that the incoming request is permitted
        self.perform_authentication(request)
        self.check_permissions(request)
        self.check_throttles(request)

三、djangorestframework的Request对象简单介绍

                                  rest-framework之序列化组件

一、 Django自带序列化组件

Django内置的serializers(把对象序列化成json字符串)
 

from django.core import serializers

from django.core import serializers
def test(request):
    book_list = Book.objects.all()    
    ret = serializers.serialize("json", book_list)
    return HttpResponse(ret)

二、rest-framework序列化之Serializer

models部分:

from django.db import models

# Create your models here.


class Book(models.Model):
    title=models.CharField(max_length=32)
    price=models.IntegerField()
    pub_date=models.DateField()
    publish=models.ForeignKey("Publish")
    authors=models.ManyToManyField("Author")
    def __str__(self):
        return self.title

class Publish(models.Model):
    name=models.CharField(max_length=32)
    email=models.EmailField()
    def __str__(self):
        return self.name

class Author(models.Model):
    name=models.CharField(max_length=32)
    age=models.IntegerField()
    def __str__(self):
        return self.name

view部分：

from rest_framework.views import APIView
from rest_framework.response import Response
from .models import *
from django.shortcuts import HttpResponse
from django.core import serializers


from rest_framework import serializers

class BookSerializers(serializers.Serializer):
    title=serializers.CharField(max_length=32)
    price=serializers.IntegerField()
    pub_date=serializers.DateField()
    publish=serializers.CharField(source="publish.name")
    #authors=serializers.CharField(source="authors.all")
    authors=serializers.SerializerMethodField()
    def get_authors(self,obj):
        temp=[]
        for author in obj.authors.all():
            temp.append(author.name)
        return temp
　　#此处可以继续用author的Serializers，
　　# def get_authors(self,obj):
　　　　#     ret=obj.authors.all()
　　　　#     ss=AuthorSerializer(ret,many=True)
　　　　#     return ss.data

class BookViewSet(APIView):

    def get(self,request,*args,**kwargs):
        book_list=Book.objects.all()
        # 序列化方式1:
        # from django.forms.models import model_to_dict
        # import json
        # data=[]
        # for obj in book_list:
        #     data.append(model_to_dict(obj))
        # print(data)
        # return HttpResponse("ok")

        # 序列化方式2:
        # data=serializers.serialize("json",book_list)
        # return HttpResponse(data)

        # 序列化方式3:
        bs=BookSerializers(book_list,many=True)     #many=True代表有多条数据，如果只有一条数据，many=False
        return Response(bs.data)
　　　　 # 序列化方式4: 
　　    # ret=models.Book.objects.all().values('nid','title')
　　　　 # dd=list(ret)
        # return HttpResponse(json.dumps(dd))

注意：

source 如果是字段，会显示字段，如果是方法，会执行方法，不用加括号（authors=serializers.CharField(source='authors.all')）

如在模型中定义一个方法，直接可以在在source指定执行

class UserInfo(models.Model):
    user_type_choices = (
        (1,'普通用户'),
        (2,'VIP'),
        (3,'SVIP'),
    )
    user_type = models.IntegerField(choices=user_type_choices)

    username = models.CharField(max_length=32,unique=True)
    password = models.CharField(max_length=64)


#视图
ret=models.UserInfo.objects.filter(pk=1).first()
aa=ret.get_user_type_display()

#serializer
xx=serializers.CharField(source='get_user_type_display')