public interface Execution<R> {
    R execute(ExecutionContext context) throws Exception;
}

public class ExecutionContext {
    // 用 ThreadLocal 存儲(chǔ)當(dāng)前上下文
    private static final ThreadLocal<ExecutionContext> CONTEXT_HOLDER =
        ThreadLocal.withInitial(ExecutionContext::new);

    private String requestId;   // 鏈路跟蹤用的請(qǐng)求ID
    private String operator;    // 操作人，用于審計(jì)
    private Map<String, Object> attributes = new HashMap<>();  // 業(yè)務(wù)參數(shù)

    /** 獲取當(dāng)前上下文 */
    public static ExecutionContext current() {
        return CONTEXT_HOLDER.get();
    }

    /** 設(shè)置上下文 */
    public static void set(ExecutionContext context) {
        CONTEXT_HOLDER.set(context);
    }

    /** 清理上下文 */
    public static void clear() {
        CONTEXT_HOLDER.remove();
    }

    // getter/setter 省略
}

@RestController
public class OrderController {

    @PostMapping("/order")
    public String createOrder(@RequestBody Order order) {
        // 1. 構(gòu)建上下文
        ExecutionContext context = new ExecutionContext();
        context.setRequestId(UUID.randomUUID().toString()); // 生成或從請(qǐng)求頭獲取
        context.setOperator("currentUser"); // 從登錄信息獲取
        context.getAttributes().put("order", order);

        // 2. 綁定到當(dāng)前線程
        ExecutionContext.set(context);

        try {
            // 3. 提交業(yè)務(wù)執(zhí)行（同步/異步由引擎決定）
            ExecutionResult<Boolean> result = executorEngine.submit(ctx -> {
                Order orderFromCtx = ctx.getAttribute("order");
                orderService.createOrder(orderFromCtx);
                return true;
            });
            return "success";
        } finally {
            // 4. 請(qǐng)求結(jié)束清理上下文，避免內(nèi)存泄漏
            ExecutionContext.clear();
        }
    }
}

public interface ExecutorEngine {
    <R> ExecutionResult<R> submit(Execution<R> execution);
}

public class SyncExecutorEngine implements ExecutorEngine {
    @Override
    public <R> ExecutionResult<R> submit(Execution<R> execution) {
        try {
            R result = execution.execute(ExecutionContext.current());
            return ExecutionResult.success(result);
        } catch (Exception e) {
            return ExecutionResult.failure(e);
        }
    }
}

public class AsyncExecutorEngine implements ExecutorEngine {
    private final Executor executor;

    public AsyncExecutorEngine(Executor executor) {
        this.executor = executor;
    }

    @Override
    public <R> ExecutionResult<R> submit(Execution<R> execution) {
        // 捕獲當(dāng)前線程上下文并傳遞到異步線程
        ExecutionContext currentCtx = ExecutionContext.current();
        CompletableFuture<R> future = CompletableFuture.supplyAsync(() -> {
            try {
                ExecutionContext.set(currentCtx);
                return execution.execute(ExecutionContext.current());
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                // 清理上下文避免內(nèi)存泄漏
                ExecutionContext.clear();
            }
        }, executor);
        return ExecutionResult.async(future);
    }
}

// 原來(lái)的同步/異步代碼無(wú)需再維護(hù)兩套
executorEngine.submit(ctx -> {
    Order order = ctx.getAttribute("order");
    orderService.createOrder(order);
    return true;
});