Comment comprendre les principes des choses Java

1. Qu'est-ce qu'une transaction Java ?

Le concept habituel est que les transactions sont uniquement liées aux bases de données.

Les transactions doivent être conformes aux principes ACID fixés par l'ISO/IEC. ACID est l'abréviation d'atomicité, de cohérence, d'isolation et de durabilité. L'atomicité d'une transaction signifie que tout échec lors de l'exécution de la transaction entraînera l'invalidité de toutes les modifications apportées par la transaction. La cohérence signifie que lorsqu'une transaction échoue, toutes les données affectées par la transaction doivent être restaurées dans leur état avant l'exécution de la transaction. L'isolement signifie que les modifications apportées aux données pendant l'exécution de la transaction ne sont pas visibles par les autres transactions avant que la transaction ne soit validée. La persistance signifie que le statut des données soumises doit être correct lorsque l'exécution de la transaction échoue.

Compréhension populaire, une transaction est un ensemble d'unités d'opération atomiques. Du point de vue de la base de données, il s'agit d'un ensemble d'instructions SQL soit toutes exécutées avec succès si l'une des instructions est exécutée incorrectement pour une raison quelconque, toutes précédemment. les instructions exécutées seront annulées. La réponse la plus simple est : soit toutes les exécutions réussissent, soit elles sont annulées et non exécutées.

Puisque la notion de transaction vient de la base de données, qu'est-ce qu'une transaction Java ? Quel est le lien ?

En fait, si un système d'application Java souhaite faire fonctionner une base de données, il est implémenté via JDBC. L'ajout, la modification et la suppression sont tous implémentés indirectement via les méthodes correspondantes, et le contrôle des transactions est également transféré en conséquence au code du programme Java. Par conséquent, les transactions d'exploitation de base de données sont traditionnellement appelées transactions Java.

2. Pourquoi les transactions Java sont nécessaires

Les transactions sont proposées pour résoudre les opérations de sécurité des données. Le contrôle des transactions consiste en fait à contrôler l'accès sécurisé aux données. Voici un exemple simple : par exemple, dans le cadre d'une activité de virement bancaire, le compte A souhaite transférer 1 000 yuans de son propre compte vers le compte B. Le solde du compte A doit d'abord être soustrait de 1 000 yuans, puis le solde du compte B doit être augmenté de 1 000 yuans. S'il y a un problème dans le réseau intermédiaire, que le prélèvement de 1 000 yuans sur le compte de A est terminé et que le fonctionnement de B échoue en raison d'une interruption du réseau, alors l'ensemble de l'entreprise échoue et un contrôle doit être effectué pour exiger l'annulation du transfert. affaires du compte de A. Cela peut garantir l'exactitude de l'entreprise. Pour mener à bien cette opération, une transaction est nécessaire. La diminution des fonds du compte A et l'augmentation des fonds du compte B sont combinées en une seule transaction. Soit toutes les exécutions sont réussies, soit toutes les opérations sont annulées. préservant ainsi la sécurité des données.

3. Types de transactions Java

Il existe trois types de transactions Java : les transactions JDBC, les transactions JTA (Java Transaction API) et les transactions de conteneur.

1. Transactions JDBC

Les transactions JDBC sont contrôlées par des objets de connexion. L'interface de connexion JDBC (java.sql.Connection) propose deux modes de transaction : la soumission automatique et la soumission manuelle. java.sql.Connection fournit les méthodes suivantes pour contrôler les transactions :

public void setAutoCommit(boolean)
public boolean getAutoCommit()
public void commit()
public void rollback()

Lorsque vous utilisez la définition de transaction JDBC, vous pouvez plusieurs Les instructions SQL sont combinées dans une transaction. L'un des inconvénients des transactions JDBC est que la portée de la transaction est limitée à une seule connexion à la base de données. Une transaction JDBC ne peut pas s'étendre sur plusieurs bases de données.

2. Transaction JTA (Java Transaction API)

JTA est une API de haut niveau, indépendante de l'implémentation et du protocole, peut utiliser JTA pour accéder aux transactions.

JTA permet aux applications d'effectuer des transactions distribuées : accéder et mettre à jour les données sur deux ou plusieurs ressources informatiques du réseau, qui peuvent être distribuées sur plusieurs bases de données. La prise en charge JTA du pilote JDBC améliore considérablement les capacités d'accès aux données.

Si vous envisagez d'utiliser JTA pour délimiter les transactions, vous aurez besoin d'un pilote JDBC qui implémente les interfaces javax.sql.XADataSource, javax.sql.XAConnection et javax.sql.XAResource. Un pilote qui implémente ces interfaces pourra participer aux transactions JTA. Un objet XADataSource est une fabrique d'objets XAConnection. Les XAConnection sont des connexions JDBC qui participent aux transactions JTA.

Vous devrez configurer XADataSource à l'aide des outils d'administration de votre serveur d'applications. Des conseils peuvent être trouvés dans la documentation du serveur d'applications et du pilote JDBC.

Les applications J2EE utilisent JNDI pour interroger les sources de données. Une fois que l'application trouve l'objet source de données, elle appelle javax.sql.DataSource.getConnection() pour obtenir une connexion à la base de données.

Les connexions XA sont différentes des connexions non-XA. Il est important de rappeler que les connexions XA participent aux transactions JTA. Cela signifie que les connexions XA ne prennent pas en charge la fonctionnalité de validation automatique de JDBC. Dans le même temps, les applications ne doivent pas appeler java.sql.Connection.commit() ou java.sql.Connection.rollback() sur les connexions XA.

Au lieu de cela, les applications doivent utiliser UserTransaction.begin(), UserTransaction.commit() et serTransaction.rollback().

3. Affaires de conteneurs

Les transactions de conteneurs sont principalement fournies par les serveurs d'applications J2EE. Les transactions de conteneurs sont principalement effectuées sur la base de JTA, qui est une implémentation d'API assez complexe basée sur JNDI. Par rapport au codage pour implémenter la gestion des transactions JTA, nous pouvons remplir la même fonction via le mécanisme de gestion des transactions de conteneur (CMT) fourni par le conteneur EJB. Cette fonction est fournie par le serveur d'applications J2EE. Cela nous permet de spécifier simplement quelle méthode ajouter à la transaction, et une fois spécifié, le conteneur se chargera des tâches de gestion des transactions. Il s'agit de notre solution de génie civil, car de cette manière nous pouvons exclure le code de transaction du codage logique, et en même temps laisser toutes les difficultés au conteneur J2EE pour les résoudre. Un autre avantage de l'utilisation d'EJB CMT est que les programmeurs n'ont pas besoin de se soucier du codage de l'API JTA. Cependant, en théorie, nous devons utiliser EJB.

Quatre. Trois types de différences entre les transactions Java

1. La limitation du contrôle des transactions JDBC réside dans une connexion à une base de données, mais son utilisation est simple.

2. Les transactions JTA sont puissantes. Les transactions peuvent s'étendre sur plusieurs bases de données ou plusieurs DAO, et leur utilisation est également compliquée.

3. Les transactions de conteneur font principalement référence à la gestion des transactions assurée par le serveur d'applications J2EE et se limitent aux applications EJB.

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!