Menangani Kompensasi dengan Peristiwa
Terapkan langkah kompensasi dalam saga koreografi dengan menerbitkan peristiwa pembatalan tertentu untuk membalikkan tindakan sebelumnya.
Menangani Kompensasi dengan Peristiwa adalah pelajaran Microservices Communication Patterns (Saga, Circuit Breaker) gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Microservices Communication Patterns (Saga, Circuit Breaker), dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Microservices Communication Patterns (Saga, Circuit Breaker) mencakup 4 pelajaran total.
Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.
Why Compensation is Crucial
In choreography sagas, services react to events. But what happens when one of those services fails to complete its part of a distributed transaction?
We need a way to undo any actions that were successfully performed by previous services. This is where compensation comes in.
What is Compensation?
Compensation is the process of reversing previously completed operations within a distributed transaction. Think of it as a 'rollback' mechanism tailored for microservices.
It ensures that if any step in a multi-service business process fails, the system can return to a consistent state.
Compensation in Choreography
In a choreography saga, there's no central orchestrator. Services communicate directly via events. So, how do we trigger compensation?
- When a service fails to complete its task, it publishes a specific compensation event.
- Other services that have successfully completed their part listen for these compensation events.
- Upon receiving a compensation event, they execute their own rollback logic.
Designing Compensation Events
Compensation events must contain enough information for services to perform their rollback. Key details often include:
- The original saga ID or transaction ID.
- Details about the original action that needs to be reversed.
- Any data required to perform the reversal (e.g., amount to refund, item to unreserve).
Example: Order Processing Saga
Consider an online order process:
- Order Service: Creates order (publishes
OrderCreated) - Payment Service: Processes payment (publishes
PaymentProcessed) - Inventory Service: Reserves stock (publishes
InventoryReserved)
What if the Inventory Service fails to reserve stock?
Initiating the Rollback
If the Inventory Service fails to reserve stock, it should:
- Not publish
InventoryReserved. - Instead, publish a compensation event, like
InventoryReservationFailed.
This event signals to other services that the saga could not complete successfully and they need to undo their actions.
Payment Service's Compensation
The Payment Service is subscribed to events that indicate failures. When it receives InventoryReservationFailed, it knows it needs to act:
- It will initiate a refund for the payment it previously processed.
- After refunding, it might publish a new event, like
PaymentRefunded, to inform other interested services.
Order Service's Compensation
The Order Service, having created the initial order, also needs to react. It might listen for InventoryReservationFailed or PaymentRefunded.
- Upon receiving such an event, the Order Service updates the order's status to 'Cancelled' or 'Failed'.
- This ensures the user sees an accurate status for their order.
Implementing Compensation Logic
Each service must contain logic to handle both successful forward-progress events and specific compensation events. This often means having separate event handlers for each.
Here's a simplified example of how a Payment Service might listen for a compensation event and trigger a refund:
public class PaymentService {
public static void main(String[] args) {
System.out.println("Payment Service Started.");
// Simulate receiving an event from a message broker
String receivedEvent = "InventoryReservationFailed: Order123";
if (receivedEvent.startsWith("InventoryReservationFailed")) {
String orderId = receivedEvent.split(":")[1];
System.out.println("Received compensation event: " + receivedEvent);
System.out.println("Initiating refund for Order ID: " + orderId + "...");
// In a real system, call a payment gateway API to refund
boolean refundSuccess = processRefund(orderId);
if (refundSuccess) {
System.out.println("Refund processed successfully for " + orderId + ".");
// Publish 'PaymentRefunded' event for other services
System.out.println("Publishing PaymentRefunded event.");
} else {
System.out.println("Refund failed for " + orderId + ".");
// Handle refund failure (e.g., alert, manual intervention)
}
} else {
System.out.println("No compensation event received yet.");
}
System.out.println("Payment Service Shutting Down.");
}
private static boolean processRefund(String orderId) {
// Simulate external refund API call
return true; // Assume success for this example
}
}Quick Check: Compensation Purpose
In a choreography saga, if the 'Inventory Service' fails to reserve items after 'Payment Service' has processed a payment, what is the primary purpose of the 'Inventory Service' publishing an InventoryReservationFailed event?
Recap: Handling Compensation
You've learned how critical compensation is in choreography sagas to maintain data consistency in distributed systems. Key takeaways:
- Compensation reverses successful actions when a saga step fails.
- In choreography, services publish specific compensation events to initiate rollbacks.
- Each service must implement logic to listen for and react to these events, performing its own undo operations.
- Clear event design and robust handling are essential for resilient sagas.
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Menangani Kompensasi dengan Peristiwa” gratis?
Ya — teks lengkap “Menangani Kompensasi dengan Peristiwa” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Microservices Communication Patterns (Saga, Circuit Breaker), upgrade ke CoddyKit PRO. Kursus Microservices Communication Patterns (Saga, Circuit Breaker) mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Menangani Kompensasi dengan Peristiwa”?
Terapkan langkah kompensasi dalam saga koreografi dengan menerbitkan peristiwa pembatalan tertentu untuk membalikkan tindakan sebelumnya. Kamu berlatih Microservices Communication Patterns (Saga, Circuit Breaker) dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai Microservices Communication Patterns (Saga, Circuit Breaker)?
Tidak diperlukan pengalaman sebelumnya. Microservices Communication Patterns (Saga, Circuit Breaker) di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.
Berapa lama pelajaran “Menangani Kompensasi dengan Peristiwa” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran Microservices Communication Patterns (Saga, Circuit Breaker) ini?
Ya. Setiap pelajaran Microservices Communication Patterns (Saga, Circuit Breaker) menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Merancang Saga Berbasis Peristiwa
- Bus Peristiwa dan Perantara Pesan
- Menangani Kompensasi dengan Peristiwa
- Membangun Konsumen Peristiwa Idempoten