Django-Simple-Api - Aber's BLOG

MVT 模式在 API 中的应用

Thu, 22 Apr 2021 10:43:41 +0000

MVT 模式指一种程序解耦的模式。M 是 Model，用于管理数据；V 是 View，用于处理具体业务逻辑；T 是 Template，用于把编程语言的对象转成用户阅读的页面。现在工作细化，后端开发已经不会去使用 Template 渲染页面了，这项工作往往是前端开发来做。

但 MVT 模式并没有落后于时代。只需要转换一下思路，就会发现 MVT 仍然是很好的程序解耦的模式——只需要把 T 换成 S（Serialization）。

以 Django 为例，传统的 MVT 开发里是这么写代码的——把 View 里准备好的 Python 对象传给 Template，然后渲染出一个 HTML 字符串。

def homepage(request):
    return render("template.html", context={"key": value})

如果写一个接口则是这么写——把 View 里准备的 Python 对象转成 JSON 字符串。

def homepage(request):
    return JSONResponse({"key": value})

两者本质上没有区别，都是把编程语言里的对象转成能让用户理解的东西。只不过 MVT 模式里，Template 的结果直接面向浏览器，让浏览器渲染给用户看；MVS 模式里，序列化的结果是给客户端，客户端使用数据渲染出结果给用户看。

许多像我一样不爱用 django-rest-framework 的 Serializer 功能的人，往往都会自己动手在 View 里处理 Python 对象，把它们转成 JSON 标准库能够转换的格式。但这其实会导致许多重复性的工作，比如一个 Model 或一个 QuerySet 转成 JSON 字符串，这应当是可以自动化的（可参见一种序列化 Django model 的新思路）。

在我写了两个需要手动序列化的项目之后，我突然觉得这么多重复性工作太愚蠢了，我为什么不把 Index.py 里的先进经验搬到 Django 里来呢。写一个中间件（能同时作用在所有视图上的装饰器）来捕捉响应值，然后通过不同的响应结果去寻找不同的处理函数，转换成不同的响应结果。于是就先有了上面自动序列化 Django Model 一文，然后有了此文。

这样处理好处是十分明显的，比如在视图函数里只需要像下面这样写，在中间件里它会自动转换成内容为 {"message": "Message"} 的 JSON 响应对象。当客户端要求修改格式时，比如要求在每个响应里都加上 {"data": ...}，不需要到每个视图里的每个返回点进行修改格式。

def find(request):
    ......
    return "Message"

了解了 MVS 模式，你再也不需要在视图函数里做一些业务逻辑无关的处理了。比如客户端要求序列化 datetime 的结果带上时区信息。视图函数（View）里不需要做任何额外的处理，只需要在业务逻辑完成后返回结果对象就行了。渲染成什么格式，XML 还是 JSON，带时区还是不带时区，这些都由中间件（Serialization）来做。

最后，由于那个序列化中间件仓促而成，所以就不开源出来了。实现思路和代码可以参考 Index.py 里的部分。

一种序列化 Django model 的新思路

Thu, 15 Apr 2021 13:56:18 +0000

在我编写一种新的 ORM 时，我更深入的研究了 Python ORM 的设计，这让我有了足够的知识来支撑起两年前的一个序列化 Django Model 的想法。

一般来说序列化 Django Model 都会使用 django-rest-framework 的序列化功能。使用它，你首先需要根据需求定义一个 Serializer 模型，然后通过这个模型去序列化 Django Model，它通常意味着你需要同时维护两套模型。而且在做复杂的跨表序列化操作时，这很容易导致 N+1 查询。

使用 Django ORM 的人都知道，Django 是有 prefetch_related 和 select_related 两个预查询功能来处理跨表查询中的 N+1 查询问题。那么预查询出来的模型缓存在哪儿了呢？

from typing import Any, Dict, List

from django.core.exceptions import FieldDoesNotExist
from django.db import models


def serialize_model(model: models.Model) -> Dict[str, Any]:
    serialized = set()

    def _serialize_model(model: models.Model) -> Dict[str, Any]:
        if model in serialized:
            return model.pk
        else:
            serialized.add(model)

        result: Dict[str, Any] = {
            name: _serialize_model(foreign_key)
            for name, foreign_key in model.__dict__["_state"]
            .__dict__.get("fields_cache", {})
            .items()
            if foreign_key is not None
        }

        for name, value in model.__dict__.items():
            try:
                model._meta.get_field(name)
            except FieldDoesNotExist:
                # 非模型字段
                continue
            else:
                result[name] = value

        for name, queryset in model.__dict__.get(
            "_prefetched_objects_cache", {}
        ).items():
            result[name] = serialize_queryset(queryset)

        return result

    return _serialize_model(model)


def serialize_queryset(queryset: models.QuerySet) -> List[Dict[str, Any]]:
    return [serialize_model(model) for model in queryset]

在我研究之后发现 prefetch_related 预查询出来的结果会作为 QuerySet 对象存放在 __dict__["_prefetched_objects_cache"] 这个字典中字段名对应的键下；select_related 预查询出来的结果会存放在 __dict__["_state"].__dict__["fields_cache"] 中字段名对应的键下。

于是这就有了上面的代码。它不会自做主张的去查询数据库，只用你查询出来的结果，成功避免了 N+1 查询问题。通过查询时的 defer 和 only 操作可以控制哪些模型字段被查询，通过预查询语句可以控制哪些外键字段被查询。它不需要你维护另一套模型，你只需要专注于数据库模型正确即可。

Django 解决跨域请求

Thu, 28 Feb 2019 00:00:00 +0000

跨域

首先我们要明白，要让一个请求被允许跨域，在响应预检方法OPTIONS时需要返回哪些头部内容。那么查一下MDN。

可以看到MDN给出了一些例子，其中较为重要的。

Access-Control-Allow-Origin: 允许访问本站的域
Access-Control-Allow-Methods：允许的请求方法
Access-Control-Allow-Credentials：能否携带Cookies，当这个被设为true时，Access-Control-Allow-Origin将不能被设为*
Access-Control-Allow-Headers：请求时允许携带的头，一般这个会用在一些非Cookies认证身份的情况

那么可以写代码了。

编写ApiView类

在之前的一篇Django解析非POST请求，我们已经为Api解析好了数据，所以这一篇我们只需要考虑跨域和CSRF保护就好。

从Django最基本的View类继承，分发请求到具体的方法这个事情，Django已经做完了，所以我们只要编写一下OPTIONS方法，解决一下跨域就行。先写一个基本的处理

class SimpleApiView(View):

    def options(self, request, *args, **kwargs):
        response = HttpResponse()
        response['Content-Length'] = '0'
        return response

关于OPTIONS应该是返回200还是204，StackOverflow有关于此的讨论。在这里，我们延续Django的源码的选择——返回200。

然后我们需要考虑从settings中读取CORS_SETTINGS。约定CORS_SETTINGS是一个dict类型，它必须拥有HOSTS，COOKIES和HEADERS三个值。分别是

HOSTS：允许访问本站的域名列表或者'*'(代表允许任意域)，默认为'*'。
COOKIES：跨域请求是否允许携带cookies，默认为False。当这个值为True且HOSTS为'*'时，直接抛出一个异常。

class SimpleApiView(View):

    def set_cors_header(self, request: HttpRequest, response: HttpResponse):
        response['Access-Control-Allow-Methods'] = ', '.join(self._allowed_methods())
        _headers = request.META.get('HTTP_ACCESS_CONTROL_REQUEST_HEADERS', "")
        response['Access-Control-Allow-Headers'] = _headers
        _hosts = settings.CORS_SETTINGS.get('HOSTS', "*")
        response['Access-Control-Allow-Origin'] = ", ".join(_hosts)
        if settings.CORS_SETTINGS.get('COOKIES', False):
            if _hosts == "*":
                response['Access-Control-Allow-Origin'] = request.META.get("HTTP_ORIGIN")
            response['Access-Control-Allow-Credentials'] = 'true'
        return response

    def dispatch(self, request, *args, **kwargs):
        return self.set_cors_header(request, super().dispatch(request, *args, **kwargs))

到这里，跨域工作就已经完成了。但我们再增加一个功能——指定某些方法不能跨域。

给类增加一个属性refused_cors_methods，使用Python提供的集合求差集的方法，我们可以完美的完成这一点。

class SimpleApiView(View):
    # 不允许跨域的方法列表
    # 方法名称均为小写, 例如 ['post', 'delete']
    refused_cors_methods = []

    def set_cors_header(self, request: HttpRequest, response: HttpResponse):
        response['Access-Control-Allow-Methods'] = ', '.join(
            set(self._allowed_methods()) - set(self.refused_cors_methods)
        )

        _headers = request.META.get('HTTP_ACCESS_CONTROL_REQUEST_HEADERS', "")
        response['Access-Control-Allow-Headers'] = _headers
        _hosts = settings.CORS_SETTINGS.get('hosts', "*")
        response['Access-Control-Allow-Origin'] = ", ".join(_hosts)
        if settings.CORS_SETTINGS.get('cookie', False):
            if _hosts == "*":
                response['Access-Control-Allow-Origin'] = request.META.get("HTTP_ORIGIN")
            response['Access-Control-Allow-Credentials'] = 'true'
        return response

    def dispatch(self, request, *args, **kwargs):
        return self.set_cors_header(request, super().dispatch(request, *args, **kwargs))

其他东西

一般来说，跨域还需要考虑到的是Django的CSRF保护机制，但这已经不属于本系列文章的内容，所以独立一篇出来——Django跨域的CSRF问题

Django 解析非POST请求

Wed, 27 Feb 2019 00:00:00 +0000

众所周知, Django的每个请求都有对应一个独立的request变量。这个变量在视图函数中使用时，有三个重要的属性GET、POST和FILES。

其中POST，FILES是解析request.body得到的结果。当我们使用POST方法接收数据时，一切都很完美。然而当使用其他方法PUT，PATCH时你就会发现这两个属性无论如何都是空！

为了解决这个问题，我们应该首先看看为什么会有这个问题。

源码分析

追溯到django.core.handlers.wsgi.WSGIRequest这个类中，我们可以看到如下代码

@cached_property
def GET(self):
    # The WSGI spec says 'QUERY_STRING' may be absent.
    raw_query_string = get_bytes_from_wsgi(self.environ, 'QUERY_STRING', '')
    return QueryDict(raw_query_string, encoding=self._encoding)

def _get_post(self):
    if not hasattr(self, '_post'):
        self._load_post_and_files()
    return self._post

def _set_post(self, post):
    self._post = post

@cached_property
def COOKIES(self):
    raw_cookie = get_str_from_wsgi(self.environ, 'HTTP_COOKIE', '')
    return parse_cookie(raw_cookie)

@property
def FILES(self):
    if not hasattr(self, '_files'):
        self._load_post_and_files()
    return self._files

POST = property(_get_post, _set_post)

FILES和POST原来都是要运行self._load_post_files函数之后才能取到结果。

那么接着追溯这个_load_post_files函数到django.http.request.HttpRequest能看到

def _load_post_and_files(self):
    """Populate self._post and self._files if the content-type is a form type"""
    if self.method != 'POST':
        self._post, self._files = QueryDict(encoding=self._encoding), MultiValueDict()
        return
    if self._read_started and not hasattr(self, '_body'):
        self._mark_post_parse_error()
        return

    if self.content_type == 'multipart/form-data':
        if hasattr(self, '_body'):
            # Use already read data
            data = BytesIO(self._body)
        else:
            data = self
        try:
            self._post, self._files = self.parse_file_upload(self.META, data)
        except MultiPartParserError:
            # An error occurred while parsing POST data. Since when
            # formatting the error the request handler might access
            # self.POST, set self._post and self._file to prevent
            # attempts to parse POST data again.
            # Mark that an error occurred. This allows self.__repr__ to
            # be explicit about it instead of simply representing an
            # empty POST
            self._mark_post_parse_error()
            raise
    elif self.content_type == 'application/x-www-form-urlencoded':
        self._post, self._files = QueryDict(self.body, encoding=self._encoding), MultiValueDict()
    else:
        self._post, self._files = QueryDict(encoding=self._encoding), MultiValueDict()

原来第一行就先判断了当前的请求方法是否是POST！不是POST就直接返回对象，不解析。

思考一下，我们该如何来解决这个问题。

Hack

或者直接把解析部分复制粘贴过来，我们自己解析是一个办法。但是这里面用了太多的内置函数，如果哪天Django悄无声息的修改了它们当中的任何一个，你的代码就失效了。

所以下面提供一个最少的使用内部函数的方法。采用了一个十分Hack的手段，欺骗函数帮助你解决这个问题。

from django.http import HttpResponseBadRequest
from django.utils.deprecation import MiddlewareMixin

class RequestParsingMiddleware(MiddlewareMixin):

    def process_request(self, request):
        if request.method not in ("GET", "POST"):
            if hasattr(request, '_post'):
                del request._post
                del request._files

            _shadow = request.method
            request.method = "POST"
            request._load_post_and_files()
            request.method = _shadow

使用的时候，只需要把这个中间件给加入项目当中即可。

另一个问题

Django是无法解析application/json格式的数据，往往前端话语权比较弱的小团队中，为了适应后端，不得不使用各种方法提交application/x-www-form-urlencoded格式的数据。

我们既然已经解决了非POST请求的数据解析，不如顺便把这个也解决了。

Django将请求体的原始数据放在request.body中，我们只需要使用json.loads(request.body)一条语句就可以解析好application/json格式的数据。

那么，修改一下上面的中间件

import json

from django.http import HttpResponseBadRequest
from django.utils.deprecation import MiddlewareMixin


class RequestParsingMiddleware(MiddlewareMixin):

    def process_request(self, request):
        request.JSON = None
        if request.content_type != "application/json":
            if request.method not in ("GET", "POST"):
                # if you want to know why do that,
                # read https://abersheeran.com/articles/Django-Parse-non-POST-Request/
                if hasattr(request, '_post'):
                    del request._post
                    del request._files

                _shadow = request.method
                request.method = "POST"
                request._load_post_and_files()
                request.method = _shadow
        else:
            try:
                request.JSON = json.loads(request.body)
            except ValueError as ve:
                return HttpResponseBadRequest("Unable to parse JSON data. Error: {0}".format(ve))

关于 TestClient

查看 Django 的测试部分的源码可以看到 PUT、PATCH 和 DELETE 的默认 content-type 都是 application/octet-stream，参考 MDN 可以得知此类型是一个未知的类型，在正常的请求里完全不会出现。

def put(self, path, data='', content_type='application/octet-stream',
        follow=False, secure=False, **extra):
    """Send a resource to the server using PUT."""
    response = super().put(path, data=data, content_type=content_type, secure=secure, **extra)
    if follow:
        response = self._handle_redirects(response, data=data, content_type=content_type, **extra)
    return response

def patch(self, path, data='', content_type='application/octet-stream',
            follow=False, secure=False, **extra):
    """Send a resource to the server using PATCH."""
    response = super().patch(path, data=data, content_type=content_type, secure=secure, **extra)
    if follow:
        response = self._handle_redirects(response, data=data, content_type=content_type, **extra)
    return response

def delete(self, path, data='', content_type='application/octet-stream',
            follow=False, secure=False, **extra):
    """Send a DELETE request to the server."""
    response = super().delete(path, data=data, content_type=content_type, secure=secure, **extra)
    if follow:
        response = self._handle_redirects(response, data=data, content_type=content_type, **extra)
    return response

那么，它在 Django 里唯一可能出现的情况就是测试时使用以上三种请求方法且未指定 content-type。通过增加一个判断，可以有效地防止这种情况的产生，从而提醒测试人员对测试进行修复（哪怕他完全没了解过这部分代码）。

在中间件最开始增加如下的判断代码即可。

if (
    request.content_type == "application/octet-stream"
    and int(request.META.get("CONTENT_LENGTH", "0")) > 0
):
    return HttpResponseBadRequest(
        "Get content-type: application/octet-stream,"
        + " you must change content-type."
    )

Django ORM 模型序列化

Sat, 09 Feb 2019 00:00:00 +0000

什么是序列化

对于Django而言，模型是一个重要的部分，我们从中获取或更改数据，都是用Django的模型对象。而前端并不能直接读取这个对象，于是需要把对象映射为JSON数据进行传递。

把模型映射到JSON数据，这一过程就称之为序列化。当然，我们只需要把模型对象转为Dict，剩下的交给json标准库就可以了。

如何序列化

在进行序列化之前，我们首先需要明白，Model的字段大致可分为三种，一种是直接存储的字段(Field)，一种是关系字段(Relation Field)，一种是Django帮助我们反向映射过来的关系(Relation)。

第一种很容易获取，直接从Model对象的属性中读取即可，我们只需要注意，把时间字段，文件字段等无法被json库直接序列化的字段转为字符串即可。

第二种与第三种，看起来不同，一个是我们自己定义，一个是Django自动生成。但实际上，使用过Django的ORM的人都知道，它们操作起来完全是一样的。那么，序列化的时候我们可以把这两种归为一类——关系字段。
对于关系字段而言，并不能直接序列化，因为它们也都是对象。那么需要一种递归的方法去获取它们的数据。
但不能无限递归下去

class ModelSerializationMixin:
    def to_dict(self):
        pass

当我们定义Model模型的时候，直接同时继承这个类，即可让Model拥有对应方法。

获取字段

Django的Model提供了一个很棒的属性_meta，里面有get_fields()，get_field()两个方法。可从前者获取模型全部字段，可以使用字段名(字符串)从后者那里拿到对应的的字段。

class ModelSerializationMixin:
    def to_dict(self):

        def get_all_fields():
            for field in self._meta.get_fields():
                print(field)

此时可以看到该对象的全部的字段。这看起来是很棒的第一步，但先等等，如果我只想获取指定的几个字段，或者不想获取指定的某几个字段。结合get_field()，稍微修改一下。

def to_dict(self, fields=None, exclude=None):
    exclude = exclude if exclude else []

    def get_all_fields():
        if fields is None:
            for field in self._meta.get_fields():
                if field.name in exclude:
                    continue
                yield field
        else:
            for field_name in fields:
                if field_name in exclude:
                    continue
                yield self._meta.get_field(field_name)

这看起来就很完美了，当不指定fields时，可以获取全部的字段，当给出了字段名的一个列表或集合之后，只返回指定的字段。

处理普通字段

对于普通的字段，例如CharField等，我们直接获取即可。不过对于DateTimeField等字段，我们需要进行适当转换才行。

def to_dict(self, fields=None, exclude=None, raw_data=False):
    exclude = exclude if exclude else []

    def get_all_fields():
        if fields is None:
            for field in self._meta.get_fields():
                if field.name in exclude:
                    continue
                yield field
        else:
            for field_name in fields:
                if field_name in exclude:
                    continue
                yield self._meta.get_field(field_name)

    for field in get_all_fields():
        result[field.name] = getattr(model, field.name)
        if not raw_data:
            # 将不能直接用json解析的对象转为字符串
            if isinstance(result[field.name], datetime.datetime):
                result[field.name] = result[field.name].strftime("%Y-%m-%d %H:%M:%S")
            elif isinstance(result[field.name], datetime.date):
                result[field.name] = result[field.name].strftime("%Y-%m-%d")
            elif isinstance(result[field.name], (File,)):
                result[field.name] = settings.MEDIA_URL + str(result[field.name])

    return result

可以看到，我们使用了field对象的name属性，它可以获取你在定义Model时定义的字段名。在这里我们使用它去获取Model对象的属性。

处理关系字段

在Django里，关系字段有四种many_to_many, many_to_one, one_to_many, one_to_one。我们可以从django.db.models.fields.__init__.Field这个类里看到，每个Field都有这四个属性。这里我们不得不使用四个条件判断语句，但为了整体代码清晰，每种不同的关系字段都由一个单独的函数来处理。

多对多的关系字段，或者反向映射的多对多关系，many_to_many为True。

def m2m(field):
    if isinstance(field, models.ManyToManyRel):
        if field.related_name is None:
            field_name = field.name + '_set'
        else:
            field_name = field.related_name
    else:
        field_name = field.name

    # 自定义规则筛选
    query_set = self.get_qs(field_name, getattr(self, field_name))

    if relation_data:
        result[field.name] = [self._to_dict(each) for each in query_set]
    else:
        result[field.name] = [each.id for each in query_set]

一对一的关系字段，或者反响映射的一对一关系，one_to_one为True。

def o2o(field):
    try:
        if relation_data:
            result[field.name] = self._to_dict(getattr(self, field.name))
        else:
            result[field.name] = getattr(self, field.name + '_id')
    except ObjectDoesNotExist:
        result[field.name] = None

一个指向另一个model的外键关系，one_to_many为True。

def o2m(field):
    if field.related_name is None:
        field_name = field.name + '_set'
    else:
        field_name = field.related_name

    # 自定义规则筛选
    query_set = self.get_qs(field_name, getattr(self, field_name))

    if relation_data:
        result[field.name] = [self._to_dict(each) for each in query_set]
    else:
        result[field.name] = [each.id for each in query_set]

其他model指向本Model的外键关系，many_to_one为True。

def m2o(field):
    if relation_data:
        result[field.name] = self._to_dict(getattr(self, field.name))
    else:
        result[field.name] = getattr(self, field.name + '_id')

把一切组合起来再稍加修改就变成如下代码：

import datetime

from django.core.exceptions import ObjectDoesNotExist
from django.conf import settings
from django.db import models
from django.core.files import File


class ModelSerializationMixin:

    def get_qs(self, field_name: str, field):
        return field.all()

    def get_exclude(self, exclude: [str]) -> []:
        return exclude if exclude else []

    @staticmethod
    def _to_dict(
            self: models.Model,
            fields: [str] = None,
            exclude: [str] = None,
            relation: bool = False,
            relation_data: bool = None,
            raw_data: bool = False
    ):
        """
        将Model对象序列化
        * int, str, float, bool 等对象正常解析
        * DateTimeField 解析为 get_datetime_format 的格式,
        * DateField 解析为 get_date_format 格式
        * FileField, ImageField 等解析为路径字符串
        :param self: 需要序列化的对象
        :param fields: str[] 需要序列化的字段名, 不给值时默认序列化所有字段
        :param exclude: str[] 不需要序列化的字段名
        :param relation: Boolean 为真时序列化关系字段
        :param relation_data: Boolean 为假时仅序列化关系字段的 id, 默认值等于 relation
        :param raw_data: Boolean 为真时将不再将 datetime 等特殊对象转为字符串,而提供原始对象
        :return: dict
        """
        if self is None:
            return None

        result = dict()  # 返回结果
        exclude = getattr(self, "get_exclude", lambda x: [] if x is None else x)(exclude)
        relation_data = relation_data if relation_data is not None else relation

        def get_all_fields():
            if fields is None:
                for field in self._meta.get_fields():
                    if field.name in exclude:
                        continue
                    yield field
            else:
                for field_name in fields:
                    if field_name in exclude:
                        continue
                    yield self._meta.get_field(field_name)

        def if_relation(func):
            # 仅在relation为真时才执行
            def inline(field):
                if not relation:
                    return None
                return func(field)

            return inline

        @if_relation
        def m2m(field):
            if isinstance(field, models.ManyToManyRel):
                if field.related_name is None:
                    field_name = field.name + '_set'
                else:
                    field_name = field.related_name
            else:
                field_name = field.name

            # 自定义规则筛选
            query_set = self.get_qs(field_name, getattr(self, field_name))

            if relation_data:
                result[field.name] = [self._to_dict(each) for each in query_set]
            else:
                result[field.name] = [each.id for each in query_set]

        @if_relation
        def o2m(field):
            if field.related_name is None:
                field_name = field.name + '_set'
            else:
                field_name = field.related_name

            # 自定义规则筛选
            query_set = self.get_qs(field_name, getattr(self, field_name))

            if relation_data:
                result[field.name] = [self._to_dict(each) for each in query_set]
            else:
                result[field.name] = [each.id for each in query_set]

        @if_relation
        def o2o(field):
            try:
                if relation_data:
                    result[field.name] = self._to_dict(getattr(self, field.name))
                else:
                    result[field.name] = getattr(self, field.name + '_id')
            except ObjectDoesNotExist:
                result[field.name] = None

        @if_relation
        def m2o(field):
            if relation_data:
                result[field.name] = self._to_dict(getattr(self, field.name))
            else:
                result[field.name] = getattr(self, field.name + '_id')

        def normal(field):
            result[field.name] = getattr(self, field.name)
            if raw_data:
                return
            # 将不能直接用json解析的对象转为字符串
            if isinstance(result[field.name], datetime.datetime):
                result[field.name] = result[field.name].strftime("%Y-%m-%d %H:%M:%S")
            elif isinstance(result[field.name], datetime.date):
                result[field.name] = result[field.name].strftime("%Y-%m-%d")
            elif isinstance(result[field.name], (File,)):
                result[field.name] = settings.MEDIA_URL + str(result[field.name])

        for field in get_all_fields():
            if field.many_to_many:
                m2m(field)
            elif field.one_to_many:
                o2m(field)
            elif field.one_to_one:
                o2o(field)
            elif field.many_to_one:
                m2o(field)
            else:
                normal(field)

        return result

    def to_dict(self, *, fields=None, exclude=None, relation=False, relation_data=None, raw_data=False):
        return self._to_dict(
            self,
            fields=fields,
            exclude=exclude,
            relation=relation,
            relation_data=relation_data,
            raw_data=raw_data
        )

当我们需要使用的时候，只需要像下面这样定义Model即可

class Article(models.Model, ModelSerializationMixin):
    title = models.CharField(max_length=20)