devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

独辟蹊径：我是如何用Java自创一套工作流引擎的（下）_java流程引擎如何设计

作者：IT小白 | 2024-07-19 15:14:51

赞

踩

java流程引擎如何设计

作者：后端小肥肠

创作不易，未经允许严禁转载。

姊妹篇：独辟蹊径：我是如何用Java自创一套工作流引擎的（上）_java工作流引擎-CSDN博客

1. 前言

在上一篇博客中，我们详细介绍了如何利用Java语言从零开始打造一套工作流引擎的基础架构。通过设计核心表结构和实现基础代码框架，我们建立了一个坚实的理论基础。今天，我们迈入《独辟蹊径：我是如何用Java自创一套工作流引擎的（下）》，将深入探讨这一引擎在实际项目中的应用和效果。

2. 项目场景模拟

本章我们将以实际项目场景来模拟自研工作流引擎的使用，分别是申请数据资源的流程和请假申请流程。

2.1. 申请数据资源流程

2.1.1. 技术流程

假设申请数据的审批级数为2级。申请数据资源的流程图如下：

在上述流程图中，从普通用户，一级审批人员，二级审批人员视角呈现了申请数据资源的整体流程；

1. 用户提交审批数据表单，填入申请人信息（姓名、电话），申请理由和需要申请的数资源；

2. 一级审批人员收到用户提交的申请后进行审批，如果驳回则整个流程结束，如果通过则进入下一审批环节；

3. 一级审批通过后二级审批人员可进行审批，如果驳回则整个流程结束，如何通过则开放数据下载链接，用户可根据链接下载申请的数据。

2.2. 请假申请流程

2.2.1. 技术流程

请假流程如下：

在上述流程中，从用户和一级审批人员的角度呈现了整个请假流程：

1. 用户提交审批数据表单，填入申请人信息（姓名、电话）、申请理由、请假天数；

2. 一级审批人员收到用户提交的申请后进行审批，如果驳回则整个流程结束，同时通知用户流程未通过，如果通过则结束流程。

2.3. 技术实现

要在工作流中集成以上两套流程，需要基于一下几个步骤实现：

1. 设计流程定义，在business_approval_workflow新建数据审批流程和请假流程。

2. 设计流程细节，设计数据审批流程和请假流程的节点细节。

上图中，申请业务数据包含两个流程节点，第一个节点审批人为admin，第二个节点审批人为super；请假流程包含一个流程节点，审批人为admin。

3. 编写提交申请接口。

提交申请业务数据流程接口直接使用《独辟蹊径：我是如何用Java自创一套工作流引擎的（上）》中提交申请接口就行：

  1.     public Boolean addRequest(RequestDTO requestDTO) {
  2.         Request request= BeanCopyUtils.copyBean(requestDTO,Request.class);
  3.         request.setStatus("1");//设置整个流程状态为正在审核
  4.         // 1. 插入数据到 request 表
  5.         baseMapper.insert(request);
  6.  
  7.  
  8.         // 2. 根据 workflow_id 查询业务流程的节点信息，找到 serial_number 为 1 的节点,即流程开始时的第一个节点
  9.         BusinessApprovalWorkflowDetail firstNode = workflowDetaiSlService.findFirstNodeByWorkflowId(request.getWorkflowId());
  10.         //获取下一级节点 填充下级节点审批人
  11.         BusinessApprovalWorkflowDetail nextNode=workflowDetaiSlService.getNextNodeByPreNode(firstNode);
  12.  
  13.         if (firstNode != null) {
  14.             // 创建一个 approval_detail 记录示例，需要根据具体情况设置字段值
  15.             ApprovalDetail approvalDetail = new ApprovalDetail();
  16.             approvalDetail.setRequestId(request.getId()); // 假设设置关联的 request_id
  17.             approvalDetail.setApproverUsername(firstNode.getNodeUsername()); // 设置首次节点的审批人用户名
  18.             approvalDetail.setApprovalTime(new Date());
  19.             approvalDetail.setNextApproverUsername(nextNode.getNodeUsername());//设置下游节点的审批人用户名
  20.             approvalDetail.setStatus("1"); // 设置初始状态为待审批
  21.             approvalDetail.setWorkflowId(request.getWorkflowId());
  22.             approvalDetail.setNodeName(firstNode.getNodeName());
  23.             approvalDetail.setNextNodeName(nextNode.getNodeName());
  24.  
  25.             // 插入数据到 approval_detail 表
  26.             approvalDetailService.save(approvalDetail);
  27.         } else {
  28.             // 如果未找到对应的节点，根据实际需求进行错误处理或日志记录
  29.             throw new RuntimeException("Unable to find the first node for workflow id: " + request.getWorkflowId());
  30.         }
  31.         return true;
  32.     }

提交请假流程接口，在编写提交请假流程接口前，需要先明确请假申请表的表结构：

  1. CREATE TABLE "public"."leave_request" (
  2.   "id" varchar(32) COLLATE "pg_catalog"."default" NOT NULL,
  3.   "workflow_id" varchar(32) COLLATE "pg_catalog"."default" NOT NULL,
  4.   "purpose" varchar(900) COLLATE "pg_catalog"."default" NOT NULL,
  5.   "leave_days" int2 NOT NULL,
  6.   "applicant_name" varchar(50) COLLATE "pg_catalog"."default",
  7.   "applicat_username" varchar(50) COLLATE "pg_catalog"."default",
  8.   "applicant_phone" varchar(11) COLLATE "pg_catalog"."default",
  9.   "version" int4 DEFAULT 1,
  10.   "is_deleted" int4 DEFAULT 0,
  11.   "create_time" timestamp(6) NOT NULL,
  12.   "update_time" timestamp(6)
  13. )
  14. ;
  15.  
  16. ALTER TABLE "public"."leave_request" 
  17.   OWNER TO "postgres";
  18.  
  19. COMMENT ON COLUMN "public"."leave_request"."workflow_id" IS '业务流程id';
  20.  
  21. COMMENT ON COLUMN "public"."leave_request"."purpose" IS '请假理由';
  22.  
  23. COMMENT ON COLUMN "public"."leave_request"."leave_days" IS '请假天数';
  24.  
  25. COMMENT ON COLUMN "public"."leave_request"."applicant_name" IS '申请人姓名';
  26.  
  27. COMMENT ON COLUMN "public"."leave_request"."applicat_username" IS '申请人用户名';
  28.  
  29. COMMENT ON COLUMN "public"."leave_request"."applicant_phone" IS '申请人电话';

编写controller层：

  1.     @GetMapping("")
  2.     public Boolean addRequest(@Validated @RequestBody LeaveRequestDTO leaveRequestDTO){
  3.       return leaveRequestService.addRequest(leaveRequestDTO);
  4.     }

编写LeaveRequestDTO：

  1. @Data
  2. @AllArgsConstructor
  3. @NoArgsConstructor
  4. public class LeaveRequestDTO {
  5.     private String workflowId;
  6.     private String purpose;
  7.     private Integer leaveDays;
  8.     private String applicantName;
  9.     private String applicantPhone;
  10.     private String applicatUsername;
  11. }

编写service层：

  1.     public Boolean addRequest(LeaveRequestDTO leaveRequestDTO) {
  2.         LeaveRequest leaveRequest= BeanCopyUtils.copyBean(leaveRequestDTO,LeaveRequest.class);
  3.         // 1. 插入数据到 request 表
  4.         baseMapper.insert(leaveRequest);
  5.         // 2. 根据 workflow_id 查询业务流程的节点信息，找到 serial_number 为 1 的节点,即流程开始时的第一个节点
  6.         BusinessApprovalWorkflowDetail firstNode = workflowDetaiSlService.findFirstNodeByWorkflowId(leaveRequest.getWorkflowId());
  7.         //获取下一级节点 填充下级节点审批人
  8.         BusinessApprovalWorkflowDetail nextNode=workflowDetaiSlService.getNextNodeByPreNode(firstNode);
  9.  
  10.         if (firstNode != null) {
  11.             // 创建一个 approval_detail 记录示例，需要根据具体情况设置字段值
  12.             ApprovalDetail approvalDetail = new ApprovalDetail();
  13.             approvalDetail.setRequestId(leaveRequest.getId()); // 假设设置关联的 request_id
  14.             approvalDetail.setApproverUsername(firstNode.getNodeUsername()); // 设置首次节点的审批人用户名
  15.             approvalDetail.setApprovalTime(new Date());
  16.             approvalDetail.setNextApproverUsername(nextNode.getNodeUsername());//设置下游节点的审批人用户名
  17.             approvalDetail.setStatus("1"); // 设置初始状态为待审批
  18.             approvalDetail.setWorkflowId(leaveRequest.getWorkflowId());
  19.             approvalDetail.setNodeName(firstNode.getNodeName());
  20.             approvalDetail.setNextNodeName(nextNode.getNodeName());
  21.  
  22.             // 插入数据到 approval_detail 表
  23.             approvalDetailService.save(approvalDetail);
  24.         } else {
  25.             // 如果未找到对应的节点，根据实际需求进行错误处理或日志记录
  26.             throw new RuntimeException("Unable to find the first node for workflow id: " + leaveRequest.getWorkflowId());
  27.         }
  28.         return true;
  29.     }

上述代码实现了提交请假申请的功能：首先将从DTO转换后的请假请求数据插入数据库，然后根据流程ID查询流程的第一个节点信息，设置首次节点的审批人并插入到审批详情表中，状态设置为待审批。 

4. 基于策略模式优化审批接口。

审批申请方法在上篇中如下：

  1.  @Transactional
  2.     @Override
  3.     public Boolean approvalApplication(ApprovalDTO approvalDTO) {
  4.         // 这里我写死了，实际获取应该走权限框架获取当前在线用户 username
  5.         String username = "xfc";
  6. //        审批人姓名，从用户表中获取
  7.         String name="小肥肠";
  8.         //查询出当前任务节点
  9.         ApprovalDetail approvalDetail = baseMapper.selectById(approvalDTO.getId());
  10.         //获取当前审批的申请信息
  11.         Request request = requestMapper.selectById(approvalDetail.getRequestId());
  12.         if(request==null){
  13.             throw new RuntimeException("申请id有误");
  14.         }
  15.  
  16.         // 审批通过
  17.         if (approvalDTO.getStatus().equals("2")) {
  18.             // 根据 workflow_id 和 node_name 联查 business_approval_workflow_detail 表，获取当前流程是否为最后节点即 is_final=1
  19.             BusinessApprovalWorkflowDetail currentWorkflowDetail = businessApprovalWorkflowDetailService.findByWorkflowIdAndNodeName(approvalDTO.getWorkflowId(), approvalDetail.getNodeName());
  20.             if (currentWorkflowDetail != null && currentWorkflowDetail.getIsFinal().equals("1")) {
  21.                 // 如果是最后节点，则删除该条数据，填充 approval_history 表，根据 request 表修改 request 数据的 status 为 2
  22.                 baseMapper.deleteById(approvalDetail.getId()); // 删除当前审批记录
  23.                 // 更新 request 表中的状态为 2（通过）
  24.                 request.setStatus("2");
  25.                 requestMapper.updateById(request);
  26.  
  27.             } else {
  28.                 // 如果不是最后节点，则更新 business_approval_workflow_detail 为下一个节点审批信息
  29.                 BusinessApprovalWorkflowDetail nextNode = businessApprovalWorkflowDetailService.getNextNodeByPreNode(currentWorkflowDetail);
  30. //                获取下一级节点的更下一级
  31.                 BusinessApprovalWorkflowDetail nextNextNode= businessApprovalWorkflowDetailService.getNextNodeByPreNode(nextNode);
  32.                 // 更新当前 approval_detail 表中的审批人和下一个审批人信息
  33.                 approvalDetail.setApproverUsername(nextNode.getNodeUsername());
  34.                 approvalDetail.setNodeName(nextNextNode.getNodeName());
  35.                 approvalDetail.setNextApproverUsername(nextNextNode!=null?nextNextNode.getNodeUsername():"");
  36.                 approvalDetail.setNextNodeName(nextNextNode!=null?nextNextNode.getNodeName():"");
  37.                 approvalDetail.setApprovalTime(new Date());
  38.                 approvalDetail.setStatus("1"); // 设置为待审批状态
  39.                 baseMapper.updateById(approvalDetail);
  40.  
  41.             }
  42.             // 填充 approval_history 表
  43.             ApprovalHistory approvalHistory = new ApprovalHistory();
  44.             approvalHistory.setRequestId(request.getId());
  45.             approvalHistory.setApproverName(name); // 设置审批人姓名，或者从用户表中获取
  46.             approvalHistory.setApprovalTime(new Date());
  47.             approvalHistory.setStatus("2"); // 通过
  48.             approvalHistory.setRemark(approvalDTO.getRemark());
  49.             approvalHistory.setWorkflowId(approvalDTO.getWorkflowId());
  50.             approvalHistory.setApplicantPhone(request.getApplicantPhone());
  51.             approvalHistory.setPurpose(request.getPurpose());
  52.             approvalHistory.setApplicantName(request.getApplicantName());
  53.             approvalHistory.setApproverUsername(username); // 设置审批人用户名，或者从用户表中获取
  54.             approvalHistoryMapper.insert(approvalHistory); // 插入审批历史记录
  55.         } else if (approvalDTO.getStatus().equals("3")) {
  56.             // 审批驳回
  57.             baseMapper.deleteById(approvalDetail.getId()); // 删除当前审批记录
  58.  
  59.             // 填充 approval_history 表
  60.             ApprovalHistory approvalHistory = new ApprovalHistory();
  61.             approvalHistory.setRequestId(request.getId());
  62.             approvalHistory.setApproverName(name); // 设置审批人姓名，或者从用户表中获取
  63.             approvalHistory.setApprovalTime(new Date());
  64.             approvalHistory.setStatus("3"); // 驳回
  65.             approvalHistory.setRemark(approvalDTO.getRemark());
  66.             approvalHistory.setWorkflowId(approvalDTO.getWorkflowId());
  67.             approvalHistory.setApplicantPhone(request.getApplicantPhone());
  68.             approvalHistory.setPurpose(request.getPurpose());
  69.             approvalHistory.setApplicantName(request.getApplicantName());
  70.             approvalHistory.setApproverUsername(username); // 设置审批人用户名，或者从用户表中获取
  71.             approvalHistoryMapper.insert(approvalHistory); // 插入审批历史记录
  72.  
  73.             // 更新 request 表中的状态为 3（驳回）
  74.                 request.setStatus("3");
  75.             requestMapper.updateById(request);
  76.  
  77.         }
  78.         return true; // 或者根据实际需求返回其他业务逻辑
  79.     }

上述代码其实是针对申请数据资源流程的审批操作，那如果要申请别的流程该怎么做呢？常规操作应该是在上述代码中增加if-else判断操作，根据不通业务进行士审批操作，但是随着业务流程增加，就会新增许多if-else操作，代码会十分雍总，代码可读性较差，可以通过引入策略工厂来解决上述问题。步骤如下：

1.新增审批策略工厂

  1. @Service
  2. public class ApprovalFactory {
  3.     @Autowired
  4.     ApprovalDataRequestService approvalDataRequestService;
  5.     @Autowired
  6.     ApprovalLeaveRequestService approvalLeaveRequestService;
  7.     private static Map<String, Function<ApprovalDTO,Boolean>> approvalMap = null;
  8.     @PostConstruct
  9.     public void init(){
  10.         approvalMap=new HashMap<>();
  11.         approvalMap.put("2",approvalDTO->approvalDataRequestService.approvalApplication(approvalDTO));
  12.         approvalMap.put("1",approvalDTO ->approvalLeaveRequestService.approvalApplication(approvalDTO));
  13.     }
  14.  
  15.     public Boolean approvalApplication(ApprovalDTO approvalDTO) {
  16.        return approvalMap.get(approvalDTO.getWorkflowId()).apply(approvalDTO);
  17.     }
  18. }

上述代码为针对审批操作的策略工厂，在类初始化过程中（使用 @PostConstruct 注解的 init() 方法），通过静态的 approvalMap 对象将审批动作和对应的处理函数关联起来。具体来说：

  • 当 workflowId 为 "2" 时，映射到 approvalDataRequestService 的 approvalApplication 方法处理数据请求的审批逻辑。
  • 当 workflowId 为 "1" 时，映射到 approvalLeaveRequestService 的 approvalApplication 方法处理请假请求的审批逻辑。

最后，approvalApplication(ApprovalDTO approvalDTO) 方法根据传入的 approvalDTO 中的 workflowId 从 approvalMap 中获取相应的处理函数，并执行该函数来完成审批操作，返回处理结果，controller层直接调用策略工厂即可：

  1.     @PostMapping("/approval")
  2.     public Boolean approvalApplication(@Validated @RequestBody ApprovalDTO approvalDTO) {
  3.         return approvalFactory.approvalApplication(approvalDTO);
  4.     }

2. 新增数据资源审批类

  1. @Service
  2. @Slf4j
  3. public class ApprovalDataRequestService {
  4.     @Autowired
  5.     IBusinessApprovalWorkflowDetailService businessApprovalWorkflowDetailService;
  6.     @Autowired
  7.     RequestMapper requestMapper;
  8.     @Autowired
  9.     ApprovalHistoryMapper approvalHistoryMapper;
  10.     @Autowired
  11.     ApprovalDetailMapper approvalDetailMapper;
  12.  
  13.     @Transactional
  14.     public Boolean approvalApplication(ApprovalDTO approvalDTO) {
  15.         // 这里我写死了，实际获取应该走权限框架获取当前在线用户 username
  16.         String username = "xfc";
  17. //        审批人姓名，从用户表中获取
  18.         String name="小肥肠";
  19.         //查询出当前任务节点
  20.         ApprovalDetail approvalDetail = approvalDetailMapper.selectById(approvalDTO.getId());
  21.         //获取当前审批的申请信息
  22.         Request request = requestMapper.selectById(approvalDetail.getRequestId());
  23.         if(request==null){
  24.             throw new RuntimeException("申请id有误");
  25.         }
  26.  
  27.         // 审批通过
  28.         if (approvalDTO.getStatus().equals("2")) {
  29.             // 根据 workflow_id 和 node_name 联查 business_approval_workflow_detail 表，获取当前流程是否为最后节点即 is_final=1
  30.             BusinessApprovalWorkflowDetail currentWorkflowDetail = businessApprovalWorkflowDetailService.findByWorkflowIdAndNodeName(approvalDTO.getWorkflowId(), approvalDetail.getNodeName());
  31.             if (currentWorkflowDetail != null && currentWorkflowDetail.getIsFinal().equals("1")) {
  32.                 // 如果是最后节点，则删除该条数据，填充 approval_history 表，根据 request 表修改 request 数据的 status 为 2
  33.                 approvalDetailMapper.deleteById(approvalDetail.getId()); // 删除当前审批记录
  34.                 // 更新 request 表中的状态为 2（通过）
  35.                 request.setStatus("2");
  36.                 requestMapper.updateById(request);
  37.  
  38.             } else {
  39.                 // 如果不是最后节点，则更新 business_approval_workflow_detail 为下一个节点审批信息
  40.                 BusinessApprovalWorkflowDetail nextNode = businessApprovalWorkflowDetailService.getNextNodeByPreNode(currentWorkflowDetail);
  41. //                获取下一级节点的更下一级
  42.                 BusinessApprovalWorkflowDetail nextNextNode= businessApprovalWorkflowDetailService.getNextNodeByPreNode(nextNode);
  43.                 // 更新当前 approval_detail 表中的审批人和下一个审批人信息
  44.                 approvalDetail.setApproverUsername(nextNode.getNodeUsername());
  45.                 approvalDetail.setNodeName(nextNextNode.getNodeName());
  46.                 approvalDetail.setNextApproverUsername(nextNextNode!=null?nextNextNode.getNodeUsername():"");
  47.                 approvalDetail.setNextNodeName(nextNextNode!=null?nextNextNode.getNodeName():"");
  48.                 approvalDetail.setApprovalTime(new Date());
  49.                 approvalDetail.setStatus("1"); // 设置为待审批状态
  50.                 approvalDetailMapper.updateById(approvalDetail);
  51.  
  52.             }
  53.             // 填充 approval_history 表
  54.             ApprovalHistory approvalHistory = new ApprovalHistory();
  55.             approvalHistory.setRequestId(request.getId());
  56.             approvalHistory.setApproverName(name); // 设置审批人姓名，或者从用户表中获取
  57.             approvalHistory.setApprovalTime(new Date());
  58.             approvalHistory.setStatus("2"); // 通过
  59.             approvalHistory.setRemark(approvalDTO.getRemark());
  60.             approvalHistory.setWorkflowId(approvalDTO.getWorkflowId());
  61.             approvalHistory.setApplicantPhone(request.getApplicantPhone());
  62.             approvalHistory.setPurpose(request.getPurpose());
  63.             approvalHistory.setApplicantName(request.getApplicantName());
  64.             approvalHistory.setApproverUsername(username); // 设置审批人用户名，或者从用户表中获取
  65.             approvalHistoryMapper.insert(approvalHistory); // 插入审批历史记录
  66.         } else if (approvalDTO.getStatus().equals("3")) {
  67.             // 审批驳回
  68.             approvalDetailMapper.deleteById(approvalDetail.getId()); // 删除当前审批记录
  69.  
  70.             // 填充 approval_history 表
  71.             ApprovalHistory approvalHistory = new ApprovalHistory();
  72.             approvalHistory.setRequestId(request.getId());
  73.             approvalHistory.setApproverName(name); // 设置审批人姓名，或者从用户表中获取
  74.             approvalHistory.setApprovalTime(new Date());
  75.             approvalHistory.setStatus("3"); // 驳回
  76.             approvalHistory.setRemark(approvalDTO.getRemark());
  77.             approvalHistory.setWorkflowId(approvalDTO.getWorkflowId());
  78.             approvalHistory.setApplicantPhone(request.getApplicantPhone());
  79.             approvalHistory.setPurpose(request.getPurpose());
  80.             approvalHistory.setApplicantName(request.getApplicantName());
  81.             approvalHistory.setApproverUsername(username); // 设置审批人用户名，或者从用户表中获取
  82.             approvalHistoryMapper.insert(approvalHistory); // 插入审批历史记录
  83.  
  84.             // 更新 request 表中的状态为 3（驳回）
  85.             request.setStatus("3");
  86.             requestMapper.updateById(request);
  87.  
  88.         }
  89.         return true; // 或者根据实际需求返回其他业务逻辑
  90.     }
  91.  
  92.  
  93. }

3.新增请假审批类

  1. @Service
  2. public class ApprovalLeaveRequestService {
  3.     public Boolean approvalApplication(ApprovalDTO approvalDTO) {
  4.         /**
  5.          * 一样的逻辑，把对request表的操作改为leave_request
  6.          */
  7.         return true;
  8.     }
  9. }

3. 结语

在本文中，针对《独辟蹊径：我是如何用Java自创一套工作流引擎的（上）》中的工作流基础代码进行了结合实际项目的扩展，本工作流引擎适用于任何相对简单的审批场景，有新的业务流程仅需针对申请表单和审批逻辑进行接口新增和策略工厂扩展即可，如本文对你有帮助请一键三连哦~

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/852170
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号