drf基礎模塊與四大組件之序列化組件

時間 2019-11-24

標籤 drf 基礎模塊四大組件序列简体版

原文原文鏈接

解析模塊

爲何要配置解析模塊

1drf給咱們經過了多種解析數據包數據方式的解析類
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數據包
    ],
}

局部配置：應用view.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提供的處理方案有2種，處理了返回異常處理，沒有處理就是返回none，後續就是服務器拋異常給前臺
4.自定義異常的意義，就是讓咱們異常的處理可以百分百返回異常處理，讓前臺獲得合理的異常信息，後臺記錄具體的異常信息。

源碼分析

# 異常模塊：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

序列化準備

模型層：model.pymysql

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

後臺管理層adminsql

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,這個主要是作路由分發的，減小壓力django

urlpatterns = [
    # ...
    url(r'^api/', include('api.urls')),

    url(r'^media/(?P<path>.*)', serve, {'document_root': settings.MEDIA_ROOT}),
]

子路由：應用下url.pyjson

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

序列化使用

序列化層:api/serializers.py就是在api文件夾下自定義一個serializers.py文件api

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
            })

反序列化使用

反序列層: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,
            })