python之Django rest_framework总结，,一、rest api

python之Django rest_framework总结，,一、rest api

一、rest api

a、api就是接口

如：- http://www.oldboyedu.com/get_user/

- http://www.oldboyedu.com/get_users/

b、api的两个用途

1、为别人提供服务

2、前后端分离

二、restful

a、--字面意思：表征状态转移

b、面向资源编程，对互联网上的任意东西都视为资源

如：- http://www.oldboyedu.com/get_user/

- http://www.oldboyedu.com/get_img/1.png

三、restful规范

a、 ---URL

b、 ---url名词

路径，视网络上任何东西都是资源，均使用名词表示（可复数）  https://api.example.com/v1/zoos  https://api.example.com/v1/animals  https://api.example.com/v1/employee

c、 ---status状态码

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 - [*]：服务器发生错误，用户将无法判断发出的请求是否成功。

d、---提交方式

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

e、 ---错误信息

状态码是4xx时，应返回错误信息，error当做key。{    error: "Invalid API key"}

f、---版本

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

h、---域名

j、---过滤，通过在url上传参的形式传递搜索条件

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

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

rest_Framework的规范：

按顺序：它的method的不同，原来没有考虑，原来是url区分，现在通过method来区分，method的不同提交方式不同，紧接着一般是面向资源的就是把url变成名词，接下就是返回值，以前没有考虑状态码，现在有考虑状态码。（一般有get，post方法，还有put,delete等方法）

四、基于Django Rest Framework框架实现

a、安装：pip3 install djangorestframework -i http://pypi.douban.com/simple/ --trusted-host=pypi.douban.com

五、什么是RESTful

a、django的中间件比rest_framework执行的早

b、认证的功能放到中间件也是可以做的

c、认证一般做，检查用户是否存在，如果存在request.user/request.auth;不存在request.user/request.auth=None

d、认证小总结：

  ---类：authenticate/authenticate_header      ---返回值：None,元组（user,auth）,异常      ---配置：                 ---视图：                                                          class IndexView(APIView):                                           authentication_classes = [MyAuthentication,]                 ---全局                                                        REST_FRAMEWORK = {                                                ‘UNAUTHENTICATED_USER‘: None,                                                ‘UNAUTHENTICATED_TOKEN‘: None,                                                "DEFAULT_AUTHENTICATION_CLASSES": [                                                 # "app02.utils.MyAuthentication",                                                ],                                               }

六、权限

a、权限才真正的做request.user/request.auth拿到它们做是否访问的判断

b、权限小总结：

     ---类：       has_permission/has_object_permission     ---返回值：True、False、exceptions.PermissionDenied(detail="错误信息")     ---配置：               ---视图：                                                  class IndexView(APIView):                                       permission_classes = [MyPermission,]                      ---全局：                                REST_FRAMEWORK = {                                "DEFAULT_PERMISSION_CLASSES": [                                # "app02.utils.MyAuthentication",                                 ],                               }

七、限制访问的频率

限制访问频率的应用：

a、对匿名用户进行限制，每个用户1分钟允许访问10次

在这里用唯一标识：self.get_ident()

b、限制访问的频率小总结：

  ---类：       allow_request/wait PS: scope = "wdp_user"     ---返回值：True、False     ---配置：                  ---视图：                                            class IndexView(APIView):                                                     throttle_classes=[AnonThrottle,UserThrottle,]                                                     def get(self,request,*args,**kwargs):                                                     self.dispatch                                                     return Response(‘访问首页‘)                   ---全局：                                          REST_FRAMEWORK = {                                                      "DEFAULT_THROTTLE_CLASSES":[                                                   ],                                                      ‘DEFAULT_THROTTLE_RATES‘:{                                                      ‘wdp_anon‘:‘5/minute‘,                                                      ‘wdp_user‘:‘10/minute‘,                                                   }                                                   }

八、认证、权限、限制访问频率返回结果的比较

1、认证、权限、限制访问频率这三个返回的结果：

a、认证返回的三种结果：
a、None
b、元组(user,auth)
c、异常 raise APIException(...)

b、权限的返回值三种结果：

a、True 有权限
b、False 没权限
c、异常

c、限制访问的频率返回值的两种结果：

a、True
b、False

实例化：v1 = ["view.xxx.path.Role","view.xxx.path.Group",]    可以循环，循环出来的每一个不能实例化如果把v1循环弄成每一个对象列表，通过rsplit切割，在通过importlib.import_module拿到每一个路径，在通过getattr把它的类名拿过来，这个类加括号就是实例化想for item in v1:m = importlib.import_module(‘view.xxx.path‘)cls = getattr(m,‘Role‘)cls()from view.xxx.path import Role,Group      v2 = [Group,Role]      这个可以循环每一个实例化for item in v2:     #循环V2的每一个元素加括号，就是实例化item()

九、Django rest_Framework框架

a、----为什么用Django rest_Framework框架？

----首先没有Django rest_Framework框架用django也是可以做出来的，只不过它为我们提供一些API常用的功能，比如：（认证，权限，限流，有了这些我们只需要写个类已配置，
它就能当都市图用，还能全局配置，如果自己写还得写中间件，写装饰器来实现，通过Django rest_Framework框架，他已经把规则写好，只需要写类，只需实现方法，返回值就可以）
实现了一部分功能。  ----设计比较好            ----单独视图+全局配置 =>Dajngo中间件（importlib/反射）=>动态配置课扩展（短信，邮件，微信等提醒）

b、Django rest_Framework原理？

先开始在路由，路由.as_view，

点击as_view

请求进来，走完以上，才走self.dispatch()

走self.dispatch()流程如下地址：http://www.cnblogs.com/mengqingjian/p/8419563.html

十、版本

a、根据url的不同来来操作，版本控制

先在setting中注册

十一、rest framework解析器

a、请求的数据进行解析：请求体进行解析。表示服务端可以解析的数据格式的种类。

Content-Type: application/url-encoding.....            request.body            request.POST                        Content-Type: application/json.....            request.body            request.POST                客户端：            Content-Type: application/json            ‘{"name":"alex","age":123}‘                服务端接收：            读取客户端发送的Content-Type的值 application/json                        parser_classes = [JSONParser,]            media_type_list = [‘application/json‘,]                    如果客户端的Content-Type的值和 application/json 匹配：JSONParser处理数据            如果客户端的Content-Type的值和 application/x-www-form-urlencoded 匹配：FormParser处理数据                        配置：            单视图：            class UsersView(APIView):                parser_classes = [JSONParser,]                            全局配置：                REST_FRAMEWORK = {                    ‘VERSION_PARAM‘:‘version‘,                    ‘DEFAULT_VERSION‘:‘v1‘,                    ‘ALLOWED_VERSIONS‘:[‘v1‘,‘v2‘],                    # ‘DEFAULT_VERSIONING_CLASS‘:"rest_framework.versioning.HostNameVersioning"                    ‘DEFAULT_VERSIONING_CLASS‘:"rest_framework.versioning.URLPathVersioning",                    ‘DEFAULT_PARSER_CLASSES‘:[                        ‘rest_framework.parsers.JSONParser‘,                        ‘rest_framework.parsers.FormParser‘,                    ]                }

十二、 rest framework序列化+Form

a、序列化：

对象 -> 字符串 序列化
字符串 -> 对象 反序列化

b、目的：
解决QuerySet序列化问题

十三、为什么要前后端分离

a、因为前端它有自己框架，这样它的效率就非常高

b、不做前后端分离，公司如果既有客户端，又有app这种情况下你就的写两遍

十四、django restful框架好处

帮助我们写了好多组件比如：

a、认证：有类，类中的方法authenticate/authenticate_header，它的返回值有None,元组，异常。如果返回值为None那就不管，它是匿名用户。

b、权限：有类，类中的方法：has_permission

c、节流：有类，类的方法：allow_request,在这里allow_request来表示限制，它是通过IP来限制，

 它的内部原理是：默认是IP，用户来用IP，这个IP可能代理IP，IP或者是代理IP拿着请求头默认放到大家能够的缓存中                          
去，每一个人的IP为p，后面的那个列表存它的方位时间，每一次请求进来获取它的当前时间根据时间的个数来比较，在                        
比较的过程中看看把不符合时间的个数来进行比较，能访问就继续，不能访问就不要继续。

d、版本：是url和hostname,他们两个钟每一个都有两个方法一个是帮你拿版本另一个是帮你反向生成url

e、解析器：用户发过来的请求体数据进行操作

f、序列化：两个功能：序列化，校验

十五、分页

分页的三种情况：

a、记录当前访问页的数据id

b、最多显示120页

c、对页码进行加密

a、基于limit offset做分页

class P1(LimitOffsetPagination):                    max_limit = 3                default_limit = 2                limit_query_param = ‘limit‘                offset_query_param = ‘offset‘                                                class IndexView(views.APIView):                def get(self,request,*args,**kwargs):                    user_list = models.UserInfo.objects.all()                    p1 = P1()                    page_user_list = p1.paginate_queryset(queryset=user_list, request=request, view=self)                    ser = IndexSerializer(instance=page_user_list, many=True)                    return Response(ser.data) # 不含上一页和下一页                    # return p1.get_paginated_response(ser.data) # 含上一页和下一页                                class IndexView(views.APIView):                def get(self,request,*args,**kwargs):                    ret = BaseResponse()                    try:                        user_list = models.UserInfo.objects.all()                        p1 = P1()                        page_user_list = p1.paginate_queryset(queryset=user_list,request=request,view=self)                        ser = IndexSerializer(instance=page_user_list,many=True)                        ret.data = ser.data                        ret.next = p1.get_next_link()                    except Exception as e:                        ret.code= 1001                        ret.error = ‘xxxx错误‘                    return Response(ret.__dict__)

b. 基于页码的分页

class P2(PageNumberPagination):                # 每页显示的数据条数                max_page_size = 5                page_size = 2                page_size_query_param = ‘size‘                # 页码                page_query_param = ‘page‘

十六、视图

1、APIView

class IndexView(views.APIView):                    def get(self, request, *args, **kwargs):                        user_list = models.UserInfo.objects.all()                        ser = IndexSerializer(instance=user_list,many=True)                        return Response(ser.data)

2、GenericAPIview(APIView)

3、GenericViewSet(ViewSetMixin,generics.GenericAPIView)

路由修改：                    urlpatterns = [                        url(r‘^index/$‘, views.IndexView.as_view({‘get‘:‘list‘,‘post‘:‘create‘})),                        url(r‘^index/(?P<pk>\d+)$‘, views.IndexView.as_view({‘get‘:‘retrieve‘})),                    ]                                视图修改：                                        class IndexView(viewsets.GenericViewSet):                        def list(self,request,*args,**kwargs):                             pass # 获取列表信息                        def retrieve(self, request, *args, **kwargs):                            pass  # 获取单条数据                        def create(self,request, *args, **kwargs):                            pass                                                自定义：                                            增                            POST                            /users/                        删                            DELETE                            /users/1/                        改                            PUT                            /users/1/                                                        patch                            /users/1/                        查                            GET                            /users/                             GET                            /users/1/                                                    urlpatterns = [                            url(r‘^index/$‘, views.IndexView.as_view()),                            url(r‘^index/(?P<pk>\d+)$‘, views.IndexView.as_view()),                        ]                                                    class IndexView(views.APIView):                            def get(self,request,*args,**kwargs):                                pk = kwargs.get(‘pk‘)                                if pk:                                    pass # 获取单条信息                                else:                                    pass # 获取列表信息                            def post(self,request,*args,**kwargs):                                pass                            def put(self,request,*args,**kwargs):                                pass                            def patch(self,request,*args,**kwargs):                                pass                            def delete(self,request,*args,**kwargs):                                pass

4、ModelViewSet

ModelViewSet(mixins.CreateModelMixin,mixins.RetrieveModelMixin,mixins.UpdateModelMixin,mixins.DestroyModelMixin,mixins.ListModelMixin,GenericViewSet)                                                class IndexView(ModelViewSet):

十七、渲染器
看到的页面时什么样子的，返回数据。
renderer_classes = [JSONRenderer,BrowsableAPIRenderer]

十八、跨域

a、 浏览器的同源策略

1、 ----对ajax请求进行阻拦

2、 ----对href属性读不阻拦

xhr=new XMLHttpRequest

xhr.open...

xhr.send(...)

b、 解决方案：

---JSONP

点击按钮：

动态添加一个

<script src=‘http://www.baidu.com/users/‘></script>                        <script>                            function func(arg){                                alert(arg)                            }                        </script

c、删除

<script src=‘http://www.baidu.com/users/‘></script>

python之Django rest_framework总结