Comment implémenter des transactions distribuées Java à l'aide d'Apache Ignite

Apache Ignite permet de maintenir la cohérence des données dans un environnement distribué via un moteur de transactions distribuées. Une application bancaire Java montre comment implémenter des transactions à l'aide d'Ignite : le nœud maître crée une transaction avec une concurrence pessimiste et des niveaux d'isolement de lecture reproductibles, récupère le compte du cache, débite le montant, enregistre le compte et valide la transaction. Créez une concurrence optimiste et des transactions de niveau d'isolement sérialisables à partir du nœud, obtenez le compte, vérifiez le solde, déduisez le montant, enregistrez le compte et validez la transaction. Exécutez l'application et regardez la console afficher le résultat indiquant que le transfert a réussi.

Comment utiliser Apache Ignite pour implémenter des transactions distribuées Java

Introduction

Apache Ignite est une plate-forme informatique distribuée offrant d'excellentes performances et évolutivité. Il fournit un moteur de traitement des transactions qui permet aux développeurs de créer des applications hautement cohérentes et performantes dans des environnements distribués.

Cas pratique

Pour démontrer comment utiliser Apache Ignite pour mettre en œuvre des transactions distribuées, nous créons une application bancaire simple. L'application sera composée de deux nœuds, un nœud maître et un nœud esclave.

pom.xml

<dependency>
  <groupId>org.apache.ignite</groupId>
  <artifactId>ignite-core</artifactId>
  <version>2.15.0</version>
</dependency>

Nœud maître

import org.apache.ignite.Ignite;
import org.apache.ignite.IgniteCache;
import org.apache.ignite.Ignition;
import org.apache.ignite.transactions.Transaction;
import org.apache.ignite.transactions.TransactionConcurrency;
import org.apache.ignite.transactions.TransactionIsolation;

public class MainNode {

  public static void main(String[] args) {
    // 初始化 Ignite 实例
    Ignite ignite = Ignition.start();

    // 获取账户缓存
    IgniteCache<Long, Account> accountCache = ignite.cache("Account");

    // 创建主事务
    try (Transaction tx = ignite.transactions().txStart(TransactionConcurrency.PESSIMISTIC,
        TransactionIsolation.REPEATABLE_READ)) {

      // 从缓存中加载账户
      Account account = accountCache.get(1L);

      // 提取 100 美元
      account.setBalance(account.getBalance() - 100);

      // 保存账户
      accountCache.put(1L, account);

      // 提交事务
      tx.commit();

      System.out.println("转账成功！");
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

Nœud esclave

import org.apache.ignite.Ignite;
import org.apache.ignite.Ignition;
import org.apache.ignite.transactions.Transaction;
import org.apache.ignite.transactions.TransactionConcurrency;
import org.apache.ignite.transactions.TransactionIsolation;

public class SlaveNode {

  public static void main(String[] args) {
    // 初始化 Ignite 实例
    Ignite ignite = Ignition.start();

    // 获取账户缓存
    IgniteCache<Long, Account> accountCache = ignite.cache("Account");

    // 创建从事务
    try (Transaction tx = ignite.transactions().txStart(TransactionConcurrency.OPTIMISTIC,
        TransactionIsolation.SERIALIZABLE)) {

      // 从缓存中加载账户
      Account account = accountCache.get(1L);

      // 检查账户余额是否足够
      if (account.getBalance() < 100) {
        tx.rollback();  // 余额不足，回滚事务
      }

      // 提取 100 美元
      account.setBalance(account.getBalance() - 100);

      // 保存账户
      accountCache.put(1L, account);

      // 提交事务
      tx.commit();

      System.out.println("转账成功！");
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

Classe de compte

public class Account {

  private Long id;
  private double balance;

  // 省略 getters 和 setters
}

Exécuter l'application

1. inNode, qui créera la transaction principale et effectuera le transfert fonctionner.
2. Exécutez le SlaveNode, qui créera des transactions esclaves et vérifiera que le solde est suffisant.
3. Observez la sortie de la console, elle imprimera le message indiquant que le transfert a réussi.

Le code ci-dessus montre comment utiliser Apache Ignite pour implémenter des transactions distribuées sur plusieurs nœuds. Il garantit l’atomicité, la cohérence, l’isolation et la durabilité (ACID) des opérations de transaction.

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!