高校一网通办的坑与解：流程引擎、认证、数据交换

1
申请人提交
2
    │
3
    ▼
4
┌──────────────┐
5
│ 节点1: 指导老师审批 │──→ 驳回 → 退回申请人
6
└──────┬───────┘
7
       │ 通过
8
       ▼
9
┌──────────────┐
10
│ 节点2: 院系领导审批 │──→ 驳回 → 退回上一级
11
└──────┬───────┘
12
       │ 通过
13
       ▼
14
┌──────────────┐
15
│ 节点3: 教务处备案 │（自动归档，无需人工操作）
16
└──────┬───────┘
17
       │
18
       ▼
19
     办结

1
-- 1. 流程定义表：一个"请假申请"就是一个流程定义
2
CREATE TABLE wf_process_definition (
3
    id          VARCHAR(32) NOT NULL,
4
    name        VARCHAR(100) NOT NULL COMMENT '流程名称',
5
    version     INT DEFAULT 1 COMMENT '版本号',
6
    category    VARCHAR(50) COMMENT '分类（人事/教务/后勤/财务）',
7
    form_url    VARCHAR(500) COMMENT '关联表单地址',
8
    status      TINYINT DEFAULT 0 COMMENT '0草稿 1发布 2停用',
9
    xml_content MEDIUMTEXT COMMENT 'BPMN 2.0 流程定义 XML',
10
    create_time DATETIME,
11
    PRIMARY KEY (id)
12
);
13

14
-- 2. 流程节点表：定义每个节点的审批人、操作、路由
15
CREATE TABLE wf_node (
16
    id              VARCHAR(32) NOT NULL,
17
    process_def_id  VARCHAR(32) NOT NULL,
18
    node_name       VARCHAR(100) COMMENT '节点名称',
19
    node_type       VARCHAR(20) COMMENT 'start/approve/auto/end',
20
    assignee_type   VARCHAR(20) COMMENT '角色/部门/指定人/自动',
21
    assignee_value  VARCHAR(500) COMMENT '审批人配置值',
22
    timeout_hours   INT DEFAULT 0 COMMENT '超时时长',
23
    PRIMARY KEY (id)
24
);
25

26
-- 3. 流程实例表：某位同学发起的一次请假申请
27
CREATE TABLE wf_process_instance (
28
    id              VARCHAR(32) NOT NULL,
29
    process_def_id  VARCHAR(32) NOT NULL,
30
    applicant_id    VARCHAR(32) COMMENT '发起人',
31
    title           VARCHAR(200) COMMENT '申请标题',
32
    status          VARCHAR(20) COMMENT 'running/completed/rejected/canceled',
33
    form_data       JSON COMMENT '表单数据',
34
    start_time      DATETIME,
35
    end_time        DATETIME,
36
    PRIMARY KEY (id)
37
);
38

39
-- 4. 任务表（待办）：当前谁要审批什么
40
CREATE TABLE wf_task (
41
    id              VARCHAR(32) NOT NULL,
42
    process_inst_id VARCHAR(32) NOT NULL,
43
    node_id         VARCHAR(32) NOT NULL,
44
    assignee_id     VARCHAR(32) COMMENT '审批人ID',
45
    status          VARCHAR(20) COMMENT 'pending/completed/rejected',
46
    opinion         VARCHAR(500) COMMENT '审批意见',
47
    create_time     DATETIME,
48
    complete_time   DATETIME,
49
    PRIMARY KEY (id)
50
);
51

52
-- 5. 流转历史表：流程的完整轨迹
53
CREATE TABLE wf_history (
54
    id              VARCHAR(32) NOT NULL,
55
    process_inst_id VARCHAR(32) NOT NULL,
56
    node_name       VARCHAR(100),
57
    operator_id     VARCHAR(32),
58
    action          VARCHAR(20) COMMENT 'submit/approve/reject/transfer',
59
    opinion         VARCHAR(500),
60
    operate_time    DATETIME
61
);

1
public class WorkflowEngine {
2

3
    // 提交申请：创建流程实例和第一个任务
4
    public ProcessInstance startProcess(String processDefId, String userId,
5
                                        Map<String, Object> formData) {
6
        // 1. 加载流程定义
7
        ProcessDefinition def = processDefRepo.findById(processDefId);
8

9
        // 2. 创建流程实例
10
        ProcessInstance inst = new ProcessInstance();
11
        inst.setProcessDefId(processDefId);
12
        inst.setApplicantId(userId);
13
        inst.setFormData(formData);
14
        inst.setStatus("running");
15
        inst.setStartTime(new Date());
16
        inst = processInstRepo.save(inst);
17

18
        // 3. 找到第一个审批节点（start 节点之后）
19
        Node firstNode = findNextNode(def.getId(), "start");
20

21
        // 4. 创建待办任务
22
        createTask(inst.getId(), firstNode, resolveAssignees(firstNode, formData));
23

24
        return inst;
25
    }
26

27
    // 审批操作：通过/驳回
28
    public void completeTask(String taskId, String userId,
29
                             boolean approved, String opinion) {
30
        // 1. 获取当前任务
31
        Task task = taskRepo.findById(taskId);
32
        ProcessInstance inst = processInstRepo.findById(task.getProcessInstId());
33
        ProcessDefinition def = processDefRepo.findById(inst.getProcessDefId());
34

35
        // 2. 更新当前任务状态
36
        task.setStatus(approved ? "completed" : "rejected");
37
        task.setOpinion(opinion);
38
        task.setCompleteTime(new Date());
39
        taskRepo.save(task);
40

41
        if (!approved) {
42
            // 3. 驳回：回到上一节点或发起人
43
            rollback(inst);
44
            return;
45
        }
46

47
        // 4. 查找下一个节点
48
        Node nextNode = findNextNode(def.getId(), task.getNodeId());
49

50
        if (nextNode == null || "end".equals(nextNode.getNodeType())) {
51
            // 5. 没有后续节点 → 流程办结
52
            inst.setStatus("completed");
53
            inst.setEndTime(new Date());
54
            processInstRepo.save(inst);
55
            return;
56
        }
57

58
        if ("auto".equals(nextNode.getNodeType())) {
59
            // 6. 自动节点（如备案、发送通知）→ 自动执行
60
            executeAutoNode(inst, nextNode);
61
            // 继续往后走
62
            completeTask(createAutoTask(inst.getId(), nextNode),
63
                        "system", true, "自动通过");
64
            return;
65
        }
66

67
        // 7. 创建下一个待办
68
        createTask(inst.getId(), nextNode,
69
                   resolveAssignees(nextNode, inst.getFormData()));
70
    }
71

72
    // 解析审批人：根据节点配置找到具体谁审批
73
    private List<String> resolveAssignees(Node node, Map<String, Object> formData) {
74
        switch (node.getAssigneeType()) {
75
            case "role":
76
                // 按角色查：如"辅导员"角色下所有用户
77
                return roleService.getUserIdsByRole(node.getAssigneeValue());
78
            case "department":
79
                // 按部门查：根据申请人所在部门
80
                String deptId = (String) formData.get("applicantDeptId");
81
                return deptService.getManagerIds(deptId);
82
            case "upward":
83
                // 逐级上升：找申请人的上级
84
                return orgService.getSuperiorIds(
85
                    (String) formData.get("applicantId"));
86
            case "fixed":
87
                // 指定人
88
                return Collections.singletonList(node.getAssigneeValue());
89
            default:
90
                throw new BusinessException("未知的审批人类型");
91
        }
92
    }
93
}

1
// 定时任务扫描超时待办
2
@Component
3
public class TaskTimeoutScanner {
4

5
    @Scheduled(fixedRate = 60000) // 每分钟扫描一次
6
    public void scanTimeoutTasks() {
7
        // 查询所有超时的待办任务
8
        List<Task> timeoutTasks = taskRepo.findTimeoutTasks(
9
            new Date(), // 当前时间 > 节点设置的超时时间
10
            10          // 每次最多处理10条
11
        );
12

13
        for (Task task : timeoutTasks) {
14
            // 1. 发送催办通知（短信/微信/邮件）
15
            notificationService.sendTimeoutAlert(task);
16

17
            // 2. 记录超时日志
18
            logService.logTimeout(task);
19

20
            // 3. 如果配置了自动转交
21
            Node node = nodeRepo.findById(task.getNodeId());
22
            if (node.getTimeoutAction() == "autoTransfer") {
23
                transferToManager(task);
24
            }
25
        }
26
    }
27
}

1
用户访问教务系统（未登录）
2
    │
3
    ▼
4
教务系统检测到未登录 → 302 重定向到 CAS 登录页
5
    │
6
    ▼
7
CAS 登录页（https://sso.hdu.edu.cn/login）
8
    │ 用户输入学号 + 密码
9
    │（可选：短信验证码 / 微信扫码）
10
    ▼
11
CAS 验证凭证 → 创建全局 Session（TGT）
12
    │
13
    ▼
14
302 重定向回教务系统，URL 上带一个 ticket
15
    │
16
    ▼
17
教务系统用 ticket 向 CAS 服务器验证
18
    │  POST https://sso.hdu.edu.cn/serviceValidate?ticket=ST-xxx&service=教务系统URL
19
    ▼
20
CAS 返回用户信息（XML/JSON）
21
    │  <cas:user>2024010101</cas:user>
22
    │  <cas:attributes>
23
    │    <name>张三</name>
24
    │    <dept>计算机学院</dept>
25
    │    <type>student</type>
26
    │  </cas:attributes>
27
    ▼
28
教务系统创建本地 Session → 用户登录成功
29

30
此后用户访问 OA 系统：
31
    │
32
    ▼
33
OA 检测未登录 → 重定向到 CAS
34
    │
35
    ▼
36
CAS 检查到已有 TGT → 直接签发 ticket
37
    │
38
    ▼
39
OA 验证 ticket → 登录成功（免密码）

1
@RestController
2
public class CasServerController {
3

4
    @PostMapping("/login")
5
    public String login(String username, String password,
6
                        String service, HttpSession session) {
7
        // 1. 验证用户名密码（对接学校统一身份库）
8
        User user = authenticationManager.authenticate(username, password);
9

10
        // 2. 创建全局票据 TGT（Ticket Granting Ticket）
11
        String tgt = UUID.randomUUID().toString();
12
        session.setAttribute("TGT", tgt);
13
        ticketRegistry.addTicket(tgt, new TicketGrantingTicket(user));
14

15
        // 3. 生成一次性服务票据 ST（Service Ticket）
16
        String st = "ST-" + UUID.randomUUID().toString();
17
        ticketRegistry.addTicket(st, new ServiceTicket(service, user));
18

19
        // 4. 重定向回业务系统
20
        return "redirect:" + service + "?ticket=" + st;
21
    }
22

23
    @GetMapping("/serviceValidate")
24
    public Map<String, Object> validate(String ticket, String service) {
25
        // 1. 验证 ST 是否有效
26
        ServiceTicket st = ticketRegistry.getTicket(ticket);
27
        if (st == null || st.isExpired() || !st.getService().equals(service)) {
28
            return Map.of("code", 400, "message", "ticket无效");
29
        }
30

31
        // 2. 删除已使用的 ST（一次性）
32
        ticketRegistry.removeTicket(ticket);
33

34
        // 3. 返回用户信息
35
        return Map.of(
36
            "code", 200,
37
            "user", st.getUser().getUsername(),
38
            "attributes", st.getUser().getAttributes()
39
        );
40
    }
41
}

1
CREATE TABLE idm_user (
2
    id              VARCHAR(32) NOT NULL PRIMARY KEY,
3
    uid             VARCHAR(50) NOT NULL UNIQUE COMMENT '学号/工号',
4
    name            VARCHAR(100) NOT NULL COMMENT '姓名',
5
    id_card_hash    VARCHAR(64) COMMENT '身份证号哈希',
6
    phone           VARCHAR(20),
7
    email           VARCHAR(200),
8
    status          TINYINT DEFAULT 1 COMMENT '1正常 0禁用 -1删除',
9
    user_type       VARCHAR(20) COMMENT 'student/teacher/admin',
10
    source          VARCHAR(50) COMMENT '数据来源系统',
11
    create_time     DATETIME,
12
    update_time     DATETIME
13
);
14

15
-- 组织架构表
16
CREATE TABLE idm_organization (
17
    id          VARCHAR(32) NOT NULL PRIMARY KEY,
18
    name        VARCHAR(200) NOT NULL COMMENT '部门名称',
19
    parent_id   VARCHAR(32) DEFAULT '0',
20
    sort        INT DEFAULT 0,
21
    type        VARCHAR(20) COMMENT 'school/college/department/lab'
22
);
23

24
-- 用户-组织关联（一个人可能属于多个组织）
25
CREATE TABLE idm_user_org (
26
    user_id     VARCHAR(32) NOT NULL,
27
    org_id      VARCHAR(32) NOT NULL,
28
    is_main     TINYINT DEFAULT 0 COMMENT '是否主部门',
29
    PRIMARY KEY (user_id, org_id)
30
);
31

32
-- 角色表
33
CREATE TABLE idm_role (
34
    id          VARCHAR(32) NOT NULL PRIMARY KEY,
35
    name        VARCHAR(100) NOT NULL,
36
    code        VARCHAR(50) NOT NULL UNIQUE,
37
    type        VARCHAR(20) COMMENT 'system/business'
38
);
39

40
-- 用户-角色关联
41
CREATE TABLE idm_user_role (
42
    user_id     VARCHAR(32) NOT NULL,
43
    role_id     VARCHAR(32) NOT NULL,
44
    PRIMARY KEY (user_id, role_id)
45
);

1
┌─────────────────────────────────────────────────┐
2
│                    消费方                          │
3
│   流程引擎 · 一网通办门户 · 数据大屏 · 报表系统    │
4
└─────────────────────┬───────────────────────────┘
5
                      │ REST API / gRPC / MQ
6
┌─────────────────────▼───────────────────────────┐
7
│              数据交换平台（API 网关层）             │
8
│                                                   │
9
│   ┌─────────┐ ┌─────────┐ ┌──────────────────┐   │
10
│   │ 请求路由 │ │ 协议转换 │ │ 数据脱敏/权限校验 │   │
11
│   └─────────┘ └─────────┘ └──────────────────┘   │
12
│                                                   │
13
│   ┌──────────────────────────────────────────┐   │
14
│   │           数据标准映射层                    │   │
15
│   │    教务"学生" → 标准"学生" → 财务"学生"    │   │
16
│   └──────────────────────────────────────────┘   │
17
└─────────────────────┬───────────────────────────┘
18
                      │
19
  ┌───────────────────┼───────────────────┐
20
  │                   │                   │
21
  ▼                   ▼                   ▼
22
┌────────┐      ┌────────┐         ┌────────┐
23
│ 教务系统 │      │ 财务系统 │  ...    │ 一卡通 │
24
└────────┘      └────────┘         └────────┘

1
{
2
    "student": {
3
        "version": "2.0",
4
        "fields": [
5
            {
6
                "name": "student_id",
7
                "displayName": "学号",
8
                "type": "string",
9
                "required": true,
10
                "maxLength": 20
11
            },
12
            {
13
                "name": "name",
14
                "displayName": "姓名",
15
                "type": "string",
16
                "required": true
17
            },
18
            {
19
                "name": "college_code",
20
                "displayName": "学院代码",
21
                "type": "string"
22
            },
23
            {
24
                "name": "college_name",
25
                "displayName": "学院名称",
26
                "type": "string"
27
            },
28
            {
29
                "name": "status",
30
                "displayName": "在校状态",
31
                "type": "string",
32
                "enum": ["在校", "休学", "毕业", "退学"]
33
            }
34
        ]
35
    }
36
}

1
@Component
2
public class EduAdapter implements DataSourceAdapter {
3

4
    // 教务系统的数据源配置
5
    @Override
6
    public String getSourceName() { return "edu_system"; }
7

8
    // 查询学生信息：将教务系统的返回映射为标准格式
9
    @Override
10
    public Map<String, Object> queryStudent(String studentId) {
11
        // 1. 调用教务系统的接口
12
        JSONObject raw = eduClient.queryStudentInfo(studentId);
13
        // raw: { "XH": "2024001", "XM": "张三", "YXMC": "计算机学院" }
14

15
        // 2. 按数据标准映射
16
        Map<String, Object> standard = new HashMap<>();
17
        standard.put("student_id", raw.getString("XH"));
18
        standard.put("name", raw.getString("XM"));
19
        standard.put("college_name", raw.getString("YXMC"));
20
        // ... 其他字段映射
21

22
        return standard;
23
    }
24

25
    // 查询成绩
26
    @Override
27
    public List<Map<String, Object>> queryGrades(String studentId) {
28
        JSONArray raw = eduClient.queryGrades(studentId);
29
        List<Map<String, Object>> result = new ArrayList<>();
30
        for (Object obj : raw) {
31
            JSONObject grade = (JSONObject) obj;
32
            Map<String, Object> item = new HashMap<>();
33
            item.put("course_name", grade.getString("KCMC"));
34
            item.put("score", grade.getBigDecimal("CJ"));
35
            item.put("semester", grade.getString("XQ"));
36
            result.add(item);
37
        }
38
        return result;
39
    }
40
}

1
@Component
2
public class DataSecurityInterceptor {
3

4
    // 根据调用方身份和请求的数据类型，决定是否脱敏
5
    public Map<String, Object> applySecurity(
6
            String callerAppId, String dataType, Map<String, Object> data) {
7

8
        // 1. 查调用方权限
9
        AppPermission perm = permissionRepo.findByAppId(callerAppId);
10

11
        // 2. 按字段级别做脱敏
12
        Map<String, Object> result = new HashMap<>(data);
13

14
        if (!perm.canViewField("phone")) {
15
            result.put("phone", maskPhone((String) data.get("phone")));
16
            // "13812345678" → "138****5678"
17
        }
18

19
        if (!perm.canViewField("id_card")) {
20
            result.put("id_card", maskIdCard((String) data.get("id_card")));
21
            // "500101199001011234" → "500101****1234"
22
        }
23

24
        if (!perm.canViewField("password_hash")) {
25
            result.remove("password_hash");
26
        }
27

28
        return result;
29
    }
30

31
    private String maskPhone(String phone) {
32
        if (phone == null || phone.length() != 11) return phone;
33
        return phone.substring(0, 3) + "****" + phone.substring(7);
34
    }
35

36
    private String maskIdCard(String idCard) {
37
        if (idCard == null || idCard.length() < 8) return idCard;
38
        return idCard.substring(0, 6) + "****" +
39
               idCard.substring(idCard.length() - 4);
40
    }
41
}

1
┌──────────────────────────────────────────────┐
2
│            网上办事大厅门户（React）            │
3
│    PC端 + 移动端（企业微信集成）               │
4
├──────────────────────────────────────────────┤
5
│  API 网关（Spring Cloud Gateway）             │
6
│  路由转发 · 统一鉴权 · 限流熔断 · 日志审计    │
7
├──────────────────────────────────────────────┤
8
│                                              │
9
│  ┌───────────┐ ┌───────────┐ ┌───────────┐ │
10
│  │ 事项微服务A │ │ 事项微服务B │ │ 事项微服务C │ │
11
│  │ (请假/销假) │ │ (用印申请) │ │ (报销审批) │ │
12
│  └─────┬─────┘ └─────┬─────┘ └─────┬─────┘ │
13
│        │             │             │        │
14
│  ┌─────┴─────────────┴─────────────┴─────┐ │
15
│  │           Activiti 流程引擎             │ │
16
│  │   BPMN 2.0 · 会签 · 并行 · 条件路由    │ │
17
│  └────────────────┬──────────────────────┘ │
18
│                   │                         │
19
│  ┌────────────────▼──────────────────────┐ │
20
│  │         数据交换层（自研 ESB）           │ │
21
│  │   教务 · 科研 · 人事 · 财务 · 一卡通   │ │
22
│  └────────────────┬──────────────────────┘ │
23
│                   │                         │
24
├────────────────────────────────────────────┤
25
│  统一身份认证（CAS + OAuth2 + 企业微信）      │
26
│  Docker + Kubernetes 容器平台                │
27
└────────────────────────────────────────────┘

1
// 低代码表单引擎核心：动态表单渲染
2
@Component
3
public class DynamicFormEngine {
4

5
    // 根据 JSON 配置渲染表单
6
    public FormVO renderForm(String formDefId, Map<String, Object> data) {
7
        FormDefinition def = formDefRepo.findById(formDefId);
8

9
        FormVO form = new FormVO();
10
        form.setTitle(def.getTitle());
11

12
        for (FieldDefinition field : def.getFields()) {
13
            FieldVO f = new FieldVO();
14
            f.setKey(field.getKey());
15
            f.setLabel(field.getLabel());
16
            f.setType(field.getType());    // text/select/date/file/user
17
            f.setRequired(field.isRequired());
18
            f.setValue(data.get(field.getKey()));
19

20
            // 动态数据源：如"选择学院"从接口获取
21
            if (field.getDataSource() != null) {
22
                f.setOptions(dataSourceService
23
                    .fetchOptions(field.getDataSource()));
24
            }
25

26
            // 联动逻辑：如选了"研究生"才显示"导师字段"
27
            if (field.getVisibilityRule() != null) {
28
                f.setVisible(evaluateVisibility(field.getVisibilityRule(), data));
29
            }
30

31
            form.addField(f);
32
        }
33
        return form;
34
    }
35
}

1
┌──────────────────────────────────────────────┐
2
│          一站式服务大厅门户（Vue 3）            │
3
│   办事中心 · 事务中心 · 消息中心 · 个人中心    │
4
├──────────────────────────────────────────────┤
5
│  统一认证网关（CAS + Session 共享）            │
6
├──────────────────────────────────────────────┤
7
│                                              │
8
│  ┌──────────────────────────────────────┐   │
9
│  │      Flowable 流程引擎（自研配置中心）  │   │
10
│  │  流程定义管理 → 流程部署 → 流程实例   │   │
11
│  │  审批人解析（角色/部门/上级/指定人）  │   │
12
│  │  超时催办 · 待办转交 · 流程监控      │   │
13
│  └────────────────┬─────────────────────┘   │
14
│                   │                          │
15
│  ┌────────────────▼─────────────────────┐   │
16
│  │   数据交换平台（ESB + 主数据管理）     │   │
17
│  │                                      │   │
18
│  │  ┌─────────┐ ┌─────────┐ ┌───────┐  │   │
19
│  │  │ 教务适配器│ │ 财务适配器│ │ 一卡通 │  │   │
20
│  │  └─────────┘ └─────────┘ └───────┘  │   │
21
│  │      主数据管理（师生/组织/课程）      │   │
22
│  │      数据质量监控 · 数据血缘追踪     │   │
23
│  └──────────────────────────────────────┘   │
24
│                                              │
25
├──────────────────────────────────────────────┤
26
│  CAS + OIDC · 微信/钉钉/企业微信多端认证      │
27
│  私有云（VMware） · MySQL · Redis              │
28
└──────────────────────────────────────────────┘

1
-- 流程实例监控SQL（重大真实场景）
2
SELECT
3
    p.id AS process_id,
4
    p.title AS 申请标题,
5
    p.create_time AS 发起时间,
6
    CASE
7
        WHEN p.status = 'running' THEN '审批中'
8
        WHEN p.status = 'completed' THEN '已完成'
9
        WHEN p.status = 'rejected' THEN '已驳回'
10
    END AS 状态,
11
    TIMEDIFF(NOW(), p.create_time) AS 已用时长,
12
    -- 统计当前节点停留时间
13
    TIMEDIFF(NOW(), t.create_time) AS 当前节点停留
14
FROM wf_process_instance p
15
LEFT JOIN wf_task t ON p.id = t.process_inst_id AND t.status = 'pending'
16
WHERE p.process_def_id = 'graduate_review'
17
  AND p.create_time > DATE_SUB(NOW(), INTERVAL 7 DAY)
18
ORDER BY p.create_time DESC;

1
┌──────────────────────────────────────────────────┐
2
│       在线服务门户（微前端 + 低代码搭建平台）        │
3
│   ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐  │
4
│   │ 办事中心│ │ 事务中心│ │ 消息中心│ │ 个人中心│  │
5
│   └────┬───┘ └────┬───┘ └────┬───┘ └────┬───┘  │
6
│        └──────────┴──────────┴──────────┘       │
7
├──────────────────────────────────────────────────┤
8
│          统一 API 网关（自研，基于 OpenAPI 3.0）    │
9
│        API 注册 · 版本管理 · 流量控制 · 鉴权      │
10
├──────────────────────────────────────────────────┤
11
│                                                   │
12
│  ┌──────────────┐  ┌──────────────┐               │
13
│  │ 流程能力 API  │  │ 数据能力 API  │  ...          │
14
│  │ (Flowable)   │  │ (数据中台)   │               │
15
│  └──────┬───────┘  └──────┬───────┘               │
16
│         │                 │                        │
17
│  ┌──────▼─────────────────▼───────────────────┐  │
18
│  │          业务能力层（API First）              │  │
19
│  │  流程服务 · 用户服务 · 组织服务 · 表单服务   │  │
20
│  │  通知服务 · 文件服务 · 搜索服务 · 日志服务   │  │
21
│  └──────────────────────────────────────────────┘  │
22
│                                                   │
23
│  ┌──────────────────────────────────────────────┐  │
24
│  │           数据中台（自研）                      │  │
25
│  │  统一数据模型 · 数据标准化 · 数据服务化       │  │
26
│  │  实时数据管道（Kafka + Flink）                 │  │
27
│  └──────────────────────────────────────────────┘  │
28
│                                                   │
29
├──────────────────────────────────────────────────┤
30
│  统一身份认证（THUID：CAS + OIDC + SAML + LDAP）    │
31
│  私有云（OpenStack）+ 容器平台（K8s）               │
32
└──────────────────────────────────────────────────┘

1
第一步：定义 API 契约（OpenAPI 3.0 规范）
2
    请假申请的 API 定义：
3
    POST /api/v1/process/leave/start   — 发起请假
4
    GET  /api/v1/process/leave/{id}    — 查询请假状态
5
    POST /api/v1/process/leave/approve — 审批请假
6
    GET  /api/v1/process/leave/calendar — 查个人请假日历
7

8
第二步：实现 API 服务
9
    基于 Flowable 引擎实现后端逻辑
10
    API 返回统一的数据结构
11

12
第三步：构建前端
13
    前端团队基于 API 文档并行开发
14
    使用低代码页面搭建平台拖拽生成表单
15
    前后端通过 API 契约联调

1
// API 契约驱动开发的典型实现
2
@RestController
3
@RequestMapping("/api/v1/process/leave")
4
@Tag(name = "请假流程", description = "清华大学在线服务-请假流程API")
5
public class LeaveProcessController {
6

7
    @PostMapping("/start")
8
    @Operation(summary = "发起请假申请")
9
    public ApiResponse<ProcessVO> startLeave(
10
            @RequestBody @Valid LeaveRequest request,
11
            @AuthenticationPrincipal User user) {
12
        // 参数校验 → 启动流程 → 返回流程实例
13
        ProcessVO process = leaveService.start(request, user.getId());
14
        return ApiResponse.success(process);
15
    }
16

17
    @PostMapping("/approve")
18
    @Operation(summary = "审批请假")
19
    public ApiResponse<Void> approveLeave(
20
            @RequestParam String taskId,
21
            @RequestParam boolean approved,
22
            @RequestParam(required = false) String opinion) {
23
        leaveService.approve(taskId, approved, opinion);
24
        return ApiResponse.success();
25
    }
26

27
    @GetMapping("/calendar")
28
    @Operation(summary = "获取个人请假日历")
29
    public ApiResponse<List<LeaveEvent>> getCalendar(
30
            @RequestParam String userId,
31
            @RequestParam String month) {
32
        List<LeaveEvent> events = leaveService.getCalendar(userId, month);
33
        return ApiResponse.success(events);
34
    }
35
}

1
// 页面搭建平台的渲染服务
2
@Service
3
public class PageRenderService {
4

5
    public String renderPage(String pageId, Map<String, Object> context) {
6
        // 1. 从数据库加载页面 JSON 配置
7
        PageConfig config = pageConfigRepo.findById(pageId);
8

9
        // 2. 解析组件树
10
        ComponentTree tree = JsonUtils.parse(config.getComponentTree());
11

12
        // 3. 递归渲染每个组件
13
        StringBuilder html = new StringBuilder();
14
        renderComponent(tree.getRoot(), context, html);
15

16
        // 4. 注入数据绑定
17
        // 每个组件声明的 dataSource 在渲染时通过 API 获取实时数据
18
        String script = generateDataBindingScript(tree, context);
19

20
        return wrapPage(html.toString(), script);
21
    }
22

23
    private void renderComponent(ComponentNode node,
24
                                 Map<String, Object> context,
25
                                 StringBuilder output) {
26
        String type = node.getType();
27
        Map<String, Object> props = node.getProperties();
28

29
        // 根据组件类型查找对应的渲染器
30
        ComponentRenderer renderer = rendererRegistry.get(type);
31
        String rendered = renderer.render(props, context);
32

33
        output.append(rendered);
34

35
        // 递归渲染子组件
36
        for (ComponentNode child : node.getChildren()) {
37
            renderComponent(child, context, output);
38
        }
39
    }
40
}