day70_10_16drf組件響應模塊，異常模塊和序列化模塊。

一。解析模塊

　　爲何要配置解析模塊？

　　1）drf給咱們經過了多種解析數據包方式的解析類。
　　2）咱們能夠經過配置來控制前臺提交的哪些格式的數據後臺在解析，哪些數據不解析。
　　3）全局配置就是針對每個視圖類，局部配置就是針對指定的視圖來，讓它們能夠按照配置規則選擇性解析數據。

　　源碼入口

# APIView類的dispatch方法中
request = self.initialize_request(request, *args, **kwargs)  # 點進去
​
# 獲取解析類
parsers=self.get_parsers(),  # 點進去
​
# 去類屬性(局部配置) 或 配置文件(全局配置) 拿 parser_classes
return [parser() for parser in self.parser_classes]

　　全局配置：項目settings.py文件

REST_FRAMEWORK = {
   # 全局解析類配置
   'DEFAULT_PARSER_CLASSES': [
       'rest_framework.parsers.JSONParser',  # json數據包
       'rest_framework.parsers.FormParser',  # urlencoding數據包
       'rest_framework.parsers.MultiPartParser'  # form-date數據包
  ],
}

　　局部配置：應用views.py的具體視圖類

from rest_framework.parsers import JSONParser
class Book(APIView):
   # 局部解析類配置，只要json類型的數據包才能被解析
   parser_classes = [JSONParser]
   pass

 

 

二。異常模塊

　　爲何要自定義異常模塊？

　　1）全部通過drf的APIView視圖類產生的異常，均可以提供異常處理方案。
　　2）drf默認提供了異常處理方案(rest_framework.views.exception_handler)，可是處理範圍有限。
　　3）drf提供的處理方案兩種，處理了返回異常現象，沒處理返回None(後續就是服務器拋異常給前臺)。
　　4）自定義異常的目的就是解決drf沒有處理的異常，讓前臺獲得合理的異常信息返回，後臺記錄異常具體信息。

　　源碼分析

# 異常模塊：APIView類的dispatch方法中
response = self.handle_exception(exc)  # 點進去
​
# 獲取處理異常的句柄(方法)
# 一層層看源碼，走的是配置文件，拿到的是rest_framework.views的exception_handler
# 自定義：直接寫exception_handler函數，在本身的配置文件配置EXCEPTION_HANDLER指向本身的
exception_handler = self.get_exception_handler()
​
# 異常處理的結果
# 自定義異常就是提供exception_handler異常處理函數，處理的目的就是讓response必定有值
response = exception_handler(exc, context)

　　如何使用：自定義exception_handler函數如何書寫實現體

# 修改本身的配置文件setting.py
REST_FRAMEWORK = {
   # 全局配置異常模塊
   'EXCEPTION_HANDLER': 'api.exception.exception_handler',
}

# 1）先將異常處理交給rest_framework.views的exception_handler去處理
# 2）判斷處理的結果(返回值)response，有值表明drf已經處理了，None表明須要本身處理
​
# 自定義異常處理文件exception，在文件中書寫exception_handler函數
from rest_framework.views import exception_handler as drf_exception_handler
from rest_framework.views import Response
from rest_framework import status
def exception_handler(exc, context):
   # drf的exception_handler作基礎處理
   response = drf_exception_handler(exc, context)
   # 爲空，自定義二次處理
   if response is None:
       # print(exc)
       # print(context)
       print('%s - %s - %s' % (context['view'], context['request'].method, exc))
       return Response({
           'detail': '服務器錯誤'
      }, status=status.HTTP_500_INTERNAL_SERVER_ERROR, exception=True)
   return response

 

三。響應模塊

　　響應類構造器：rest_framework.response.Response

def __init__(self, data=None, status=None,
                template_name=None, headers=None,
                exception=False, content_type=None):
    """
      :param data: 響應數據
      :param status: http響應狀態碼
      :param template_name: drf也能夠渲染頁面，渲染的頁面模板地址（不用瞭解）
      :param headers: 響應頭
      :param exception: 是否異常了
      :param content_type: 響應的數據格式（通常不用處理，響應頭中帶了，且默認是json）
  """
   pass

　　使用：常規實例化響應對象

# status就是解釋一堆 數字 網絡狀態碼的模塊
from rest_framework import status就是解釋一堆 數字 網絡狀態碼的模塊
# 通常狀況下只須要返回數據，status和headers都有默認值
return Response(data={數據}, status=status.HTTP_200_OK, headers={設置的響應頭})

 

四。序列化組件：

　　知識點：Serializer(偏底層)、ModelSerializer(重點)、ListModelSerializer(輔助羣改)

　　Serializer：

　　1.序列化準備：

　　模型層：models.py

class User(models.Model):
    SEX_CHOICES = [
        [0, '男'],
        [1, '女'],
    ]
    name = models.CharField(max_length=64)
    pwd = models.CharField(max_length=32)
    phone = models.CharField(max_length=11, null=True, default=None)
    sex = models.IntegerField(choices=SEX_CHOICES, default=0)
    icon = models.ImageField(upload_to='icon', default='icon/default.jpg')
​
    class Meta:
        db_table = 'old_boy_user'
        verbose_name = '用戶'
        verbose_name_plural = verbose_name
​
    def __str__(self):
        return '%s' % self.name

　　後臺管理層：admin.py

from django.contrib import admin
from . import models
​
admin.site.register(models.User)

　　配置層：settings.py

# 註冊rest_framework
INSTALLED_APPS = [
    # ...
    'rest_framework',
]
​

　　配置數據庫

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'day70',
        'USER': 'root',
        'PASSWORD': '123'
    }
}

　　media資源

MEDIA_URL = '/media/'  # 後期高級序列化類與視圖類，會使用該配置
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')  # media資源路徑

　　國際化配置

LANGUAGE_CODE = 'zh-hans'
TIME_ZONE = 'Asia/Shanghai'
USE_I18N = True
USE_L10N = True
USE_TZ = False

主路由：項目下urls.py
urlpatterns = [
    # ...
    url(r'^api/', include('api.urls')),
​
    url(r'^media/(?P<path>.*)', serve, {'document_root': settings.MEDIA_ROOT}),
]

　　子路由：應用下urls.py

urlpatterns = [
    url(r'^users/$', views.User.as_view()),
    url(r'^users/(?P<pk>.*)/$', views.User.as_view()),
]

　　2.序列化使用

　　序列化層：api/serializers.py

"""
1）設置須要返回給前臺 那些model類有對應的 字段，不須要返回的就不用設置了
2）設置方法字段，字段名能夠隨意，字段值有 get_字段名 提供，來完成一些須要處理在返回的數據
"""
# 序列化組件 - 爲每個model類經過一套序列化工具類
# 序列化組件的工做方式與django froms組件很是類似
from rest_framework import serializers, exceptions
from django.conf import settings
​
from . import models
​
class UserSerializer(serializers.Serializer):
    name = serializers.CharField()
    phone = serializers.CharField()
    # 序列化提供給前臺的字段個數由後臺決定，能夠少提供，
    # 可是提供的數據庫對應的字段，名字必定要與數據庫字段相同
    # sex = serializers.IntegerField()
    # icon = serializers.ImageField()
​
    # 自定義序列化屬性
    # 屬性名隨意，值由固定的命名規範方法提供:
    #       get_屬性名(self, 參與序列化的model對象)
    #       返回值就是自定義序列化屬性的值
    gender = serializers.SerializerMethodField()
    def get_gender(self, obj):
        # choice類型的解釋型值 get_字段_display() 來訪問
        return obj.get_sex_display()
​
​
    icon = serializers.SerializerMethodField()
    def get_icon(self, obj):
        # settings.MEDIA_URL: 本身配置的 /media/，給後面高級序列化與視圖類準備的
        # obj.icon不能直接做爲數據返回，由於內容雖然是字符串，可是類型是ImageFieldFile類型
        return '%s%s%s' % (r'http://127.0.0.1:8000', settings.MEDIA_URL, str(obj.icon))

　　視圖層

"""
1）從數據庫中將要序列化給前臺的model對象，或是對個model對象查詢出來
    user_obj = models.User.objects.get(pk=pk) 或者
    user_obj_list = models.User.objects.all()
2）將對象交給序列化處理，產生序列化對象，若是序列化的是多個數據，要設置many=True
    user_ser = serializers.UserSerializer(user_obj) 或者
    user_ser = serializers.UserSerializer(user_obj_list, many=True)
3）序列化 對象.data 就是能夠返回給前臺的序列化數據
    return Response({
        'status': 0,
        'msg': 0,
        'results': user_ser.data
    })
"""
class User(APIView):
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                # 用戶對象不能直接做爲數據返回給前臺
                user_obj = models.User.objects.get(pk=pk)
                # 序列化一下用戶對象
                user_ser = serializers.UserSerializer(user_obj)
                # print(user_ser, type(user_ser))
                return Response({
                    'status': 0,
                    'msg': 0,
                    'results': user_ser.data
                })
            except:
                return Response({
                    'status': 2,
                    'msg': '用戶不存在',
                })
        else:
            # 用戶對象列表(queryset)不能直接做爲數據返回給前臺
            user_obj_list = models.User.objects.all()
            # 序列化一下用戶對象
            user_ser_data = serializers.UserSerializer(user_obj_list, many=True).data
            return Response({
                'status': 0,
                'msg': 0,
                'results': user_ser_data
            })

　　3.反序列化使用

　　反序列層：api/serializers.py

"""
1）設置必填與選填序列化字段，設置校驗規則
2）爲須要額外校驗的字段提供局部鉤子函數，若是該字段不入庫，且不參與全局鉤子校驗，能夠將值取出校驗
3）爲有聯合關係的字段們提供全局鉤子函數，若是某些字段不入庫，能夠將值取出校驗
4）重寫create方法，完成校驗經過的數據入庫工做，獲得新增的對象
"""
class UserDeserializer(serializers.Serializer):
    # 1) 哪些自動必須反序列化
    # 2) 字段都有哪些安全校驗
    # 3) 哪些字段須要額外提供校驗
    # 4) 哪些字段間存在聯合校驗
    # 注：反序列化字段都是用來入庫的，不會出現自定義方法屬性，會出現能夠設置校驗規則的自定義屬性(re_pwd)
    name = serializers.CharField(
        max_length=64,
        min_length=3,
        error_messages={
            'max_length': '太長',
            'min_length': '過短'
        }
    )
    pwd = serializers.CharField()
    phone = serializers.CharField(required=False)
    sex = serializers.IntegerField(required=False)
​
    # 自定義有校驗規則的反序列化字段
    re_pwd = serializers.CharField(required=True)
​
    # 小結：
    # name，pwd，re_pwd爲必填字段
    # phone，sex爲選填字段
    # 五個字段都必須提供完成的校驗規則
​
​
    # 局部鉤子：validate_要校驗的字段名(self, 當前要校驗字段的值)
    # 校驗規則：校驗經過返回原值，校驗失敗，拋出異常
    def validate_name(self, value):
        if 'g' in value.lower():  # 名字中不能出現g
            raise exceptions.ValidationError('名字非法，是個雞賊！')
        return value
​
    # 全局鉤子：validate(self, 系統與局部鉤子校驗經過的全部數據)
    # 校驗規則：校驗經過返回原值，校驗失敗，拋出異常
    def validate(self, attrs):
        pwd = attrs.get('pwd')
        re_pwd = attrs.pop('re_pwd')
        if pwd != re_pwd:
            raise exceptions.ValidationError({'pwd&re_pwd': '兩次密碼不一致'})
        return attrs
​
    # 要完成新增，須要本身重寫 create 方法
    def create(self, validated_data):
        # 儘可能在全部校驗規則完畢以後，數據能夠直接入庫
        return models.User.objects.create(**validated_data)

　　視圖層

"""
1）book_ser = serializers.UserDeserializer(data=request_data)  # 數據必須賦值data
2）book_ser.is_valid()  # 結果爲 經過 | 不經過
3）不經過返回 book_ser.errors 給前臺，經過 book_ser.save() 獲得新增的對象，再正常返回
"""
class User(APIView):
    # 只考慮單增
    def post(self, request, *args, **kwargs):
        # 請求數據
        request_data = request.data
        # 數據是否合法（增長對象須要一個字典數據）
        if not isinstance(request_data, dict) or request_data == {}:
            return Response({
                'status': 1,
                'msg': '數據有誤',
            })
        # 數據類型合法，但數據內容不必定合法，須要校驗數據，校驗(參與反序列化)的數據須要賦值給data
        book_ser = serializers.UserDeserializer(data=request_data)
​
        # 序列化對象調用is_valid()完成校驗，校驗失敗的失敗信息都會被存儲在 序列化對象.errors
        if book_ser.is_valid():
            # 校驗經過，完成新增
            book_obj = book_ser.save()
            return Response({
                'status': 0,
                'msg': 'ok',
                'results': serializers.UserSerializer(book_obj).data
            })
        else:
            # 校驗失敗
            return Response({
                'status': 1,
                'msg': book_ser.errors,
            })