如何使用Django RF通过单个端点创建关联多类型订单模型

核心思路 #

通过单个POST端点接收请求，先验证订单类型及对应字段，再原子性创建BaseOrder和对应类型的子订单（TypeAOrder/TypeBOrder），确保数据一致性。

实现步骤 #

1. 确认模型结构（假设已定义） #

确保子订单模型与BaseOrder通过一对一关联绑定：

from django.db import models

class BaseOrder(models.Model):
    ORDER_TYPE_CHOICES = (('A', 'Type A'), ('B', 'Type B'))
    order_type = models.CharField(max_length=10, choices=ORDER_TYPE_CHOICES)
    customer_name = models.CharField(max_length=100)
    created_at = models.DateTimeField(auto_now_add=True)
    # 其他公共字段（如金额、地址等）

class TypeAOrder(models.Model):
    base_order = models.OneToOneField(BaseOrder, on_delete=models.CASCADE, related_name='type_a')
    specific_field_a = models.CharField(max_length=50)  # A类专属字段
    # 更多A类专属字段

class TypeBOrder(models.Model):
    base_order = models.OneToOneField(BaseOrder, on_delete=models.CASCADE, related_name='type_b')
    specific_field_b = models.IntegerField()  # B类专属字段
    # 更多B类专属字段

2. 编写输入序列化器 #

创建一个统一的序列化器处理请求数据，同时做类型校验：

from rest_framework import serializers
from .models import BaseOrder, TypeAOrder, TypeBOrder

class OrderCreateSerializer(serializers.Serializer):
    order_type = serializers.ChoiceField(choices=BaseOrder.ORDER_TYPE_CHOICES)
    customer_name = serializers.CharField(max_length=100)
    # 公共字段
    specific_field_a = serializers.CharField(max_length=50, required=False)
    specific_field_b = serializers.IntegerField(required=False)

    def validate(self, data):
        """验证对应订单类型的必填字段是否存在"""
        order_type = data['order_type']
        if order_type == 'A' and not data.get('specific_field_a'):
            raise serializers.ValidationError("Type A订单必须提供specific_field_a")
        if order_type == 'B' and not data.get('specific_field_b'):
            raise serializers.ValidationError("Type B订单必须提供specific_field_b")
        return data

3. 实现视图逻辑 #

使用APIView重写post方法，通过事务保证数据原子性：

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from django.db import transaction
from .serializers import OrderCreateSerializer
from .models import BaseOrder, TypeAOrder, TypeBOrder

class OrderCreateView(APIView):
    def post(self, request):
        serializer = OrderCreateSerializer(data=request.data)
        if not serializer.is_valid():
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        # 原子事务：要么全创建成功，要么回滚
        with transaction.atomic():
            # 1. 创建BaseOrder
            base_order = BaseOrder.objects.create(
                order_type=serializer.validated_data['order_type'],
                customer_name=serializer.validated_data['customer_name']
                # 传入其他公共字段
            )

            # 2. 根据订单类型创建对应子订单
            order_type = serializer.validated_data['order_type']
            if order_type == 'A':
                TypeAOrder.objects.create(
                    base_order=base_order,
                    specific_field_a=serializer.validated_data['specific_field_a']
                    # 传入其他A类专属字段
                )
            elif order_type == 'B':
                TypeBOrder.objects.create(
                    base_order=base_order,
                    specific_field_b=serializer.validated_data['specific_field_b']
                    # 传入其他B类专属字段
                )

        # 返回合并后的订单数据
        output_serializer = BaseOrderOutputSerializer(base_order)
        return Response(output_serializer.data, status=status.HTTP_201_CREATED)

4. 编写输出序列化器（可选） #

如果需要返回合并后的订单详情，创建输出序列化器：

class TypeAOrderSerializer(serializers.ModelSerializer):
    class Meta:
        model = TypeAOrder
        fields = ['specific_field_a']  # 按需指定返回字段

class TypeBOrderSerializer(serializers.ModelSerializer):
    class Meta:
        model = TypeBOrder
        fields = ['specific_field_b']

class BaseOrderOutputSerializer(serializers.ModelSerializer):
    type_a = TypeAOrderSerializer(read_only=True)
    type_b = TypeBOrderSerializer(read_only=True)

    class Meta:
        model = BaseOrder
        fields = ['id', 'order_type', 'customer_name', 'created_at', 'type_a', 'type_b']

5. 配置URL #

在urls.py中绑定端点：

from django.urls import path
from .views import OrderCreateView

urlpatterns = [
    path('orders/', OrderCreateView.as_view(), name='create-order'),
]

关键注意点 #

• 事务原子性：使用transaction.atomic()确保BaseOrder和子订单要么同时创建成功，要么全部回滚，避免数据不一致。
• 字段校验：在序列化器的validate方法中严格校验对应类型的必填字段，避免创建子模型时出现字段缺失错误。
• 扩展性：如果后续新增订单类型，只需新增子模型、更新序列化器的校验逻辑和视图的创建分支即可，无需修改核心流程。

内容的提问来源于stack exchange，提问作者Brian C