• Serializer 关系
    • 检查关系。
  • API 参考
    • StringRelatedField
    • PrimaryKeyRelatedField
    • HyperlinkedRelatedField
    • SlugRelatedField
    • HyperlinkedIdentityField
  • 嵌套关系
    • 举个栗子
    • 可写嵌套序列化类
  • 自定义关系字段
    • 举个栗子
  • 自定义超链接字段
    • 举个栗子
  • 进一步说明
    • queryset 参数
    • 自定义 HTML 显示
    • Select field cutoffs
    • 反向关系
    • 通用关系
    • 具有 Through 模型的 ManyToManyFields

    官方原文链接

    Serializer 关系

    关系字段用于表示模型关系。 它们可以应用于 ForeignKey，ManyToManyField 和 OneToOneField 关系，反向关系以及 GenericForeignKey 等自定义关系。

    注意： 关系字段在 relations.py 中声明，但按照惯例，你应该从 serializers 模块导入它们，使用 from rest_framework import serializers 引入，并像 serializers.<FieldName> 这样引用字段。

    检查关系。

    在使用 ModelSerializer 类时，将自动为你生成序列化字段和关系。检查这些自动生成的字段可以学习如何定制关系风格。

    为此，使用 python manage.py shell 打开 Django shell，然后导入序列化类，实例化它并打印对象表示形式…

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

    API 参考

    为了解释各种类型的关系字段，我们将为我们的示例使用几个简单的模型。我们的模型将使用音乐专辑，以及每张专辑中列出的曲目。

    1. class Album(models.Model):
    2.     album_name = models.CharField(max_length=100)
    3.     artist = models.CharField(max_length=100)
    5. class Track(models.Model):
    6.     album = models.ForeignKey(Album, related_name='tracks', on_delete=models.CASCADE)
    7.     order = models.IntegerField()
    8.     title = models.CharField(max_length=100)
    9.     duration = models.IntegerField()
    11.     class Meta:
    12.         unique_together = ('album', 'order')
    13.         ordering = ['order']
    15.     def __unicode__(self):
    16.         return '%d: %s' % (self.order, self.title)

    StringRelatedField

    StringRelatedField 用于使用 __unicode__ 方法表示关系。

    例如，下面的序列化类。

    1. class AlbumSerializer(serializers.ModelSerializer):
    2.     tracks = serializers.StringRelatedField(many=True)
    4.     class Meta:
    5.         model = Album
    6.         fields = ('album_name', 'artist', 'tracks')

    将序列化为以下形式。

    1. {
    2.     'album_name': 'Things We Lost In The Fire',
    3.     'artist': 'Low',
    4.     'tracks': [
    5.         '1: Sunflower',
    6.         '2: Whitetail',
    7.         '3: Dinosaur Act',
    8.         ...
    9.     ]
    10. }

    该字段是只读的。

    参数:

    • many - 如果是一对多的关系，就将此参数设置为 True.

    PrimaryKeyRelatedField

    PrimaryKeyRelatedField 用于使用其主键表示关系。

    例如，以下序列化类：

    1. class AlbumSerializer(serializers.ModelSerializer):
    2.     tracks = serializers.PrimaryKeyRelatedField(many=True, read_only=True)
    4.     class Meta:
    5.         model = Album
    6.         fields = ('album_name', 'artist', 'tracks')

    将序列化为这样的表示：

    1. {
    2.     'album_name': 'Undun',
    3.     'artist': 'The Roots',
    4.     'tracks': [
    5.         89,
    6.         90,
    7.         91,
    8.         ...
    9.     ]
    10. }

    默认情况下，该字段是可读写的，但您可以使用 read_only 标志更改此行为。

    参数:

    • queryset - 验证字段输入时用于模型实例查询的查询集。必须显式地设置查询集，或设置 read_only=True。
    • many - 如果应用于一对多关系，则应将此参数设置为 True。
    • allow_null - 如果设置为 True，那么该字段将接受 None 值或可为空的关系的空字符串。默认为 False。
    • pk_field - 设置为一个字段来控制主键值的序列化/反序列化。例如， pk_field=UUIDField(format='hex') 会将 UUID 主键序列化为其紧凑的十六进制表示形式。

    HyperlinkedRelatedField

    HyperlinkedRelatedField 用于使用超链接来表示关系。

    例如，以下序列化类：

    1. class AlbumSerializer(serializers.ModelSerializer):
    2.     tracks = serializers.HyperlinkedRelatedField(
    3.         many=True,
    4.         read_only=True,
    5.         view_name='track-detail'
    6.     )
    8.     class Meta:
    9.         model = Album
    10.         fields = ('album_name', 'artist', 'tracks')

    将序列化为这样的表示：

    1. {
    2.     'album_name': 'Graceland',
    3.     'artist': 'Paul Simon',
    4.     'tracks': [
    5.         'http://www.example.com/api/tracks/45/',
    6.         'http://www.example.com/api/tracks/46/',
    7.         'http://www.example.com/api/tracks/47/',
    8.         ...
    9.     ]
    10. }

    默认情况下，该字段是可读写的，但您可以使用 read_only 标志更改此行为。

    注意：该字段是为映射到接受单个 URL 关键字参数的 URL 的对象而设计的，如使用 lookup_field 和 lookup_url_kwarg 参数设置的对象。

    这适用于包含单个主键或 slug 参数作为 URL 一部分的 URL。

    如果需要更复杂的超链接表示，你需要自定义该字段，稍后会详解。

    参数：

    • view_name - 用作关系目标的视图名称。如果你使用的是标准路由器类，则这将是一个格式为 <modelname>-detail 的字符串。必填.
    • queryset - 验证字段输入时用于模型实例查询的查询集。必须显式地设置查询集，或设置 read_only=True。
    • many - 如果应用于一对多关系，则应将此参数设置为 True。
    • allow_null - 如果设置为 True，那么该字段将接受 None 值或可为空的关系的空字符串。默认为 False。
    • lookup_field - 用于查找的目标字段。对应于引用视图上的 URL 关键字参数。默认是 'pk'.
    • lookup_url_kwarg - 与查找字段对应的 URL conf 中定义的关键字参数的名称。默认使用与 lookup_field 相同的值。
    • format - 如果使用格式后缀，则超链接字段将使用与目标相同的格式后缀，除非使用 format 参数进行覆盖。

    SlugRelatedField

    SlugRelatedField 用于使用目标上的字段来表示关系。

    例如，以下序列化类：

    1. class AlbumSerializer(serializers.ModelSerializer):
    2.     tracks = serializers.SlugRelatedField(
    3.         many=True,
    4.         read_only=True,
    5.         slug_field='title'
    6.      )
    8.     class Meta:
    9.         model = Album
    10.         fields = ('album_name', 'artist', 'tracks')

    将序列化为这样的表示：

    1. {
    2.     'album_name': 'Dear John',
    3.     'artist': 'Loney Dear',
    4.     'tracks': [
    5.         'Airport Surroundings',
    6.         'Everything Turns to You',
    7.         'I Was Only Going Out',
    8.         ...
    9.     ]
    10. }

    默认情况下，该字段是可读写的，但您可以使用 read_only 标志更改此行为。

    将 SlugRelatedField 用作读写字段时，通常需要确保 slug 字段与 unique=True 的模型字段相对应。

    参数：

    • slug_field - 用来表示目标的字段。这应该是唯一标识给定实例的字段。例如， username。必填
    • queryset - 验证字段输入时用于模型实例查询的查询集。必须显式地设置查询集，或设置 read_only=True。
    • many - 如果应用于一对多关系，则应将此参数设置为 True。
    • allow_null - 如果设置为 True，那么该字段将接受 None 值或可为空的关系的空字符串。默认为 False。

    HyperlinkedIdentityField

    此字段可以作为身份关系应用，例如 HyperlinkedModelSerializer 上的 'url' 字段。它也可以用于对象的属性。例如，以下序列化类：

    1. class AlbumSerializer(serializers.HyperlinkedModelSerializer):
    2.     track_listing = serializers.HyperlinkedIdentityField(view_name='track-list')
    4.     class Meta:
    5.         model = Album
    6.         fields = ('album_name', 'artist', 'track_listing')

    将序列化为这样的表示：

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

    该字段始终为只读。

    参数：

    • view_name - 用作关系目标的视图名称。如果你使用的是标准路由器类，则这将是一个格式为 <modelname>-detail 的字符串。必填。
    • lookup_field - 用于查找的目标字段。对应于引用视图上的 URL 关键字参数。默认是 'pk'。
    • lookup_url_kwarg - 与查找字段对应的 URL conf 中定义的关键字参数的名称。默认使用与 lookup_field 相同的值。
    • format - 如果使用格式后缀，则超链接字段将使用与目标相同的格式后缀，除非使用 format 参数进行覆盖。

    嵌套关系

    嵌套关系可以通过使用序列化类作为字段来表达。

    如果该字段用于表示一对多关系，则应将 many=True 标志添加到序列化字段。

    举个栗子

    例如，以下序列化类：

    1. class TrackSerializer(serializers.ModelSerializer):
    2.     class Meta:
    3.         model = Track
    4.         fields = ('order', 'title', 'duration')
    6. class AlbumSerializer(serializers.ModelSerializer):
    7.     tracks = TrackSerializer(many=True, read_only=True)
    9.     class Meta:
    10.         model = Album
    11.         fields = ('album_name', 'artist', 'tracks')

    将序列化为这样的嵌套表示：

    1. >>> album = Album.objects.create(album_name="The Grey Album", artist='Danger Mouse')
    2. >>> Track.objects.create(album=album, order=1, title='Public Service Announcement', duration=245)
    3. <Track: Track object>
    4. >>> Track.objects.create(album=album, order=2, title='What More Can I Say', duration=264)
    5. <Track: Track object>
    6. >>> Track.objects.create(album=album, order=3, title='Encore', duration=159)
    7. <Track: Track object>
    8. >>> serializer = AlbumSerializer(instance=album)
    9. >>> serializer.data
    10. {
    11.     'album_name': 'The Grey Album',
    12.     'artist': 'Danger Mouse',
    13.     'tracks': [
    14.         {'order': 1, 'title': 'Public Service Announcement', 'duration': 245},
    15.         {'order': 2, 'title': 'What More Can I Say', 'duration': 264},
    16.         {'order': 3, 'title': 'Encore', 'duration': 159},
    17.         ...
    18.     ],
    19. }

    可写嵌套序列化类

    默认情况下，嵌套序列化类是只读的。如果要支持对嵌套序列化字段的写操作，则需要创建 create() 和/或 update() 方法，以明确指定应如何保存子关系。

    1. class TrackSerializer(serializers.ModelSerializer):
    2.     class Meta:
    3.         model = Track
    4.         fields = ('order', 'title', 'duration')
    6. class AlbumSerializer(serializers.ModelSerializer):
    7.     tracks = TrackSerializer(many=True)
    9.     class Meta:
    10.         model = Album
    11.         fields = ('album_name', 'artist', 'tracks')
    13.     def create(self, validated_data):
    14.         tracks_data = validated_data.pop('tracks')
    15.         album = Album.objects.create(**validated_data)
    16.         for track_data in tracks_data:
    17.             Track.objects.create(album=album, **track_data)
    18.         return album
    20. >>> data = {
    21.     'album_name': 'The Grey Album',
    22.     'artist': 'Danger Mouse',
    23.     'tracks': [
    24.         {'order': 1, 'title': 'Public Service Announcement', 'duration': 245},
    25.         {'order': 2, 'title': 'What More Can I Say', 'duration': 264},
    26.         {'order': 3, 'title': 'Encore', 'duration': 159},
    27.     ],
    28. }
    29. >>> serializer = AlbumSerializer(data=data)
    30. >>> serializer.is_valid()
    31. True
    32. >>> serializer.save()
    33. <Album: Album object>

    自定义关系字段

    在极少数情况下，现有的关系类型都不符合您需要的表示形式，你可以实现一个完全自定义的关系字段，该字段准确描述应该如何从模型实例生成输出表示。

    要实现自定义关系字段，您应该重写 RelatedField，并实现 .to_representation(self, value) 方法。此方法将字段的目标作为 value 参数，并返回应用于序列化目标的表示。value 参数通常是一个模型实例。

    如果要实现读写关系字段，则还必须实现 .to_internal_value(self, data) 方法。

    要提供基于 context 的动态查询集，还可以覆盖 .get_queryset(self)，而不是在类上指定 .queryset 或初始化该字段。

    举个栗子

    例如，我们可以定义一个关系字段，使用它的顺序，标题和持续时间将音轨序列化为自定义字符串表示。

    1. import time
    3. class TrackListingField(serializers.RelatedField):
    4.     def to_representation(self, value):
    5.         duration = time.strftime('%M:%S', time.gmtime(value.duration))
    6.         return 'Track %d: %s (%s)' % (value.order, value.name, duration)
    8. class AlbumSerializer(serializers.ModelSerializer):
    9.     tracks = TrackListingField(many=True)
    11.     class Meta:
    12.         model = Album
    13.         fields = ('album_name', 'artist', 'tracks')

    将序列化为这样的表示：

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

    自定义超链接字段

    在某些情况下，您可能需要自定义超链接字段的行为，以表示需要多个查询字段的 URL。

    您可以通过继承 HyperlinkedRelatedField 来实现此目的。有两个可以被覆盖的方法：

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

    get_url 方法用于将对象实例映射到其 URL 表示。

    如果 view_name 和 lookup_field 属性未配置为正确匹配 URL conf，可能会引发 NoReverseMatch 。

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

    如果您想支持可写的超链接字段，那么您还需要重写 get_object，以便将传入的 URL 映射回它们表示的对象。对于只读超链接字段，不需要重写此方法。

    此方法的返回值应该是与匹配的 URL conf 参数对应的对象。

    可能会引发 ObjectDoesNotExist 异常。

    举个栗子

    假设我们有一个带有两个关键字参数的 customer 对象的 URL，如下所示：

    1. /api/<organization_slug>/customers/<customer_pk>/

    这没办法用仅接受单个查找字段的默认实现来表示。

    在这种情况下，我们需要继承 HyperlinkedRelatedField 并重写其中的方法来获得我们想要的行为：

    1. from rest_framework import serializers
    2. from rest_framework.reverse import reverse
    4. class CustomerHyperlink(serializers.HyperlinkedRelatedField):
    5.     # We define these as class attributes, so we don't need to pass them as arguments.
    6.     view_name = 'customer-detail'
    7.     queryset = Customer.objects.all()
    9.     def get_url(self, obj, view_name, request, format):
    10.         url_kwargs = {
    11.             'organization_slug': obj.organization.slug,
    12.             'customer_pk': obj.pk
    13.         }
    14.         return reverse(view_name, kwargs=url_kwargs, request=request, format=format)
    16.     def get_object(self, view_name, view_args, view_kwargs):
    17.         lookup_kwargs = {
    18.            'organization__slug': view_kwargs['organization_slug'],
    19.            'pk': view_kwargs['customer_pk']
    20.         }
    21.         return self.get_queryset().get(**lookup_kwargs)

    请注意，如果您想将此风格与通用视图一起使用，那么您还需要覆盖视图上的 .get_object 以获得正确的查找行为。

    一般来说，我们建议尽可能在 API 表示方式下使用平面风格，但嵌套 URL 风格在适度使用时也是合理的。

    进一步说明

    queryset 参数

    queryset 参数只对可写关系字段是必需的，在这种情况下，它用于执行模型实例查找，该查找从基本用户输入映射到模型实例。

    在 2.x 版本中，如果正在使用 ModelSerializer 类，则序列化类有时会自动确定 queryset 参数。

    此行为现​​在替换为始终为可写关系字段使用显式 queryset 参数。

    这样做可以减少 ModelSerializer 提供的隐藏 “魔术” 数量（指 ModelSerializer 在内部帮我们完成的工作），使字段的行为更加清晰，并确保在使用 ModelSerializer 快捷方式（高度封装过，使用简单）或使用完全显式的 Serializer 类之间转换是微不足道的。

    自定义 HTML 显示

    模型内置的 __str__ 方法用来生成用于填充 choices 属性的对象的字符串表示形式。这些 choices 用于在可浏览的 API 中填充选择的 HTML input。

    要为这些 input 提供自定义表示，请重写 RelatedField 子类的 display_value() 方法。这个方法将接收一个模型对象，并且应该返回一个适合表示它的字符串。例如：

    1. class TrackPrimaryKeyRelatedField(serializers.PrimaryKeyRelatedField):
    2.     def display_value(self, instance):
    3.         return 'Track: %s' % (instance.title)

    Select field cutoffs

    在渲染可浏览的 API 关系字段时，默认只显示最多 1000 个可选 item。如果存在更多项目，则会显示 “More than 1000 items…” 的 disabled 选项。

    此行为旨在防止由于显示大量关系而导致模板无法在可接受的时间范围内完成渲染。

    有两个关键字参数可用于控制此行为：

    • html_cutoff - 设置 HTML select 下拉菜单中显示的选项的最大数量。设置为 None 可以禁用任何限制。默认为 1000。
    • html_cutoff_text - 设置一个文本字符串，在 HTML select 下拉菜单超出最大显示数量时显示。默认是 "More than {count} items…"

    你还可以在 settings 中用 HTML_SELECT_CUTOFF 和 HTML_SELECT_CUTOFF_TEXT 来全局控制这些设置。

    在强制执行 cutoff 的情况下，您可能希望改为在 HTML 表单中使用简单的 input 字段。你可以使用 style 关键字参数来做到这一点。例如：

    1. assigned_to = serializers.SlugRelatedField(
    2.    queryset=User.objects.all(),
    3.    slug_field='username',
    4.    style={'base_template': 'input.html'}
    5. )

    反向关系

    请注意，反向关系不会自动包含在 ModelSerializer 和 HyperlinkedModelSerializer 类中。要包含反向关系，您必须明确将其添加到字段列表中。例如：

    1. class AlbumSerializer(serializers.ModelSerializer):
    2.     class Meta:
    3.         fields = ('tracks', ...)

    通常需要确保已经在关系上设置了适当的 related_name 参数，可以将其用作字段名称。例如：

    1. class Track(models.Model):
    2.     album = models.ForeignKey(Album, related_name='tracks', on_delete=models.CASCADE)
    3.     ...

    如果你还没有为反向关系设置相关名称，则需要在 fields 参数中使用自动生成的相关名称。例如：

    1. class AlbumSerializer(serializers.ModelSerializer):
    2.     class Meta:
    3.         fields = ('track_set', ...)

    通用关系

    如果要序列化通用外键，则需要自定义字段，以明确确定如何序列化关系。

    例如，给定一个以下模型的标签，该标签与其他任意模型具有通用关系：

    1. class TaggedItem(models.Model):
    2.     """
    3.     Tags arbitrary model instances using a generic relation.
    5.     See: https://docs.djangoproject.com/en/stable/ref/contrib/contenttypes/
    6.     """
    7.     tag_name = models.SlugField()
    8.     content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
    9.     object_id = models.PositiveIntegerField()
    10.     tagged_object = GenericForeignKey('content_type', 'object_id')
    12.     def __unicode__(self):
    13.         return self.tag_name

    以下两种模式可以用相关的标签：

    1. class Bookmark(models.Model):
    2.     """
    3.     A bookmark consists of a URL, and 0 or more descriptive tags.
    4.     """
    5.     url = models.URLField()
    6.     tags = GenericRelation(TaggedItem)
    9. class Note(models.Model):
    10.     """
    11.     A note consists of some text, and 0 or more descriptive tags.
    12.     """
    13.     text = models.CharField(max_length=1000)
    14.     tags = GenericRelation(TaggedItem)

    我们可以定义一个可用于序列化标签实例的自定义字段，并使用每个实例的类型来确定它应该如何序列化。

    1. class TaggedObjectRelatedField(serializers.RelatedField):
    2.     """
    3.     A custom field to use for the `tagged_object` generic relationship.
    4.     """
    6.     def to_representation(self, value):
    7.         """
    8.         Serialize tagged objects to a simple textual representation.
    9.         """
    10.         if isinstance(value, Bookmark):
    11.             return 'Bookmark: ' + value.url
    12.         elif isinstance(value, Note):
    13.             return 'Note: ' + value.text
    14.         raise Exception('Unexpected type of tagged object')

    如果你需要的关系具有嵌套表示，则可以在 .to_representation() 方法中使用所需的序列化类：

    1.     def to_representation(self, value):
    2.         """
    3.         Serialize bookmark instances using a bookmark serializer,
    4.         and note instances using a note serializer.
    5.         """
    6.         if isinstance(value, Bookmark):
    7.             serializer = BookmarkSerializer(value)
    8.         elif isinstance(value, Note):
    9.             serializer = NoteSerializer(value)
    10.         else:
    11.             raise Exception('Unexpected type of tagged object')
    13.         return serializer.data

    请注意，使用 GenericRelation 字段表示的反向通用键可以使用常规关系字段类型进行序列化，因为关系中目标的类型总是已知的。

    具有 Through 模型的 ManyToManyFields

    默认情况下，将指定带有 through 模型的 ManyToManyField 的关系字段设置为只读。

    如果你要明确指定一个指向具有 through 模型的 ManyToManyField 的关系字段，请确保将 read_only 设置为 True 。