django-rest-framework之序列化

时间 2019-11-26

标签 django rest framework 序列栏目 Python 繁體版

原文原文链接

前言：昨天学习了rest-framework序列化方面的知识，故写了博客记录一下。官网:http://www.django-rest-framework.org/tutorial/1-serialization/#working-with-serializers。html

先后端分离：前台的开发和后台的开发分离开。这个方案的实现就是要借助API，API简单说就是开发人员提供编程接口被其余人调用，他们调用以后会返回数据供其使用。API的类型有多种，可是如今比较主流且实用的就是RESTful API。前端

1、开始

Okay, we're ready to get coding. To get started, let's create a new project to work with.首先建立一个Django项目。python

cd ~ django-admin.py startproject tutorial cd tutorial

Once that's done we can create an app that we'll use to create a simple Web API.接着建立一个APPshell

python manage.py startapp snippets

We'll need to add our new snippets app and the rest_framework app to INSTALLED_APPS. Let's edit the tutorial/settings.py file:修改全局配置文件。数据库

INSTALLED_APPS = ( ... 'rest_framework', 'snippets.apps.SnippetsConfig', )

Please note that if you're using Django <1.9, you need to replace snippets.apps.SnippetsConfig with snippets.django

若是你使用的Django <1.9，则须要更换snippets.apps.SnippetsConfig为snippets。编程

2、建立模型类

For the purposes of this tutorial we're going to start by creating a simple Snippet model that is used to store code snippets(片断). Go ahead and edit the snippets/models.py file.json

咱们将首先建立一个Snippet用于存储代码片断的简单模型，编辑snippets/models.py文件。后端

from django.db import models # Create your models here.

# pygments能够实现代码高亮　官网:http://pygments.org/
from pygments.lexers import get_all_lexers  # lexers:词法分析器
from pygments.styles import get_all_styles LEXERS = [item for item in get_all_lexers() if item[1]] LANGUAGE_CHOICES = sorted([(item[1][0], item[0]) for item in LEXERS]) STYLE_CHOICES = sorted((item, item) for item in get_all_styles()) class Snippet(models.Model): created = models.DateTimeField(auto_now_add=True)  # 自动添加建立时间
    title = models.CharField(max_length=100, blank=True, default='') code = models.TextField() linenos = models.BooleanField(default=False) language = models.CharField(choices=LANGUAGE_CHOICES, default='python', max_length=100) style = models.CharField(choices=STYLE_CHOICES, default='friendly', max_length=100) class Meta: ordering = ('created',)  # 根据建立时间来排序

初始化而且同步到数据库:api

python manage.py makemigrations snippets
python manage.py migrate

3、建立序列化类

The first thing we need to get started on our Web API is to provide a way of serializing(序列化) and deserializing(反序列化) the snippet instances into representations such as json. We can do this by declaring(声明) serializers that work very similar to Django's forms.

首先我要问你了，一般状况下，前端从调用后台API，API确定须要返回数据给前端，那返回的数据是什么类型呢？

目前主流用的比较多的是JSON，可能有少部分还在用XML。

那咱们在学习django-rest-framework时，有没有提供什么方法可以将数据实例信息自动转换为JSON？并且也能够将前端传给后台的JSON数据转换为python的数据类型(dict/list/set...)。固然有，序列化器(serializers)能够实现。首先你得声明(引入)序列化器，请看下面这个例子：

# 用Web API的第一件事是提供一种将代码片断实例序列化和反序列化为表示形式的方法json。 # 咱们能够经过声明与Django表单很是类似的序列化器来作到这一点。在snippets命名的目录中建立一个文件， # serializers.py并添加如下内容

from rest_framework import serializers from snippets.models import Snippet, LANGUAGE_CHOICES, STYLE_CHOICES class SnippetSerializer(serializers.Serializer): # 序列化器类的第一部分定义了序列化/反序列化的字段。
    id = serializers.IntegerField(read_only=True) title = serializers.CharField(required=False, allow_blank=True, max_length=100) # 利用字段标志控制序列化器渲染到HTML页面时的的显示模板
    code = serializers.CharField(style={'base_template': 'textarea.html'}) linenos = serializers.BooleanField(required=False) language = serializers.ChoiceField(choices=LANGUAGE_CHOICES, default='python') style = serializers.ChoiceField(choices=STYLE_CHOICES, default='friendly') def create(self, validated_data): """ The create() and update() methods define how fully fledged instances are created or modified when calling serializer.save() Create and return a new `Snippet` instance, given the validated data. 给定通过验证的数据，建立并返回一个新的 Snippet 实例 """
        return Snippet.objects.create(**validated_data) def update(self, instance, validated_data): """ Update and return an existing `Snippet` instance, given the validated data. 给定通过验证的数据，更新并返回一个已经存在的 Snippet 实例 """ instance.title = validated_data.get('title', instance.title) instance.code = validated_data.get('code', instance.code) instance.linenos = validated_data.get('linenos', instance.linenos) instance.language = validated_data.get('language', instance.language) instance.style = validated_data.get('style', instance.style) instance.save() # 更新
        return instance

序列化器类的第一部分定义了序列化/反序列化的字段。该create()和update()方法分别定义实例如何建立和更新。

关于下面这行代码：

code = serializers.CharField(style={'base_template': 'textarea.html'})

暂时须要知道的就是它的功能是控制序列化器渲染到HTML页面时的的显示模板，至于为何要这样作，是由于这对于控制如何显示可浏览的API特别有用，这将在后面的文章中看到。

实际上也能够经过使用ModelSerializer来节省本身的时间，咱们稍后会看到，接下来看看序列化器的具体做用。

4、使用序列化器

在咱们进一步了解以前，咱们将熟悉使用咱们新的Serializer类。咱们进入Django shell：

python manage.py shell

接下来的操做就和学习Django的ORM时那样，建立并保存Snippet模型实例：

from snippets.models import Snippet from snippets.serializers import SnippetSerializer from rest_framework.renderers import JSONRenderer from rest_framework.parsers import JSONParser snippet = Snippet(code='foo = "bar"\n') snippet.save() snippet = Snippet(code='print "hello, world"\n') snippet.save()

这个时候查看数据库就会发现相关的表中已经多了两行数据，就是咱们刚才建立的数据：

咱们如今有几个片断实例能够玩。咱们来看看序列化这些实例之一

serializer = SnippetSerializer(snippet)
serializer.data
# {'id': 2, 'title': u'', 'code': u'print "hello, world"\n', 'linenos': False, 'language': u'python', 'style': u'friendly'}

At this point we've translated the model instance into Python native datatypes.

从上面的代码，能够看到，咱们已经将model的实例信息转换为python原生的数据类型，即字典。

To finalize the serialization process we render the data into json.

为了完成序列化过程，咱们将数据转换成json。

content = JSONRenderer().render(serializer.data)
content
# '{"id": 2, "title": "", "code": "print \\"hello, world\\"\\n", "linenos": false, "language": "python", "style": "friendly"}'

这里已经出现了json格式，也就是说这个json格式的数据就是要展现在某个URL上，大概能够感受到，等下咱们在访问某个URL时，会返回上面这堆数据供你使用，这其实就完成了一个序列化的过程，也能够看出客户端的功能雏形。

序列化是为了返回json格式的数据给客户端查看和使用数据，那么当客户端须要修改、增长或者删除数据时，就要把过程反过来了，也就是反序列化，把客户端提交的json格式的数据反序列化。

反序列化是相似的。首先咱们将一个流解析为Python本机数据类型...

from django.utils.six import BytesIO stream = BytesIO(content) data = JSONParser().parse(stream)

...then we restore those native datatypes into a fully populated object instance.

先检查数据是否有误，再保存数据：

serializer = SnippetSerializer(data=data) serializer.is_valid() # True
serializer.validated_data # OrderedDict([('title', ''), ('code', 'print "hello, world"\n'), ('linenos', False), ('language', 'python'), ('style', 'friendly')])
serializer.save() # <Snippet: Snippet object>

这个时候查看数据库又多了一条数据：

We can also serialize querysets instead of model instances. To do so we simply add a many=True flag to the serializer arguments.

咱们也能够序列化查询集而不是模型实例。为此，咱们只须要为serializer参数添加一个标志many=True

serializer = SnippetSerializer(Snippet.objects.all(), many=True) serializer.data # [OrderedDict([('id', 1), ('title', u''), ('code', u'foo = "bar"\n'), ('linenos', False), ('language', 'python'), ('style', 'friendly')]), OrderedDict([('id', 2), ('title', u''), ('code', u'print "hello, world"\n'), ('linenos', False), ('language', 'python'), ('style', 'friendly')]), OrderedDict([('id', 3), ('title', u''), ('code', u'print "hello, world"'), ('linenos', False), ('language', 'python'), ('style', 'friendly')])]

5、使用 ModelSerializers

在上面的SnippetSerializer类中，咱们继承的是serializers.Serializer类，能够看到SnippetSerializer类中有不少代码实际上是和models.py中的Snippet模型相似同样的，因此这里咱们能够改进一下。就像在Django中提供了Form类和ModelForm类同样，django-rest-framework为咱们提供了Serializer类和ModelSerializer类。利用它可让咱们的代码简洁不少，修改serializers.py：

# Our SnippetSerializer class is replicating a lot of information that's also contained in the Snippet model. # It would be nice if we could keep our code a bit more concise.
class SnippetSerializer(serializers.ModelSerializer): class Meta: model = Snippet fields = ('id', 'title', 'code', 'linenos', 'language', 'style')

One nice property that serializers have is that you can inspect(检查/查看) all the fields in a serializer instance, by printing its representation. Open the Django shell with python manage.py shell, then try the following:

序列化器具备的一个不错的属性是能够经过打印其表示来检查序列化器实例中的全部字段。打开Django shell python manage.py shell，而后尝试如下操做：

from snippets.serializers import SnippetSerializer serializer = SnippetSerializer() print(repr(serializer)) # SnippetSerializer(): # id = IntegerField(label='ID', read_only=True) # title = CharField(allow_blank=True, max_length=100, required=False) # code = CharField(style={'base_template': 'textarea.html'}) # linenos = BooleanField(required=False) # language = ChoiceField(choices=[('Clipper', 'FoxPro'), ('Cucumber', 'Gherkin'), ('RobotFramework', 'RobotFramework'), ('abap', 'ABAP'), ('ada', 'Ada')... # style = ChoiceField(choices=[('autumn', 'autumn'), ('borland', 'borland'), ('bw', 'bw'), ('colorful', 'colorful')...

记住，ModelSerializer类不会作任何特别神奇的事情，它们只是建立序列化器类的快捷方式：

一组自动肯定的字段。
简单的默认实现create()和update()方法。

6、编写常规的Django视图

接下来要作的就是使用咱们的新的Serializer类编写一些API视图。编辑snippets/views.py：

from django.shortcuts import render

# Create your views here.
from django.http import HttpResponse, JsonResponse
from django.views.decorators.csrf import csrf_exempt
from rest_framework.renderers import JSONRenderer
from rest_framework.parsers import JSONParser
from snippets.models import Snippet
from snippets.serializers import SnippetSerializer


@csrf_exempt
def snippet_list(request):
    """
    because we want to be able to POST to this view from clients
    that won't have a CSRF token we need to mark the view as csrf_exempt
    List all code snippets, or create a new snippet.
    """
    if request.method == "GET":
        snippets = Snippet.objects.all()
        serializer = SnippetSerializer(snippets, many=True)
        return JsonResponse(serializer.data, safe=False)

    elif request.method == "POST":
        data = JSONParser().parse(request)
        serializer = SnippetSerializer(data=data)
        if serializer.is_valid():
            serializer.save()
            return JsonResponse(serializer.data, status=201)
        return JsonResponse(serializer.errors, status=400)


@csrf_exempt
def snippet_detail(request, pk):
    """
    Retrieve, update or delete a code snippet.
    """
    try:
        snippet = Snippet.objects.get(pk=pk)
    except Snippet.DoesNotExist:
        return HttpResponse(status=404)

    if request.method == "GET":
        serializer = SnippetSerializer(snippet)
        return JsonResponse(serializer.data)

    elif request.method == "PUT":
        data = JSONParser().parse(request)
        serializer = SnippetSerializer(snippet, data=data)
        if serializer.is_valid():
            serializer.save()
            return JsonResponse(serializer.data)
        return JsonResponse(serializer.errors, status=400)

    elif request.method == 'DELETE':
        snippet.delete()
        return HttpResponse(status=204)

上面的代码都比较好理解，定义了不一样http动做时后台不一样的操做，在这里也体现了restful API的理念。

because we want to be able to POST to this view from clients that won't have a CSRF token we need to mark the view as csrf_exempt.

由于咱们但愿可以从不具备CSRF令牌的客户端对此视图进行POST，所以咱们须要给视图加个一个装饰器csrf_exempt

为了让视图函数被调用，那固然须要设计一下url了，这里的处理和平时Django开发时是同样的。首先建立snippets/urls.py

from django.conf.urls import url from snippets import views urlpatterns = [ url(r'^snippets/$', views.snippet_list), url(r'^snippets/(?P<pk>[0-9]+)/$', views.snippet_detail), ]

We also need to wire up the root urlconf, in the tutorial/urls.py file, to include our snippet app's URLs.

from django.conf.urls import url, include

urlpatterns = [
    url(r'^', include('snippets.urls')),
]

7、对API进行测试

完成了上面那些工做后，就能够开始测试了，退出shell模式并启动服务器，根据咱们刚才设计的url发送请求，须要先安装httpie模块：

pip install httpie

而后在命令行窗口访问，效果以下：

也能够访问指定id的数据：

固然了，也能够直接在浏览器查看，直接输入那个URL就能够了：