reverse反解析

 #路由中定义namespace、name，reverse可将其转换为url

 url = reverse('namespace：name')

 return redirect（url）

HttpRequest对象

1.路径参数

　　位置参数

应用中urls.py
```
 url(r'^(\d+)/(\d+)/$', views.index),
```

视图中函数: 参数的位置不能错

def index(request, value1, value2):

      # 构造上下文

      context = {'v1':value1, 'v2':value2}

      return render(request, 'Book/index.html', context)

　　关键字参数

应用中urls.py
- 其中?P<value1>部分表示为这个参数定义的名称为value1
- 可以是其它名称，起名要做到见名知意
```
url(r'^(?P<value1>\d+)/(?P<value2>\d+)/$', views.index),
```

视图中函数: 参数的位置可以变，跟关键字保持一致即可

def index(request, value2, value1):

      # 构造上下文

      context = {'v1':value1, 'v2':value2}

      return render(request, 'Book/index.html', context)

2.查询字符串Query String

　　获取请求路径中的查询字符串参数（形如?k1=v1&k2=v2），可以通过request.GET属性获取，返回QueryDict对象。

 # /get/?a=1&b=2&a=3

 def get(request):

     a = request.GET.get('a')

     b = request.GET.get('b')

     alist = request.GET.getlist('a')

     print(a)  #

     print(b)  #

     print(alist)  # ['1', '3']

     return HttpResponse('OK')

3.表单类型 Form Data

前端发送的表单类型的请求体数据，可以通过request.POST属性获取，返回QueryDict对象。

 def post(request):

     a = request.POST.get('a')

     b = request.POST.get('b')

     alist = request.POST.getlist('a')

     print(a)

     print(b)

     print(alist)

     return HttpResponse('OK')

4.非表单类型 Non-Form Data

非表单类型的请求体数据，Django无法自动解析，可以通过request.body属性获取最原始的请求体数据，自己按照请求体格式（JSON、XML等）进行解析。request.body返回bytes类型。

例如要获取请求体中的如下JSON数据

{"a": 1, "b": 2}

可以进行如下方法操作：

 import json

 def post_json(request):

     json_str = request.body

     json_str = json_str.decode()  # python3.6 无需执行此步

     req_data = json.loads(json_str)

     print(req_data['a'])

     print(req_data['b'])

     return HttpResponse('OK')

5.请求头

可以通过request.META属性获取请求头headers中的数据，request.META为字典类型。

常见的请求头如：

CONTENT_LENGTH– The length of the request body (as a string).
CONTENT_TYPE– The MIME type of the request body.
HTTP_ACCEPT– Acceptable content types for the response.
HTTP_ACCEPT_ENCODING– Acceptable encodings for the response.
HTTP_ACCEPT_LANGUAGE– Acceptable languages for the response.
HTTP_HOST– The HTTP Host header sent by the client.
HTTP_REFERER– The referring page, if any.
HTTP_USER_AGENT– The client’s user-agent string.
QUERY_STRING– The query string, as a single (unparsed) string.
REMOTE_ADDR– The IP address of the client.
REMOTE_HOST– The hostname of the client.
REMOTE_USER– The user authenticated by the Web server, if any.
REQUEST_METHOD– A string such as"GET"or"POST".
SERVER_NAME– The hostname of the server.
SERVER_PORT– The port of the server (as a string).

具体使用如:

def get_headers(request):

    print(request.META['CONTENT_TYPE'])

    return HttpResponse('OK')

6.其他常用HttpRequest对象属性

method：一个字符串，表示请求使用的HTTP方法，常用值包括：'GET'、'POST'。
user：请求的用户对象。
path：一个字符串，表示请求的页面的完整路径，不包含域名和参数部分。
encoding：一个字符串，表示提交的数据的编码方式。
- 如果为None则表示使用浏览器的默认设置，一般为utf-8。
- 这个属性是可写的，可以通过修改它来修改访问表单数据使用的编码，接下来对属性的任何访问将使用新的encoding值。
FILES：一个类似于字典的对象，包含所有的上传文件。

HttpResponse对象

1 HttpResponse

可以使用django.http.HttpResponse来构造响应对象。

HttpResponse(content=响应体, content_type=响应体数据类型, status=状态码)

 from django.http import HttpResponse

 def response(request):

     return HttpResponse('itcast python', status=400)

     或者

     response = HttpResponse('itcast python')

     response.status_code = 400

     response['itcast'] = 'Python'

     return response

2 HttpResponse子类

Django提供了一系列HttpResponse的子类，可以快速设置状态码

HttpResponseRedirect 301
HttpResponsePermanentRedirect 302
HttpResponseNotModified 304
HttpResponseBadRequest 400
HttpResponseNotFound 404
HttpResponseForbidden 403
HttpResponseNotAllowed 405
HttpResponseGone 410
HttpResponseServerError 500

3 JsonResponse

若要返回json数据，可以使用JsonResponse来构造响应对象，作用：

帮助我们将数据转换为json字符串
设置响应头Content-Type为application/json

 from django.http import JsonResponse

 def response(request):

     return JsonResponse({'city': 'beijing', 'subject': 'python'})

4 redirect重定向

 from django.shortcuts import redirect

 def response(request):

     return redirect('/get_header')

cookie和session

示例代码：

 def set_cookie(request):

     '''设置cookie'''

     name=request.GET.get('name')

     pwd=request.GET.get('pwd')

     response=HttpResponse('set cookie')

     response.set_cookie('name',name)

     response.set_cookie('pwd',pwd,max_age=60)

     return response

 def get_cookie(request):

     '''获取cookie'''

     name=request.COOKIES.get('name')

     pwd=request.COOKIES.get('pwd')

     return HttpResponse("name:%s,pwd:%s"%(name,pwd))

 def del_cookie(request):

     '''删除cookie'''

     response=HttpResponse('del cookie')

     response.delete_cookie('name')

     return response

 def to_session(request):

     '''session操作'''

     name=request.COOKIES.get('name')

     # 1） 以键值对的格式写session。

     request.session['name']=name

     # 2）根据键读取值。

     session_name=request.session.get('name')

     return HttpResponse('%s'%session_name)

     # 3）清除所有session，在存储中删除值部分。

     request.session.clear()

     # 4）清除session数据，在存储中删除session的整条数据。

     request.session.flush()

     # 5）删除session中的指定键及值，在存储中只删除某个键及对应的值。

     del request.session['name']

     # 6）设置session的有效期单位秒

     request.session.set_expiry(60)

中间件

1 .中间件的定义方法

定义一个中间件工厂函数，然后返回一个可以被调用的中间件。

中间件工厂函数需要接收一个可以调用的get_response对象。

返回的中间件也是一个可以被调用的对象，并且像视图一样需要接收一个request对象参数，返回一个response对象。

 def simple_middleware(get_response):

     # 此处编写的代码仅在Django第一次配置和初始化的时候执行一次。

     def middleware(request):

         # 此处编写的代码会在每个请求处理视图前被调用。

         response = get_response(request)

         # 此处编写的代码会在每个请求处理视图之后被调用。

         return response

     return middleware

示例代码

2.例如，在book应用中新建一个middleware.py文件

 def my_middleware(get_response):

     print('init 被调用')

     def middleware(request):

         print('before request 被调用')

         response = get_response(request)

         print('after response 被调用')

         return response

     return middleware

3.定义好中间件后，需要在settings.py 文件中添加注册中间件

 MIDDLEWARE = [

     'django.middleware.security.SecurityMiddleware',

     'django.contrib.sessions.middleware.SessionMiddleware',

     'django.middleware.common.CommonMiddleware',

     # 'django.middleware.csrf.CsrfViewMiddleware',

     'django.contrib.auth.middleware.AuthenticationMiddleware',

     'django.contrib.messages.middleware.MessageMiddleware',

     'django.middleware.clickjacking.XFrameOptionsMiddleware',

     'book.middleware.my_middleware',  # 添加中间件

 ]

rest_framework实现序列化器

1.配置文件setting

INSTALLED_APPS = [

    'rest_framework'

]

2.创建序列化器文件 serializers.py

　　方式一继承Serializer

 from rest_framework import serializers

 from book.models import BookInfo

 class BookInfoSerializer(serializers.Serializer):

     '''书籍数据序列化'''

     def custom_validate(value):

         if value == 'hehe':

             raise serializers.ValidationError('书名不能为hehe')

     id = serializers.IntegerField(label='id', read_only=True)

     name = serializers.CharField(label='书名', max_length=20, validators=[custom_validate])  # validators为自定义限定函数集

     click_count = serializers.IntegerField(label='点击量', required=False)

     scan_count = serializers.IntegerField(label='浏览量', required=False)

     image = serializers.ImageField(label='封面', required=False)

     create_time = serializers.DateTimeField(label='创建时间', required=False)

     peopleinfo_set = serializers.PrimaryKeyRelatedField(read_only=True, many=True)

     def validate_click_count(self, value):  # 指定字段限定条件，命名方式为validate_字段名，接收字段值value

         if value < 0:

             raise serializers.ValidationError('点击量不能小于0')

         return value

     def validate_scan_count(self, value):

         if value < 0:

             raise serializers.ValidationError('浏览量不能小于0')

         return value

     def validate(self, attrs): # 多个字段限定条件，固定函数名validate，传入字典字段值attrs

         click_count = attrs.get('click_count')

         scan_count = attrs.get('scan_count')

         if click_count > scan_count:

             raise serializers.ValidationError('浏览量不能小于点击量')

         return attrs

     def create(self, validated_data):

         '''新增数据'''

         return BookInfo.objects.create(**validated_data)

     def update(self, instance, validated_data):

         '''更新数据'''

         instance.name = validated_data.get('name', instance.name)

         instance.click_count = validated_data.get('click_count', instance.click_count)

         instance.scan_count = validated_data.get('scan_count', instance.scan_count)

         instance.create_time = validated_data.get('create_time', instance.create_time)

         instance.save()

         return instance

　　方式二继承ModelSerializer

 from rest_framework import serializers

 from book.models import BookInfo

 class BookInfoSerializers(serializers.ModelSerializer):

     class Meta:

         model = BookInfo

         # fields='__all__' #取所有字段

         # fields=['id','name','click_count'] # 取该字典中的字段

         exclude = ['image']  # 取除了该字段的其他字段

         read_only_fields = ['id', 'click_count', 'scan_count']  # 只读字段

         # 字段限定条件

         extra_kwargs = {

             'click_count': {'min_value': 0, 'required': True},

             'scan_count': {'min_value': 0, 'required': True}

         }

rest_framework实现三个级别view

1.setting中增加如下：

 REST_FRAMEWORK = {

     'DEFAULT_RENDERER_CLASSES': (  # 默认响应渲染类

         'rest_framework.renderers.JSONRenderer',  # json渲染器

         'rest_framework.renderers.BrowsableAPIRenderer',  # 浏览API渲染器

     )

 }

2. 一级视图继承类 from rest_framework.views import APIView

 # 一级视图 继承类 from rest_framework.views import APIView

 from django.shortcuts import render

 from rest_framework.response import Response

 from rest_framework import status

 from rest_framework.views import APIView

 from book.models import BookInfo

 from book.serializers import BookInfoModelSerializer

 class BookListView(APIView):

     def get(self, request):

         books = BookInfo.objects.all() #获取BookInfo模型所有数据

         serializer = BookInfoModelSerializer(books, many=True) #初始化BookInfoModelSerializer序列化器

         return Response(serializer.data) #返回数据

     def post(self, request):

         data = request.data #获取请求数据

         serializer = BookInfoModelSerializer(data=data) #初始化BookInfoModelSerializer序列化器

         serializer.is_valid(raise_exception=True)#校验请求的数据，如果有异常抛出异常

         serializer.save()# 保存操作

         return Response(serializer.data)#返回数据

 class BookDetailView(APIView):

     def get(self, request, id):

         book = BookInfo.objects.get(id=id) #查询模型BookInfo中指定数据

         serializer = BookInfoModelSerializer(book) #初始化BookInfoModelSerializer序列化器

         return Response(serializer.data) #返回数据

     def put(self, request, id):

         book = BookInfo.objects.get(id=id)#查询模型BookInfo中指定数据

         data = request.data# 获取请求数据

         serializer = BookInfoModelSerializer(book, data=data)#初始化BookInfoModelSerializer序列化器

         serializer.is_valid(raise_exception=True) #校验数据，如异常抛出

         serializer.save() #保存数据

         return Response(serializer.data)#返回数据

     def delete(self, request, id):

         book = BookInfo.objects.get(id=id)# 查询模型BookInfo中指定数据

         book.delete()# 删除数据

         return Response(status=status.HTTP_204_NO_CONTENT)#返回状态

 urlpatterns=[

     # 一级视图 继承类 from rest_framework.views import APIView

     url(r'^booklist/$',views.BookListView.as_view(),name='booklist'),

     url(r'^bookdetail/(?P<id>\d+)$',views.BookDetailView.as_view(),name='bookdetail'),

 ]

urls Code

3. 二级视图继承类 from rest_framework.generics import GenericAPIView

 # 二级视图 继承类 from rest_framework.generics import GenericAPIView

 from rest_framework.generics import GenericAPIView

 from book.models import BookInfo

 from book.serializers import BookInfoModelSerializer

 from rest_framework.response import Response

 class BookListGenericAPIView(GenericAPIView):

     queryset = BookInfo.objects.all()# 获取所有数据赋值给queryset

     serializer_class = BookInfoModelSerializer #初始化序列化器属性

     def get(self, request):

         books = self.get_queryset()  # 通过父类方法获取queryset

         serializer = self.get_serializer(books, many=True)  # 通过父类方法获取serializer_class

         return Response(serializer.data) #返回数据

     def post(self, request):

         data = request.data #获取请求数据

         serializer = self.get_serializer(data=data)

         serializer.is_valid(raise_exception=True)#校验数据，如异常抛出

         serializer.save()#保存数据

         return Response(serializer.data)#返回数据

 class BookDetailGenericAPIView(GenericAPIView):

     queryset = BookInfo.objects.all()# 获取所有数据赋值给queryset

     serializer_class = BookInfoModelSerializer#初始化序列化器属性

     # lookup_field = 'pk' #默认参数为pk

     lookup_field = 'id'  # 可重写父类属性

     def get(self, request, id):

         book = self.get_object()#通过父类方法获取模型中指定数据

         serializer = self.get_serializer(book)# 通过父类方法获取序列化器

         return Response(serializer.data)#返回数据

     def put(self, request, id):

         book = self.get_object()

         serializer = self.get_serializer(instance=book, data=request.data)

         serializer.is_valid(raise_exception=True)

         serializer.save()

         return Response(serializer.data)#返回数据

     def delete(self, request, id):

         book = self.get_object()

         book.delete()

         return Response(status=status.HTTP_204_NO_CONTENT)#返回状态

 urlpatterns=[

     # 二级视图 继承类 from rest_framework.generics import GenericAPIView

     url(r'^booklistgeneric/$', views.BookListGenericAPIView.as_view(), name='booklistgeneric'),

     url(r'^bookdetailgeneric/(?P<id>\d+)$', views.BookDetailGenericAPIView.as_view(), name='bookdetailgeneric'),

 ]

urls Code

3.1. 二级视图和Mixin配合使用,Mixin中已经封装了get、post、get、put、delete相应功能，对应方法list、create、retrieve、update、destroy

 # 二级视图和Mixin配合使用,Mixin中已经封装了get、post、get、put、delete相应功能，对应方法list、create、retrieve、update、destroy

 from rest_framework.mixins import ListModelMixin, CreateModelMixin

 from rest_framework.mixins import RetrieveModelMixin, UpdateModelMixin, DestroyModelMixin

 from rest_framework.generics import GenericAPIView

 class BookListMixinGenericAPIView(ListModelMixin, CreateModelMixin, GenericAPIView):

     # queryset = BookInfo.objects.all()

     # serializer_class = BookInfoModelSerializer

     # 重写父类方法，获取数据

     def get_queryset(self):

         return BookInfo.objects.all()

     # 重写父类方法，设置序列化器

     def get_serializer_class(self):

         return BookInfoModelSerializer

     def get(self, request):

         return self.list(request)

     def post(self, request):

         return self.create(request)

 class BookDetailMixinGenericAPIView(RetrieveModelMixin, UpdateModelMixin, DestroyModelMixin, GenericAPIView):

     # 获取所有数据赋值给queryset

     queryset = BookInfo.objects.all()

     # 设置序列化器属性

     serializer_class = BookInfoModelSerializer

     def get(self, request, pk):

         return self.retrieve(request)

     def put(self, request, pk):

         return self.update(request)

     def delete(self, request, pk):

         return self.destroy(request)

urlpatterns=[

    # 二级视图和Mixin配合使用

    url(r'^booklistmixingeneric/$', views.BookListMixinGenericAPIView.as_view(), name='booklistmixingeneric'),

    url(r'^bookdetailmixingeneric/(?P<pk>\d+)$', views.BookDetailMixinGenericAPIView.as_view(), name='bookdetailmixingeneric'),

]

urls Code

4.三级视图,高度封装

 # 三级视图,高度封装

 from rest_framework.generics import CreateAPIView,ListAPIView

 class BookListAPIView(ListAPIView,CreateAPIView):

     queryset = BookInfo.objects.all()

     serializer_class = BookInfoModelSerializer

 from rest_framework.generics import RetrieveAPIView, UpdateAPIView, DestroyAPIView

 class DetailAPIView(RetrieveAPIView, UpdateAPIView, DestroyAPIView):

     queryset = BookInfo.objects.all()

     serializer_class = BookInfoModelSerializer

 from rest_framework.generics import RetrieveDestroyAPIView, RetrieveUpdateAPIView, RetrieveUpdateDestroyAPIView

 urlpatterns=[

     # 三级视图

     url(r'^booklistapiview/$', views.BookListAPIView.as_view(), name='booklistapiview'),

     url(r'^detailapiview/(?P<pk>\d+)$', views.DetailAPIView.as_view(), name='detailapiview'),

 ]

urls Code

5.视图集ViewSet、ModelViewSet、ReadOnlyModelViewSet

 ##################################视图集 ##########################################

 """

 1. 有相同的相关业务逻辑 (对一个模型的 增删改查的操作)

 2. 列表试图和详情视图中 有重复的属性

 我们想到把 增删改查 放到一个视图中

 class Index(View):

     def list()              get

         pass

     def retrieve()          get

         pass

 """

 from rest_framework.viewsets import ViewSet

 from rest_framework.viewsets import ViewSet

 from django.shortcuts import get_object_or_404

 from rest_framework.response import Response

 class BookViewSet(ViewSet):

     def list(self,request):                 # 获取所有数据    GET

         queryset = BookInfo.objects.all()

         serializer = BookInfoModelSerializer(queryset,many=True)

         return Response(serializer.data)#返回数据

     def retrieve(self,request,pk=None):     #获取某一个      GET

         queryset = BookInfo.objects.all()

         user = get_object_or_404(queryset, pk=pk)

         serializer = BookInfoModelSerializer(user)

         return Response(serializer.data)#返回数据

 ##################################视图集 ModelViewSet##########################################

 ##################################视图集  action ##########################################

 from rest_framework.viewsets import ModelViewSet

 from rest_framework.decorators import action

 class BookModelViewSet(ModelViewSet):

     serializer_class = BookInfoModelSerializer

     queryset = BookInfo.objects.all()

     """

     单独给视图集添加方法(路由)

     1. 根据阅读量进行排序

     2. 只修改某一本书籍的名字

     """

     #根据阅读量进行排序

     # methods=None,  设置 允许以什么请求访问该方法 默认是get

     # detail=None

     # 因为我们的Router是自动生成url的

     # 如果detail 为True 表示 自动生成的url路由为: prefix/pk/函数名/

     # 如果detail 为False 表示 自动生成的url路由为: prefix/函数名/

     @action(methods=['GET'],detail=False)

     def book_readcount(self,request):

         #1. 对数据进行排序

         books = BookInfo.objects.all().order_by('readcount')

         #2. 用序列化器将对象列表转换为字典列表

         serialzier = self.get_serializer(books,many=True)

         #3.返回

         return Response(serialzier.data)#返回数据

     # detail为True表示单个实例，网址为这种形式：^prefix/{pk}/set_bookname/$

     @action(methods=['post'], detail=True)

     def set_bookname(self, request, pk=None):

         book = self.get_object()

         serializer = BookInfoModelSerializer(data=request.data)

         if serializer.is_valid():

             book.name = request.data['name']

             book.save()

             return Response({'message': '重置成功'})#返回数据

         else:

             return Response(serializer.errors,status=status.HTTP_400_BAD_REQUEST)#返回数据

 from rest_framework.viewsets import ReadOnlyModelViewSet

 class BookReadOnlyModelViewSet(ReadOnlyModelViewSet):

     queryset = BookInfo.objects.all()

     serializer_class = BookInfoModelSerializer

 from django.conf.urls import url

 from book import views

 from rest_framework.routers import DefaultRouter,SimpleRouter

 rounter = DefaultRouter()

 rounter.register(r'books',views.BookViewSet,base_name='')

 rounter.register(r'booksmodel',views.BookModelViewSet,base_name='')

 rounter.register(r'bookreadonlymodel',views.BookReadOnlyModelViewSet,base_name='')

 urlpatterns=[

     # url(r'^books/$',views.BookViewSet.as_view({'get':'list'})),

     # url(r'^books/(?P<pk>\d+)/$',views.BookViewSet.as_view({'get':'retrieve'})),

 ]

 urlpatterns += rounter.urls

 app_name='book'

urls Code

其他功能

1.认证Authentication

可以在配置文件中配置全局默认的认证方案

 REST_FRAMEWORK = {

     'DEFAULT_AUTHENTICATION_CLASSES': (

         'rest_framework.authentication.BasicAuthentication',   # 基本认证

         'rest_framework.authentication.SessionAuthentication',  # session认证

     )

 }

也可以在每个视图中通过设置authentication_classess属性来设置

 from rest_framework.viewsets import ModelViewSet

 from .serializers import BookSerializer

 from .models import BookInfo

 # Create your views here.

 #认证管理

 from rest_framework.authentication import SessionAuthentication

 class BookModelViewSet(ModelViewSet):

     """

     图书管理视图

     """

     serializer_class = BookSerializer

     def get_queryset(self):

         return BookInfo.objects.all()

     #认证管理

     #认证管理一般和权限管理配合使用

     # authentication_classes = [SessionAuthentication]

认证失败会有两种可能的返回值：

401 Unauthorized 未认证
403 Permission Denied 权限被禁止

2.权限Permissions

权限控制可以限制用户对于视图的访问和对于具体数据对象的访问。

在执行视图的dispatch()方法前，会先进行视图访问权限的判断
在通过get_object()获取具体对象时，会进行对象访问权限的判断

使用

可以在配置文件中设置默认的权限管理类，如

 REST_FRAMEWORK = {

     'DEFAULT_PERMISSION_CLASSES': (

         'rest_framework.permissions.IsAuthenticated',

     )

 }

如果未指明，则采用如下默认配置

 'DEFAULT_PERMISSION_CLASSES': (

    'rest_framework.permissions.AllowAny',

 )

也可以在具体的视图中通过permission_classes属性来设置，如

 from rest_framework.viewsets import ModelViewSet

 from .serializers import BookSerializer

 from .models import BookInfo

 # Create your views here.

 #认证管理

 from rest_framework.authentication import SessionAuthentication

 #权限管理

 from rest_framework.permissions import IsAuthenticated,AllowAny,IsAdminUser

 class BookModelViewSet(ModelViewSet):

     """

     图书管理视图

     """

     serializer_class = BookSerializer

     def get_queryset(self):

         return BookInfo.objects.all()

     #认证管理

     #认证管理一般和权限管理配合使用

     # authentication_classes = [SessionAuthentication] #权限管理

     # 通过python manager createsuperuser 就可以创建一个管理员账号,登录之后就可以访问

     # permission_classes = [IsAuthenticated]

提供的权限

AllowAny 允许所有用户
IsAuthenticated 仅通过认证的用户
IsAdminUser 仅管理员用户
IsAuthenticatedOrReadOnly 认证的用户可以完全操作，否则只能get读取

举例

 from rest_framework.authentication import SessionAuthentication

 from rest_framework.permissions import IsAuthenticated

 from rest_framework.generics import RetrieveAPIView

 class BookDetailView(RetrieveAPIView):

     queryset = BookInfo.objects.all()

     serializer_class = BookInfoSerializer

     authentication_classes = [SessionAuthentication]

     permission_classes = [IsAuthenticated]

自定义权限

如需自定义权限，需继承rest_framework.permissions.BasePermission父类，并实现以下两个任何一个方法或全部

```
has_permission(self, request, view)
```
是否可以访问视图， view表示当前视图对象
```
has_object_permission(self, request, view, obj)
```
是否可以访问数据对象， view表示当前视图， obj为数据对象

class MyPermission(BasePermission):

    def has_object_permission(self, request, view, obj):

        """控制对obj对象的访问权限，此案例决绝所有对对象的访问"""

        return False

class BookInfoViewSet(ModelViewSet):

    queryset = BookInfo.objects.all()

    serializer_class = BookInfoSerializer

    permission_classes = [IsAuthenticated, MyPermission]

3.限流Throttling

微博限流文档

可以对接口访问的频次进行限制，以减轻服务器压力。

使用

可以在配置文件中，使用DEFAULT_THROTTLE_CLASSES和DEFAULT_THROTTLE_RATES进行全局配置，

 REST_FRAMEWORK = {

     'DEFAULT_THROTTLE_CLASSES': (

         'rest_framework.throttling.AnonRateThrottle',

         'rest_framework.throttling.UserRateThrottle'

     ),

     'DEFAULT_THROTTLE_RATES': {

         'anon': '100/day',

         'user': '1000/day'

     }

 }

 #DEFAULT_THROTTLE_RATES可以使用second,minute,hour或day来指明周期。

也可以在具体视图中通过throttle_classess属性来配置，如

 from rest_framework.throttling import UserRateThrottle

 from rest_framework.views import APIView

 class ExampleView(APIView):

     throttle_classes = (UserRateThrottle,)

     ...

可选限流类

1） AnonRateThrottle限制所有匿名未认证用户，使用IP区分用户。

使用DEFAULT_THROTTLE_RATES['anon']来设置频次

2）UserRateThrottle限制认证用户，使用User id 来区分。

使用DEFAULT_THROTTLE_RATES['user']来这是频次

3）ScopedRateThrottle限制用户对于每个视图的访问频次，使用ip或user id。

例如：

 class ContactListView(APIView):

     throttle_scope = 'contacts'

     ...

 class ContactDetailView(APIView):

     throttle_scope = 'contacts'

     ...

 class UploadView(APIView):

     throttle_scope = 'uploads'

     ...

 REST_FRAMEWORK = {

     'DEFAULT_THROTTLE_CLASSES': (

         'rest_framework.throttling.ScopedRateThrottle',

     ),

     'DEFAULT_THROTTLE_RATES': {

         'contacts': '1000/day',

         'uploads': '20/day'

     }

 }

实例

 from rest_framework.viewsets import ModelViewSet

 from .serializers import BookSerializer

 from .models import BookInfo

 # Create your views here.

 #认证管理

 from rest_framework.authentication import SessionAuthentication

 #权限管理

 from rest_framework.permissions import IsAuthenticated,AllowAny,IsAdminUser

 #限流

 from rest_framework.throttling import UserRateThrottle,AnonRateThrottle,ScopedRateThrottle

 class BookModelViewSet(ModelViewSet):

     """

     图书管理视图

     """

     serializer_class = BookSerializer

     def get_queryset(self):

         return BookInfo.objects.all()

     #认证管理

     #认证管理一般和权限管理配合使用

     # authentication_classes = [SessionAuthentication]

     #权限管理

     # 通过python manager createsuperuser 就可以创建一个管理员账号,登录之后就可以访问

     # permission_classes = [IsAuthenticated]

     #限流

     throttle_classes = [AnonRateThrottle]

4.过滤Filtering

文档

对于列表数据可能需要根据字段进行过滤，我们可以通过添加django-fitlter扩展来增强支持。

pip install django-filter

安装应用:

INSTALLED_APPS = [

    ...

    'django_filters',

    ...

]

在配置文件中增加过滤后端的设置：

REST_FRAMEWORK = {

    'DEFAULT_FILTER_BACKENDS': ('django_filters.rest_framework.DjangoFilterBackend',)

}

在视图中添加filter_fields属性，指定可以过滤的字段

 from rest_framework.viewsets import ModelViewSet

 from .serializers import BookSerializer

 from .models import BookInfo

 # Create your views here.

 class BookModelViewSet(ModelViewSet):

     """

     图书管理视图

     """

     serializer_class = BookSerializer

     def get_queryset(self):

         return BookInfo.objects.all()

     #过滤

     filter_fields = ['id','name','pub_date']

 # 127.0.0.1:8000/books/?name=西游记

5.排序OrderingFilter

文档

对于列表数据，REST framework提供了OrderingFilter过滤器来帮助我们快速指明数据按照指定字段进行排序。

使用方法：

在类视图中设置filter_backends，使用rest_framework.filters.OrderingFilter过滤器，REST framework会在请求的查询字符串参数中检查是否包含了ordering参数，如果包含了ordering参数，则按照ordering参数指明的排序字段对数据集进行排序。

前端可以传递的ordering参数的可选字段值需要在ordering_fields中指明。

示例：

 from rest_framework.viewsets import ModelViewSet

 from .serializers import BookSerializer

 from .models import BookInfo

 # Create your views here.

 #排序

 from rest_framework.filters import OrderingFilter

 class BookModelViewSet(ModelViewSet):

     """

     图书管理视图

     """

     serializer_class = BookSerializer

     def get_queryset(self):

         return BookInfo.objects.all()

     #排序

     filter_backends = [OrderingFilter]

     ordering_fields = ['id','readcount','commentcount']

     # 127.0.0.1:8000/books/?ordering=-readcount

6.分页Pagination

REST framework提供了分页的支持。

我们可以在配置文件中设置全局的分页方式，如：

 REST_FRAMEWORK = {

     'DEFAULT_PAGINATION_CLASS':  'rest_framework.pagination.PageNumberPagination',

     'PAGE_SIZE': 100  # 每页数目

 }

也可通过自定义Pagination类，来为视图添加不同分页行为。在视图中通过pagination_clas属性来指明。

 class LargeResultsSetPagination(PageNumberPagination):

     page_size = 1000

     page_size_query_param = 'page_size'

     max_page_size = 10000

 class BookDetailView(RetrieveAPIView):

     queryset = BookInfo.objects.all()

     serializer_class = BookInfoSerializer

     pagination_class = LargeResultsSetPagination

可选分页器

1）PageNumberPagination

前端访问网址形式：

GET  http://api.example.org/books/?page=4

可以在子类中定义的属性：

page_size 每页数目
page_query_param 前端发送的页数关键字名，默认为"page"
page_size_query_param 前端发送的每页数目关键字名，默认为None
max_page_size 前端最多能设置的每页数量

 from rest_framework.viewsets import ModelViewSet

 from .serializers import BookSerializer

 from .models import BookInfo

 # Create your views here.

 #分页

 from rest_framework.pagination import PageNumberPagination

 class StandartPageNumberPagination(PageNumberPagination):

     page_size = 2                   #默认每页返回的条数

     max_page_size = 50              #每页返回的最大条数

     page_size_query_param = 'ps'    #url中设置 page_size的键,默认为page_size

     page_query_param = 'p'          #url中设置 page的键,默认为page

 class BookModelViewSet(ModelViewSet):

     """

     图书管理视图

     """

     serializer_class = BookSerializer

     def get_queryset(self):

         return BookInfo.objects.all()

     #分页

     pagination_class = StandartPageNumberPagination

     #http://127.0.0.1:8000/books/?p=1&ps=4

2）LimitOffsetPagination

前端访问网址形式：

GET http://api.example.org/books/?limit=100&offset=400

可以在子类中定义的属性：

default_limit 默认限制，默认值与PAGE_SIZE设置一致
limit_query_param limit参数名，默认'limit'
offset_query_param offset参数名，默认'offset'
max_limit 最大limit限制，默认None

 from rest_framework.viewsets import ModelViewSet

 from .serializers import BookSerializer

 from .models import BookInfo

 # Create your views here.

 #分页

 from rest_framework.pagination import LimitOffsetPagination

 class BookModelViewSet(ModelViewSet):

     """

     图书管理视图

     """

     serializer_class = BookSerializer

     def get_queryset(self):

         return BookInfo.objects.all()

     pagination_class = LimitOffsetPagination

     # http://127.0.0.1:8000/books/?limit=2&offset=4

7.异常处理 Exceptions

文档

REST framework提供了异常处理，我们可以自定义异常处理函数。例如处理关于数据库的异常

 from rest_framework.views import exception_handler

 from rest_framework import status

 from django.db import DatabaseError

 from rest_framework.response import Response

 def custom_exception_handler(exc, context):

     #exc 当前异常的对象

     #context 哪个地方出的问题

     #先调用REST framework默认的异常处理方法获得标准错误响应对象

     response = exception_handler (exc, context)

     #在此处补充自定义的异常处理

     if response is None:

         view = context['view']

         if isinstance(exc, DatabaseError):

             print('[%s]: %s' % (view, exc))

             response = Response({'detail': '服务器内部错误'}, status=status.HTTP_507_INSUFFICIENT_STORAGE)

     return response

在配置文件中声明自定义的异常处理

REST_FRAMEWORK = {

    'EXCEPTION_HANDLER': 'book.exceptions.custom_exception_handler'

}

如果未声明，会采用默认的方式，如下

REST_FRAMEWORK = {

    'EXCEPTION_HANDLER': 'rest_framework.views.exception_handler'

}

手动触发异常

 from rest_framework.viewsets import ModelViewSet

 from .serializers import BookSerializer

 from .models import BookInfo

 # Create your views here.

 class BookModelViewSet(ModelViewSet):

     """

     图书管理视图

     """

     serializer_class = BookSerializer

     def get_queryset(self):

         from django.db import DatabaseError

         raise DatabaseError('error')

         return BookInfo.objects.all()

REST framework定义的异常

APIException 所有异常的父类
ParseError 解析错误
AuthenticationFailed 认证失败
NotAuthenticated 尚未认证
PermissionDenied 权限决绝
NotFound 未找到
MethodNotAllowed 请求方式不支持
NotAcceptable 要获取的数据格式不支持
Throttled 超过限流次数
ValidationError 校验失败

8.自动生成接口文档

REST framework可以自动帮助我们生成接口文档。

接口文档以网页的方式呈现。

自动接口文档能生成的是继承自APIView及其子类的视图。

1. 安装依赖

REST framewrok生成接口文档需要coreapi库的支持。

pip install coreapi

2. 设置接口文档访问路径

在总路由中添加接口文档路径。

文档路由对应的视图配置为rest_framework.documentation.include_docs_urls，

参数title为接口文档网站的标题。

from rest_framework.documentation import include_docs_urls

urlpatterns = [

    ...

    url(r'^docs/', include_docs_urls(title='API接口文档'))

]

3. 文档描述说明的定义位置

1）单一方法的视图，可直接使用类视图的文档字符串，如

class BookListView(generics.ListAPIView):

    """

    返回所有图书信息.

    """

2）包含多个方法的视图，在类视图的文档字符串中，分开方法定义，如

class BookListCreateView(generics.ListCreateAPIView):

    """

    get:

    返回所有图书信息.

    post:

    新建图书.

    """

3）对于视图集ViewSet，仍在类视图的文档字符串中封开定义，但是应使用action名称区分，如

class BookInfoViewSet(mixins.ListModelMixin, mixins.RetrieveModelMixin, GenericViewSet):

    """

    list:

    返回图书列表数据

    retrieve:

    返回图书详情数据

    latest:

    返回最新的图书数据

    read:

    修改图书的阅读量

    """

4. 访问接口文档网页

浏览器访问 127.0.0.1:8000/docs/，即可看到自动生成的接口文档。

Django中views笔记

两点说明：

1）视图集ViewSet中的retrieve名称，在接口文档网站中叫做read

2）参数的Description需要在模型类或序列化器类的字段中以help_text选项定义，如：

 class BookInfo(models.Model):

     ...

     readcount= models.IntegerField(default=0, verbose_name='阅读量', help_text='阅读量')

     ...

 或

 class BookSerializer(serializers.ModelSerializer):

     class Meta:

         model = BookInfo

         fields = '__all__'

         extra_kwargs = {

             'readcount':{

                 'help_text':'阅读量'

             }

         }

Django中views笔记

reverse反解析

HttpRequest对象

1.路径参数

位置参数

关键字参数

2.查询字符串Query String

3.表单类型 Form Data

4.非表单类型 Non-Form Data

5.请求头

6.其他常用HttpRequest对象属性

HttpResponse对象

1 HttpResponse

2 HttpResponse子类

3 JsonResponse

4 redirect重定向

cookie和session

中间件

1 .中间件的定义方法

2.例如，在book应用中新建一个middleware.py文件

3.定义好中间件后，需要在settings.py 文件中添加注册中间件

rest_framework实现序列化器

1.配置文件setting

2.创建序列化器文件 serializers.py

rest_framework实现三个级别view

1.setting中增加如下：

2. 一级视图 继承类 from rest_framework.views import APIView

3. 二级视图 继承类 from rest_framework.generics import GenericAPIView

3.1. 二级视图和Mixin配合使用,Mixin中已经封装了get、post、get、put、delete相应功能，对应方法list、create、retrieve、update、destroy

4.三级视图,高度封装

5.视图集ViewSet、ModelViewSet、ReadOnlyModelViewSet

其他功能

1.认证Authentication

2.权限Permissions

使用

提供的权限

举例

自定义权限

3.限流Throttling

使用

可选限流类

实例

4.过滤Filtering

5.排序OrderingFilter

使用方法：

6.分页Pagination

可选分页器

7.异常处理 Exceptions

REST framework定义的异常

8.自动生成接口文档

1. 安装依赖

2. 设置接口文档访问路径

3. 文档描述说明的定义位置

4. 访问接口文档网页

两点说明：

相关文章

　　位置参数

　　关键字参数

2. 一级视图继承类 from rest_framework.views import APIView

3. 二级视图继承类 from rest_framework.generics import GenericAPIView