[PYTHON] Comprendre la commodité de Django Rest Framework

introduction

Cet article est une suite de Last. L'article précédent décrivait la partie conceptuelle de l'API. Cette fois, j'aimerais créer une API en utilisant Python et Django. L'API créée cette fois-ci est aussi simple que d'envoyer des données (à partir du navigateur) et de les enregistrer dans la base de données, et de les déplacer vers n'importe quel point de terminaison pour afficher les données dans la base de données. Il crée également des API sans utiliser ** Django Rest Framework **. La raison en est que je pensais pouvoir comprendre la commodité du framework Django Rest en construisant avec du ** code Python ** sans utiliser le framework fourni par Django.

Personne cible

Ceux qui connaissent la grammaire de base de Python et ceux qui connaissent le mécanisme de base de Django. (L'installation et l'installation de Django sont considérablement omises.)

Réglage initial

Le premier élément important dans la création d'une API est le ** type de données à gérer **. L'envoi de données à l'API ne signifie pas qu'elles seront stockées dans la base de données sans autorisation, mais l'API stockera les données en fonction du modèle des données conçu dans ** models.py **. Commencez par définir la partie ** quel type de données traiter ** dans le modèle.

models.py

from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=100)
    description = models.TextField()
    timestamp = models.DateField(auto_now_add=True)

    def __str__(self):
        return self.title

Cette fois, j'ai conçu un modèle qui suppose que les données du blog sont gérées par l'API. Données qui ont un titre, le contenu de l'article, la date et l'heure de publication. Si vous pouvez écrire un modèle, passons à ** migrer **. Ensuite, enregistrez ** Post ** dans ** admin.py ** et entrez des données de test à partir de la page d'administration. Entrez une valeur appropriée pour chaque élément et enregistrez-la comme indiqué dans la figure ci-dessous.

Afficher les données sur n'importe quel point de terminaison

Maintenant, affichons les données enregistrées à partir de la page d'administration sur n'importe quel point de terminaison. La première chose à retenir est que les API modernes renvoient des ** données JSON ** lorsque vous envoyez une requête. Par conséquent, la valeur de retour de la fonction posts de ** views.py ** est ** JsonResponse **. En dehors de cela, le code simple rapproche ** QuerySet ** des données JSON. Tournez le QuerySet avec une instruction for pour en faire un type de dictionnaire et placez-le dans la liste. A partir de là, Django fera le travail pour vous, et les données de type dictionnaire dans la liste Python seront automatiquement ** sérialisées ** en données JSON.

views.py

from .models import Post

def posts(request):

    posts = Post.objects.all()
    post_list = []
    for post in posts:
        post_dict = {
            'pk': post.pk,
            'title': post.title,
            'description': post.description,
            'timestamp': post.timestamp,
        }
        post_list.append(post_dict)

    return JsonResponse(post_list, safe=False)

    # non-Pour convertir des données de type dict en données JSON"safe=False"Décrire.

Créez n'importe quel point de terminaison.

urls.py

from application_name.views import posts #ajouter à

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/post/', posts), #ajouter à
]

À ce stade, configurons un serveur local une fois et passons au point de terminaison créé. Je n'ai pas eu besoin de saisir la clé primaire cette fois, mais c'est pratique lors de la vérification lors de tests comme celui-ci. J'ai pu confirmer correctement les données, donc ce fut un succès! Vient ensuite la requête POST.

Traitement d'écriture pour la requête POST

Le rôle de l'API utilisant Django est de stocker de nouvelles données basées sur models.py dans la base de données lorsqu'elles sont envoyées via une ** requête POST **. C'est difficile à comprendre même si j'écris un peu, donc pour expliquer brièvement, le rôle du côté API est de ** traiter ** et ** sauvegarder ** les données envoyées sous une forme facile à sauvegarder. Alors ensuite, j'écrirai le code à traiter et enregistrer.

views.py

#Ajoutez le code suivant. L'instruction if suivante est écrite au-dessus du traitement de la requête GET.
from django.http import HttpResponse
import json

def posts(request):

    if request.method == 'POST':
        data = json.loads(request.body)
        post = Post(
            title=data['title'],
            description=data['description'],
            )
        post.save()
        return HttpResponse(201)

    posts = Post.objects.all()
    # ~~Ce qui suit est omis~~

** Django ** n'a pas de fonction standard pour ** désérialiser ** automatiquement (renvoyer les données JSON sous une forme gérable) pour les données JSON envoyées, donc le code à désérialiser est fourni. Vous devez l'écrire. Cette fonctionnalité est nécessaire car elle ne peut être enregistrée dans la base de données que si elle est restaurée dans un format de données pouvant être géré par Python. Placez les données JSON dans une variable appropriée et désérialisez (processus) à l'aide de cette variable. De plus, ** Django ** n'a pas la capacité de sauvegarder automatiquement les données des vues, donc écrivez explicitement ** post.save ** à la fin.

En fait envoyer une demande POST

Cette fois, j'aimerais utiliser ** axios ** pour envoyer une ** requête POST ** à l'API. Si vous souhaitez implémenter ** ajax ** dans votre propre application, il est recommandé d'utiliser la ** bibliothèque axios ** de Javascript. Tout d'abord, créez une page dans des modèles pour envoyer une requête POST. Ajoutez axios à cette page en utilisant ** cdn **.

main.html

    <body>
        <p>Test Page</p>   
    </body>
    <script src="https://unpkg.com/axios/dist/axios.min.js"></script> #Ajouter avec cdn
</html>

Créé avec ** fonction basée ** dans la vue. Faites également le routage.

views.py

def main_page(request):
    return render(request, 'main.html', context=None)

urls.py

from application_name.views import main_page #ajouter à

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', main_page),    #Ajouter un itinéraire
    path('api/post/', posts),
]

Configurez un serveur local et accédez à l'URL où ** main.html ** est affiché. Vérifions donc si l'API fonctionne correctement depuis la console ** des outils de développement **. Étant donné que les données envoyées par la requête POST doivent être des ** données JSON **, faites-en un type de dictionnaire. Faites-en une variable par souci de clarté en tant qu'argument.

console

/* 
Créer une fonction asynchrone
Envoyer une demande et répondre
Je veux attendre car il faut du temps pour envoyer une demande
Le point de terminaison de l'API peut être un chemin relatif car le serveur est déjà opérationnel
*/

async function addPost(title, description) {
    const response = await axios.post('api/post/', {'title': title, 'description': description})
    console.log(response)
}

//Instanciation
addPost('sending from axios', 'some test messages')

Cependant, si vous faites cela, vous devriez obtenir une instruction d'erreur ** 403 Forbidden **. Lorsque le 403 revient ainsi, vous pouvez voir toutes les ** requêtes ** que vous avez envoyées dans les outils de développement du navigateur ** Réseau **. Comme vous pouvez le voir dans l'image ci-dessous, vous pouvez voir la partie (données) de la charge utile que vous essayiez d'envoyer. Ensuite, si vous regardez la partie ** Response **, vous verrez des ** instructions html ** que vous voyez souvent. Pour faciliter l'affichage de cette réponse dans votre navigateur, copiez la ** instruction html de réponse ** et réécrivez-la avec ** innerHTML **. C'est un peu difficile à expliquer avec des mots, alors jetez un œil au code ci-dessous.

console

document.querySelector('body').innerHTML = `Instruction HTML de réponse`

Si vous l'exécutez avec ceci, vous devriez voir que l'erreur vient du côté de Django. Je mettrai l'écran d'erreur ci-dessous. Si vous regardez la déclaration d'erreur, vous pouvez voir que la ** vérification CSRF ** a échoué. Si vous utilisez le formulaire avec Django, cela indique que vous pouvez utiliser ** csrf_token **, mais cette fois nous envoyons des données en utilisant ajax, donc cette méthode ne peut pas le résoudre. Pour faire ajax dans Django, utilisez une méthode que vous n'utilisez pas normalement. Pour expliquer le flux de la ** vérification CSRF ** en premier lieu, Django montre que la face avant accède aux données du même site au lieu d'y accéder depuis un autre emplacement, et Django les reçoit. Donne des autorisations de données au recto. Si vous pensez à nouveau à ** 403 Forbidden ** avec cela à l'esprit, vous pouvez voir que cela signifie que vous n'avez pas l'autorité (l'autorisation) pour gérer les données. Cependant, comme mentionné précédemment, le formulaire n'est pas utilisé, donc ** csrf_token ** ne peut pas être utilisé. Donc cette fois, mettez csrf_token dans ** Cookie ** et collez-le dans un fichier javascript.

sample.js

axios.defaults.xsrfCookieName = 'csrftoken'
axios.defaults.xsrfHeaderName = "X-CSRFTOKEN"

À l'origine, en collant le code ci-dessus en haut du ** fichier js ** qui envoie la requête ajax, vous pouvez faire la requête en utilisant axios have ** Cookie ** avec csrf_token par défaut. Je vais. Cela devrait résoudre l'erreur précédente. Puisque nous n'aurons aucune fonction autre que la communication ajax utilisant Javascript cette fois, créez un fichier js avec un nom arbitraire et écrivez uniquement le code ci-dessus. Chargez (connectez) ce fichier avec ** main.html ** comme indiqué ci-dessous, et faites-le également fonctionner sur la console des outils de développement.

main.html

    <body>
        <p>Test Page</p>   
    </body>
    <script src="https://unpkg.com/axios/dist/axios.min.js"></script>
    <script type="text/javascript" src="{% static 'sample.js' %}"></script> #ajouter à
</html>

Lorsque je mets une valeur dans l'argument dans la console et que je l'instancie comme auparavant, le code d'état 201 est renvoyé sans aucune erreur cette fois. En d'autres termes, c'est un succès! Pour le moment, accédez au point de terminaison ** 'api / post /' ** et vérifiez si les données POSTÉES s'affichent correctement. プライマリーキーが3のデータが先ほど追加したデータなので、ちゃんとGET, POSTリクエストが動いていることが分かります。

Pourquoi utiliser Django Rest Framework

Tout d'abord, je pense que la raison principale est que ** Django Rest Framework ** (DRF) réduit considérablement le code lié au traitement des données et à l'authentification que nous ne traitons pas cette fois. Cependant, je pense que la prochaine raison est que les verbes HTTP tels que PUT, PATCH et DELETE seront disponibles. Normalement, ** Django ** les ignore, vous ne pouvez donc pas l'utiliser si vous le souhaitez. ** DRF ** gère facilement les autres requêtes, vous pouvez donc tirer le meilleur parti de sa fonction d'API. Je pense qu'il y a beaucoup d'autres raisons, mais pour le moment, je pense que ce sont les deux principales raisons.

finalement

Comment était le contenu de l'article? Il sert également de mémorandum à moi, et il est devenu assez long, alors merci à ceux qui l'ont lu jusqu'au bout. Si vous avez des erreurs ou des erreurs typographiques, n'hésitez pas à les signaler. La prochaine fois, j'aimerais créer une application simple en utilisant une API externe.