Microservices Communication Patterns (Saga, Circuit Breaker) · 课时

编排式 Saga 详解

探索编排式方法：由专用服务协调分布式事务的各个步骤。

编排式 Saga 详解 是 CoddyKit 上的免费 Microservices Communication Patterns (Saga, Circuit Breaker) 课时。这是第 3 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Microservices Communication Patterns (Saga, Circuit Breaker) 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Microservices Communication Patterns (Saga, Circuit Breaker) 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Introducing Orchestration Sagas

Welcome to the Orchestration Saga! In a distributed system, sometimes a business transaction needs to involve multiple services.

An Orchestration Saga is a pattern where a central service, called an orchestrator, takes charge of guiding the entire transaction.

The Role of the Orchestrator

Think of the orchestrator as a project manager for your distributed transaction. It knows all the steps and coordinates them.

It sends commands to participant services.
It waits for responses (events) from those services.
It decides the next step based on the responses.

How it Works: A Simple Flow

Unlike a Choreography Saga where services react to events from each other, here the orchestrator is in control:

Orchestrator sends a command to Service A.
Service A performs its task and sends a completion event back to the orchestrator.
Orchestrator receives the event and sends a command to Service B.
This continues until the transaction is complete.

Example: Online Order Process

Let's use an online order as an example. An order might need to:

Create an order in the Order Service.
Reserve items in the Inventory Service.
Process payment in the Payment Service.
Initiate shipping in the Shipping Service.

An orchestrator would manage this sequence.

Orchestrator's State Management

The orchestrator must keep track of the saga's current state and context. This means it needs to store information like:

Which steps have completed?
What data was returned by previous steps?
What is the current status (e.g., PAYMENT_PENDING, INVENTORY_RESERVED)?

This state is crucial for deciding the next action or handling failures.

Commands & Events

The orchestrator communicates using two main types of messages:

Commands: Sent from the orchestrator to a service, telling it what to do (e.g., ReserveInventory).
Events: Sent from a service back to the orchestrator, reporting the outcome (e.g., InventoryReserved, PaymentFailed).

This clear distinction helps maintain control.

Handling Failures & Compensation

What if a step fails? The orchestrator is responsible for compensation.

If the Payment Service fails, the orchestrator detects the PaymentFailed event. It then knows to send compensation commands to previous services, such as ReleaseInventory to the Inventory Service and CancelOrder to the Order Service.

Orchestrator Flow Demo

Let's look at a simplified Java example. This isn't a full microservice, but it shows how an orchestrator's logic might flow, reacting to simulated service outcomes.

Notice how it tracks sagaState and triggers compensation if payment fails.

public class OrderSagaOrchestrator {

  public static void main(String[] args) {
    System.out.println("Saga Orchestrator Started: Order 123");
    String sagaState = "ORDER_INITIATED";

    System.out.println("Orchestrator: Sending 'CREATE_ORDER' command.");
    // Simulate Order Service success
    sagaState = "ORDER_CREATED";
    System.out.println("Orchestrator: Received 'ORDER_CREATED' event.");

    if (sagaState.equals("ORDER_CREATED")) {
      System.out.println("Orchestrator: Sending 'RESERVE_INVENTORY' command.");
      // Simulate Inventory Service success
      sagaState = "INVENTORY_RESERVED";
      System.out.println("Orchestrator: Received 'INVENTORY_RESERVED' event.");
    }

    if (sagaState.equals("INVENTORY_RESERVED")) {
      System.out.println("Orchestrator: Sending 'PROCESS_PAYMENT' command.");
      // Simulate Payment Service *failure*
      System.out.println("Orchestrator: Received 'PAYMENT_FAILED' event.");
      sagaState = "PAYMENT_FAILED";
    }

    if (sagaState.equals("PAYMENT_FAILED")) {
      System.out.println("Orchestrator: Initiating compensation!");
      System.out.println("Orchestrator: Sending 'CANCEL_ORDER' command.");
      System.out.println("Orchestrator: Sending 'RELEASE_INVENTORY' command.");
      sagaState = "SAGA_COMPENSATED";
      System.out.println("Orchestrator: Saga completed with compensation.");
    } else {
      System.out.println("Orchestrator: Sending 'CONFIRM_ORDER' command.");
      System.out.println("Orchestrator: Sending 'SHIP_ORDER' command.");
      sagaState = "SAGA_COMPLETED_SUCCESSFULLY";
      System.out.println("Orchestrator: Saga completed successfully.");
    }
  }
}

Advantages of Orchestration

Orchestration Sagas offer clear benefits:

Centralized Control: Easier to understand the overall flow.
Simplified Participant Services: Services don't need to know about the entire saga; they just follow orchestrator commands.
Easier Debugging: The orchestrator's state makes it simpler to trace issues.
Explicit Compensation: Compensation logic is clearly defined within the orchestrator.

Check Your Understanding

Which of the following statements accurately describe key characteristics of an Orchestration Saga?

Recap: Orchestration Saga

You've learned about the Orchestration Saga pattern!

It uses a central orchestrator service to manage a distributed transaction.
The orchestrator sends commands to services and receives events as responses.
It maintains the saga's state to know where it is in the transaction.
It explicitly handles compensation by issuing rollback commands if a step fails.

This pattern provides clear control and simplifies participant services.

常见问题解答

「编排式 Saga 详解」课时是免费的吗？

是的 — 「编排式 Saga 详解」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Microservices Communication Patterns (Saga, Circuit Breaker) 课程的其余内容，请升级到 CoddyKit PRO。 Microservices Communication Patterns (Saga, Circuit Breaker) 课程共包含 4 节课。

「编排式 Saga 详解」这节课中我会学到什么？

探索编排式方法：由专用服务协调分布式事务的各个步骤。你通过在浏览器中直接运行的动手代码来练习 Microservices Communication Patterns (Saga, Circuit Breaker)，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Microservices Communication Patterns (Saga, Circuit Breaker) 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Microservices Communication Patterns (Saga, Circuit Breaker) 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 3 节课，共 4 节。

「编排式 Saga 详解」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Microservices Communication Patterns (Saga, Circuit Breaker) 课中编写并运行代码吗？

能。每节 Microservices Communication Patterns (Saga, Circuit Breaker) 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Microservices Communication Patterns (Saga, Circuit Breaker)