使用LiteFlow实现阻塞审批工作流

news2025/3/14 23:29:07

在 LiteFlow 中实现阻塞的审批工作流，你可以使用异步处理与同步逻辑结合，实现节点的等待

使用 LiteFlow 实现阻塞审批工作流

下面是如何实现一个带有阻塞审批功能的 LiteFlow 工作流示例。

1. 引入依赖

确保您的 pom.xml 文件中已引入 LiteFlow 和 Spring Boot 的相关依赖：

<dependency>
    <groupId>com.yomahub</groupId>
    <artifactId>liteflow-spring-boot-starter</artifactId>
    <version>2.13.0</version> <!-- 请根据需要调整版本 -->
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.6.0</version> <!-- 请根据需要调整版本 -->
</dependency>

2. 创建工作流节点

在审批节点中，我们可以使用 Java 的 CountDownLatch 或 BlockingQueue 来实现阻塞，模拟等待用户审批的过程。

import com.yomahub.liteflow.core.NodeComponent;
import java.util.concurrent.CountDownLatch;

public class ApprovalNode extends NodeComponent {
    
    // 创建一个 CountDownLatch，用于阻塞
    private static final CountDownLatch latch = new CountDownLatch(1);

    @Override
    public void process() {
        System.out.println("正在等待审批...");
        try {
            // 在这里模拟一个阻塞操作，例如等待用户的审批
            latch.await(); // 阻塞等待，直到 latch.countDown() 被调用
            System.out.println("审批通过，继续处理");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 重置中断状态
            System.out.println("审批被中断");
        }
    }

    // 模拟审批通过的方法，可以在外部调用
    public static void approve() {
        latch.countDown(); // 释放阻塞
    }
}

public class NotifyNode extends NodeComponent {
    @Override
    public void process() {
        System.out.println("通知节点处理逻辑");
    }
}

public class FinalNode extends NodeComponent {
    @Override
    public void process() {
        System.out.println("最终处理节点逻辑");
    }
}

3. 配置工作流

在 src/main/resources 目录下创建一个 liteflow.xml 文件，内容如下：

<liteflow>
    <chain id="approvalChain">
    	THEN(approvalNode, notifyNode, finalNode);
    </chain>
</liteflow>

4. 控制器实现审批

我们可以通过 Spring Controller 来模拟用户审批。在这里，我们提供一个 REST API 用于批准审批。

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ApprovalController {

    @GetMapping("/approve")
    public String approve() {
        ApprovalNode.approve(); // 调用静态方法释放阻塞
        return "审批已通过";
    }
}

5. 主程序

使用 Spring Boot 启动应用程序并执行工作流。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import com.yomahub.liteflow.core.FlowExecutor;

import javax.annotation.Resource;

@SpringBootApplication
public class LiteFlowDemoApplication {

    @Resource
    private FlowExecutor flowExecutor;

    public static void main(String[] args) {
        SpringApplication.run(LiteFlowDemoApplication.class, args);
    }

    @PostConstruct
    public void runFlow() {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            try {
                flowExecutor.execute("approvalChain");
            } catch (InterruptedException e) {
            	Thread.currentThread().interrupt(); // 恢复中断状态
                System.err.println("Task was interrupted.");
            } catch (Exception e) {
            	System.out.println("工作流执行出错: " + e.getMessage());
            }
        }); // 在新线程中启动工作流
        
        //可以在这里处理 future 的结果或异常
        future.exceptionally(ex -> {
            System.err.println("异步任务执行失败: " + ex.getMessage());
            return null;
        });
    }
    
}