Django Rest Framework中文文档：Serializer relations

这是对DRF官方文档：Serializer relations的翻译，根据个人的理解对内容做了些补充、修改和整理。

一，django模型间的关系

在我们对数据进行建模时，最重要的一点就是根据功能需求分析出实体及其关系，

在实现阶段：

一个实体对应一个模型，一个模型就是一张数据表；
实体间的关系由模型中的关系字段进行表示，模型间的关系就是数据表间的关系。

这种设计理念与关系型数据库的设计理念相符。而关系型数据库的强大之就处在于表示与处理各表之间的关联关系。

为此，Django 提供了定义三种最常见的数据库关联关系的方法的关系字段：

OneToOneFieldForeignKeyManyToManyField

二，检查序列化器实例详情

Serializer

ModelSerializer

ModelSerializer

>>> from myapp.serializers import AccountSerializer
>>> serializer = AccountSerializer()
>>> print repr(serializer)  # Or `print(repr(serializer))` in Python 3.x.
AccountSerializer():
    id = IntegerField(label='ID', read_only=True)
    name = CharField(allow_blank=True, max_length=100, required=False)
    owner = PrimaryKeyRelatedField(queryset=User.objects.all())

三，序列化关系字段

为了解释各种类型的关系字段，官网的教程为我们提供了一些简单的模型：用于音乐专辑以及其中的歌曲。

class Album(models.Model):
    album_name = models.CharField(max_length=100)
    artist = models.CharField(max_length=100)


class Track(models.Model):
    album = models.ForeignKey(Album, related_name='tracks', on_delete=models.CASCADE)	# 多对一关系
    order = models.IntegerField()
    title = models.CharField(max_length=100)
    duration = models.IntegerField()

    class Meta:
        unique_together = ('album', 'order')
        ordering = ['order']

    def __str__(self):
        return '%d: %s' % (self.order, self.title)

模型中只用到多对一关系，Album 是主模型，产生主表，Track 是从模型，产生从表。

（一）StringRelatedField

StringRelatedField__str__

字段参数：

many

使用示例：

class AlbumSerializer(serializers.ModelSerializer):
    tracks = serializers.StringRelatedField(many=True)

    class Meta:
        model = Album
        fields = ['album_name', 'artist', 'tracks']

__str__

将产生以下形式的序列化结果：

{
    'album_name': 'Things We Lost In The Fire',
    'artist': 'Low',
    'tracks': [
        '1: Sunflower',
        '2: Whitetail',
        '3: Dinosaur Act',
        ...
    ]
}

（二）PrimaryKeyRelatedField

PrimaryKeyRelatedField

字段参数：

querysetquerysetread_only=Truemanyallow_nullpk_field

使用示例：

class AlbumSerializer(serializers.ModelSerializer):
    tracks = serializers.PrimaryKeyRelatedField(many=True, read_only=True)

    class Meta:
        model = Album
        fields = ['album_name', 'artist', 'tracks']

PrimaryKeyRelatedFieldread_only

效果就是 tracks 属性将使用 Track 模型的主键即 id （我们没在模型中指定主键）来产生关联关系，并使用主键值。

将产生以下形式的序列化结果：

{
    'album_name': 'Undun',
    'artist': 'The Roots',
    'tracks': [
        89,
        90,
        91,
        ...
    ]
}

（三）HyperlinkedRelatedField

HyperlinkedRelatedField

字段参数：

view_namequerysetquerysetread_only=Truemanyallow_nulllookup_fieldlookup_url_kwarglookup_fieldformatformat

使用示例：

class AlbumSerializer(serializers.ModelSerializer):
    tracks = serializers.HyperlinkedRelatedField(
        many=True,
        read_only=True,
        view_name='track-detail'
    )

    class Meta:
        model = Album
        fields = ['album_name', 'artist', 'tracks']

HyperlinkedRelatedFieldread_only

效果就是 tracks 属性将使用 Track 模型的主键即 id （我们没在模型中指定主键）来产生关联关系，并使用主键值。

将产生以下形式的序列化结果：

{
    'album_name': 'Graceland',
    'artist': 'Paul Simon',
    'tracks': [
        'http://www.example.com/api/tracks/45/',
        'http://www.example.com/api/tracks/46/',
        'http://www.example.com/api/tracks/47/',
        ...
    ]
}

（四）SlugRelatedField

SlugRelatedFieldSlug

SlugRelatedField

字段参数：

slug_fieldquerysetquerysetread_only=Truemanyallow_null

使用示例：

class AlbumSerializer(serializers.ModelSerializer):
    tracks = serializers.SlugRelatedField(
        many=True,
        read_only=True,
        slug_field='title'
     )

    class Meta:
        model = Album
        fields = ['album_name', 'artist', 'tracks']

read_onlyunique=True

效果就是 tracks 属性将使用 Track 模型的 title 字段来产生关联关系，并使用其值。

将产生以下形式的序列化结果：

{
    'album_name': 'Dear John',
    'artist': 'Loney Dear',
    'tracks': [
        'Airport Surroundings',
        'Everything Turns to You',
        'I Was Only Going Out',
        ...
    ]
}

（五）HyperlinkedIdentityField

HyperlinkedIdentityFieldHyperlinkedModelSerializer

字段参数：

view_namelookup_fieldlookup_url_kwarglookup_fieldformatformat

使用示例：

class AlbumSerializer(serializers.HyperlinkedModelSerializer):
    track_listing = serializers.HyperlinkedIdentityField(view_name='track-list')

    class Meta:
        model = Album
        fields = ['album_name', 'artist', 'track_listing']

这个字段是只读写的。

效果就是 tracks 属性将使用 Track 模型的主键即 id （我们没在模型中指定主键）来产生关联关系，并使用主键值。

将产生以下形式的序列化结果：

{
    'album_name': 'The Eraser',
    'artist': 'Thom Yorke',
    'track_listing': 'http://www.example.com/api/track_list/12/',
}

四，嵌套关系

与在序列化器中使用序列化关系字段专门序列化模型间关系的方式所不同的是，序列化器本身还能作为序列化字段来表示一种模型间的嵌套关系。例如：

class TrackSerializer(serializers.ModelSerializer):
    class Meta:
        model = Track
        fields = ['order', 'title', 'duration']

class AlbumSerializer(serializers.ModelSerializer):
    tracks = TrackSerializer(many=True, read_only=True)

    class Meta:
        model = Album
        fields = ['album_name', 'artist', 'tracks']

序列化效果：

>>> album = Album.objects.create(album_name="The Grey Album", artist='Danger Mouse')
>>> Track.objects.create(album=album, order=1, title='Public Service Announcement', duration=245)
<Track: Track object>
>>> Track.objects.create(album=album, order=2, title='What More Can I Say', duration=264)
<Track: Track object>
>>> Track.objects.create(album=album, order=3, title='Encore', duration=159)
<Track: Track object>
>>> serializer = AlbumSerializer(instance=album)
>>> serializer.data
{
    'album_name': 'The Grey Album',
    'artist': 'Danger Mouse',
    'tracks': [
        {'order': 1, 'title': 'Public Service Announcement', 'duration': 245},
        {'order': 2, 'title': 'What More Can I Say', 'duration': 264},
        {'order': 3, 'title': 'Encore', 'duration': 159},
        ...
    ],
}

create()update()

class TrackSerializer(serializers.ModelSerializer):
    class Meta:
        model = Track
        fields = ('order', 'title', 'duration')

class AlbumSerializer(serializers.ModelSerializer):
    tracks = TrackSerializer(many=True)

    class Meta:
        model = Album
        fields = ('album_name', 'artist', 'tracks')

    def create(self, validated_data):
        tracks_data = validated_data.pop('tracks')
        album = Album.objects.create(**validated_data)
        for track_data in tracks_data:
            Track.objects.create(album=album, **track_data)
        return album

>>> data = {
    'album_name': 'The Grey Album',
    'artist': 'Danger Mouse',
    'tracks': [
        {'order': 1, 'title': 'Public Service Announcement', 'duration': 245},
        {'order': 2, 'title': 'What More Can I Say', 'duration': 264},
        {'order': 3, 'title': 'Encore', 'duration': 159},
    ],
}
>>> serializer = AlbumSerializer(data=data)
>>> serializer.is_valid()
True
>>> serializer.save()
<Album: Album object>

五，自定义关系字段

RelatedField.to_representation(self, value)

value

import time

class TrackListingField(serializers.RelatedField):
    def to_representation(self, value):
        duration = time.strftime('%M:%S', time.gmtime(value.duration))
        return 'Track %d: %s (%s)' % (value.order, value.name, duration)

class AlbumSerializer(serializers.ModelSerializer):
    tracks = TrackListingField(many=True)

    class Meta:
        model = Album
        fields = ['album_name', 'artist', 'tracks']

效果如下：

{
    'album_name': 'Sometimes I Wish We Were an Eagle',
    'artist': 'Bill Callahan',
    'tracks': [
        'Track 1: Jim Cain (04:39)',
        'Track 2: Eid Ma Clack Shaw (04:19)',
        'Track 3: The Wind and the Dove (04:34)',
        ...
    ]
}

.to_internal_value(self, data)

queryset.get_queryset(self)queryset

六，自定义超链接字段

HyperlinkedRelatedField

get_url(self, obj, view_name, request, format)

view_namelookup_fieldNoReverseMatch

get_object(self, queryset, view_name, view_args, view_kwargs)

ObjectDoesNotExist

假设我们有一个 customer 对象的 URL，它接受两个关键字参数：

/api/<organization_slug>/customers/<customer_pk>/

HyperlinkedRelatedField

from rest_framework import serializers
from rest_framework.reverse import reverse

class CustomerHyperlink(serializers.HyperlinkedRelatedField):
    # 我们将它们定义为类属性，因此我们不需要将它们作为参数传递。
    view_name = 'customer-detail'
    queryset = Customer.objects.all()

    def get_url(self, obj, view_name, request, format):
        url_kwargs = {
            'organization_slug': obj.organization.slug,
            'customer_pk': obj.pk
        }
        return reverse(view_name, kwargs=url_kwargs, request=request, format=format)

    def get_object(self, view_name, view_args, view_kwargs):
        lookup_kwargs = {
           'organization__slug': view_kwargs['organization_slug'],
           'pk': view_kwargs['customer_pk']
        }
        return self.get_queryset().get(**lookup_kwargs)

.get_object

官方建议还是尽可能使用序列化关系字段 API ，但适度使用嵌套的 URL 样式也是合理的。

在这里插入图片描述