[Django] DRF 작동 흐름

DRF로 작성한 API에 POST Request를 보냈을 시 View와 Serializer에서 어떤 흐름으로 코드가 흘러가고 데이터베이스에 생성되는지 나름대로 정리해보았다.

# snippets/models.py
from django.db import models
from pygments.lexers import get_all_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']

# 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)
    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):
        """
        Create and return a new `Snippet` instance, given the validated data.
        """
        return Snippet.objects.create(**validated_data)

# snippets/views.py
from rest_framework.mixins import CreateModelMixin
from rest_framework.viewsets import GenericViewSet

from .serializers import SnippetSerializer

class SnippetViewSet(GenericViewSet, CreateModelMixin):
    serializer_class = SnippetSerializer

    def create(self, request, *args, **kwargs):
        return super().create(request, *args, **kwargs)

위와 같은 models.py , serializers.py , views.py로 Snippet을 Create하는 API를 만들었다고 가정해보자.

{
    "title": "title",
    "code": "code",
    "language": "python",
    "style": "friendly"
}

우리는 위와 같은 JSON Request를 통해 POST Method로 Django에 요청을 보낼 것이다.

1. Views의 create 함수 안으로 데이터가 들어간다.

class SnippetViewSet(GenericViewSet, CreateModelMixin):
    serializer_class = SnippetSerializer

    def create(self, request, *args, **kwargs):
        print(request.data)
        return super().create(request, *args, **kwargs)

{'title': 'title', 'code': 'code', 'language': 'python', 'style': 'friendly'}

print 문으로 create 함수의 request.data를 찍어보면 우리가 요청한 데이터가 잘 찍히는 것을 확인할 수 있다. 이 request안에 담긴 데이터는 CreateModelMixin 의 create 함수로 이동하게 된다.

2. CreateModelMixin 함수 안으로 데이터는 이동한다.

class CreateModelMixin:
    """
    Create a model instance.
    """
    def create(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        self.perform_create(serializer)
        headers = self.get_success_headers(serializer.data)
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

    def perform_create(self, serializer):
        serializer.save()

    def get_success_headers(self, data):
        try:
            return {'Location': str(data[api_settings.URL_FIELD_NAME])}
        except (TypeError, KeyError):
            return {}

CreateModelMixin 함수 안을 들여다보면 위와 같이 생겼다. 먼저 get_serializer 함수를 통해서 serializer를 가지고 오게 된다. 가지고 온 serializer을 is_valid()를 통해서 유효성 검사를 한뒤 perform_create 함수를 통해서 serializer를 저장하게 된다. is_valid()에서는

# 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)
    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 validate_title(self, data):
        print(data)
        if data == "error":
            raise serializers.ValidationError("Invalid Value.")
        return data

    def create(self, validated_data):
        """
        Create and return a new `Snippet` instance, given the validated data.
        """
        return Snippet.objects.create(**validated_data)

DRF의 Serializer Class를 보면 to_internal_value 라는 함수가 있다.

def to_internal_value(self, data):
        """
        Dict of native values <- Dict of primitive datatypes.
        """
        if not isinstance(data, Mapping):
            message = self.error_messages['invalid'].format(
                datatype=type(data).__name__
            )
            raise ValidationError({
                api_settings.NON_FIELD_ERRORS_KEY: [message]
            }, code='invalid')

        ret = OrderedDict()
        errors = OrderedDict()
        fields = self._writable_fields

        for field in fields:
            validate_method = getattr(self, 'validate_' + field.field_name, None)
            primitive_value = field.get_value(data)
            try:
                validated_value = field.run_validation(primitive_value)
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
                errors[field.field_name] = exc.detail
            except DjangoValidationError as exc:
                errors[field.field_name] = get_error_detail(exc)
            except SkipField:
                pass
            else:
                set_value(ret, field.source_attrs, validated_value)

        if errors:
            raise ValidationError(errors)

        return ret

        for field in fields:
            validate_method = getattr(self, 'validate_' + field.field_name, None)
            primitive_value = field.get_value(data)
            try:
                validated_value = field.run_validation(primitive_value)
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
                errors[field.field_name] = exc.detail
            except DjangoValidationError as exc:
                errors[field.field_name] = get_error_detail(exc)
            except SkipField:
                pass
            else:
                set_value(ret, field.source_attrs, validated_value)

이 코드를 보면 serializer에 있는 field들을 for 문으로 하나 하나 검사하면서 validate_{field.field_name} 으로 validate_method를 설정해주는 것을 확인할 수 있다.

즉, 만약 title 이라는 field가 있다면 validate_title 함수가 있는지 확인하고 validate를 진행한 후 data를 다시 반환한다.