Golang任务编排框架LightFlow详解

Golang任务编排框架LightFlow详解 我想分享我的最新项目 LightFlow，这是一个用 Go 语言构建的开源任务编排框架。它旨在简化复杂任务流的管理，同时专注于执行时机。

核心特性：

  • 隔离的上下文：每个 Step 都通过隔离的上下文链接，仅允许访问相关数据。
  • 可合并的流程：轻松将现有的 Flow 组合成新的流程，实现灵活的过程管理。
  • 检查点恢复：如果任务失败，可以从中断处恢复，避免不必要的已完成任务重新执行。
  • 专注于执行时机：直接在代码中定义任务依赖关系，确保框架有效管理执行顺序。

你可以在 GitHub 上找到 LightFlow 这里。欢迎社区的任何反馈或问题！


更多关于Golang任务编排框架LightFlow详解的实战教程也可以访问 https://www.itying.com/category-94-b0.html

1 回复

更多关于Golang任务编排框架LightFlow详解的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


LightFlow 的设计理念非常符合现代微服务架构的需求，特别是其隔离上下文和检查点恢复机制。以下是一个典型的使用示例，展示如何定义具有依赖关系的任务流：

package main

import (
    "context"
    "fmt"
    "github.com/Bilibotter/light-flow"
)

func main() {
    // 创建流程实例
    flow := lightflow.NewFlow("订单处理流程")
    
    // 定义步骤
    validateStep := flow.AddStep("验证订单", func(ctx context.Context) error {
        orderID := ctx.Value("order_id").(string)
        fmt.Printf("验证订单 %s\n", orderID)
        return nil
    })
    
    paymentStep := flow.AddStep("处理支付", func(ctx context.Context) error {
        amount := ctx.Value("amount").(float64)
        fmt.Printf("处理支付 %.2f\n", amount)
        return nil
    })
    
    inventoryStep := flow.AddStep("更新库存", func(ctx context.Context) error {
        productID := ctx.Value("product_id").(int)
        fmt.Printf("更新产品 %d 库存\n", productID)
        return nil
    })
    
    // 设置依赖关系
    paymentStep.DependsOn(validateStep)
    inventoryStep.DependsOn(paymentStep)
    
    // 准备上下文数据
    ctx := context.WithValue(context.Background(), "order_id", "ORD12345")
    ctx = context.WithValue(ctx, "amount", 99.99)
    ctx = context.WithValue(ctx, "product_id", 42)
    
    // 执行流程
    if err := flow.Execute(ctx); err != nil {
        fmt.Printf("流程执行失败: %v\n", err)
    }
}

对于检查点恢复功能，可以这样实现：

// 保存检查点
checkpoint, err := flow.SaveCheckpoint()
if err != nil {
    // 处理错误
}

// 从检查点恢复执行
recoveredFlow, err := lightflow.LoadFromCheckpoint(checkpoint)
if err != nil {
    // 处理错误
}

// 继续执行
err = recoveredFlow.Resume(context.Background())

流程合并的示例：

func createSubFlow(name string) *lightflow.Flow {
    flow := lightflow.NewFlow(name)
    flow.AddStep("步骤A", func(ctx context.Context) error {
        fmt.Println("执行步骤A")
        return nil
    })
    flow.AddStep("步骤B", func(ctx context.Context) error {
        fmt.Println("执行步骤B")
        return nil
    })
    return flow
}

func main() {
    // 创建子流程
    subFlow1 := createSubFlow("子流程1")
    subFlow2 := createSubFlow("子流程2")
    
    // 合并到主流程
    mainFlow := lightflow.NewFlow("主流程")
    mainFlow.Merge(subFlow1)
    mainFlow.Merge(subFlow2)
    
    // 设置跨流程依赖
    mainFlow.GetStep("子流程2.步骤A").DependsOn(
        mainFlow.GetStep("子流程1.步骤B")
    )
}

LightFlow 的隔离上下文通过每个步骤独立的 context 实现，这避免了数据污染问题。检查点恢复机制基于步骤的状态持久化，确保故障恢复时不会重复执行已完成步骤。框架通过拓扑排序确保依赖关系的正确执行顺序，这种设计在处理复杂业务流程时特别有效。

回到顶部