Criando API REST com Django Rest Framework 2/10

Dando continuidade ao post anterior da nossa série de posts sobre Django Rest Framework, hoje falarei sobre serialização de dados. Abordaremos aqui a parte da modelagem de dados e como poderemos serializa-los afim de disponibilizar via API, vamos lá.

Entendendo oque é serialização de dados

Serialização de dados na computação está ligado diretamente à armazenagem e transmissão de dados. Serialização é a responsável pela tradução de estruturas de dados em um formato de armazenagem que possa ser transmitido e reconstruido em outro ambiente computacional. Em resumo, ela será responsável por prover a transmissão de um dado de um lugar para outro, onde a mesma se encarregará de prover toda a infraestrutura computacional que o dado necessita para tal. Fazendo uma análogia com o mundo real, imagine que seus dados sejam um parque de diversões que irá mudar de local. Para ser transportado esse parque precisa ser desmontado e colocado em caminhões, e ao chegar no local de mudança o brinquedos precisam ser remontados exatamente como eram montados no outro lugar. É exatamente isso que acontece com seus dados no processo de serialização e desserialização.

Criando uma aplicação no nosso projeto

Dando continuidade ao desenvolvimento do nosso projeto ‘spotify’ iniciado no post anterior, precisamos agora criar uma aplicação chamada ‘playlist’ que terá toda a nossa necessária para a construção da nossa API, com o terminal aberto e o virtualenv devidamente iniciado, execute o comando abaixo:

$ python manage.py startapp playlist

Com nossa aplicação criada, você terá a seguinte estrutura no projeto:

├── db.sqlite3
├── manage.py
├── playlist
│ ├── admin.py
│ ├── apps.py
│ ├── __init__.py
│ ├── migrations
│ │ └── __init__.py
│ ├── models.py
│ ├── tests.py
│ └── views.py
└── tutorial
├── __init__.py
├── settings.py
├── urls.py
└── wsgi.py

Feito isso, precisamos registrar nossa aplicação no settings.py:

Criando os modelos

Com a nossa aplicação devidamente configurada em nosso projeto, precisamos agora criar nossos modelos, que serão a base para criação das nossas tabelas no banco de dados, e os responsáveis por armazenar os dados que serao expostos na nossa API.

No no arquivo models.py da nossa aplicação playlist, colocaremos o código abaixo:

Com nossos modelos prontos, precisamos criar as tabelas e migrações em nosso banco de dados, para isso execute o comando abaixo:

$ python manage.py makemigrations

E por fim, o migrate para criação das tabelas:

$ python manage.py migrate

Testando os modelos

Como pretendo abordar profundamente os conceitos de criação de API com django rest framework, seria interessante também abranger a parte de testes, epara começar essa etapa iniciaremos testando os models. Para começar, precisamos organizar nossos testes de uma forma certa. Dentro da nossa aplicação playlist, criaremos uma pasta chamada tests com um arquivo __init__.py ficando a estrutura final dessa forma:

├── admin.py
├── apps.py
├── __init__.py
├── migrations
│ ├── 0001_initial.py
│ └── __init__.py
├── models.py
├── serializers.py
├── tests
│ ├── __init__.py
│ └── test_models.py

└── views.py

Dentro da pasta tests, crie um arquivo chamado tests_models.py com o conteúdo abaixo:

Começamos nossos testes importanto os recursos necessários. Usaremos aqui, a model-mommy que é uma biblioteca que nos auxilia na criação de dados fake para nossos testes, para isso precisamos instalar ela com o comando abaixo:

$ pip install model_mommy

Feito isso, é hora de escrevermos nosso primeiro teste, abaixo dos imports, adicione o seguinte código:

Nossa classe TestRecord é responsável por testar o modelo Record, criaremos aqui testes muito simples que apenas verificarão se está tudo certo com a criação de objetos pelos nossos models.

No método setUp() criamos uma gravadora com o auxílio da model-mommy, e no método test_record_creation(), verificamos se a gravadora criada realmente é uma instância da classe Record, e se o método __str__() realmente nos retorna o nome dessa gravadora como foi definido no método __str__() desse model no arquivo playlist/models.py.

Finalizado essa etapa, podemos replicar esses mesmos testes nos outros modelos como mostrado no código abaixo:

Com o código finalizado é hora de testarmos se os testes estão passando, para isso execute:

$ python manage.py test

Se tudo estiver correto, você terá uma resposta parecida com isso:

Creating test database for alias 'default'...
.....
----------------------------------------------------------------------
Ran 5 tests in 0.032s
OK
Destroying test database for alias 'default'...

Com nossas tabelas devidamente criadas e testadas precisamos agora criar uma classe serializadora para serializar nossos dados.

Serializando os dados

A primeira coisa que precisaremos para serializar/desserializar nosso dados, será uma classe para fazer esse trabalho para nós. A django rest framework nos disponibiliza duas formas para fazermos isso, a primeira é algo mais ‘mão na massa’ e a segunda algo mais direto utilizando os conceitos do DRY do django, sem mais delonga, crie um arquivo chamado playlist/serializers.py com o código abaixo:

Essa classe herda da Serializer que é uma classe interna do django rest framework e será a responsável por fazer todo o trabalho para nós, pode verificar que ela é muito parecida com o Forms do django onde basicamente oque fizemos foi definir campos já presentes em nosso model e métodos create e update que irão atuar sobre nossos dados.

Para entender melhor como funciona a serialização de dados com a django rest framework, faremos um overview com shell do django para entendermos melhor tudo isso, para isso execute:

$ python manage.py shell

E faça os imports abaixo:

$ from playlist.models import Record
$
from playlist.serializers import RecordSerializer

E criaremos uma gravadora que usaremos para serializar:

$ record = Record(name="Sony Music")
$ record.save()

Após criar e salvar nossa gravadora no banco, vamos verificar se tudo deu certo, para isso execute:

$ sonymusic = Record.objects.all()
$ print(sonymusic)
<QuerySet [<Record: Sony Music>]>

Se tudo deu certo, a queryset vai retornar a gravadora que acabamos de criar com todos os dados serializados de sua representação, como é mostrado no código abaixo:

$ sonymusicserializer = RecordSerializer(sonymusic)
$ print(sonymusicserializer)
RecordSerializer(<QuerySet [<Record: Sony Music>]>):
id = IntegerField(label='ID', read_only=True)
name = CharField(max_length=100)

Como visto acima, nosso objeto foi serializado e já se encontra apto para ser renderizado.

Facilitando as coisas com ModelSerializer

Para facilitar nosso trabalho e podermos usar o DRY (Don’t Repeat Yourself) do django, a django rest framework nos disponibiliza uma classe ModelSerializer que usará como base um model já definido no nosso playlist/models.py, é algo semelhante ao ModelForm do django, basicamente oque teremos que fazer é herdar da ModelSerializer, indicar um modelo que será a base para essa classe e por fim informar os campos que deveremos usar, o atributo fields recebe uma tupla:

Ou uma lista:

Mas podemos usar o atalho ‘__all__’, caso quisermos indicar o uso de todos os campos como é visto no código abaixo:

Finalizado essa etapa, já estamos aptos à renderizar esses dados e disponibilizálos em nossa API, mas isso fica para o próximo post né?

❤ Gostou? Vamos espalhá-lo — curte e compartilha aí o/