如何在Django序列化器中复用validate_semester自定义验证器？

我有如下serializer.py文件，其中SubjectSerializer类包含validate_semester()方法，用于在给Student或Subject对象分配学期ID前，验证该ID是否存在于学期表中。我希望在StudentSerializer类中复用这个方法。

from rest_framework import serializers
from .models import *
from .helpers import SEMESTER_NOT_STORED


class SemesterSerializer(serializers.Serializer):
    id = serializers.IntegerField(required=False)
    name = serializers.CharField(max_length=100, required=False)


class SubjectSerializer(serializers.ModelSerializer):
    semester = SemesterSerializer()

    class Meta:
        model = Subject
        fields = ["id", "name", "code", "semester"]

    def create(self, validated_data):
        semester = validated_data.pop("semester")
        serializer = SemesterSerializer(semester)
        subject = Subject.objects.create(
            semester_id=serializer.data["id"], **validated_data
        )
        return subject

    def validate_semester(self, value):
        id = value.get("id")
        try:
            Semester.objects.get(id=id)
        except Semester.DoesNotExist:
            raise serializers.ValidationError({"id":[SEMESTER_NOT_STORED.format(id)]})
        return value


class SemesterSubjectSerializer(serializers.ModelSerializer):
    subjects = SubjectSerializer(many=True, read_only=True)

    class Meta:
        model = Semester
        fields = ["id", "name", "subjects"]


class StudentSerializer(serializers.ModelSerializer):
    semester = SemesterSerializer()

    class Meta:
        model = Student
        fields = ["id", "name", "email", "semester"]

    def create(self, validated_data):
        semester = validated_data.pop("semester")
        serializer = SemesterSerializer(semester)
        student = Student.objects.create(
            id=None, semester_id=serializer.data["id"], **validated_data
        )
        return student

我也尝试在模型层添加验证，但验证不生效，还出现了IntegrityError错误：

from django.core.validators import MinLengthValidator, MaxLengthValidator
from .helpers import SEMESTER_NOT_STORED

def validate_semester(id):
    semesters = list(Semester.objects.all().values_list("id", flat=True))
    if id not in semesters:
        raise ValueError({"id":[SEMESTER_NOT_STORED.format(id)]})

class Semester(models.Model):
    name = models.CharField(max_length=100)

    def __str__(self):
        return self.name

class Student(models.Model):
    name = models.CharField(max_length=30)
    email = models.EmailField()
    semester = models.ForeignKey(Semester, on_delete=models.DO_NOTHING, default=None, validators=[validate_semester])

方法1：提取公共验证函数 #

把validate_semester逻辑抽成独立函数，放在helpers.py或单独的工具文件中，让两个序列化器直接调用：

1. 在helpers.py中添加：

from rest_framework import serializers
from .models import Semester
from .helpers import SEMESTER_NOT_STORED

def validate_semester(value):
    semester_id = value.get("id")
    try:
        Semester.objects.get(id=semester_id)
    except Semester.DoesNotExist:
        raise serializers.ValidationError({"id": [SEMESTER_NOT_STORED.format(semester_id)]})
    return value

2. 修改两个序列化器：

# SubjectSerializer中
def validate_semester(self, value):
    return validate_semester(value)

# StudentSerializer中
def validate_semester(self, value):
    return validate_semester(value)

方法2：创建基类序列化器 #

定义一个包含验证逻辑的基类，让SubjectSerializer和StudentSerializer继承它：

class BaseSemesterRelatedSerializer(serializers.ModelSerializer):
    semester = SemesterSerializer()

    def validate_semester(self, value):
        semester_id = value.get("id")
        try:
            Semester.objects.get(id=semester_id)
        except Semester.DoesNotExist:
            raise serializers.ValidationError({"id": [SEMESTER_NOT_STORED.format(semester_id)]})
        return value

# 修改SubjectSerializer
class SubjectSerializer(BaseSemesterRelatedSerializer):
    class Meta:
        model = Subject
        fields = ["id", "name", "code", "semester"]

    def create(self, validated_data):
        semester = validated_data.pop("semester")
        serializer = SemesterSerializer(semester)
        subject = Subject.objects.create(
            semester_id=serializer.data["id"], **validated_data
        )
        return subject

# 修改StudentSerializer
class StudentSerializer(BaseSemesterRelatedSerializer):
    class Meta:
        model = Student
        fields = ["id", "name", "email", "semester"]

    def create(self, validated_data):
        semester = validated_data.pop("semester")
        serializer = SemesterSerializer(semester)
        student = Student.objects.create(
            id=None, semester_id=serializer.data["id"], **validated_data
        )
        return student

失效原因 #

1. Django模型字段的validators不适用于ForeignKey：ForeignKey的验证逻辑由Django内部处理，自定义validator不会自动触发关联存在性检查。
2. 抛出错误类型错误：模型验证应抛出django.core.exceptions.ValidationError，而非ValueError，且错误格式不符合Django验证规范。
3. DRF序列化器默认不会触发模型的full_clean()方法，导致模型层验证不执行。

修复模型层验证（可选） #

如果你坚持在模型层做验证，可重写模型的clean方法，并在序列化器中触发验证：

1. 修改模型代码：

from django.core.exceptions import ValidationError
from .helpers import SEMESTER_NOT_STORED

class Student(models.Model):
    name = models.CharField(max_length=30)
    email = models.EmailField()
    semester = models.ForeignKey(Semester, on_delete=models.DO_NOTHING, default=None)

    def clean(self):
        super().clean()
        if self.semester_id is not None:
            try:
                Semester.objects.get(id=self.semester_id)
            except Semester.DoesNotExist:
                raise ValidationError({"semester": SEMESTER_NOT_STORED.format(self.semester_id)})

2. 修改序列化器的create方法：

def create(self, validated_data):
    semester = validated_data.pop("semester")
    serializer = SemesterSerializer(semester)
    student = Student(semester_id=serializer.data["id"], **validated_data)
    student.full_clean()  # 触发模型验证
    student.save()
    return student

注意：相比序列化器层验证，模型层验证会在对象保存前才触发，无法提前拦截无效请求，推荐优先使用序列化器层的复用方案。

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