Introduction au framework Django REST : développement avec des exemples

Le Django REST Framework est largement distribué en tant que package Python standard dont les utilisateurs peuvent avoir besoin pour commencer à développer des API RESTful. Il est sophistiqué, puissant, incroyablement facile à utiliser et offre une version attrayante et navigable pour les API. Le Django REST Framework offre la possibilité de renvoyer des objets JSON. Ce cadre offre une sérialisation puissante du modèle et affiche les données à l'aide de vues basées sur les fonctions de base dans un visualiseur entièrement REST. En savoir plus sur le framework Django REST ci-dessous :

Qu'est-ce que le framework Django REST ?

Le Django REST Framework est un kit d'outils flexible et robuste qui permet aux développeurs de créer facilement des API Web. Il propose également des vues généralisées basées sur les classes et des sérialiseurs pour l'API. En tant que code source, il est abrégé en DRF, qui représente une bibliothèque Python pour développer des interfaces de programmation d'applications Web. Comme dans cet article, nous parlons d'API de développement avec des instructions pas à pas.

Mais avant de commencer avec le guide, il est important de comprendre pourquoi le cadre est même important. De nombreux frameworks disponibles permettent aux développeurs de créer facilement des API pour leurs applications de blocs, mais le framework Django REST est préféré. Ce cadre est pratique à utiliser de plusieurs façons et offre les avantages mentionnés ci-dessous-

• Il offre aux navigateurs Web une interface de programmation d'application performante, ce qui est une grande victoire pour les développeurs.
• Il a des politiques d'authentification, y compris les packages pour OAuth1, OAuth2, etc.
• le processeur de sérialisation qu'il contient prend en charge les sources de données ORM et non ORM
• ce cadre a une documentation complète et offre un excellent support communautaire
• Il est utilisé et approuvé par de grandes plateformes, notamment Mozilla, Heroku, RedHat, etc.

Lis : Applications Django : tout ce que vous devez savoir sur

Définir le développement du framework Django REST

Pour commencer, vous devez installer les dépendances Python pour le système d'exploitation. Si vous utilisez la plate-forme Windows, vous pouvez facilement installer la plate-forme Linux comme système d'exploitation secondaire avec une boîte virtuelle ou une commande manuelle. Pour continuer avec le framework, vous pouvez utiliser des outils de gestion Python efficaces et pratiques.

La plupart des outils sont une aide incontournable. Ils permettent aux développeurs de modifier rapidement les versions de Python, de définir des versions spécifiques à un projet, de gérer l'environnement virtuel et d'installer plusieurs versions sur le système. Si vous utilisez des systèmes d'exploitation Linux ou Mac, il serait facile de l'installer.

Avec l'aide du framework Django REST , nous pouvons convertir une application non RESTful en une application RESTful. Ceci inclut les procédures mentionnées ci-dessous -

Configuration DRF

Pour la configuration DRF, vous devez installer-

Coquille

$ pip install djangorestframework

$ pip freeze > requirements.txt

Paramètres de mise à jour :py :

Python

INSTALLED_APPS = (

'django.contrib.admin',

'django.contrib.auth',

'django.contrib.contenttypes',

'django.contrib.sessions',

'django.contrib.messages',

'django.contrib.staticfiles',

'parler',

'rest_framework'

)

Structure reposante

Dans un développement d'API RESTful, les points de terminaison représentent sa structure et l'accès des utilisateurs depuis l'application à l'aide de méthodes telles que GET, PUT, POST, DELETE. Ces points de terminaison sont logiquement organisés autour de l'élément et des collections, qui sont tous deux comptés comme des ressources. S'il existe une seule ressource, les liens correspondants seront utilisés comme URL pour les éléments et les collections.

AVOIR

PUBLIER

METTRE

EFFACER

/des postes/

Afficher tous les messages

Ajouter un nouveau message

Mettre à jour tous les messages

Supprimer tous les messages

/messages/<id>

Afficher <identifiant>

N / A

Mettre à jour <id>

Supprimer l'identifiant

Sérialiseurs et vues

Les sérialiseurs constituent le principal élément constitutif du framework Django REST . Ils sont utilisés pour élaborer la représentation de divers enregistrements de données basés sur les modèles Django. Les sérialiseurs sont la classe Python standard qui peut hériter du comportement du modèle à partir du framework.

À l'intérieur de la classe des sérialiseurs, des ensembles de champs distincts sont présents qui utilisent les types de données de leur package du même framework. Ils ont également remarqué les similitudes entre le framework et les classes. Les classes de sérialiseur ne pensent pas à elles seules et elles sont intégrées à des vues qui gèrent l'essentiel de la logique de service REST. De plus, il utilise les classes de sérialiseur pour transformer les données. Par exemple, une méthode de vue Django régulière est-

de coffeehouse.stores.models import Store

de coffeehouse.stores.serializers importer StoreSerializer

depuis rest_framework.decorators importer api_view

from rest_framework.response import Response

@api_view(['OBTENIR','POSTER','SUPPRIMER'])

def rest_store(request):

si request.method == 'GET' :

stores = Store.objects.all()

sérialiseur = StoreSerializer(magasins, plusieurs=True)

retourner la réponse (serializer.data)

elif request.method == 'POST' :

… #logique pour l'opération HTTP POST

elif request.method == 'SUPPRIMER' :

… #logique pour l'opération HTTP DELETE

Vues basées sur les classes

À l'aide de vues basées sur les classes, le framework Django REST permet d'accéder aux fonctions suprêmes et complexes des utilisateurs. Les vues basées sur les classes offrent les fonctions de véritables classes Python à part entière et permettent aux vues Django de fonctionner facilement à l'aide de principes de programmation orientés objet qui conduisent à une plus grande réutilisation avec des temps de mise en œuvre courts.

Les vues basées sur les classes Django mettent en évidence une approche puissante pour créer des vues Django, et elles constituent également une alternative aux méthodes utilisées pour créer des API. Pour développer une vue basée sur les classes, il est important de créer une classe qui peut hériter d'une des autres classes. Par exemple:

# vues.py

depuis Django.views.generic import TemplateView

classe AboutIndex(TemplateView):

template_name = 'index.html'

def get_context_data(self, **kwargs):

# **kwargs contient les valeurs d'initialisation du contexte des mots clés (le cas échéant)

# Implémentation de la base d'appels pour obtenir un contexte

context = super(AboutIndex, self).get_context_data(**kwargs)

# Ajouter des données de contexte à transmettre au modèle

context['aboutdata'] = 'Données personnalisées'

contexte de retour

# URL.py

depuis coffeehouse.about.views importer AboutIndex

à partir du chemin d'importation django.urls

modèles d'url = [

chemin('about/index/',AboutIndex.as_view(),{'onsale':True}),

Checkout: Top 12 des questions et réponses d'entrevue Django pour les débutants

Mettre à jour les vues

Pour s'adapter à la structure de l'application RESTful, il est important de refactoriser les vues actuelles. Vous pouvez commenter ces vues et les ajouter comme-

Python

depuis django.shortcuts importer le rendu

depuis django.http importer HttpResponse

depuis rest_framework.decorators importer api_view

from rest_framework.response import Response

à partir de talk.models import Post

de talk.serializers importer PostSerializer

à partir de talk.forms importer PostForm

def home(demande):

tmpl_vars = {'form' : PostForm()}

renvoie le rendu (requête, 'talk/index.html', tmpl_vars)

@api_view(['OBTENIR'])

def post_collection(request):

si request.method == 'GET' :

posts = Post.objects.all()

sérialiseur = PostSerializer(posts, many=True)

retourner la réponse (serializer.data)

@api_view(['OBTENIR'])

def post_element(request, pk):

essayer:

post = Post.objects.get(pk=pk)

sauf Post.DoesNotExist :

renvoie la réponse HTTP (statut = 404)

si request.method == 'GET' :

sérialiseur = PostSerializer(post)

retourner la réponse (serializer.data)

Explication

• Dans les instructions données ci-dessus, le décorateur @api_view analyse la requête HTTP correspondante, qui est transmise à la fonction view.
• Maintenant, la vue utilise soit un seul article s'il s'agit d'un élément, soit saisit l'intégralité des données s'il s'agit de la collection
• Enfin, les données sont maintenant sérialisées dans le JSON et renvoyées en conséquence

API navigable sur le Web ou URL mise à jour

Certaines URL mises à jour pour Python sont :

# URL de conversation

depuis django.conf.urls modèles d'importation, URL

urlpatterns = patterns(

'parler.vues',

url(r'^$', 'accueil'),

# API

url(r'^api/v1/posts/$', 'post_collection'),

url(r'^api/v1/posts/(?P<pk>[0-9]+)$', 'post_element')

)

Refactoriser pour l'intégration de l'API RESTful

Il inclut les principales méthodes HTTP telles que-

AVOIR

Au chargement initial de la page, il est important d'afficher les publications, et pour cela, vous pouvez ajouter cette requête :

load_posts()

// Charger tous les articles au chargement de la page

fonction load_posts() {

$.ajax({

url : "api/v1/posts/", // le point de terminaison

tapez : "GET", // méthode http

// gère une réponse réussie

succès : fonction(json) {

pour (var je = 0; je < json.longueur; je++) {

console.log(json[i])

$(“#talk”).prepend(“<li id='post-“+json[i].id+”'><strong>”+json[i].text+”</strong> – <em> “ +json[i].author+"</em> – <span>"+json[i].created+

“</span> – <a id='delete-post-“+json[i].id+”'>supprime moi</a></li>”);

}

},

// gère une réponse qui n'aboutit pas

erreur : fonction(xhr,errmsg,err) {

$('#results').html("<div class='alert-box alert radius' data-alert>Oups ! Nous avons rencontré une erreur : "+errmsg+

” <a href='#' class='close'>&times;</a></div>”); // ajoute l'erreur au dom

console.log(xhr.status + ":" + xhr.responseText); // fournit un peu plus d'informations sur l'erreur à la console

}

});

} ;

PUBLIER

Les requêtes POST sont gérées de la même manière et vous pouvez tester cela en mettant à jour les vues. Vous pouvez mettre à jour la fonction post_collection() dans views.py :

@api_view(['OBTENIR', 'POSTER'])

def post_collection(request):

si request.method == 'GET' :

posts = Post.objects.all()

sérialiseur = PostSerializer(posts, many=True)

retourner la réponse (serializer.data)

elif request.method == 'POST' :

data = {'text' : request.DATA.get('the_post'), 'author' : request.user.pk}

sérialiseur = PostSerializer(data=data)

si serializer.is_valid() :

sérialiseur.save()

renvoyer la réponse (serializer.data, status=status.HTTP_201_CREATED)

renvoyer la réponse (serializer.errors, status=status.HTTP_400_BAD_REQUEST)

Lisez aussi: Salaire du développeur Django en Inde

L'essentiel

La partie REST du framework Django REST est assez simple et tout ce que vous avez à faire est de mettre à jour la fonction de l'élément post afin de gérer la requête. Si vous avez encore des questions, il existe un certain nombre de frameworks et de ressources Django REST pour l'improvisation.

Si vous souhaitez en savoir plus sur Django et d'autres langages et outils de développement full-stack, consultez le diplôme PG upGrad & IIIT-B en développement logiciel full-stack, conçu pour les professionnels et offrant plus de 500 heures de formation rigoureuse, Plus de 9 projets et affectations, statut d'ancien de l'IIIT-B, projets de synthèse pratiques et aide à l'emploi avec les meilleures entreprises.