• DRF概述


    一. REST

    1. 什么是编程?

    数据结构和算法的结合

    2. 什么是REST?

    回顾曾经做过的图书管理系统, 我们是这样设计URL的:

       127.0.0.1:9001/books/
       127.0.0.1:9001/get_all_books/   访问所有的数据
                
        127.0.0.1:9001/books/{id}/     
        127.0.0.1:9001/books/{id}?method=get   访问单条数据
                
        127.0.0.1:9001/books/add/
        127.0.0.1:9001/books/?type=create   创建数据
                
        127.0.0.1:9001/books/delete/
                
        127.0.0.1:9001/books/update/   
    

    以上定义的URL虽然也可以实现功能, 但是因个人习惯等的不同, 同一个功能会产生五花八门的URL, 而且响应回去的数据(包括错误提示等)格式也没有统一的规范, 这就造成了前后端交互上的困难.

    由此产生了REST. REST下的URL唯一代表资源, http请求方式区分用户行为, 如下是符合REST规范的URL设计示例:

      url的设计规范:
        GET:     127.0.0.1:9001/books/           # 获取所有数据
        GET:      127.0.0.1:9001/books/{id}      # 获取单条数据
        POST:    127.0.0.1:9001/books/           # 增加数据
        DELETE:   127.0.0.1:9001/books/{id}      # 删除数据
        PUT:      127.0.0.1:9001/books/{id}      # 修改数据
      数据响应规范:
        GET:     127.0.0.1:9001/books/          # 返回[{}, {}, {}]
        GET:      127.0.0.1:9001/books/{id}      # 返回单条数据{}
        POST:    127.0.0.1:9001/books/          # 返回添加成功的数据{}
        DELETE:   127.0.0.1:9001/books/{id}      # 返回空"" 
        PUT:      127.0.0.1:9001/books/{id}      # 返回{} ,更新后完整的一条记录,注意并非一个字段
      错误处理:
            { "error": "error_message" }
    

    REST是一种软件架构设计风格, 不是标准, 也不是技术实现, 它只是提供了一组设计原则和约束条件, 是目前最流行的API设计规范, 用于web数据接口的设计.

    参考链接:

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

    http://www.scienjus.com/my-restful-api-best-practices/

    那么, 我们接下来要学习的Django REST Framework与REST有什么关系呢?

    事实上, DRF(Django REST Framework)是一套基于Django开发的, 帮助我们更好的设计符合REST规范的web应用的一个Django App, 所以, 从本质上来讲, DRF是一个Django的App.

    二. 知识准备

    学习DRF之前, 首先回顾一下一个知识点:

    1. CBV(class based view)

    from django.views import View
    class LoginView(View):
        def get(self, request):
            pass
        def post(self, request):
            pass
    

    2. 类方法 classmethodclassonlymethod

    class Person(object):
        def __init__(self, name, age):
            self.name = name
            self.age = age
        
        # 注意: Person类加载的时候,会执行装饰器函数classmethod(sleeping),并将结果赋给sleeping
        @classmethod
        def sleeping(cls):	# 相当于 sleeping = classmethod(sleeping)
            print("Tom is sleeping")
            
        @classonlymethod
        def shopping(cls):
            print("Tom is shopping")
            
    Person.sleeping()	# 类直接调用 类方法(用@classmethod装饰)
    Person.Angel()		# 类直接调用 方法(用@classonlymethod装饰)
    
    Tom = Person('Tom', '19')
    Tom.sleeping()		# 对象可以直接调用 类方法
    Tom.shopping()		# baocuo,对象不能调用由@classonlymethod装饰的方法
    

    总结:

    • @classmethod(python加的装饰器)装饰的方法可以被对象和类调用.
    • @classonlymethod(Django加的装饰器)只能被调用.

    3. 反射、 isinstance()

    (1)getattr()

    描述: getattr()函数通过name这个字符串去object中找名字叫做name的属性, 如果找到了, 就返回这个对象的属性值, 如果找不到, 就返回default

    语法:

    getattr(object, name[, default])
    

    参数:

    • object -- 对象
    • name -- 字符串, 对象的属性
    • default -- 默认返回值, 如果不提供参数, 在没有对应属性时, 将触发AttributeError

    返回值: 返回对象属性


    (2)hasattr()

    描述: hasattr()函数用于判断对象是否包含对应的属性.

    语法:

    hasattr(object, name)
    

    参数:

    • object -- 对象
    • name -- 字符串, 属性名

    返回值: 如果对象object中存在一个名字叫做name的属性, 那么就返回True, 否则返回False.


    (3)setattr()

    描述: setsttr()函数对应函数getsttr(), 用于给对象objectname的属性重新设置值, 注意该属性name必须存在.

    语法:

    setattr(object, name, value)
    

    参数:

    • object -- 对象
    • name -- 字符串, 对象属性
    • value -- 属性值

    返回值: 无

    (4)isinstance()

    描述: isinstance()函数用来判断一个对象是否是一个已知的类型.

    # isinstence()与type()的区别:
    -- type()不会认为子类是一种父类类型,不考虑继承关系.
    -- isinstence()会认为子类是一种父类类型,考虑继承关系.
    如果要判断两个类型是否相同推荐使用isinstence().
    

    语法:

    isinstence(object, classinfo)
    

    参数:

    • object -- 实例对象
    • classinfo -- 可以是直接或间接类名, 基本类型或者由它们组成的元组

    返回值: 如果对象的类型与参数二的类型(classinfo)相同则返回True, 否则返回False.

    4. self定位

    我们要明确, self指向的始终是调用者.

    5. http请求协议

    协议就是沟通双方约定俗成的规范, 也即是解析数据的规则

    6. form表单的enctype属性中有三种请求协议

    如果通过form表单提交用户数据, 可以使用form表单的enctype属性来定义数据编码协议, 该属性有三个值, 代表三种数据编码协议:

    • application/x-www-form-urlencoded: 该值使用&符号链接多个键值对, 键值对用等号拼接. 该值是enctype属性的默认值.
    • multipart/form-data: 上传文件, 图片时使用该值.
    • text/plain: 空格转换为+号.

    7. JavaScript中的object(如: {name:'alex'} <==> json)的相互转换方式

    JSON.stringify(data)  ==> 相当于python的 json.dumps()
    JSON.parse(data)      ==> 相当于python的 json.loads()
    

    三. Django REST Framework ( DRF )

    1. 为什么要使用DRF?

    DRF从本质上来讲, 它就是一个Django的App, 有了这样一个App, 我们就可以更好的设计出符合RESTful规范的web应用. 实际上, 即便没有DRF, 我们也能够自行设计出符合RESTful规范的web应用, 如下示例:

    from django.shortcuts import HttpResponse
    from django.views import View
    from * import models
    import json
    class CourseView(View):
        def get(self, request):
            course_list = list()
            
            for course in models.Course.objects.all():
                course = {
                    'course_name': course.course_name,
                    'description': course.description,
                }
                course_list.append(course)
    	
        	return HttpResponse(json.dumps(course_list, ensure_ascii=False))
    

    在上面的代码中, 我们获取所有的课程数据, 并且根据REST规范, 将所有资源通过列表返回给用户, 可见, 就算没有DRF, 我们也能够设计出符合RESTful规范的接口, 甚至是整个App应用. 但是, 如果所有的接口都自定义, 难免会出现重复代码, 为了提高工作效率, 我们建议使用优秀的工具, DRF就是这样一个优秀的工具, 另外, 它不仅能够帮助我们快速的设计出符合RESTful规范的接口, 还提供了诸如 认证 , 权限 等等其他强大的功能.

    2. 什么时候使用DRF?

    RESTful 是目前最流行的API设计规范, 如果使用Django开发你的web应用, 那么请尽量使用DRF, 如果使用的是Flask, 则可以使用Flask-RESTful.

    3. DRF的使用

    DRF官方文档

    DRF安装

    # 安装django
    pip install django
    
    # 安装djangorestframework
    pip install djangorestframework
    

    安装完成以后, 我们就可以开始使用DRF框架来实现我们的web应用了. 该框架包含以下知识点:

      - APIView
      - 解析器组件
      - 序列化组件
      - 视图组件
      - 认证组件
      - 权限组件
      - 频率控制组件
      - 分页组件
      - 相应器组件
      - url控制
    

    4. APIView

    介绍DRF, 必须介绍APIView, 它是重中之重, 是下面所有组件的基础, 因为所有的请求都是通过APIView来分发的. 那么它究竟是如何来分发请求的呢? 想要弄明白这个问题, 就必须解读它的源码, 而想要解读DRF的APIView源码, 就必须首先弄清楚django中views.View类的源码, 为什么使用了视图函数类调用as_view()之后, 请求就可以被不同的函数处理了呢?

    (1)回顾CBV, 解读View源码

    # urls.py中代码如下:
    from django.urls import path, include, re_path
    from classbasedView import views
    urlpatterns = [
        re_path('login/$', views.LoginView.as_view())
    ]
    
    # views.py中代码如下:
    from django.views import View
    class LoginView(View):
        def get(self, request):
            pass
        def post(self, request):
            pass
    

    以上代码执行流程如下(源码解读):

    • (1)启动django项目, 即执行了python manage.py runserver 127.0.0.1:8000之后

    • (2)开始加载settings.py配置文件

      • 读取models.py
      • 加载views.py
      • 加载urls.py, 执行as_view(): views.LoginView.as_view()
    • (3)由于LoginView中没有as_view, 因此执行父类View中的as_view方法, 父类View的相关源码如下:

    class View:
        http_method_names = ['get', 'post', 'put', ...]
        def __init__(self, **kwargs):
            for key, value in kwargs.items():
                setattr(self, key, value)
                
        @classonlymethod
        def as_view(cls, **initkwargs):
            for key in initkwargs:
                ...
            def view(request, * args, **kwargs):
                """
                实例化一个对象,对象名称为self,self是cls的对象,谁调用了as_view,cls就是谁(当前调用as_view的是LoginView),所以,此时的self就是LoginView实例化对象.
                """
                self = cls(**initkwargs)
                if hassttr(self, 'get') and not hasattr(self, 'head'):
                    self.head = self.get
                self.request = request
                self.args = args
                self.kwargs = kwargs
                return self.dispatch(request, *args, **kwargs)
        	view.view_class = cls
            view.view_initkwargs = initwargs
            
            update_wrapper(view, cls, updated=())
            update_wrapper(view, cls.dispatch, assigned=())
            return view
        
        def dispatch(self, request, *args, **kwargs):
            if request.method.lower() in self.http_method_name:
                # 通过getattr找到的属性,已和对象绑定,访问时不需要再指明对象了
                # 即不需要再: self.handler, 直接handler()执行
                handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
            else:
                handler = self.http_method_not_allowed
            return handler(request, *args, **kwargs)            
    

    上面的源码中可以看出as_view是一个类方法, 并且方法中定义了view函数, 且as_view将view函数返回, 此时url与某一个函数的对应关系建立, 并开始等待用户请求.

    • (4)当用户发来请求(如get请求), 开始执行url对应的view函数, 并传入request对象, View类中view函数的执行结果是返回self.dispatch(request, *args, **kwargs)的执行结果, 这里的self是指LoginView的实例化对象. 由于LoginView中没有dispatch方法, 所以去执行父类APIView中的dispatch方法, 同样, APIView类中的dispatch函数中也是通过反射找到self(此时self指LoginView的实例化对象)所属类(即LoginView)中的get方法, dispatch函数中的handler(request, *args, **kwargs)表示执行LoginView类中的get方法, 其执行结果就是dispatch的执行结果, 也就是请求url对应view函数的执行结果, 最后将结果返回给用户.

    (2)APIView

    使用:

    # views.py中代码:
    from rest_framework.views import APIView	# 引入APIView
    class LoginView(APIView):	# 继承APIView
        def get(self, request):
            pass
        def post(self, request):
            pass
        
    # urls.py中代码:
    from django.urls import path, include, re_path
    from classbasedView import views
    urlspatterns = [
        re_path('login/$', views.LoginView.as_view())
    ]
    

    源码解读:

    • (1)启动django项目: python manage.py runserver 127.0.0.1:8000
    • (2)开始加载settings.py文件
    • (3)读取models.py文件
    • (4)加载views.py文件
    • (5)加载urls.py文件, 执行as_view(): views.LoginView.as_view()
    • (6)由于LoginView中没有as_view, 因此去执行父类APIView中的as_view方法, 父类APIView的相关源码如下:
    class APIView(View):
        ...
        # api_settings是APISettings类的实例化对象
        parser_classes = api_settings.DEFAULT_PARSER_CLASSES
        ...
        settings = api_setings
        schema = DefaultSchema()
        
        @classmethod
        def as_view(cls, **initkwargs):		# cls指LoginView
            if isinstence(getattr(cls, 'queryset', None), models.query.Queryset):
                ...
            # 下面一句表示去执行APIView父类(即View类)中的as_view方法
            view = super(APIView, cls).as_view(**initkwargs)
            view.cls = cls
            view.initkwargs = initkwargs
            return csrf_exempt(view)
        
        def dispatch(self, request, *args, **kwargs):
            ...
            request = self.initialize_request(request, *args, **kwargs)
            ...
            try:
                self.initial(request, *args, **kwargs)
                if request.method.lower() in self.http_method_name:
                    handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
                else:
                    handler = self.http_method_not_allowed
               	response = self.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
    

    参考上面的View源码解读, 我们已经知道View中的as_view方法返回view函数, 此时url与view对应关系已经建立, 等待用户请求.

    • (7)当用户发来请求(如get请求), 开始执行url对应的view函数, 并传入request对象, View类中view函数的执行结果是返回self.dispatch(request, *args, **kwargs)的执行结果, 这里的self是指LoginView的实例化对象, LoginView中没有dispatch方法, 所以去执行父类APIView中的dispatch方法, 同样, APIview类中的dispatch函数中也是通过反射找到self(此时self指LoginView的实例对象)所属类(即LoginView)中的get方法, dispatch函数中的handler(request, *args, **kwargs)表示执行LoginView类中的get方法, 其执行结果就是dispatch的执行结果, 也就是请求url对应view函数的执行结果, 最后将结果返回给用户.

    四. 补充知识点

    1. 关于装饰器

    若类中有装饰器函数, 那么当类加载的时候, 装饰器函数就会执行, 如下代码:

    class Person(object):
        @classmethod	# 相当于 sleeping = classmethod(sleeping)
        def sleeping(cls):
            print('Tom is sleeping')
        
        print(sleeping)	
        # 加载类时执行,结果是:<classmethod object at 0x000001F2C29C8198>
    

    注意: 类中直接print会执行打印并输出结果, 而函数只有调用时才会执行, 如下所示:

    def func():
        print('Hello World!')
        
    # 函数func 加载 不会执行打印
    # 而只有当我们调用 func() 才会执行打印
    

    2. __dict__方法

    class Person(object):
        def __init__(self, name, age):
            self.name = name
            self.age = age
            
        def sing(self):
            print('I am singing!')
    
    p1 = Person('alex', 18)
    print(p1.__dict__)	# {'name':'alex', 'age':18}
    print(Person.__dict__)
    '''
    {'__module__': '__main__', 
    '__init__': <function Person.__init__ at 0x0000021E1A46A8C8>, 
    'sing': <function Person.sing at 0x0000021E1A46A950>, 
    '__dict__': <attribute '__dict__' of 'Person' objects>, 
    '__weakref__': <attribute '__weakref__' of 'Person' objects>, 
    '__doc__': None}
    '''
    

    总结:

    • 对象.__dict__ 返回对象的所有成员字典;
    • 类.__dict__ 返回类的所有成员字典;

    我们可以通过 对象.name 取出成员, 字典没有这种取值方式, 使用 对象.name 的本质是执行类中的 __getitem__ 方法.

    3. 对程序进行功能扩展的两种方式

    现在有如下两种需求:

    # 需求一: 计算下面add函数的执行时间(不重写add函数的前提下)
    def add(x, y):
        return x + y
    
    # 解决方式: 装饰器
    def outer(func):
        def inner(*args, **kwargs):
            import time
            start_time = time.time()
            ret = func(*args, **kwargs)
            end_time = time.time()
            print(end_time - start_time)
        return inner
    
    @outer
    def add(x, y):
        return x + y
    
    # 需求二: 扩展类中函数的功能(在不重写Father类的前提下)
    class Father(object):
        def show(self):
            print('father show is excuted!')
    
    father = Father()
    father.show()
    
    # 解决方式: 重新写一个类, 继承Father类, 重写show()方法, 用super()调用
    class Son(Father):
        def show(self):
            print('son show is excuted!')
            super().show()
    
    son = Son()
    son.show()
    

    总结:

    • 面向过程的方式对程序功能进行扩展:
      • 装饰器
    • 面向对象的方式对程序功能进行扩展:
      • 类的继承
      • 方法重写
      • super()执行父类的方法

    4. super()函数

    描述: super()函数是用于调用父类(超类)的一个方法. super是用来解决多重继承问题, 直接用类名调用父类方法在使用单继承的时候没有问题, 但是如果使用多继承, 会涉及到查找顺序(MRO)、重复调用(钻石继承)等种种问题.

    MRO就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表.

    语法:

    super(type[, object-or-type])
    

    参数:

    • type -- 类
    • object-or-type -- 类, 一般是self

    返回值: 无

    注意: Python3.x 和 Python2.x的一个区别是: Pyhton3 可以直接使用 super().xxx 代替 super(Class, self).xxx.

    Python3.x与Python2.x中super()的用法对比:

    # Python3.x实例:
    class A:
        pass
    class B(A):
        def add(self, x):
            super().add(x)
            
    # Python2.x实例:
    class A(object):	# Python2.x记得要继承object
        pass
    class B(A):
        def add(x):
            super(B, self).add(x)
    

    实例说明:

    class FooParent(object):
        def __init__(self):
            self.parent = 'I am the parent!'
            print('Parent')
        
        def bar(self, message):
            print('%s from Parent!' % message)
            
    class FooChild(FooParent):
        def __init__(self):
            '''
            以super(B, self)的格式作为参照,
            super(FooChild, self)首先找到FooChild的父类(即FooParent),
            然后把类B(即super()的第一个参数)的对象FooChild转换为FooParent的对象
            '''
            super(FooChild, self).__init__()
            print('Child')
            
        def bar(self, message):
            super(FooChild, self).bar(message)
            print('Child bar function!')
            print(self.parent)
            
    if __name__ == '__main__':
        fooChild = FooChild()
        fooChild.bar('HelloWorld')
        
        
    ##执行结果:
    # Parent
    # Child
    # HelloWorld from Parent!
    # Child bar fuction!
    # I am the parent!
    
  • 相关阅读:
    devexpress GridView按条件给行号上色
    简答正则表达式的使用
    devexpress 给GridView添加行号
    C# Winfrom 简单的运用Timer控件
    C# 简单TCP协议
    Lucene全文检索-从零开始(3)
    Lucene全文检索-从零开始(2)
    Lucene全文检索-从零开始(1)
    js 高级编程前三章
    莫名的胸闷
  • 原文地址:https://www.cnblogs.com/haitaoli/p/10293367.html
Copyright © 2020-2023  润新知