Compétences en traitement des transactions dans le framework Django

Django est un framework Web Python populaire. Son efficacité et son évolutivité sont l'une des raisons de sa popularité. Dans les applications, des interactions de données parfois complexes et la cohérence entre plusieurs requêtes doivent être gérées. À ce stade, vous devez utiliser des techniques de traitement des transactions dans Django pour garantir l'intégrité et la cohérence des données.

Dans Django, il existe deux méthodes de traitement des transactions : le traitement des transactions basé sur les fonctions et le traitement des transactions basé sur le gestionnaire de contexte. Cet article fournira une analyse détaillée de ces deux techniques.

1. Traitement des transactions basé sur les fonctions

Django fournit le décorateur transaction.atomic() pour implémenter le traitement des transactions basé sur les fonctions. Ce décorateur peut être utilisé sur les fonctions d'affichage (vues) et les commandes de gestion (commandes de gestion).

Utilisez ce décorateur dans une fonction d'affichage. Lorsque la fonction d'affichage renvoie un code de réponse HTTP HTTP 500 (erreur du serveur), Django annulera toutes les opérations écrites dans la base de données.

Par exemple, ce qui suit est une fonction d'affichage utilisée pour traiter les données transmises depuis le front-end et qui doit mettre à jour plusieurs tables en même temps :

@transaction.atomic
def my_view(request):
    # 处理从前端传入的数据
    # ...
    # 更新表1
    # ...
    # 更新表2
    # ...

Dans le code ci-dessus, lorsqu'une exception se produit, toutes les demandes de la base de données sera automatiquement révoquée. Les opérations d'écriture garantissent l'intégrité et la cohérence des données. Dans le même temps, le décorateur prend également en charge plusieurs transactions imbriquées. Lorsqu'une transaction imbriquée échoue, seule la base de données exploitée par la transaction imbriquée sera annulée, mais pas toutes les transactions.

2. Traitement des transactions basé sur le gestionnaire de contexte

Dans Django 1.8, le traitement des transactions basé sur le gestionnaire de contexte a été introduit. Cette technique prend en charge les transactions imbriquées et les problèmes de cohérence entre les bases de données.

Ce qui suit est un exemple d'utilisation de l'instruction with :

from django.db import transaction

def my_view(request):

    with transaction.atomic():
        # 处理请求
        # ...
        # 更新表1
        # ...
        # 更新表2
        # ...

Dans le code ci-dessus, la transaction sera automatiquement validée ou annulée. L'effet est cohérent avec l'utilisation de transaction.atomic().

De plus, si vous devez démarrer manuellement une transaction et surveiller les éventuels messages d'erreur, vous pouvez utiliser transaction.set_autocommit(False) :

from django.db import connection, transaction

def my_view(request):

    connection.set_autocommit(False)
    try:
        # 处理请求
        # ...
        # 更新表1
        # ...
        # 更新表2
        # ...

        connection.commit()
    except:
        connection.rollback()
    finally:
        connection.set_autocommit(True)

Ce qui précède est une méthode de contrôle manuel des transactions dans une fonction, et le code est relativement longue. Si vous devez la réutiliser, vous pouvez encapsuler cette méthode dans une classe distincte.

3. Notes

Lors de l'utilisation du traitement des transactions dans Django, vous devez faire attention aux points suivants :

1. Django soumettra automatiquement l'opération de modification de la base de données par défaut et la transaction ne sera pas exécutée à ce moment. Set_autocommit(False) doit être défini pour désactiver la validation automatique.

2. Si vous devez gérer des blocages ou d'autres exceptions, vous devez utiliser des mécanismes de gestion des exceptions pour éviter d'endommager les données.

3. Lorsque vous utilisez des transactions dans les commandes de gestion, vous devez faire attention au temps de soumission des transactions. Étant donné que les commandes peuvent être de longue durée, les transactions de longue durée peuvent utiliser trop de ressources de base de données, ce qui ralentit l'ensemble de la base de données. Dans ce cas, des packages tiers tels que les extensions Django peuvent être utilisés pour optimiser les transactions de longue durée.

En bref, l'utilisation de techniques de traitement des transactions dans Django peut garantir l'intégrité et la cohérence des données et réduire la corruption des données causée par des opérations inattendues. Dans le même temps, comprendre les compétences de Django en matière de traitement des transactions peut également aider les développeurs à mieux optimiser le code et à améliorer l'efficacité du fonctionnement des applications.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!