Why is the difference between Serializer methods and View methods?

user_7089055 0
Viewed 914

In Django DRF, I can add the following method to a serializer:

    def create(self, validated_data):
        user = User(
            email=validated_data['email'],
            username=validated_data['username']
        )
        user.set_password(validated_data['password'])
        user.save()
        return user

Previous to discovering this, I thought you typically did this within a view, by overriding a View/ViewSet methods.

I had thought that all the Serializer did was to transform the data and send it out or receive it from external calls.

Can someone explain to me the difference between doing this on the view vs doing it on a serializer?

And more broadly, what is the benefit of calling methods on the serializer instead of somewhere else?

django-rest-framework django
1 Answers

A serialiser's job is to take one blob of data and convert it into another blob of data. Most typically it converts from a model to some form of dict and vice versa. You typically have at least one serialiser per model, but you may have any number of serialisers for different use cases. For example, you may get data in different forms, e.g. from a registration form and from an API call, and you want to convert both into a valid User instance. So you may define two different serialisers for those two different scenarios, which both end up with the same User instance. And you may need to customise some aspects of those serialisers to fit the occasion.

Views on the other hand take an HTTP request, do something and then decide what response to return. That doing something may involve using serialisers, but it doesn't have to. The biggest job of a view is to decide what to do when something succeeds or fails, like rendering a different response or redirecting to a different URL.

You need to decide how reusable some piece of logic is. Think of serialisers as transforming one type of data into another; call it converting type A into type B and vice versa. "Type" here being what your input/output data looks like exactly. Then consider where in your application you'll encounter a data blob of type A and whether you'll need to convert it into type B more than once. If so, you'll probably want to make a specific serialiser for it, instead of repeating the same logic inside two or more views.

user_4760
Related