Explication détaillée de la requête et de la réponse Django : compréhension approfondie du mécanisme de base de l'interaction Web Http

News 2023-08-06 18:14:40 views: null

Cet article explore en profondeur le traitement des requêtes et des réponses dans Django, depuis les bases et le cycle de vie de la requête et de la réponse de Django jusqu'à l'introduction détaillée des objets HttpRequest et HttpResponse. Aborde également les vues de Django et la gestion des requêtes et des réponses, ainsi que les considérations de sécurité et de traitement asynchrone. Enfin, comparez les similitudes et les différences entre Django et Flask, FastAPI et d'autres frameworks dans le traitement des réponses aux requêtes. Que vous découvriez Django ou que vous soyez un développeur expérimenté, cet article peut vous aider à mieux comprendre la gestion des requêtes et des réponses de Django.

1. Connaissance de base de la requête Django HttpRequest et de la réponse HttpResponse

Dans les applications Web, les modèles de requête et de réponse sont des concepts très importants. Lorsque l'utilisateur saisit une URL dans la barre d'adresse du navigateur ou clique sur un lien, une requête est envoyée au serveur. Une fois que le serveur a traité la demande, il renverra une réponse au navigateur. Il s'agit d'un modèle de requête-réponse HTTP typique.

1.1 L'objet de requête de Django HttpRequest

Dans Django, lorsqu'une requête HTTP arrive à l'application Django, elle est d'abord convertie en un objet HttpRequest par un fichier URLconf. Cet objet contient toutes les informations pertinentes sur cette requête HTTP.

def view(request):
    # request 是一个 HttpRequest 对象
    print(request.method)  # 输出请求方法，比如 "GET" 或 "POST"

1.2 L'objet de réponse de Django HttpResponse

Les vues Django doivent renvoyer un objet HttpResponse. Cet objet représente la réponse du serveur au client (généralement un navigateur). Cet objet HttpResponse sera converti en une réponse HTTP et envoyé au client.

from django.http import HttpResponse

def view(request):
    # 创建一个 HttpResponse 对象
    response = HttpResponse("Hello, World!")
    return response  # 这个响应将会被发送给客户端

1.3 Méthode HTTP Get/Post

Une méthode HTTP est une "instruction" qu'un client peut envoyer à un serveur. Les méthodes les plus courantes incluent GET et POST.

  • GET : généralement utilisé pour obtenir (ou interroger) des informations sur les ressources.
  • POST : généralement utilisé pour mettre à jour les informations sur les ressources.

Dans Django, vous pouvez methodaccéder aux méthodes de la requête via la propriété de l'objet HttpRequest :

def view(request):
    print(request.method)  # 输出请求方法，比如 "GET" 或 "POST"

2. Le cycle de vie d'une requête Django

Une fois qu'une application Django reçoit une requête HTTP, elle passe par une série d'étapes qui forment ensemble le cycle de vie de la requête. Voici les détails du processus :

2.1 La demande arrive

Lorsqu'une requête arrive dans une application Django, elle est d'abord reçue par le serveur WSGI. Un projet Django est exécuté comme une application Python par un serveur WSGI tel que Gunicorn ou uWSGI.

# 这是一个简单的WSGI应用的示例，当然，实际的Django WSGI应用更加复杂
def application(environ, start_response):
    start_response('200 OK', [('Content-Type', 'text/plain')])
    return [b"Hello World!"]

2.2 Analyse d'URL

Ensuite, la demande sera envoyée à l'analyseur d'URL, et l'analyseur d'URL fera correspondre l'URL en fonction de la liste des modèles d'URL définis dans le module URLConf. Les modèles d'URL sont définis à l'aide des expressions régulières de Python.

# urls.py
from django.urls import path

from . import views

urlpatterns = [
    path('articles/2003/', views.special_case_2003),
    path('articles/<int:year>/', views.year_archive),
]

2.3 Traitement des vues

Une fois que l'analyseur d'URL trouve un modèle correspondant, il appelle la fonction d'affichage associée à ce modèle, en transmettant à la vue l'objet HttpRequest et tous les paramètres extraits de l'URL.

# views.py
from django.http import HttpResponse

def special_case_2003(request):
    return HttpResponse("Special case for 2003")

def year_archive(request, year):
    return HttpResponse(f"Articles for {
      
      year}")

2.4 Retour de réponse

Une fois que la fonction d'affichage a traité la demande, elle crée un objet HttpResponse et le renvoie. Cet objet de réponse passera par une série de traitements par le middleware, et sera finalement converti en une réponse HTTP, puis envoyé au client.

# 视图函数返回一个响应
def view(request):
    response = HttpResponse("Hello, World!")
    return response  # 这个响应将会被发送给客户端

3. Détails de Django HttpRequest

Dans Django, toutes les requêtes HTTP sont encapsulées dans l'objet HttpRequest. Ci-dessous, nous présenterons en détail les propriétés et méthodes communes de l'objet HttpRequest.

3.1 Attributs HttpRequest

L'objet HttpRequest possède de nombreuses propriétés qui nous aident à obtenir des informations détaillées sur la requête HTTP. Voici quelques-unes des propriétés les plus couramment utilisées :

  • path : Une chaîne représentant le chemin de la requête, n'incluant pas le nom de domaine ou le chemin de l'URL racine du site.

  • method : une chaîne représentant la méthode de la requête HTTP. Les valeurs courantes sont "GET", "POST", etc.

  • GET : Un objet de type dictionnaire contenant tous les paramètres GET.

  • POST : un objet de type dictionnaire contenant tous les paramètres POST.

  • COOKIES : Un dictionnaire contenant tous les cookies. Les clés et les valeurs sont des chaînes.

  • FILES : un objet de type dictionnaire contenant tous les fichiers téléchargés.

  • user : Un objet User représentant l'utilisateur actuel. Si l'utilisateur n'est pas actuellement connecté, il s'agira d'une instance AnonymousUser.

def view(request):
    # 打印一些 HttpRequest 属性的值
    print(request.path)  # 输出请求路径，比如 "/my-path/"
    print(request.method)  # 输出请求方法，比如 "GET"
    print(request.GET)  # 输出 GET 参数，比如 <QueryDict: {'key': ['value']}>
    print(request.user)  # 输出当前用户，如果用户未登录，将输出 AnonymousUser

3.2 Méthode HttpRequest

En plus des propriétés, l'objet HttpRequest possède quelques méthodes utiles :

  • is_ajax() : retourne True si la requête a été faite via XMLHttpRequest.

  • is_secure() : renvoie True si la requête a été effectuée via HTTPS.

  • is_authenticated() : renvoie True si l'utilisateur actuel est connecté.

def view(request):
    # 打印一些 HttpRequest 方法的返回值
    print(request.is_ajax())  # 如果请求是 AJAX 请求，输出 True
    print(request.is_secure())  # 如果请求是 HTTPS 请求，输出 True
    print(request.is_authenticated())  # 如果当前用户已登录，输出 True

4. Vue Django Afficher et demander le traitement HttpRequest

Dans Django, une vue est une fonction Python qui prend une requête Web et renvoie une réponse Web. Cette réponse peut être le contenu HTML d'une page Web, une redirection, une erreur 404, un document XML, une image ou tout autre type de contenu. En termes simples, le travail d'une vue Django consiste à accepter une requête Web et à renvoyer une réponse Web.

4.1 Créer une vue

Dans Django, la création d'une vue consiste simplement à définir une fonction Python qui prend un HttpRequestobjet comme premier argument et renvoie un HttpResponseobjet. Comme suit:

from django.http import HttpResponse

def hello(request):
    return HttpResponse("Hello, World!")

Dans cet exemple, hellola fonction est une vue qui prend un HttpRequestobjet et renvoie un HttpResponseobjet contenant "Hello, World!".

4.2 Afficher les paramètres

Le premier argument d'une fonction d'affichage est toujours HttpRequestl'objet, et les arguments capturés à partir de l'URL seront transmis à la fonction d'affichage en tant qu'arguments supplémentaires. Par exemple:

from django.http import HttpResponse

def hello(request, name):
    return HttpResponse(f"Hello, {
      
      name}!")

Dans cet exemple, hellola vue prend deux paramètres : un HttpRequestobjet et une namechaîne. Vous pouvez définir dans URLConf comment extraire ce nameparamètre de l'URL.

4.3 Objet HttpResponse

Les vues doivent renvoyer un HttpResponseobjet. HttpResponseLa classe django.httpest définie dans le module et représente une réponse HTTP, ou une réponse du serveur au client.

HttpResponseLes objets contiennent généralement du contenu textuel, HTML ou JSON. Outre le contenu du texte, vous pouvez également contrôler d'autres paramètres de réponse HTTP en définissant HttpResponsedifférentes propriétés (telles que content_typeet ).status

from django.http import HttpResponse

def hello(request):
    response = HttpResponse("Hello, World!", content_type="text/plain", status=200)
    return response

5. Détails de Django HttpResponse

L'objet HttpResponse est l'objet de résultat renvoyé dans la vue Django, qui est renvoyé par la vue Django et livré au client via le framework Django.

5.1 Attribut HttpResponse

L'objet HttpResponse a des propriétés communes que nous pouvons utiliser pour définir notre réponse. Voici quelques propriétés communes :

  • content : contenu du corps de la réponse, généralement une chaîne ou une chaîne d'octets.

  • status_code : code d'état HTTP, tel que 200, 404, etc.

  • content_type : le type MIME de la réponse, la valeur par défaut est 'text/html'.

from django.http import HttpResponse

def view(request):
    response = HttpResponse()
    response.content = "Hello, World!"
    response.status_code = 200
    response.content_type = 'text/plain'
    return response

5.2 Méthode HttpResponse

En plus des propriétés, l'objet HttpResponse possède quelques méthodes utiles :

  • set_cookie(key, value, max_age=None, expires=None) : définit un cookie. key est le nom du cookie et value est la valeur du cookie. max_age est la durée de vie maximale du cookie, en secondes. expires est l'heure d'expiration du cookie, qui est un objet datetime ou un horodatage UNIX.

  • delete_cookie(key) : supprime un cookie.

from django.http import HttpResponse

def view(request):
    response = HttpResponse("Hello, World!")
    response.set_cookie('my_cookie', 'cookie_value', max_age=60*60*24)  # 设置一个一天后过期的 Cookie
    return response

5.3 Objets HttpResponse spéciaux

En plus des objets HttpResponse ordinaires, Django fournit également des objets HttpResponse spéciaux pour générer des réponses spécifiques. Par exemple:

  • JsonResponse : cet objet de réponse prend un dictionnaire ou une liste et renvoie une réponse de type application/json.

  • HttpResponseRedirect : Cet objet de réponse est utilisé pour générer une réponse de redirection.

  • HttpResponseNotFound : Cet objet de réponse est utilisé pour générer une réponse d'erreur 404.

from django.http import JsonResponse, HttpResponseRedirect, HttpResponseNotFound

def view_json(request):
    return JsonResponse({
    
    'key': 'value'})  # 返回一个 JSON 响应

def view_redirect(request):
    return HttpResponseRedirect('/another-url/')  # 重定向到另一个 URL

def view_404(request):
    return HttpResponseNotFound('<h1>Page not found</h1>')  # 返回一个 404 错误

6. Vue Django Vue et traitement des réponses HttpResponse

Dans Django, les vues sont les principaux gestionnaires des requêtes Web et sont également responsables de la construction et du retour des réponses. Les vues reçoivent des objets HttpRequest en tant que paramètres et génèrent des objets HttpResponse en tant que valeurs de retour. Maintenant que nous avons discuté en détail de HttpRequest et HttpResponse, regardons comment les gérer dans la vue.

6.1 Traitement des demandes

Le traitement de la requête consiste principalement à extraire les données de l'objet HttpRequest, puis à exécuter la logique correspondante en fonction de ces données.

def view(request):
    # 获取 GET 请求的参数
    name = request.GET.get('name', 'Guest')
    # 根据请求参数执行逻辑
    message = f"Hello, {
      
      name}!"
    return HttpResponse(message)

Dans cet exemple, nous obtenons le paramètre 'name' de la requête GET et l'utilisons pour générer un message de bienvenue.

6.2 Construire la réponse

La construction d'une réponse consiste essentiellement à créer un objet HttpResponse, puis à le remplir avec du contenu.

def view(request):
    # 创建 HttpResponse 对象
    response = HttpResponse()
    # 填充响应内容
    response.content = "Hello, World!"
    response.status_code = 200
    response['Content-Type'] = 'text/plain'
    return response

Dans cet exemple, nous créons un objet HttpResponse, puis définissons son contenu, son code d'état et son en-tête Content-Type.

6.3 Raccourcis

Dans les vues Django, nous devons souvent effectuer certaines opérations courantes, telles que le rendu d'un modèle, la redirection vers une autre URL ou le renvoi d'une erreur 404. Pour simplifier ces opérations, Django fournit quelques raccourcis.

from django.shortcuts import render, redirect, get_object_or_404
from .models import MyModel

def view(request):
    # 渲染一个模板
    context = {
    
    'key': 'value'}
    return render(request, 'my_template.html', context)

def redirect_view(request):
    # 重定向到另一个 URL
    return redirect('/another-url/')

def detail_view(request, pk):
    # 获取一个对象或返回 404 错误
    obj = get_object_or_404(MyModel, pk=pk)
    return render(request, 'detail.html', {
    
    'obj': obj})

7. Considérations de sécurité pour les requêtes et réponses Django

La sécurité est une considération très importante lors du traitement des requêtes Web et de la génération de réponses. Heureusement, Django fournit des outils et des techniques intégrés pour nous aider à accroître la sécurité de nos applications.

7.1 Protection CSRF

La falsification de requête intersite (CSRF) est une attaque dans laquelle un attaquant falsifie la requête d'un utilisateur. Django fournit un mécanisme de protection CSRF qui vérifie automatiquement les jetons CSRF lors du traitement des requêtes POST.

from django.views.decorators.csrf import csrf_exempt

@csrf_exempt  # 用这个装饰器来禁用 CSRF 保护
def my_view(request):
    # view code here...

Dans la plupart des cas, vous devez laisser Django gérer automatiquement la protection CSRF. Mais dans certains cas, vous devrez peut-être le désactiver, comme dans l'exemple ci-dessus.

7.2 Stockage sécurisé des données

Lorsque vous recevez des informations sensibles, telles que des mots de passe, lors du traitement d'une demande, vous devez utiliser les méthodes sécurisées fournies par Django pour stocker ces informations.

from django.contrib.auth.hashers import make_password

def register(request):
    password = request.POST['password']
    hashed_password = make_password(password)  # 使用哈希函数来安全存储密码
    # save hashed_password to database...

7.3 Paramètres de sécurité pour les en-têtes de réponse HTTP

Django fournit des paramètres que vous pouvez utiliser pour augmenter la sécurité des en-têtes de réponse HTTP, tels que SECURE_CONTENT_TYPE_NOSNIFFet SECURE_BROWSER_XSS_FILTER. Vous pouvez les configurer dans vos paramètres Django.

# settings.py
SECURE_CONTENT_TYPE_NOSNIFF = True
SECURE_BROWSER_XSS_FILTER = True

7.4 Traitement sécurisé des entrées utilisateur

Ne faites jamais confiance aux données saisies par l'utilisateur. Vous devez toujours nettoyer et valider les données saisies par l'utilisateur.

from django.core.exceptions import ValidationError

def view(request):
    comment = request.POST['comment']
    if len(comment) > 100:
        raise ValidationError("Comment is too long!")
    # save comment to database...

8. Requête et réponse asynchrones Django

Django 3.1 a introduit la prise en charge de la vue asynchrone et du middleware, ce qui signifie que vous pouvez utiliser Python asyncet awaitdes mots clés pour gérer les tâches asynchrones. Ceci est utile pour gérer les tâches liées aux E/S ou d'autres tâches qui peuvent bénéficier d'une exécution simultanée.

8.1 Vues asynchrones

La façon de créer une vue asynchrone est très similaire à la création d'une vue synchrone, mais vous devez définir la fonction de vue en tant que async deffonction, puis utiliser le mot-clé dans le corps de la fonction await.

from django.http import JsonResponse

async def async_view(request):
    data = await get_data()  # 假设 get_data 是一个异步函数
    return JsonResponse(data)

Dans cet exemple, get_dataune fonction asynchrone, nous utilisons awaitle mot clé pour l'appeler. Pendant que Django attend get_datala fin, il peut libérer des ressources du serveur pour gérer d'autres requêtes.

8.2 Intergiciel asynchrone

Vous pouvez également créer un middleware asynchrone, qui peut gérer les demandes et les réponses avant d'entrer dans la vue ou après avoir quitté la vue.

class SimpleMiddleware:
    async def __call__(self, request, get_response):
        response = await get_response(request)
        return response

Dans ce cas, SimpleMiddlewareun middleware asynchrone qui ne fait rien avant et après le traitement de la requête mais transmet simplement la requête au middleware ou à la vue suivante.

8.3 Fonctionnement de la base de données

Dans les vues asynchrones ou le middleware de Django, vous ne devez pas effectuer d'opérations de base de données synchrones, car cela pourrait bloquer la boucle d'événements. Vous devez utiliser les fonctions fournies par Django asgiref.sync.sync_to_asyncpour envelopper les opérations de base de données synchrones dans un thread.

from asgiref.sync import sync_to_async
from django.contrib.auth.models import User

async def async_view(request):
    get_user = sync_to_async(User.objects.get)
    user = await get_user(id=1)
    return JsonResponse({
    
    'username': user.username})

Dans cet exemple, nous utilisons sync_to_asyncla fonction pour User.objects.getencapsuler le dans un thread, puis utilisons awaitle mot-clé pour l'appeler dans la vue asynchrone.

Bien sûr, nous comparerons ensuite les similitudes et les différences entre Django et d'autres frameworks Python traditionnels (tels que Flask et FastAPI) dans le traitement des requêtes et des réponses.

Résumé Comparaison de Django et d'autres frameworks Python traditionnels dans la section requête-réponse

9.1 Django contre flacon

Flask est un autre framework Web Python populaire Comparé à Django, Flask est un framework plus léger avec plus de personnalisation.

  • Objet de requête : l'objet de Flask est similaire requestà l'objet de Django à bien des égards, mais l'objet de Flask est syntaxiquement plus concis. Dans Flask, vous pouvez accéder directement aux paramètres POST via , tandis que dans Django, vous devez utiliser .HttpRequestrequestrequest.form['key']request.POST.get('key')

  • Objets de réponse : Flask vous permet de renvoyer des chaînes directement à partir de la vue, puis de les convertir automatiquement en Responseobjets, tandis que Django vous oblige à créer explicitement un HttpResponseobjet.

  • Paramètres d'URL : Flask fournit un moyen concis de définir des paramètres dans l'URL, par exemple @app.route('/user/<username>'), dans Django, vous devez utiliser des expressions régulières dans urls.py pour définir les paramètres d'URL.

# Flask
@app.route('/user/<username>')
def show_user_profile(username):
    # show the user profile for that user
    return 'User %s' % username

# Django
from django.urls import path

def show_user_profile(request, username):
    # show the user profile for that user
    return HttpResponse('User %s' % username)

urlpatterns = [
    path('user/<str:username>/', show_user_profile),
]

9.2 Django contre FastAPI

FastAPI est un framework Web Python émergent, qui offre des performances rapides, simples et élevées, et dispose d'un support intégré pour la programmation asynchrone.

  • Vérification de type : FastAPI prend en charge la vérification de type Python. Vous pouvez définir directement le type dans le paramètre et FastAPI effectuera automatiquement la vérification des données. Alors que dans Django, vous devez valider les données et gérer vous-même les erreurs.

  • Programmation asynchrone : bien que Django 3.1 ait commencé à prendre en charge les vues et le middleware asynchrones, le support de FastAPI pour la programmation asynchrone est plus complet. asyncVous pouvez utiliser les mots-clés et dans FastAPI awaitpour définir des fonctions d'opération de chemin asynchrone, tandis que dans Django, vous devrez peut-être utiliser asgiref.sync.sync_to_asyncpour envelopper les opérations de base de données.

  • Documentation automatique : FastAPI peut générer automatiquement une documentation d'API basée sur votre code, ce qui peut vous aider à mieux tester et déboguer votre API. Dans Django, vous devez utiliser une bibliothèque tierce telle que DRF ou écrire manuellement la documentation de l'API.

# FastAPI
from fastapi import FastAPI

app = FastAPI()

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    return {
    
    "item_id": item_id}

En général, Django, Flask et FastAPI sont tous d'excellents frameworks Web Python, et ils ont chacun leurs propres avantages. Lequel choisir dépend des exigences de votre projet et du paradigme de programmation que vous préférez utiliser.

Si cela vous est utile, veuillez accorder plus d'attention au
compte public WeChat personnel : [Perspective complète de Python]
TeahLead_KrisChang, 10+ ans d'expérience dans l'industrie de l'Internet et de l'intelligence artificielle, 10+ ans d'expérience dans la technologie et la gestion d'équipe commerciale, Tongji Software Baccalauréat en ingénierie, maîtrise en gestion de l'ingénierie Fudan, architecte principal du service cloud certifié Aliyun, responsable de l'activité de produits d'IA avec des centaines de millions de revenus.

Je suppose que tu aimes

Origine blog.csdn.net/magicyangjay111/article/details/131624340
conseillé
Classement
du quotidien
Plus
2024-07-22(0)
2024-07-21(0)
2024-07-20(0)
2024-07-19(0)
2024-07-18(0)
2024-07-17(0)
2024-07-16(0)
2024-07-15(0)
2024-07-14(0)
2024-07-13(0)

Code World

© 2018 codetd.com