day82

今日内容：

1.CBV源码分析：

　　CBV:class base view(基于类的视图函数)

　　FBV:function base view(基于方法的视图函数)

　　要想使用CBV首先需要导入

from django.views import View

　　然后写基于类并且继承View的视图函数（内部的get方法对应的是前台的get请求，若是post请求则写一个post方法）

class Books(View):
    def get(self, request):
        return render(request, 'login.html')

　　使用CBV时，配置的url也是不同的

url(r'^login/', views.Books.as_view()),

　　接下来我们分析继承的这个View

　　我们先来说这个as_view,因为我们在配置路由时就用到此方法

    @classonlymethod
    def as_view(cls, **initkwargs):
        """
        Main entry point for a request-response process.
        """
        for key in initkwargs:
            if key in cls.http_method_names:
                raise TypeError("You tried to pass in the %s method name as a "
                                "keyword argument to %s(). Don't do that."
                                % (key, cls.__name__))
            if not hasattr(cls, key):
                raise TypeError("%s() received an invalid keyword %r. as_view "
                                "only accepts arguments that are already "
                                "attributes of the class." % (cls.__name__, key))

        def view(request, *args, **kwargs):
            self = cls(**initkwargs)
            if hasattr(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 = initkwargs

        # take name and docstring from class
        update_wrapper(view, cls, updated=())

        # and possible attributes set by decorators
        # like csrf_exempt from dispatch
        update_wrapper(view, cls.dispatch, assigned=())
        return view

　　首先我们看到as_view下的一个for循环该代码针对的是一些安全性校验

        for key in initkwargs:
            if key in cls.http_method_names:
                raise TypeError("You tried to pass in the %s method name as a "
                                "keyword argument to %s(). Don't do that."
                                % (key, cls.__name__))
            if not hasattr(cls, key):
                raise TypeError("%s() received an invalid keyword %r. as_view "
                                "only accepts arguments that are already "
                                "attributes of the class." % (cls.__name__, key))

　　然后这个as_view内部的这个view才是我们的重点：

　　　　1.它在类方法内部

　　　　2.同时他是一个闭包函数(内层函数包含对外部作用域的引用)

        def view(request, *args, **kwargs):
　　　　　　　#引用了外部函数的cls，该cls指向的就是我们所写的类
            self = cls(**initkwargs)
　　　　　　　#判断self类中是不是有该get方法
            if hasattr(self, 'get') and not hasattr(self, 'head'):
                self.head = self.get
　　　　　　　#赋值操作
            self.request = request
            self.args = args
            self.kwargs = kwargs
　　　　　　　#返回，执行dispatch方法
            return self.dispatch(request, *args, **kwargs)

　　在dispatch中首先判断该请求是何种请求，然后通过getattr返回该属性值，执行我们所写的类中的方法，最后返回结果

    def dispatch(self, request, *args, **kwargs):
        # Try to dispatch to the right method; if a method doesn't exist,
        # defer to the error handler. Also defer to the error handler if the
        # request method isn't on the approved list.
        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
        return handler(request, *args, **kwargs)

　　总结：请求来了--->as_view---->view---->dispatch--->分发到不同的函数,执行函数,拿到结果.,然后返回

resful规范：

　　什么是resful：是一个规范，面向资源编程，把网络中所有东西想象成资源

规范：
　　1.API：与用户的通信协议，总是使用https：因为比较安全
　　2.域名：
　　　　https://api.example.com  尽量将API部署在专用域名（会存在跨域问题）
   　　https://example.org/api/  API很简单
   　　例如写一个查询所有图书的api接口:https://api.example.com/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:请求方式
　　　　GET：从服务器取出资源（一项或多项）
   　　POST：在服务器新建一个资源
   　　PUT：在服务器更新资源（客户端提供改变后的完整资源）
   　　PATCH：在服务器更新资源（客户端提供改变的属性）
   　　DELETE：从服务器删除资源
　　6.过滤：通过在url上传参的形式传递搜索条件
　　　　https://api.example.com/v1/zoos?limit=10：指定返回记录的数量
　　7.状态吗：请求回去需要有状态码
　　　　也可以自定义状态码（1开头为正在执行，2开头执行成功，3开头重定向，4开头客户端错误，5服务器错误）
　　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，RESTful API最好做到Hypermedia，即返回结果中提供链接，连向其他API方法，
　　　　使得用户不查文档，也知道下一步应该做什么。
    　　　　{
     　　　　　　status:100
     　　　　　　msg:成功
     　　　　　　url:127.0.0.1/books/1
    　　　　}
   　　　　核心:返回结果中提供链接

2.2 postman软件:模拟发请求的软件
2.3 格式化json格式数据(-https://www.json.cn/)
2.4 put请求,django不会帮我解析body内的数据,需要自己处理

3 drf(django rest framework)框架(django的app)

　　安装:djangorestframework
 　　　　-它是一个app,要在咱的项目中用
 　　　　-只是快速的构建resful规范的接口
 　　　　-csrf_exempt:局部禁用csrf(csrf是可以局部使用,局部禁用)
 　　　　-以后再执行的dispatch方法是APIView的dispatch方法
　　　　 -getattr和setattr
　　 -重点掌握这三点:
  　　　　-request.data 是个方法,包装成了属性,前台传过来body体中数据的数据,放在里面
  　　　　-request.query_params  这个是原来GET中的数据
 　　　　 -request把原来的request包装进去了

4 序列化

　　-1 自己写for循环来处理(麻烦)
 　　-2 django提供的序列化组件(不可控)

  from django.core import serializers
  ret=serializers.serialize('json','queryset对象')
  ret就是序列化之后的字符串了,不需要再序列化了

　　-3 drf给咱提供的序列化组件

-1 先导入
   from rest_framework.serializers import Serializer
   from rest_framework import serializers
  -2 写一个类,继承Serializer
   class BookSerializers(serializers.Serializer):
        name = serializers.CharField()
        price = serializers.CharField()
  -3 在类内部写属性:
   name=serializers.CharField()
  -4 使用:
   -先生成对象,需要传参数 instance:要序列化的对象(可能是queryset,也可能是单个对象)
   many:如果是queryset---True,,如果是单个对象--False
　　　　ser = BookSerializers(instance=books,many=True)
　　　　ser = BookSerializers(books,many=True)
　　　　#instance可加可不加
　　　　ser = BookSerializers(books,many=False)
　　　　#单条记录many=False
　　-5 对象.data --->是一个字典
　　　　return JsonResponse(ser.data,safe=False)