django rest framework

 

django rest framework

一. 什么是RESTful 

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

 

二. RESTful API设计

API与用户的通讯协议，老是使用HTTPs协议。

restful 规范（10）：

按url来记，从左到右, 而后发送请求，在返回响应

		1. 根据method不一样，进行不一样操做 6
			GET/POST/PUT/DELETE/PATCH
		2. 面向资源编程 4  使用名词表示资源
			http://www.luffycity.com/salary
		 
		3. 体现版本 3
			http://www.luffycity.com/v1/salary
			http://www.luffycity.com/v2/salary
			
			https://v4.bootcss.com/
			https://v3.bootcss.com/
		4. 体现是API 2
			http://www.luffycity.com/api/v1/salary
			http://www.luffycity.com/api/v2/salary	
			
			http://api.luffycity.com/v1/salary	
			http://api.luffycity.com/v2/salary	
		5. https 1
			https://www.luffycity.com/api/v1/salary
			https://www.luffycity.com/api/v2/salary	
			
		6. 响应式设置状态码  8
			200
			300
			400
			500
			return HttpResponse('adfasdf',status=300)
		
		7. 条件 5
			https://www.luffycity.com/api/v2/salary?page=1&size=10
		
		8. 返回值  7
			https://www.luffycity.com/api/v2/salary
			GET: 全部列表
			{
				code: 10000,
				data: [    
					{'id':1,'title':'高亮'},
					{'id':1,'title':'龙泰'},
					{'id':1,'title':'小东北'},
				]
			}
				
			POST: 返回新增的数据
				{'id':1,'title':'高亮'}
				
			https://www.luffycity.com/api/v2/salary/1/
			GET: 获取单条数据
					{'id':1,'title':'高亮'}
			PUT：更新
					{'id':1,'title':'高亮'}
			PATCH: 局部更新
					{'id':1,'title':'高亮'}
			DELETE：删除
				
		9. 返回错误信息  9
			{
				code: 100001,
				error: 'xxx错误'
			}
		
		10. Hypermedia API  10
			ret = {
				code: 1000,
				data:{
					id:1,
					name:'小强',
					depart_id:http://www.luffycity.com/api/v1/depart/8/
				}
			}
	
		建议你们使用restful规范

摘自：http://www.ruanyifeng.com/blog/2014/05/restful_api.html 　　

django rest framework框架的做用：

--->>>  基于这个组件来帮助咱们快速的开发符合restful规范的接口，它是Django里面的一个组件，这个组件为咱们提供了如下的功能：
		- 权限
		- 认证
		- 访问频率限制
		- 序列化   把queryset数据转变为json数据给用户返回.
		- 路由 
		- 视图
			面试题：你的写的类都继承过哪些类？
			class View(object):
			
			class APIView(View):
			
			class GenericAPIView(views.APIView):
			
			class GenericViewSet(ViewSetMixin, generics.GenericAPIView)
			# ViewSetMixin 是对as_view里面的参数进行处理
			
			class ModelViewSet(mixins.CreateModelMixin,
                   mixins.RetrieveModelMixin,
                   mixins.UpdateModelMixin,
                   mixins.DestroyModelMixin,
                   mixins.ListModelMixin,
                   GenericViewSet):
		- 分页 
		- 解析器
		- 渲染器
		- 版本 
	按照HTTP请求的生命周期去记； 先是进入路由，在视图，进入dispatch（）里面，然
	后提供的是版本，权限，认证，频率，而后从 解析器()里面取数据，再序列化，分页，渲染器。

三. 基于Django实现

路由系统：

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^books$', views.BookView.as_view(),name='books')]

 

视图函数CBV:

class BookView(APIView):

	# def get(self,request):
	# 	book_list = Book.objects.all()
	#
	# 	#序列化方式1： 取全部的字段，封装为 列表里面套 字典的形式
	# 	# from django.forms.models import model_to_dict
	# 	#
	# 	# data=[]
	# 	# for obj in book_list:
	# 	# 	data.append(model_to_dict(obj))
	# 	# print(data)
	# 	# 序列化方式2:  跟第一种差很少。
	# 	# data = serializers.serialize("json", book_list)
	# 	# return HttpResponse(data)
	# 	# 序列化方式3:
	# 	bs = BookModelSerializers(book_list, many=True,context={'request': request})
	# 	return Response(bs.data)

	def get(self,request):
		return RequestView(Book,BookModelSerializers,self).get(request)

	def post(self,request):

		# print(request.data)  #获得提交的数据，是一个对象
		# bs = BookModelSerializers(data=request.data)  # many=True是序列化一个querset对象的一个列表；
		# if bs.is_valid():
		# 	print(bs.validated_data)
		# 	bs.save()
		# 	return Response(bs.data)
		# else:
		# 	return Response(bs.errors)
		

　　

django rest framework的源码流程

按照上面的代码分析：

1.当咱们访问请求的时候，将会执行路由系统中的views.BookView.as_view()

 2.当前咱们本身写的这个类没有as_view()方法，所以会找父类的as_view()方法；即在APIView的as_view()方法

 

 

super(APIView,cls)------>为当前父类（view）

super(APIView,cls) 首先找到 APIView的父类（就是类view），而后把 APIView类转换为 view类；

super(APIView,self)------>为当前父类（view）的对象;

3.执行父类view下的as_view()方法:

 

 

 即经过上面的源码能够知道，当请求来的时候，首先会执行 当前调用as_view()方法的这个类的dispatch方法。

因为咱们本身没有写dispatch方法，因此会调用父类的APIView下面的dispatch方法。

4.执行APIView下面的dispatch方法

 

 

 5.具体执行self.initialize_request(request, *args, **kwargs)的方法

initialize_request是APIView类里面的一个方法，从新封装了request对象，增长了一些属性信息

 

 

 认证信息。主要经过APIView类中的get_authenticators(rest_framework/views.py)方法获取，这个方法会返回一个全部认证对象的列表

在全局定义的

DEFAULT_AUTHENTICATION_CLASSES

authentication_classes = api_settings.DEFAULT_AUTHENTICATION_CLASSES

　　

 

咱们本身也能够在本身写的这个views.BookView下自定制一个类属性

authentication_classes=[TokenAuth,] 

TokenAuth

from rest_framework import exceptions

from rest_framework.authentication import BaseAuthentication
from .models import *


class TokenAuth(BaseAuthentication):
	def authenticate(self, request):
		token = request.GET.get("token")
		token_obj = Token.objects.filter(token=token).first()
		if not token_obj:
			raise exceptions.AuthenticationFailed("验证失败123!")
		else:
			return token_obj.user.pk, token_obj.token

	# def authenticate_header(self, request):
	#     pass
	# 只是咱们继承了BaseAuthentication的认证组件 就不用写了。

　　

默认的认证配置信息是在rest_framework/settings.py文件中定义的

 

 

 

 6.dispatch中的initialize_request方法执行完成以后，还有执行一个重要方法是self.initial(request, *args, **kwargs)，这个方法也是APIView类里的。在这个方法里面初始化
被从新封装的request对象

实现功能：

• 版本处理
• 用户认证
• 权限
• 访问频率限制

版本组件：

 

 

 执行self.determine_version(request, *args, **kwargs)的结果返回的是一个元组（版本号，版本对象）

 

版本放在url 里面的用这个类

from rest_framework.versioning import URLPathVersioning

版本放在url 后面做为参数的用这个类

from rest_framework.versioning import QueryParameterVersioning

设置版本及获取版本

a. 基于url的get传参方式

 

 

 

 

 

 

REST_FRAMEWORK = {
    'DEFAULT_VERSION': 'v1',            # 默认版本
    'ALLOWED_VERSIONS': ['v1', 'v2'],   # 容许的版本
    'VERSION_PARAM': 'version'          # URL中获取值的key
}

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.versioning import QueryParameterVersioning


class TestView(APIView):
    versioning_class = QueryParameterVersioning

    def get(self, request, *args, **kwargs):

        # 获取版本
        print(request.version)
        # 获取版本管理的类
        print(request.versioning_scheme)

        # 反向生成URL
        reverse_url = request.versioning_scheme.reverse('test', request=request)
        print(reverse_url)

        return Response('GET请求，响应内容')

    def post(self, request, *args, **kwargs):
        return Response('POST请求，响应内容')

    def put(self, request, *args, **kwargs):
        return Response('PUT请求，响应内容')

更多的版本的传参方式点击　　

认证组件：

 

 

执行APIView里面的perform_authentication方法，该方法返回request.user,则会调用新封装的Request对象里面的user方法。在user方法里面最终调用了Request类里面的_authenticate方法 

 

 

 

 

 

 执行rest_framework.request.Request类中的_authenticate方法，这个方法会遍历认证类，并根据认证结果给self.user, self.auth赋值。因为user,和auth都有property属性，
因此给赋值的时候先在先执行setter方法

 

 

 self.authenticators就是包含当前类下面全部的认证组件类的对象的一个列表。遍历列表，执行 对象.authenticate()。

authenticate方法的返回值为一个元组（user_auth_tuple）  

self.user,self.auth=user_auth_tuple

 

 

 上面其余两个 权限；访问频率限制的原理跟认证是同样的。

 7.dispatch中的initial方法执行完以后，会继续判断request.method并执行method相应的method.

 

 8.执行BookView中定义的请求方法，返回数据

 

Django Rest Framework框架组件的执行流程

rest framework组件为咱们提供了下面的这些功能：
按照HTTP请求的生命周期去记； 先是进入路由，在视图，进入dispatch（）里面，然
后提供的是版本，权限，认证，频率，而后从 解析器()里面取数据，再序列化，分页，渲染器。　　

这些功能详细的使用点击我