Gobrs-Async 框架Gobrs-Async 核心包 com.gobrs.async.core.task 详解：高

Gobrs-Async 核心包 `com.gobrs.async.core.task` 详解：高性能异步任务编排指南

一、Gobrs-Async 框架概览

Gobrs-Async 是一款功能强大、配置灵活、带有全链路异常回调、内存优化、异常状态管理于一身的高性能多线程并发编程和动态编排框架。它诞生于应对复杂业务场景下异步线程复杂性、任务依赖性以及异常状态难以控制的痛点，为开发者提供了简洁优雅的任务编排解决方案。

与传统的 CompletableFuture 相比，Gobrs-Async 的核心理念在于将任务编排逻辑从代码中剥离出来，通过配置文件即可定义复杂的任务依赖关系，而无需编写大量冗余的异步编排代码。框架底层主要使用 CountDownLatch、ReentrantLock、volatile 等并发技术，无需依赖任何中间件即可完成高性能的异步任务调度。

在 Gobrs-Async 的架构中，com.gobrs.async.core.task 包承担着任务定义与生命周期管理的核心职责。每个异步执行单元都需要继承该包中的 AsyncTask 抽象类，并通过实现其核心方法来定义任务的具体行为。可以说，理解这个包是掌握整个 Gobrs-Async 框架的基石。

二、核心类 AsyncTask 详解

AsyncTask 是 com.gobrs.async.core.task 包中最核心的抽象类，开发者自定义的所有异步任务都需要继承它。Gobrs-Async 相对于其他异步编排框架的一个显著优势在于，它对任务的生命周期提供了完善的支持，从节点的开始、执行到结束（包括中间出现异常）都有相应的方法可供覆写。

2.1 AsyncTask 核心方法

方法	用途	说明
`task(Object o, TaskSupport support)`	任务的核心业务逻辑	必须实现，执行具体的业务处理
`begin(Object o, TaskSupport support)`	任务开始前的准备工作	可选，任务开始前调用，可用于初始化操作
`end(Object o, TaskSupport support)`	任务结束后的收尾工作	可选，任务执行完成后调用，无论成功或失败
`nessary(Object o, TaskSupport support)`	判断任务是否需要执行	可选，返回 true 则执行，false 则跳过
`onError(TaskSupport support, Throwable throwable)`	任务异常处理回调	可选，任务执行出现异常时调用

2.2 注解 @Task

Gobrs-Async 提供了 @Task 注解，用于为任务配置额外的执行属性：

timeoutInMilliseconds：设置任务的超时时间（毫秒），超过该时间后任务将被中断
name：指定任务的名称，便于在配置文件中引用

三、快速上手

3.1 环境准备与依赖引入

在 Spring Boot 项目中引入 Gobrs-Async 的 starter 依赖：

xml

<dependency>
    <groupId>io.github.memorydoc</groupId>
    <artifactId>gobrs-async-starter</artifactId>
    <version>1.2.9-RELEASE</version>
</dependency>

3.2 定义异步任务

创建自定义的异步任务类，继承 AsyncTask 并覆写 task() 方法。以电商订单处理场景为例，定义以下几个异步任务：

java

import com.gobrs.async.core.TaskSupport;
import com.gobrs.async.core.task.AsyncTask;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class UserInfoTask extends AsyncTask<OrderContext, UserInfo> {
    
    @Override
    public void begin(OrderContext context, TaskSupport support) {
        log.info("用户信息查询任务开始，订单ID: {}", context.getOrderId());
    }
    
    @Override
    public UserInfo task(OrderContext context, TaskSupport support) {
        // 模拟查询用户信息
        log.info("查询用户信息，用户ID: {}", context.getUserId());
        UserInfo userInfo = new UserInfo();
        userInfo.setUserId(context.getUserId());
        userInfo.setUserName("张小明");
        userInfo.setVipLevel(3);
        return userInfo;
    }
    
    @Override
    public void end(OrderContext context, TaskSupport support) {
        log.info("用户信息查询任务结束");
    }
    
    @Override
    public void onError(TaskSupport support, Throwable throwable) {
        log.error("用户信息查询任务执行失败", throwable);
    }
}

java

@Slf4j
@Component
public class ProductInfoTask extends AsyncTask<OrderContext, ProductInfo> {
    
    @Override
    public ProductInfo task(OrderContext context, TaskSupport support) {
        log.info("查询商品信息，商品ID: {}", context.getProductId());
        // 模拟商品信息查询
        ProductInfo productInfo = new ProductInfo();
        productInfo.setProductId(context.getProductId());
        productInfo.setProductName("高性能编程实战指南");
        productInfo.setPrice(129.00);
        productInfo.setStock(1000);
        return productInfo;
    }
}

java

@Slf4j
@Component
public class InventoryTask extends AsyncTask<OrderContext, InventoryInfo> {
    
    @Override
    public InventoryInfo task(OrderContext context, TaskSupport support) {
        // 从上下文中获取商品信息
        ProductInfo productInfo = support.getTaskResult(ProductInfoTask.class);
        log.info("查询库存信息，商品ID: {}, 商品名称: {}", 
                 productInfo.getProductId(), productInfo.getProductName());
        // 模拟库存查询
        InventoryInfo inventoryInfo = new InventoryInfo();
        inventoryInfo.setProductId(productInfo.getProductId());
        inventoryInfo.setAvailableStock(850);
        return inventoryInfo;
    }
}

java

@Slf4j
@Component
public class OrderCalculationTask extends AsyncTask<OrderContext, OrderResult> {
    
    @Override
    public OrderResult task(OrderContext context, TaskSupport support) {
        // 获取前置任务的执行结果
        UserInfo userInfo = support.getTaskResult(UserInfoTask.class);
        ProductInfo productInfo = support.getTaskResult(ProductInfoTask.class);
        InventoryInfo inventoryInfo = support.getTaskResult(InventoryTask.class);
        
        log.info("开始计算订单信息，用户: {}, 商品: {}", 
                 userInfo.getUserName(), productInfo.getProductName());
        
        OrderResult orderResult = new OrderResult();
        orderResult.setOrderId(context.getOrderId());
        orderResult.setUserName(userInfo.getUserName());
        orderResult.setProductName(productInfo.getProductName());
        
        // 根据用户 VIP 等级计算折扣
        double discount = calculateDiscount(userInfo.getVipLevel());
        double finalPrice = productInfo.getPrice() * discount;
        orderResult.setFinalPrice(finalPrice);
        orderResult.setAvailableStock(inventoryInfo.getAvailableStock());
        
        return orderResult;
    }
    
    private double calculateDiscount(int vipLevel) {
        if (vipLevel >= 5) return 0.8;
        if (vipLevel >= 3) return 0.9;
        return 1.0;
    }
}

3.3 配置任务编排规则

在 application.yml 中配置任务依赖关系：

yaml

spring:
  gobrs:
    async:
      rules:
        - name: "orderProcess"
          content: "UserInfoTask,ProductInfoTask->InventoryTask->OrderCalculationTask"
      config:
        timeout-core-size: 200  # 超时监听线程池核心线程数

上述配置的含义：UserInfoTask 和 ProductInfoTask 并行执行，两者都完成后执行 InventoryTask，最后执行 OrderCalculationTask。

3.4 启动任务编排

java

@RestController
@RequestMapping("/order")
public class OrderController {
    
    @Autowired
    private GobrsAsync gobrsAsync;
    
    @PostMapping("/process")
    public OrderResult processOrder(@RequestBody OrderRequest request) {
        // 构建任务上下文参数
        OrderContext context = new OrderContext();
        context.setOrderId(request.getOrderId());
        context.setUserId(request.getUserId());
        context.setProductId(request.getProductId());
        
        // 方式一：所有任务共享同一个参数（DataContext 上下文）
        AsyncResult<OrderResult> asyncResult = gobrsAsync.go(
            "orderProcess", 
            () -> context, 
            5000  // 超时时间 5 秒
        );
        
        // 获取执行结果
        return asyncResult.getResult();
    }
}

四、高级特性与最佳实践

4.1 任务条件执行（nessary 方法）

nessary() 方法返回 true 时任务被执行，返回 false 时任务被跳过。这在需要根据上下文动态决定是否执行某个任务时非常有用：

java

@Slf4j
@Component
public class CouponTask extends AsyncTask<OrderContext, CouponInfo> {
    
    @Override
    public boolean nessary(OrderContext context, TaskSupport support) {
        // 只有使用优惠券时才执行该任务
        return context.isUseCoupon();
    }
    
    @Override
    public CouponInfo task(OrderContext context, TaskSupport support) {
        log.info("查询可用优惠券信息");
        CouponInfo coupon = new CouponInfo();
        coupon.setDiscountAmount(10.0);
        return coupon;
    }
}

4.2 任务超时控制

使用 @Task 注解配置任务的超时时间：

java

@Slf4j
@Component
@Task(timeoutInMilliseconds = 3000)  // 任务超时时间 3 秒
public class SlowApiTask extends AsyncTask<OrderContext, String> {
    
    @Override
    public String task(OrderContext context, TaskSupport support) {
        // 模拟耗时操作
        Thread.sleep(2000);
        return "慢速 API 调用结果";
    }
}

需要注意的是，超时任务不支持线程复用，因为需要通过控制线程超时来进行逻辑判断。

4.3 获取前置任务结果

通过 TaskSupport 对象的 getTaskResult(Class taskClass) 方法，可以获取任意前置任务的执行结果：

java

// 获取指定类型任务的执行结果
UserInfo userInfo = support.getTaskResult(UserInfoTask.class);

// 获取所有任务的执行结果 Map
Map<Class<?>, Object> allResults = support.getTaskResults();

4.4 灵活的参数传递机制

Gobrs-Async 支持两种参数传递方式：

方式一：共享参数（DataContext 模式）

所有任务使用同一个上下文对象，适用于任务间需要共享数据的场景：

java

OrderContext sharedContext = new OrderContext();
AsyncResult asyncResult = gobrsAsync.go("orderProcess", () -> sharedContext, 5000);

方式二：差异化参数

不同任务使用不同的参数，通过 Map 传递，Map 的 key 为任务类的 Class 类型：

java

Map<Class<?>, Object> params = new HashMap<>();
params.put(UserInfoTask.class, userContext);
params.put(ProductInfoTask.class, productContext);
AsyncResult asyncResult = gobrsAsync.go("orderProcess", () -> params, 5000);

4.5 多命名空间配置

Gobrs-Async 支持多命名空间，即可以在同一配置文件中定义多个不同的任务编排规则：

yaml

spring:
  gobrs:
    async:
      rules:
        - name: "orderProcess"
          content: "UserInfoTask,ProductInfoTask->InventoryTask->OrderCalculationTask"
        - name: "refundProcess"
          content: "RefundCheckTask->RefundApprovalTask->RefundExecuteTask"
        - name: "productSearch"
          content: "SearchTask,HotRankTask,RecommendTask->MergeResultTask"

启动时只需指定对应的规则名称即可：

java

AsyncResult result1 = gobrsAsync.go("orderProcess", () -> params, 5000);
AsyncResult result2 = gobrsAsync.go("refundProcess", () -> params, 3000);

五、完整示例：电商订单聚合处理

下面是一个完整的模拟电商订单聚合处理示例，包含数据模拟、任务编排和结果输出。

5.1 数据模型定义

java

@Data
public class OrderContext {
    private String orderId;
    private String userId;
    private String productId;
    private boolean useCoupon;
}

@Data
public class UserInfo {
    private String userId;
    private String userName;
    private int vipLevel;
    private List<String> tags;
}

@Data
public class ProductInfo {
    private String productId;
    private String productName;
    private Double price;
    private Integer stock;
    private String category;
}

@Data
public class InventoryInfo {
    private String productId;
    private Integer availableStock;
    private String warehouse;
}

@Data
public class CouponInfo {
    private String couponId;
    private Double discountAmount;
    private String description;
}

@Data
public class OrderResult {
    private String orderId;
    private String userName;
    private String productName;
    private Double originalPrice;
    private Double discountAmount;
    private Double finalPrice;
    private Integer availableStock;
    private List<String> userTags;
}

5.2 模拟数据任务

java

@Slf4j
@Component
public class UserInfoTask extends AsyncTask<OrderContext, UserInfo> {
    
    @Override
    public UserInfo task(OrderContext context, TaskSupport support) {
        // 模拟耗时 500ms 的用户信息查询
        try { Thread.sleep(500); } catch (InterruptedException e) {}
        
        // 模拟数据库查询返回的用户信息
        UserInfo userInfo = new UserInfo();
        userInfo.setUserId(context.getUserId());
        userInfo.setUserName("张小明");
        userInfo.setVipLevel(3);
        userInfo.setTags(Arrays.asList("高活跃用户", "新用户"));
        log.info("✅ 用户信息查询完成: {} (VIP {})", userInfo.getUserName(), userInfo.getVipLevel());
        return userInfo;
    }
}

@Slf4j
@Component
public class ProductInfoTask extends AsyncTask<OrderContext, ProductInfo> {
    
    @Override
    public ProductInfo task(OrderContext context, TaskSupport support) {
        // 模拟耗时 800ms 的商品信息查询（HTTP 调用）
        try { Thread.sleep(800); } catch (InterruptedException e) {}
        
        ProductInfo productInfo = new ProductInfo();
        productInfo.setProductId(context.getProductId());
        productInfo.setProductName("《高性能编程实战》");
        productInfo.setPrice(129.00);
        productInfo.setStock(1000);
        productInfo.setCategory("技术书籍");
        log.info("✅ 商品信息查询完成: {} ￥{}", productInfo.getProductName(), productInfo.getPrice());
        return productInfo;
    }
}

@Slf4j
@Component
public class CouponTask extends AsyncTask<OrderContext, CouponInfo> {
    
    @Override
    public boolean nessary(OrderContext context, TaskSupport support) {
        return context.isUseCoupon();
    }
    
    @Override
    public CouponInfo task(OrderContext context, TaskSupport support) {
        // 模拟耗时 300ms 的优惠券查询
        try { Thread.sleep(300); } catch (InterruptedException e) {}
        
        CouponInfo coupon = new CouponInfo();
        coupon.setCouponId("COUPON_001");
        coupon.setDiscountAmount(15.0);
        coupon.setDescription("新用户专享优惠券");
        log.info("✅ 优惠券查询完成: 优惠 {} 元", coupon.getDiscountAmount());
        return coupon;
    }
}

@Slf4j
@Component
public class InventoryTask extends AsyncTask<OrderContext, InventoryInfo> {
    
    @Override
    public InventoryInfo task(OrderContext context, TaskSupport support) {
        ProductInfo productInfo = support.getTaskResult(ProductInfoTask.class);
        // 模拟耗时 400ms 的库存查询
        try { Thread.sleep(400); } catch (InterruptedException e) {}
        
        InventoryInfo inventoryInfo = new InventoryInfo();
        inventoryInfo.setProductId(productInfo.getProductId());
        inventoryInfo.setAvailableStock(productInfo.getStock() - 150);
        inventoryInfo.setWarehouse("华东一号仓");
        log.info("✅ 库存信息查询完成: 剩余库存 {}", inventoryInfo.getAvailableStock());
        return inventoryInfo;
    }
}

@Slf4j
@Component
public class OrderCalculationTask extends AsyncTask<OrderContext, OrderResult> {
    
    @Override
    public OrderResult task(OrderContext context, TaskSupport support) {
        UserInfo userInfo = support.getTaskResult(UserInfoTask.class);
        ProductInfo productInfo = support.getTaskResult(ProductInfoTask.class);
        InventoryInfo inventoryInfo = support.getTaskResult(InventoryTask.class);
        CouponInfo couponInfo = support.getTaskResult(CouponTask.class);
        
        OrderResult result = new OrderResult();
        result.setOrderId(context.getOrderId());
        result.setUserName(userInfo.getUserName());
        result.setProductName(productInfo.getProductName());
        result.setOriginalPrice(productInfo.getPrice());
        result.setUserTags(userInfo.getTags());
        result.setAvailableStock(inventoryInfo.getAvailableStock());
        
        // 计算最终价格
        double price = productInfo.getPrice();
        double discount = calculateDiscount(userInfo.getVipLevel());
        double couponAmount = couponInfo != null ? couponInfo.getDiscountAmount() : 0;
        double finalPrice = price * discount - couponAmount;
        
        result.setDiscountAmount(couponAmount);
        result.setFinalPrice(finalPrice);
        
        log.info("✅ 订单计算完成: 原价￥{} → VIP折扣 {}折 → 优惠券减￥{} → 最终￥{}", 
                 price, discount, couponAmount, finalPrice);
        return result;
    }
    
    private double calculateDiscount(int vipLevel) {
        switch (vipLevel) {
            case 5: return 0.85;
            case 4: return 0.9;
            case 3: return 0.95;
            default: return 1.0;
        }
    }
}

5.3 编排配置与执行

配置文件 application.yml：

yaml

spring:
  gobrs:
    async:
      rules:
        - name: "orderAggregation"
          content: "UserInfoTask,ProductInfoTask,CouponTask->InventoryTask->OrderCalculationTask"
      config:
        timeout-core-size: 100
      task-interrupt: true  # 局部异常是否打断主流程

执行入口：

java

@Service
@Slf4j
public class OrderService {
    
    @Autowired
    private GobrsAsync gobrsAsync;
    
    public OrderResult processOrder(String orderId, String userId, String productId, boolean useCoupon) {
        OrderContext context = new OrderContext();
        context.setOrderId(orderId);
        context.setUserId(userId);
        context.setProductId(productId);
        context.setUseCoupon(useCoupon);
        
        log.info("🚀 开始处理订单，订单号: {}", orderId);
        long startTime = System.currentTimeMillis();
        
        AsyncResult<OrderResult> asyncResult = gobrsAsync.go(
            "orderAggregation", 
            () -> context, 
            10000  // 10 秒超时
        );
        
        OrderResult result = asyncResult.getResult();
        long elapsed = System.currentTimeMillis() - startTime;
        
        log.info("🎉 订单处理完成，耗时: {}ms", elapsed);
        return result;
    }
}

5.4 运行结果示例

执行上述代码后，控制台输出如下：

text

🚀 开始处理订单，订单号: ORDER_2026001
✅ 用户信息查询完成: 张小明 (VIP 3)
✅ 商品信息查询完成: 《高性能编程实战》 ￥129.0
✅ 优惠券查询完成: 优惠 15.0 元
✅ 库存信息查询完成: 剩余库存 850
✅ 订单计算完成: 原价￥129.0 → VIP折扣 0.95折 → 优惠券减￥15.0 → 最终￥107.55
🎉 订单处理完成，耗时: 892ms

由于 UserInfoTask、ProductInfoTask 和 CouponTask 是并行执行的，所以总耗时约等于最慢的 ProductInfoTask（800ms）加上 InventoryTask（400ms），最终约 900ms 即可完成全部处理。

六、总结

com.gobrs.async.core.task 包是 Gobrs-Async 框架的任务定义基石。通过继承 AsyncTask 并实现 task() 方法，开发者可以轻松地将业务逻辑封装为异步执行单元；通过 begin()、end()、nessary()、onError() 等生命周期方法，可以精细控制任务的执行流程和异常处理。

Gobrs-Async 的优势在于将任务编排逻辑从代码中剥离出来，通过简洁的 YAML 配置即可定义复杂的任务依赖关系，极大地降低了异步编程的复杂度，让开发者能够专注于核心业务逻辑的实现。在微服务聚合查询、多数据源并行处理、工作流编排等场景下，Gobrs-Async 都是一个值得推荐的解决方案。

示例

YAML 配置示例

gobrs:
  async:
    config:
      enable: true                              # 全局开关，开启异步编排引擎
      timeout-core-size: 200                    # 超时监听线程池核心线程数
      rules:
        # ==================== 规则1：电商订单处理（多级依赖） ====================
        - name: "order-processing"              # 规则名称，代码中通过此名称调用
          content: "UserInfoTask,ProductInfoTask,CouponTask->InventoryTask->OrderCalculationTask"
          task-interrupt: false                 # 局部异常不打断主流程
          # catchable: true                     # 可选：异常原样抛出，不包装（场景需时开启）
          # transaction: false                  # 可选：是否开启事务回滚

        # ==================== 规则2：分叉聚合场景 ====================
        - name: "data-sync"
          content: "UserTask->AddressTask,OrderTask,ProductTask->ResultMergeTask"
          task-interrupt: true

        # ==================== 规则3：任意依赖完成即触发（:any 关键字） ====================
        - name: "fast-response"
          content: "FastApiTask,SlowDbTask,CacheTask->CallbackTask:any"
          task-interrupt: true

        # ==================== 规则4：竞争独占模式（:exclusive 关键字） ====================
        - name: "resource-contention"
          content: "HttpTask,RpcTask,MqTask->ResourceTask:any:exclusive"
          task-interrupt: true

        # ==================== 规则5：多分支并行编排（分号分隔） ====================
        - name: "multi-branch"
          content: "StartTask->A1Task->A2Task->EndTask;StartTask->B1Task->B2Task->EndTask"
          task-interrupt: false

        # ==================== 规则6：配置化异常处理（catchable: true） ====================
        - name: "error-handling-demo"
          content: "SafeTask,UnstableApiTask->FallbackTask"
          task-interrupt: false
          catchable: true                       # 异常不包装，原样抛出供业务处理

规则内容语法速查

符号/关键字	含义	示例
`,`	并行执行（无依赖，同时启动）	`A,B->C`
`->`	串行依赖（箭头左侧完成后右侧才开始）	`A->B->C`
`;`	分支分隔符（分叉编排）	`A->B->C;A->D->E`
`:any`	任意依赖完成即触发	`A,B,C->D:any`
`:exclusive`	竞争独占，触发后中断其他依赖任务	`A,B,C->D:any:exclusive`
`:not`	表示任务不执行	`A->B:not`

、任务类定义

基础任务示例

java

import com.gobrs.async.core.TaskSupport;
import com.gobrs.async.core.anno.Task;
import com.gobrs.async.core.task.AsyncTask;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@Task(name = "UserInfoTask", timeoutInMilliseconds = 3000)  // 任务名称 + 超时配置
public class UserInfoTask extends AsyncTask<OrderContext, UserInfo> {

    @Override
    public void prepare(Object o) {
        log.info("任务开始前的准备工作");
    }

    @Override
    public UserInfo task(OrderContext context, TaskSupport support) {
        log.info("查询用户信息，用户ID: {}", context.getUserId());
        // 模拟业务逻辑
        UserInfo userInfo = new UserInfo();
        userInfo.setUserId(context.getUserId());
        userInfo.setUserName("张小明");
        userInfo.setVipLevel(3);
        return userInfo;
    }

    @Override
    public void onSuccess(TaskSupport support) {
        log.info("任务执行成功回调");
    }

    @Override
    public void onFail(TaskSupport support) {
        log.error("任务执行失败回调");
    }

    @Override
    public boolean nessary(Object o, TaskSupport support) {
        // 返回 true 则执行任务，false 则跳过
        return true;
    }
}

依赖结果获取示例

java

@Slf4j
@Component
@Task(name = "OrderCalculationTask", timeoutInMilliseconds = 5000)
public class OrderCalculationTask extends AsyncTask<OrderContext, OrderResult> {

    @Override
    public OrderResult task(OrderContext context, TaskSupport support) {
        // 通过 getTaskResult 方法获取前置任务的执行结果
        UserInfo userInfo = support.getTaskResult(UserInfoTask.class);
        ProductInfo productInfo = support.getTaskResult(ProductInfoTask.class);
        CouponInfo couponInfo = support.getTaskResult(CouponTask.class);

        log.info("用户: {}, 商品: {}", userInfo.getUserName(), productInfo.getProductName());

        OrderResult result = new OrderResult();
        result.setOrderId(context.getOrderId());
        result.setUserName(userInfo.getUserName());
        result.setProductName(productInfo.getProductName());

        double finalPrice = productInfo.getPrice();
        if (couponInfo != null) {
            finalPrice -= couponInfo.getDiscountAmount();
        }

        result.setFinalPrice(Math.max(finalPrice, 0));
        return result;
    }
}

条件执行示例（nessary 方法）

java

@Slf4j
@Component
@Task(name = "CouponTask")
public class CouponTask extends AsyncTask<OrderContext, CouponInfo> {

    @Override
    public boolean nessary(OrderContext context, TaskSupport support) {
        // 只有使用优惠券时才执行该任务
        return context.isUseCoupon();
    }

    @Override
    public CouponInfo task(OrderContext context, TaskSupport support) {
        CouponInfo coupon = new CouponInfo();
        coupon.setDiscountAmount(15.0);
        return coupon;
    }
}

事务回滚配置（可选）

java

@Slf4j
@Component
@Task(name = "PaymentTask", callback = true)  // callback = true 开启事务回滚支持
public class PaymentTask extends AsyncTask<OrderContext, PaymentResult> {

    @Override
    public PaymentResult task(OrderContext context, TaskSupport support) {
        // 支付业务逻辑
        return new PaymentResult();
    }

    @Override
    public void rollback(DataContext dataContext) {
        // 事务回滚业务逻辑
        log.info("执行支付回滚操作");
    }
}

启动任务编排

java

@Service
public class OrderService {

    @Autowired
    private GobrsAsync gobrsAsync;

    public OrderResult processOrder(String orderId, String userId, boolean useCoupon) {
        // 构建上下文参数
        OrderContext context = new OrderContext();
        context.setOrderId(orderId);
        context.setUserId(userId);
        context.setUseCoupon(useCoupon);

        // 启动任务编排（规则名称与 YAML 中的 name 对应）
        AsyncResult<OrderResult> asyncResult = gobrsAsync.go(
            "order-processing",           // YAML 中配置的规则名称
            () -> context,                // 参数供应器
            10000                         // 整体超时时间（毫秒）
        );

        // 获取执行结果
        return asyncResult.getResult();
    }
}

参数传递两种方式

共享参数（DataContext 模式）

java

OrderContext sharedContext = new OrderContext();
AsyncResult<OrderResult> result = gobrsAsync.go(
    "order-processing", () -> sharedContext, 10000
);

差异化参数

Map<Class<?>, Object> params = new HashMap<>();
params.put(UserInfoTask.class, userParam);
params.put(ProductInfoTask.class, productParam);
params.put(CouponTask.class, couponParam);

AsyncResult<OrderResult> result = gobrsAsync.go(
    "order-processing", () -> params, 10000
);

七、完整运行结果示例

🚀 开始处理订单，订单号: ORDER_001

第一阶段（并行）：
✅ UserInfoTask 完成: 张小明 (VIP 3)
✅ ProductInfoTask 完成: 《高性能编程实战》 ￥129.0
✅ CouponTask 完成: 优惠 15.0 元

第二阶段：
✅ InventoryTask 完成: 剩余库存 850

第三阶段：
✅ OrderCalculationTask 完成: 原价￥129.0 → 最终￥114.0

🎉 订单处理完成，总耗时: 892ms

配置项说明汇总

配置项	类型	说明
`enable`	boolean	全局开关，开启/关闭异步编排引擎
`timeout-core-size`	int	超时监听线程池核心线程数
`rules[].name`	string	规则唯一标识，代码调用时使用
`rules[].content`	string	任务依赖关系表达式
`rules[].task-interrupt`	boolean	局部异常是否打断主流程
`rules[].catchable`	boolean	异常是否原样抛出（不包装）
`rules[].transaction`	boolean	是否开启事务回滚

Gobrs-Async 框架

Gobrs-Async 核心包 com.gobrs.async.core.task 详解：高性能异步任务编排指南

一、Gobrs-Async 框架概览

二、核心类 AsyncTask 详解

2.1 AsyncTask 核心方法

2.2 注解 @Task

三、快速上手

3.1 环境准备与依赖引入

3.2 定义异步任务

3.3 配置任务编排规则

3.4 启动任务编排

四、高级特性与最佳实践

4.1 任务条件执行（nessary 方法）

4.2 任务超时控制

4.3 获取前置任务结果

4.4 灵活的参数传递机制

4.5 多命名空间配置

五、完整示例：电商订单聚合处理

5.1 数据模型定义

5.2 模拟数据任务

5.3 编排配置与执行

5.4 运行结果示例

六、总结

示例

YAML 配置示例

规则内容语法速查

、任务类定义

基础任务示例

依赖结果获取示例

条件执行示例（nessary 方法）

事务回滚配置（可选）

启动任务编排

参数传递两种方式

共享参数（DataContext 模式）

差异化参数

七、完整运行结果示例

配置项说明汇总

Gobrs-Async 核心包 `com.gobrs.async.core.task` 详解：高性能异步任务编排指南