如果要实现一个如下图所示的 审批 流程，如果是我们自己手动实现该如何做？
image.png
首先说下支持的功能需求：

  1. 审批人员可以是无限数量的
  2. 只能是一人一级一级的审批，不能多个人在同一级审批

下面来说说核心代码

创建审批单

注意：这个审批单仅仅是一个通用的承载审批流程的数据，并不是业务上的审批单（如：请假单，里面包含请假的数据），关于这种审批的数据，需要自己根据业务需求来关联这里的 审批单

审批流程定义数据结构：

  1. @Data
  2. @ToString
  3. public class ApprovalProcessDefine {
  4.     /**
  5.      * 数据类型
  6.      */
  7.     private ApprovalDataType dataType;
  9.     /**
  10.      * 目前仅支持按系统账户
  11.      */
  12.     private List<Integer> accounts;
  13. }
  • 数据类型：这个审批单可以支持很多中数据类型，比如请假、报销 之类的
  • accounts：这里定义为一个 list，那么整个审批流程就是按照这个顺序 一级一级的审批

这里实现是从配置文件读取的，你完全可以做成可配置的，或则数据更丰富的。

审批流程节点：

  1. @Data
  2. @ToString
  3. public class ApprovalProcessNode {
  4.     // 节点顺序，等同于数组的索引+1
  5.     private Integer node;
  6.     // 该节点需要这个指定的 账户才能审批
  7.     private Integer accountId;
  8.     // 账户名称
  9.     private String accountName;
  10. }
  • 账户信息：这个好理解，就是展示当前是哪一个人进行审批的信息
  • node：这个简单说，就是当前这个审批人是在第几个 节点 进行审批，他可以用来计算下一个节点该谁审批

审批单实体定义：

  2. @Table(name = "`approval`")
  3. public class Approval {    
  4.     /**
  5.      * 创建人ID
  6.      */
  7.     @Column(name = "created_by_id")
  8.     private Integer createdById;
  10.     /**
  11.      * 创建人
  12.      */
  13.     @Column(name = "created_by")
  14.     private String createdBy;
  16.     /**
  17.      * 创建时间
  18.      */
  19.     @Column(name = "created_time")
  20.     private Date createdTime;
  22.     /**
  23.      * 更新人ID
  24.      */
  25.     @Column(name = "updated_by_id")
  26.     private Integer updatedById;
  28.     /**
  29.      * 更新人
  30.      */
  31.     @Column(name = "updated_by")
  32.     private String updatedBy;
  34.     /**
  35.      * 更新时间
  36.      */
  37.     @Column(name = "updated_time")
  38.     private Date updatedTime;
  40.     /**
  41.      * 数据类型，请自定义
  42.      */
  43.     @Column(name = "data_type")
  44.     private Byte dataType;
  46.     /**
  47.      * 根据类型来的 id
  48.      */
  49.     @Column(name = "data_id")
  50.     private Integer dataId;
  52.     /**
  53.      * 审核状态: 0 刚创建，1 审批中，2 拒绝，3通过
  54.      */
  55.     private Byte status;
  57.     /**
  58.      * 状态改变时间
  59.      */
  60.     @Column(name = "status_change_time")
  61.     private Date statusChangeTime;
  63.     /**
  64.      * 节点审批状态
  65.      */
  66.     @Column(name = "node_status")
  67.     private Byte nodeStatus;
  69.     /**
  70.      * 节点状态改变时间
  71.      */
  72.     @Column(name = "node_status_change_time")
  73.     private Date nodeStatusChangeTime;
  75.     /**
  76.      * 当前待审批人ID；表示当前需要该账户进行审批
  77.      */
  78.     @Column(name = "pending_by_id")
  79.     private Integer pendingById;
  81.     /**
  82.      * 审批人
  83.      */
  84.     @Column(name = "pending_by")
  85.     private String pendingBy;
  87.     /**
  88.      * 审批流程经过的最大节点数量，即需要审批多少次才算最终通过，只支持单节点审批
  89.      */
  90.     @Column(name = "process_node_max")
  91.     private Integer processNodeMax;
  93.     /**
  94.      * 审批流程已经经过的节点数量，也就是当前节点是多少，满足 max=current 则审批通过
  95.      */
  96.     @Column(name = "process_node_current")
  97.     private Integer processNodeCurrent;
  99.     /**
  100.      * 是否删除
  101.      */
  102.     @Column(name = "is_deleted")
  103.     private Boolean isDeleted;
  105.     /**
  106.      * 审批流程定义，当前审批需要哪些账户参与
  107.      */
  108.     @Column(name = "process_define_json")
  109.     private String processDefineJson;
  111.     /**
  112.      * 审批额外字段
  113.      */
  114.     private String extend;
  115. }

创建审批单：

  1.  public Long create(ApprovalDataType dataType, Integer dataId, String extend, UserInfo userInfo) {
  2.         /*
  3.             1. 根据数据类型，获取该审批单的审批人员定义
  4.             2. 根据定义构建审批进度节点
  5.             3. 创建审批单
  6.             4. 发送审批单创建事件
  7.          */
  8.          // 获得这个审批单的 审批流程定义
  9.         final ApprovalProcessDefine processDefine = approvalConfig.getProcessDefine(dataType);
  10.         // 转换为人员审批节点
  11.         final List<ApprovalProcessNode> processNodes = buildProcessNodes(processDefine.getAccounts());
  12.         if (CollectionUtil.isEmpty(processNodes)) {
  13.             throwErr(StrUtil.format("提供的审批流程定义为空"));
  14.         }
  16.         // 创建审批单相关信息
  17.         final Approval record = new Approval();
  18.         record.setDataType(dataType.getValue());
  19.         record.setDataId(dataId);
  20.         record.setStatus(ApprovalStatus.APPROVAL_ING.getValue());
  21.         final Date now = new Date();
  22.         record.setStatusChangeTime(now);
  23.         record.setNodeStatus(ApprovalStatus.APPROVAL_ING.getValue());
  24.         record.setNodeStatusChangeTime(now);
  27.         // 获取第一个审批人信息, 转换的 人员审批节点 第一个就是需要该人员审批
  28.         final ApprovalProcessNode processNode = processNodes.get(0);
  29.         record.setPendingBy(processNode.getAccountName());
  30.         record.setPendingById(processNode.getAccountId());
  31.         record.setProcessDefineJson(JSON.toJSONString(processNodes));
  32.         record.setProcessNodeCurrent(processNode.getNode()); // 当前审批节点顺序
  33.         record.setProcessNodeMax(processNodes.size()); // 计算最大审批节点数量
  35.         record.setCreatedBy(userInfo.getName());
  36.         record.setCreatedById(userInfo.getId());
  37.         record.setCreatedTime(now);
  39.         approvalMapper.insertSelective(record);
  41.         final Long id = record.getId();
  42.         approvalEventPublisher.publishCreateEvent(id, dataType, dataId);
  43.         return id;
  44.     }

构建审批人员节点：

  1.     /**
  2.      * 构建审批流程节点，并且按照给定的顺序返回
  3.      *
  4.      * @param accountIds
  5.      * @return
  6.      */
  7.     private List<ApprovalProcessNode> buildProcessNodes(List<Integer> accountIds) {
  8.         if (CollectionUtil.isEmpty(accountIds)) {
  9.             return null;
  10.         }
  11.         // 从账户信息中获取 账户名称
  12.         final List<Account> accounts = accountService.listById(accountIds);
  13.         // 结果和查询的不一致
  14.         if (accountIds.size() != accounts.size()) {
  15.             final List<Integer> tempAccountIds = new ArrayList<>(accountIds);
  16.             final List<Integer> targetAccountIds = accounts.stream().map(Account::getId).collect(Collectors.toList());
  17.             tempAccountIds.removeAll(targetAccountIds);
  18.             throwErr("审批流程中的审批人已经不存在：" + tempAccountIds);
  19.         }
  21.         final Map<Integer, Account> accountMap = accounts.stream().collect(Collectors.toMap(Account::getId, Function.identity()));
  23.         List<ApprovalProcessNode> nodes = new ArrayList<>(accountIds.size());
  24.         for (int i = 0; i < accountIds.size(); i++) {
  25.             ApprovalProcessNode node = new ApprovalProcessNode();
  26.             node.setNode(i + 1); // 重要的是这里的 node 是 索引 +1
  27.             final Account account = accountMap.get(accountIds.get(i));
  28.             node.setAccountId(account.getId());
  29.             node.setAccountName(account.getName());
  30.             nodes.add(node);
  31.         }
  32.         return nodes;
  33.     }

审批单审核操作

审批单审核核心需要做的事情就是：判定当次审批结果，根据审批结果决定是 审批结束 还是 下一个审批人继续审批？
审批人意见：

  1. @Data
  2. @ToString
  3. @NoArgsConstructor
  4. public class ApprovalOpinion {
  5.     /**
  6.      * 审批人
  7.      */
  8.     private Integer pendingById;
  9.     /**
  10.      * 审批人
  11.      */
  12.     private String pendingBy;
  13.     /**
  14.      * 审批是否通过
  15.      */
  16.     private Boolean pass;
  17.     /**
  18.      * 审批意见
  19.      */
  20.     private String opinion;
  22.     public ApprovalOpinion(Integer pendingById, String pendingBy, Boolean pass, String opinion) {
  23.         this.pendingById = pendingById;
  24.         this.pendingBy = pendingBy;
  25.         this.pass = pass;
  26.         this.opinion = opinion;
  27.     }
  28. }

审批核心操作：

  1.      /**
  2.      * @param approval        当前审批单
  3.      * @param approvalOpinion 审批人与审批意见
  4.      * @param finish          当前的审批是否已经完成(中间节点的审批不会回调)，如果有值则根据状态判定 整个审批流程 是通过还是拒绝
  5.      *                          java.util.function.Consumer
  6.      */
  7.     @Override
  8.     @Transactional(propagation = Propagation.REQUIRED)
  9.     public void doApproval(Approval approval, ApprovalOpinion approvalOpinion, Consumer<ApprovalStatus> finish) {
  10.         ApprovalStatus approvalStatus = approvalOpinion.getPass() ? ApprovalStatus.APPROVAL_PASS : ApprovalStatus.APPROVAL_REJECT;
  12.         final Long approvalId = approval.getId();
  13.         // 当次审核通过
  14.         if (ApprovalStatus.APPROVAL_PASS == approvalStatus) {
  15.             final Approval record = new Approval();
  16.             record.setId(approvalId);
  17.             record.setNodeStatus(approvalStatus.getValue());
  18.             record.setNodeStatusChangeTime(new Date());
  19.             // 需要判断当前审批是否已经完成,如果已经完成，则整个审批流程已经完成
  20.             //   如果整个审批流程还未结束，则计算下一个审批节点的相关信息
  21.             final Integer processNodeMax = approval.getProcessNodeMax();
  22.             final Integer processNodeCurrent = approval.getProcessNodeCurrent();
  23.             // 审批单当前的审批顺序 + 1 如果 小于等于 流程的最大节点，则说明还有下一个审批人
  24.             if (processNodeCurrent + 1 <= processNodeMax) {
  25.                 // 还未结束，需要下一个审批节点
  26.                 // 解析流程定义，流程定义从创建的时候，就需要存储在审批单上，因为一般 流程定义都是可以修改的
  27.                 // 但是修改流程定义，不能影响已经正在使用的审批
  28.                 final List<ApprovalProcessNode> approvalProcessNodes = parseProcessDefineJson(approval.getProcessDefineJson());
  29.                 // 由于这个 node 记录的是索引 +1，所以这里直接获取，就是下一个审批人节点信息
  30.                 final ApprovalProcessNode nextApprovalProcessNode = approvalProcessNodes.get(processNodeCurrent);
  31.                 // 换下一个审批人
  32.                 record.setProcessNodeCurrent(nextApprovalProcessNode.getNode());
  33.                 record.setPendingById(nextApprovalProcessNode.getAccountId());
  34.                 record.setPendingBy(nextApprovalProcessNode.getAccountName());
  35.                 // 换下一个人，要重置审批结果为待审批
  36.                 record.setNodeStatus(ApprovalStatus.APPROVAL_ING.getValue());
  37.                 approvalMapper.updateByPrimaryKeySelective(record);
  38.                 // 添加审批记录操作，每个审批人 操作一次，就会有一条审批记录
  39.                 approvalRecordService.add(approvalId, processNodeCurrent, approvalOpinion);
  40.                 // 发送审批事件：业务方，可以通过监听此事件，完成 发送邮件 或则 订单消息之类的通知到当前审批人
  41.                  /**
  42.                  * @param approvalId     审批单 ID
  43.                  * @param dataType       数据类型
  44.                  * @param dataId         数据类型原始 ID
  45.                  * @param isFinall       是否是最终结果
  46.                  * @param approvalStatus 最终结果才会有值
  47.                  */
  48.                 approvalEventPublisher.publishApprovalEvent(approvalId, ApprovalDataType.valueOf(approval.getDataType()), approval.getDataId(), false, null);
  49.             } else {
  50.                 // 如果已经结束，则整个审批流程通过
  51.                 record.setStatus(approvalStatus.getValue());
  52.                 record.setStatusChangeTime(new Date());
  53.                 approvalMapper.updateByPrimaryKeySelective(record);
  54.                 // 整个审批流程结束，则回调业务方，业务方可以更改自己的数据
  55.                 finish.accept(approvalStatus);
  56.                 approvalEventPublisher.publishApprovalEvent(approvalId, ApprovalDataType.valueOf(approval.getDataType()), approval.getDataId(), true, approvalStatus);
  57.                 approvalRecordService.add(approvalId, processNodeCurrent, approvalOpinion);
  58.             }
  59.         } else {
  60.             // 被拒绝：则整个流程结束
  61.             final Approval record = new Approval();
  62.             record.setId(approvalId);
  63.             record.setNodeStatusChangeTime(new Date());
  64.             record.setNodeStatus(approvalStatus.getValue());
  65.             record.setStatus(approvalStatus.getValue());
  66.             record.setStatusChangeTime(new Date());
  67.             approvalMapper.updateByPrimaryKeySelective(record);
  68.             finish.accept(approvalStatus);
  70.             approvalRecordService.add(approvalId, approval.getProcessNodeCurrent(), approvalOpinion);
  71.             approvalEventPublisher.publishApprovalEvent(approvalId, ApprovalDataType.valueOf(approval.getDataType()), approval.getDataId(), true, approvalStatus);
  72.         }
  73.     }

业务方调用审核操作示例

  1. @ConditionalOnBean
  2.     @Override
  3.     @Transactional(propagation = Propagation.REQUIRED)
  4.     public void approval(Integer id, PerformanceApprovalRequest params, UserInfo userInfo) {
  5.         /*
  6.           审批要做的事情
  7.           1. 检查状态
  8.           2. 检查当前操作人是否是 审批者
  9.           3. 处理
  10.          */
  11.         final Performance performance = getId(id);
  12.         final Long approvalId = performance.getApprovalId();
  14.         final Approval approval = approvalService.getById(approvalId);
  15.         if (approval == null) {
  16.             throwErr("该审批已失效");
  17.         }
  18.         final ApprovalStatus status = ApprovalStatus.valueOf(approval.getStatus());
  19.         if (ApprovalStatus.APPROVAL_ING != status) {
  20.             throwErr("状态异常：当前审批状态不在审批中");
  21.         }
  23.         final Integer pendingById = approval.getPendingById();
  24.         if (pendingById != userInfo.getId()) {
  25.             throwErr(StrUtil.format("审批人异常：您不是当前审批人，当前审批人为 {} [id={}]", approval.getPendingBy(), approval.getPendingById()));
  26.         }
  29.         // 处理审批
  30.         final ApprovalOpinion approvalOpinion = new ApprovalOpinion(userInfo.getId(), userInfo.getName(), params.getIsPass(), params.getOpinion());
  31.         approvalService.doApproval(approval,
  32.                 approvalOpinion,
  33.                 finishStatus -> {
  34.                     // 审批有最终结果，就改变业务审批单的状态
  35.                     if (ApprovalStatus.APPROVAL_PASS == finishStatus) {
  36.                         this.changeApprovalStatus(id, finishStatus, userInfo);
  37.                     } else {
  38.                         this.changeApprovalStatus(id, finishStatus, userInfo);
  39.                     }
  40.                 });
  41.     }

如何获取 UI 上的审批流程数据？

上面有了 审批单信息、审批操作处理，那么如何构建 UI 展示的数据信息呢？这里其实也是一个小难点

  1.   /**
  2.      * 转换审批单流程节点信息
  3.      *
  4.      * @param approval
  5.      * @return
  6.      */
  7.     private List<ApprovalProcessNodeDetail> convertProcessNodeDetail(Approval approval) {
  8.         // 从审批单获取流程定义
  9.         final String processDefineJson = approval.getProcessDefineJson();
  10.         final List<ApprovalProcessNode> approvalProcessNodes = parseProcessDefineJson(processDefineJson);
  11.         final int processNodeCurrent = approval.getProcessNodeCurrent();
  13.         // 获取到审批记录，填充审批记录信息
  14.         List<ApprovalRecord> records = approvalRecordService.listByApprovalId(approval.getId());
  15.         final Map<Integer, ApprovalRecord> recordMap = records.stream().collect(Collectors.toMap(ApprovalRecord::getProcessNodeCurrent, Function.identity()));
  17.         List<ApprovalProcessNodeDetail> list = new ArrayList<>(approvalProcessNodes.size());
  18.         // 循环审批流程定义，然后填充 审批记录信息：比如审批意见
  19.         for (ApprovalProcessNode approvalProcessNode : approvalProcessNodes) {
  20.             final Integer node = approvalProcessNode.getNode();
  21.             final ApprovalProcessNodeDetail nodeDetail = new ApprovalProcessNodeDetail();
  22.             nodeDetail.setNode(node);
  23.             nodeDetail.setAccountId(approvalProcessNode.getAccountId());
  24.             nodeDetail.setAccountName(approvalProcessNode.getAccountName());
  26.             final ApprovalRecord record = recordMap.get(node);
  27.             // 如果已经有对应的审批记录，则使用审批记录中的相关信息
  28.             // 如果没有，留空即可
  29.             if (record != null) {
  30.                 nodeDetail.setStatus(record.getNodeStatus());
  31.                 nodeDetail.setStatusChangeTime(record.getNodeStatusChangeTime());
  32.                 nodeDetail.setAccountName(record.getPendingBy());
  33.                 nodeDetail.setOpinion(record.getOpinion());
  34.                 list.add(nodeDetail);
  35.                 continue;
  36.             }
  37.             // 已通过，因为没有通过的话，就不会继续到下一审批人了
  38.             if (node < processNodeCurrent) {
  39.                 nodeDetail.setStatus(ApprovalStatus.APPROVAL_PASS.getValue());
  40.             } else if (node == processNodeCurrent) {
  41.                 // 如果是当前节点，就直接复制当前状态上的
  42.                 nodeDetail.setStatus(approval.getNodeStatus());
  43.             }
  44.             list.add(nodeDetail);
  45.         }
  46.         return list;
  47.     }

审批流程节点详细信息：

  2. /**
  3.  * 审批流程节点详细：可以包含谁审核的，审核时间，原因等
  4.  *
  5.  * @author zhuqiang
  6.  * @date 2021/7/23 10:23
  7.  */
  8. @Data
  9. @ToString
  10. public class ApprovalProcessNodeDetail {
  11.     // 节点顺序, 数组索引 +1
  12.     private Integer node;
  13.     // 该节点需要这个指定的 账户才能审批
  14.     private Integer accountId;
  15.     // 账户名称
  16.     private String accountName;
  17.     /**
  18.      * 审批状态
  19.      */
  20.     private Byte status;
  21.     /**
  22.      * 状态时间
  23.      */
  24.     private Date statusChangeTime;
  26.     /**
  27.      * 审批意见
  28.      */
  29.     private String opinion;
  31. }

上面的 list 审批流程节点数据，就能实现下面这个 UI 了
image.png