Solution de transactions distribuées avec architecture de microservices du framework Java

Les solutions de transactions distribuées dans le framework Java incluent : Mécanisme de compensation : effectuez l'opération inverse après un échec de transaction, adapté aux transactions simples. Modèle Saga : Décomposez la transaction en étapes indépendantes, chaque étape est exécutée indépendamment et annulée en cas d'échec. Validation en deux phases (2PC) : coordonne plusieurs participants (tels que des bases de données) pour valider ou annuler une transaction.

Solution de transactions distribuées dans l'architecture de microservices du framework Java

Les transactions distribuées sont l'un des problèmes importants qui doivent être résolus dans l'architecture des microservices. La réalisation de transactions ACID sur plusieurs microservices est essentielle pour garantir l’intégrité et la cohérence des données. Cet article abordera diverses approches de solutions de transactions distribuées dans le framework Java et fournira un cas pratique pour démontrer la mise en œuvre de ces solutions.

Méthode 1 : Mécanisme de compensation

Le mécanisme de compensation consiste à effectuer l'action inverse après l'échec d'une transaction. Cette approche est simple et facile à mettre en œuvre, mais peut ne pas convenir aux transactions imbriquées ou au traitement asynchrone.

@Transactional
public void transfer(Account fromAccount, Account toAccount, BigDecimal amount) {
    fromAccount.withdraw(amount);
    toAccount.deposit(amount);
}

@Transactional
public void compensateTransfer(Account fromAccount, Account toAccount, BigDecimal amount) {
    toAccount.withdraw(amount);
    fromAccount.deposit(amount);
}

Méthode 2 : Modèle Saga

Le modèle Saga décompose une transaction en une série d'étapes indépendantes ou « sous-transactions ». Chaque étape est exécutée dans une transaction distincte et peut être annulée en cas d'échec.

public class TransferSaga {

    private TransferStep transferStep;
    private CompensateTransferStep compensateTransferStep;

    public TransferSaga(TransferStep transferStep, CompensateTransferStep compensateTransferStep) {
        this.transferStep = transferStep;
        this.compensateTransferStep = compensateTransferStep;
    }

    public void execute(Account fromAccount, Account toAccount, BigDecimal amount) {
        transferStep.execute(fromAccount, toAccount, amount);
        compensateTransferStep.compensate(fromAccount, toAccount, amount);
    }
}

Méthode 3 : validation en deux phases (2PC)

2PC est un protocole de transaction distribué qui coordonne plusieurs participants (tels que des bases de données) impliqués dans une transaction. Ce protocole garantit que tous les participants valident la transaction ou l'annulent.

Cas pratique

Considérons un système avec deux microservices : order-service 和 payment-service。当客户下订单时，order-service 创建订单并向 payment-service Envoyer une demande de paiement.

La solution utilisant le mécanisme de compensation est la suivante :

@Transactional
public void createOrder(Order order) {
    orderRepository.save(order);
    paymentService.requestPayment(order.getId(), order.getAmount());
}

@Transactional
public void compensateCreateOrder(Order order) {
    orderRepository.delete(order);
}

@Transactional
public void requestPayment(Long orderId, BigDecimal amount) {
    Payment payment = new Payment();
    payment.setOrderId(orderId);
    payment.setAmount(amount);
    paymentRepository.save(payment);
}

@Transactional
public void compensateRequestPayment(Payment payment) {
    paymentRepository.delete(payment);
}

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!