Traitement des transactions en JAVA-JavaBase-php.cn

Traitement des transactions en JAVA

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

Le concept courant est que les transactions sont liées à la base de données. Une transaction est une séquence d'opérations pour accéder à la base de données. Le système d'application de base de données complète l'accès à la base de données via des ensembles de transactions. L'exécution correcte des transactions fait passer la base de données d'un état à un autre.

Les transactions doivent être conformes aux principes ACID établis par l'ISO/IEC.

ACID est l'abréviation d'atomicité, de cohérence, d'isolement et de durabilité. Les transactions doivent être conformes aux principes ACID établis par l'ISO/IEC. ACID est l'abréviation d'atomicité, de cohérence, d'isolation et de durabilité.

a. Atomicité

signifie indivisibilité. Soit toutes les transactions sont exécutées, soit aucune n'est exécutée. Si toutes les sous-transactions de la transaction sont soumises avec succès, toutes les opérations de base de données sont soumises et l'état de la base de données est converti ; si une sous-transaction échoue, les opérations de base de données des autres sous-transactions sont annulées, c'est-à-dire que la base de données revient à l'état avant l'exécution de la transaction. Aucune transition d'état ne se produit.

b. Cohérence

L'exécution d'une transaction convertit la base de données d'un état correct à un autre état correct.

c. Isolement

Avant que la transaction ne soit correctement validée, toute modification apportée aux données par la transaction ne peut être fournie à aucune autre transaction, c'est-à-dire avant que la transaction ne soit correctement validée. , ses résultats possibles ne doivent pas être affichés pour une autre transaction.

d. Durabilité

Une fois qu'une transaction est soumise correctement, ses résultats seront stockés en permanence dans la base de données. Même s'il y a d'autres échecs après la soumission de la transaction, les résultats du traitement de la transaction. sera sauvegardé.

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 exploite une base de données, celle-ci est implémentée via JDBC. Ensuite, 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é au code du programme Java en conséquence. Par conséquent, les transactions d'exploitation de base de données sont traditionnellement appelées transactions Java.

2. Pourquoi les transactions sont nécessaires

Une phrase simple : maintenir la cohérence 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. Voici l'introduction la plus simple. Enfin, nous présenterons l'utilisation des transactions jdbc. Vous pouvez rechercher et apprendre les deux autres types par vous-même.

a. Transaction JDBC

La transaction JDBC est contrôlée par l'objet Connection. 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()

Copier après la connexion

Lorsque vous utilisez la démarcation des transactions JDBC, vous pouvez combiner plusieurs instructions SQL en une seule 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.

b. Transaction JTA (Java Transaction API)

JTA est une API de haut niveau, indépendante de la mise en œuvre et du protocole, qui 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 prévoyez 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 XAConnections sont des connexions JDBC qui participent aux transactions JTA et vous devrez configurer XADataSource à l'aide des outils d'administration du serveur d'applications.

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().

c. Transactions 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. Une fois spécifié, le conteneur sera responsable des tâches de gestion des transactions. Il s'agit de notre solution de génie civil, car de cette façon 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.

使用EJB CMT的另外一个好处就是程序员无需关心JTA API的编码，不过，理论上我们必须使用EJB。

d、JDBC事务的使用

(1)步骤：

首先，设置事务的提交方式为非自动提交：conn.setAutoCommit(false);接下来，将需要添加事务的代码放入try，catch块中。

然后，在try块内添加事务的提交操作，表示操作无异常，提交事务：conn.commit();尤其不要忘记，在catch块内添加回滚事务，表示操作出现异常，撤销事务：conn.rollback();最后，设置事务提交方式为自动提交：conn.setAutoCommit(true);这样，通过简单的几步，我们就可以完成对事务处理的编写了。

(2)伪代码：

con = DriverManager.getConnection(url, user, password)；
String result = "";
String sql1 = "";
// LAST_INSERT_ID() 获取刚刚插入的自动递增的ID
String sql2 = "";
int flag;
try {
    con.setAutoCommit(false);// 更改JDBC事务的默认提交方式
    pstmt = con.prepareStatement(sql1);
    flag = pstmt.executeUpdate();
    if (flag > 0) {
        pstmt = con.prepareStatement(sql2);
        int i = pstmt.executeUpdate();
        if (i > 0) {
            con.commit();//提交JDBC事务
            result = "add data success!!";
        } else {
            result = "add data fail!!";
       }
    } else {
        result = "add data fail!!";
    }
} catch (SQLException e) {
    try {
        con.rollback();//回滚JDBC事务
    } catch (SQLException e1) {
    // TODO Auto-generated catch block
        result = "add data fail!! SQLException";
        e1.printStackTrace();
    }
    result = "add data fail!! SQLException";
    e.printStackTrace();
} finally {
    try {
        con.setAutoCommit(true); // 恢复JDBC事务的默认提交方式
    } catch (SQLException e) {
    // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
return result;

Copier après la connexion

4、三种事务差异

1、JDBC事务控制的局限性在一个数据库连接内，但是其使用简单。

2、JTA事务的功能强大，事务可以跨越多个数据库或多个DAO，使用也比较复杂。

3、容器事务，主要指的是J2EE应用服务器提供的事务管理，局限于EJB应用使用。

5、总结

事务控制是构建J2EE应用不可缺少的一部分，合理选择应用何种事务对整个应用系统来说至关重要。一般说来，在单个JDBC 连接连接的情况下可以选择JDBC事务，在跨多个连接或者数据库情况下，需要选择使用JTA事务，如果用到了EJB，则可以考虑使用EJB容器事务。

更多相关知识请关注java基础教程栏目

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!