drf基础

1.什么是编程?

数据结构和算法的结合

2.什么是REST?

同一个功能会产生五花八门的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.

什么是restful规范？
　　是一套规范，规则，用于程序之间进行数据交换的约定。
　　他规定了一些协议，对我们感受最直接的就是，以前写增删改查的时候需要些四个视图寒素，restful规范写一个接口，根据http协议的请求方式分为不同的操作，比如post,get,put,patch,delete.
　　除此之外restful规范还规定了：
　　　　1.数据之间一般通过json来传递
　　　　2.-url 一般用名词 http://www.baidu.com/article/（面向资源变成，网上所有的数据都是资源）
　　　　3.根据请求方式的不同去做不同的操作：get,post,put,delete,patch
　　　　4.根据筛选条件可以在url后面添加参数:http://www.baidu.com/article?page=1&categroy=1
　　　　　　注意筛选条件都放在url中进行传递

　　扩展：适用于前后端分离的项目，app开发，程序之间(与编程语言无关)

3.Django REST FrameWork(DRF)

3.1 什么是drf?
　　帮助我们在django的基础上快速的搭建遵循restful规范接口的程序，本质上是django的app

3.2 为什么要使用drf？
    本质上讲，drf就是django的一个app。有个这样一个app我们可以快速的基于restful规范开发接口。实际上没有DRF，我们也能设计出符合Restful规范的接口。
　　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规范的接口, 还提供了诸如 认证 , 权限 等等其他强大的功能.　

3.3 什么时候使用DRF?
　　drf一般应用在前后端分离项目和移动端项目中使用。

3.4 drf如何帮助我们快速开发?(drf提供了那些功能？)
　　- url：执行响应的视图函数
　　- 视图：继承了apiview等视图函数(apiview继承了django的view)
　　- 解析器：根据用户请求方式的不同，进行数据解析，解析之后放在request.data中
　　　　　　在进行解析的时候，drf会读取http请求头，content-type
　　　　　　如果是content-type:x-www-urlencoded，那么drf会根据&符号进行分割的形式去处理
　　　　　　如果是content-type:applications/json，那么drf会根据json形式去处理请求体
　　- 序列化：可以对象和对象列表(queryset)进行序列化，也可以对用户提交的数据进行校验
　　- 渲染器：可以帮助我们把json数据血染到页面上进行友好的展示(内部会对请求设备进行判断，会根据请求设备的不同，渲染成不同的页面)
　　- 分页器：在url里面里面体现出来，里面有page参数

4.Drf的使用

# 安装django
    pip install django

# 安装djangorestframework
    pip install djangorestframework

安装完成以后, 我们就可以开始使用DRF框架来实现我们的web应用了. 该框架包含以下知识点:
　　- APIView: 继承APIview(在内部继承了django的View)
　　- 解析器组件: 解析请求体中的数据，将其变成我们想要的数据格式，request.data
　　- 序列化组件: 提供对象和对象列表(quesyset)进行序列化操作以及表单验证的功能
　　- 视图组件
　　- 认证组件
　　- 权限组件
　　- 频率控制组件
　　- 分页组件
　　- 相应器组件
　　- url控制

5.drf基本使用

初识drf：(只有在前后端分离或者是app接口的项目时，才会有用)
    1.安装drf：pip3 install djangorestframework(就是django的app)
    2.注册app rest_framework
        INSTALLED_APPS = [
            'rest_framework'
        ]
    3.写路由
        from django.conf.urls import url
        from django.contrib import admin
        from api import views
        urlpatterns = [
            url(r'^drf/info/', views.DrfInfoView.as_view()),
        ]
    4.导入：from rest_framework.views import APIView
           from rest_framework.response import Response

restful规范：
    1.根据url 请求方式的不同，提供不同的功能
        get：获取数据
        post：增加数据
        put：全部更新
        patch：局部更新
        delete：删除
    2.不管请求和响应都是json格式的字符串，注意：django里面没有request.data
    3.在drf里面不使用request.POST，而是使用request.body和requets.data，因为drf使用json格式来进行传递数据，如果前后端使用格式不同，会导致后端的request.POST接收不到数据
    4.restful规范里面请求单条的数据时必须使用关键字参数(id,pk等，后端url设计 url(r'^drf/Category/(?P<pk>\d+)/$',views.DrfCategoryView.as_view()),)

6.drf实例

from django.conf.urls import url
from django.contrib import admin
from api import views
urlpatterns = [
    url(r'^drf/category/$', views.DrfCategoryView.as_view()),
    url(r'^drf/category/(?P<pk>\d+)/$', views.DrfCategoryView.as_view()),
]

from api import models
from django.forms.models import model_to_dict  将获取到的quesyset类型转成字典类型，也可以使用json来做
class DrfCategoryView(APIView):
    def get(self,request,*args,**kwargs):
        """获取所有文章分类/单个文章分类"""
        pk = kwargs.get('pk')
        if not pk:
            queryset = models.Category.objects.all().values('id','name')
            data_list = list(queryset)
            return Response(data_list)
        else:
            category_object = models.Category.objects.filter(id=pk).first()
            data = model_to_dict(category_object)
            return Response(data)

    def post(self,request,*args,**kwargs):
        """增加一条分类信息"""
        models.Category.objects.create(**request.data)
        return Response('成功')

    def delete(self,request,*args,**kwargs):
        """删除"""
        pk = kwargs.get('pk')
        models.Category.objects.filter(id=pk).delete()
        return Response('删除成功')

    def put(self,request,*args,**kwargs):
        """更新"""
        pk = kwargs.get('pk')
        models.Category.objects.filter(id=pk).update(**request.data)
        return Response('更新成功')

7.drf的解析器

drf的serializers帮助我们提供了
    1. 表单数据校验
    2. 序列化

1.如何serializers获取外键中的中文，而不是id
　　方法一：通过制定source的方式获取内容
　　class ArticleSerializer(serializers.ModelSerializer):
　　　　name = serializers.CharFiled(source='category.name')
　　　　class Meta:
　　　　　　model = models.Article
　　　　　　fields = ['id','title','status']

　　方法二：通过serializers.SerializerMethodField()方法
　　class ArticleSerializer(serializers.ModelsSerializer):
　　　　name = serializers.SerializerMethodField() #相当于钩子方法
　　　　class Meta:
　　　　　　model = models.Article
　　　　　　fields = ['id','title','status']

　　　　def get_name(self,obj): # 

　　方法三：depth = 1。其实depth默认为0，就是只取自己表里面的数据
　　意思是跨一层表进行数据的读取，最大为10

2.如何通过serializers获取choises中的中文
　　例如models里面的status状态字段，获取发布和删除
　　status_choise = (
　　　　(1,'发布'),
　　　　(2,'删除')
　　)
　　status = models.IntegerField(verbose_name='状态',choices=status_choise,default=1)
　　class ArticleSerializer(serializers.ModelSerializer,):
    　　status = serializers.CharField(source='get_status_display',required=False)
　　　　 #status = serializers.SerializerMehhodField()
    　　class Meta:
        　　model = models.Article
        　　fields = ['id','title','summary','content','category','name','status']
　　　　 #def_status(self.obj):
　　　　　　　　return obj.get_status_display()
　　

　　get_status_display:使用get_字段名__display()获取对应字符串，但是在drf里面不需要添加()，因为drf源码会去判断当前字段是什么类型的，如果是方法，会自动加上扩号，如果是对象.xxx，则直接取出内容
　　required=False：告诉后台在执行的时候该字段不是必须被填写的，是自己增加的字段，只是用作展示，但是在实际增加数据的时候不想要该字段。

8.drf解析器实例

class ArticleSerializer(serializers.ModelSerializer,):
    name = serializers.CharField(source='category.name',required=False)
    # name = serializers.SerializerMethodField() #相当于钩子方法，下面必须写get_name方法
    status = serializers.CharField(source='get_status_display',required=False)
    # required=False：告诉后台在执行的时候该字段不是必须被填写的，是自己增加的字段，只是用作展示，但是在实际增加数据的时候不想要该字段。
    class Meta:
        model = models.Article
        # fields = "__all__"
        fields = ['id','title','summary','content','category','name','status']

    # def get_name(self,obj):
    #     return obj.category.name

class ArticleView(APIView):
    def get(self,request,*args,**kwargs):
        pk = kwargs.get('pk')
        if not pk :
            object = models.Article.objects.all()
            ser = ArticleSerializer(instance=object,many=True)
            return Response(ser.data)
        else:
            object = models.Article.objects.filter(id=pk).first()
            ser = ArticleSerializer(instance=object,many=False,)
            return Response(ser.data)

    def delete(self,request,*args,**kwargs):
        # 删除
        pk = kwargs.get('pk')
        models.Article.objects.filter(id=pk).delete()
        return Response('删除成功')

    def put(self,request,*args,**kwargs):
        # 全部更新
        pk = kwargs.get('pk')
        object1 = models.Article.objects.filter(id=pk).first()
        ser = ArticleSerializer(instance=object1,data=request.data)
        if ser.is_valid():
            ser.save()
            return Response(ser.data)
        return Response(ser.errors)

    def patch(self,request,*args,**kwargs):
        # 局部更新
        # partial=True 允许字段为空
        pk = kwargs.get('pk')
        object = models.Article.objects.filter(id=pk).first()
        ser = ArticleSerializer(instance=object,data=request.data,partial=True)
        if ser.is_valid():
            ser.save()
            return Response(ser.data)
        return Response(ser.errors)

    def post(self,request,*args,**kwargs):
        ser = ArticleSerializer(data=request.data)
        if ser.is_valid():
            ser.save()
            return Response('增加成功!')
        return Response(ser.errors)

9.drf默认机制

1.drf会判断请求源是什么，会返回不同的请求格式
    如果是postman的话，会直接返回json
    如果是浏览器，会返回好看的渲染页面
2. 如果不返回好看的页面在浏览器加上?format=json

other

1.django查找模板的顺序
    1.1 优先在根目录下查找templates
    1.2 根据app的注册顺序去每个app的templates目录中去找

2.在url路由里面最后添加终止符，防止其他路由匹配截胡
3.drf的配置都写在settings里面

pass