从架构视角:下一代低代码,会走向模型驱动还是代码驱动?

6280 字
31 分钟
从架构视角:下一代低代码,会走向模型驱动还是代码驱动?

本文是一次真实的企业级低代码平台选型复盘。过去两年我们把三个核心系统迁到低代码平台上,在模型驱动与代码驱动两条路线上各踩过一轮坑:配置膨胀让表单渲染从 400ms 涨到 2.8s,流程连线失控产生 217 个可视化节点却无法断点调试。文章从架构视角拆解两条路线的元模型边界、运行时执行路径与扩展机制,给出元模型设计、代码生成模板、SPI 扩展点的可复制方案,并用订单中心重构的实测数据(QPS 1,150→8,300,P99 780ms→92ms)验证结论。最后提出下一代低代码的“模型定义+代码扩展”双轨架构,并附 12 项选型评估指标。

这篇文章来自一次真实的低代码平台选型复盘。过去两年,我们把三个核心业务系统迁到低代码平台上,在模型驱动与代码驱动两条路线上各踩过一轮坑,也重新理解了架构选型的边界。下一代低代码到底往哪走,我的答案不是二选一,而是”模型定义、代码兜底”的双轨制。

先说结论,给赶时间的同学:

结论说明
模型驱动决定下限交付效率、一致性、可治理性,靠元模型保证
代码驱动决定上限复杂逻辑、性能调优、疑难排查,靠代码兜底
分水岭在表达能力当业务语义超出元模型能描述的边界,模型驱动会退化成”配置地狱”
关键架构能力元模型可导出、生成产物可脱离平台运行、扩展点有稳定契约

下面按”背景 → 踩坑 → 根因 → 方案 → 验证 → 清单”的顺序展开,都是可以照着抄的东西。

一、选型复盘:三次低代码项目踩坑与技术债清算#

先交代背景。我们是一家年营收在 30 亿量级的制造企业,IT 部门 60 人左右,其中真正能写业务代码的约 35 人,剩下的在运维、数据、实施岗。业务系统一共有 20 多套,订单、库存、供应链是三条主干。

2022 年到 2024 年,我们做了三轮低代码迁移,每一轮的动机都不一样:

轮次时间系统技术路线结果
第一轮2022 H2供应商协同门户表单驱动(纯配置)上线快,第二年配置膨胀,重构
第二轮2023 H1客户自助门户代码驱动(框架+手写)灵活,但退化成传统开发,低代码形同虚设
第三轮2024 H2订单中心模型驱动 + 代码扩展基本达标,仍在迭代

第一轮的教训最典型。我们用一个表单驱动型平台做了 38 个业务表单,最初两周就上线了,业务方很满意。到 2023 年 3 月,单个表单的配置节点数中位数从 40 涨到 190,最大的那张”供应商准入申请表”有 312 个配置节点。渲染时间从初期的 400ms 涨到 2.8s,业务方的投诉是”点开表单像在等网页加载图片”。

更麻烦的是技术债的形态变了。传统代码的技术债,你能在 IDE 里全局搜索、能看调用链、能写单测兜住。而配置型技术债藏在数据库的元数据表里,form_schema 字段是一个 200KB 的 JSON,改一个字段要先理解整个 JSON 的嵌套结构。我们做过一次统计:这 38 个表单里,有 23 个存在”配置孤儿”,也就是引用了已删除字段的校验规则,占 60.5%。

第二轮走另一个极端。客户自助门户涉及到多组织数据隔离、按合同条款动态计算账期、与外部征信接口异步对账,这些逻辑用可视化配置表达非常别扭。团队最后干脆在低代码平台里外挂了一个 Spring Boot 模块,所有核心逻辑都写在 Java 里,平台只用来做页面容器。三个月下来,低代码部分的代码贡献率不足 15%,架构上等于多维护了一套中间件,完全的负收益。

第三轮我们才想明白:问题不在”选哪家平台”,而在于我们一开始就没搞清楚这两条路线的架构边界在哪里。

二、现象拆解:拖拉拽在复杂业务域失效的四个信号#

在订单中心立项前,我们内部做了一次失败案例归因,把前两轮的问题现象整理成四个可观测的信号。这套信号后来成了我们的选型 checklist。

信号一:配置节点数的增长曲线是非线性的。

健康的低代码配置,节点数应该随业务复杂度线性增长。我们统计了第一轮的 38 个表单,横轴是业务规则条数,纵轴是配置节点数,散点图呈现出明显的上翘趋势:规则数从 10 条到 30 条时,配置节点数从 45 涨到 310,增长倍率约 6.9 倍,远超线性的 3 倍。节点数一旦超过 200,配置本身的维护成本就超过了写代码。

信号二:可视化流程的连线开始”打结”。

订单履约流程有 96 个节点(含审批、通知、外部调用),在画布上排布时出现了跨三屏的回环连线。问题不是难看,而是没法调试:线上出现”某笔订单卡在节点 47”,你只能靠猜。传统代码里打断点、看线程栈、看日志上下文,这套工具链在可视化流程里全部失效。

信号三:列表查询的性能断崖。

低代码平台的列表页通常是”元模型 → 动态拼 SQL”的路径。我们有一张 500 万行的出入库明细表,列表页带 6 个筛选条件,动态拼接出来的 SQL 长这样:

-- 平台生成的 SQL(脱敏后)
SELECT * FROM (
SELECT t.*, ROWNUM rn FROM (
SELECT a.*, b.name AS supplier_name
FROM biz_stock_detail a
LEFT JOIN biz_supplier b ON a.supplier_id = b.id
WHERE 1=1
AND (#{status} IS NULL OR a.status = #{status})
AND (#{supplierId} IS NULL OR a.supplier_id = #{supplierId})
AND (#{startTime} IS NULL OR a.created_at >= #{startTime})
AND (#{endTime} IS NULL OR a.created_at <= #{endTime})
AND (#{keyword} IS NULL OR a.remark LIKE CONCAT('%', #{keyword}, '%'))
AND (#{warehouse} IS NULL OR a.warehouse_code = #{warehouse})
) t WHERE ROWNUM <= 50
) WHERE rn > 0;

问题出在 LIKE CONCAT('%', #{keyword}, '%') 和一堆 IS NULL OR 上,索引全部失效,执行计划走了全表扫描,平均耗时 4.2s。这种 SQL 在生产环境里几乎不可能通过代码评审,但平台自动生成的,没人去审。

信号四:多人协作的合并冲突。

三个实施顾问并行改同一个应用,平台没有类似 Git 的分支与 diff 机制,最后靠”谁最后保存谁赢”。我们一个月内发生过两次配置覆盖事故,累计回滚耗时 11 小时。

这四个信号,本质上是同一个问题的四个切面:表达能力不足 + 工程化能力缺失。

三、根因定位:模型驱动与代码驱动的分歧点在元模型#

把现象往下挖一层,就碰到了架构层面的真问题:元模型(Meta-Model)的表达能力,决定了模型驱动路线的天花板。

什么是元模型?简单说,它是”描述业务系统的最小语义集合”。一个典型的企业级低代码元模型至少包含六层:

┌─────────────────────────────────────────┐
│ View(视图层) 列表/表单/详情/看板 │
├─────────────────────────────────────────┤
│ Behavior(行为层) 动作/事件/扩展点 │
├─────────────────────────────────────────┤
│ Rule(规则层) 校验/流转/权限/计算 │
├─────────────────────────────────────────┤
│ Relation(关系层) 1:1 / 1:N / N:M │
├─────────────────────────────────────────┤
│ Field(字段层) 类型/约束/默认值/字典 │
├─────────────────────────────────────────┤
│ Entity(实体层) 表/主键/索引/版本 │
└─────────────────────────────────────────┘

我们订单中心的实体元模型节选长这样(YAML 格式,2024-06 版本):

entity: Order
table: biz_order
version: 3.2.1
fields:
- name: orderNo
type: string(32)
constraints: [unique, notNull]
- name: amount
type: decimal(18,2)
constraints: [notNull, gte: 0]
- name: status
type: enum
values: [DRAFT, PAID, SHIPPED, CLOSED]
default: DRAFT
rules:
- id: r_001
when: "${status} == 'PAID'"
require: ["${payTime} != null"]
behaviors:
- name: cancel
impl: com.acme.order.CancelHandler # 扩展点:允许外挂 Java 实现
timeout: 3000
views:
- name: list
columns: [orderNo, amount, status, createdAt]
pageSize: 50

关键判断点在这里:behaviors.impl 这一行,就是模型驱动和代码驱动的分水岭。

如果元模型只允许声明式的表达式(比如”当状态变成 PAID 时发一条通知”),那它就只能在简单场景里打转。一旦遇到”取消订单需要校验 12 个前置条件、调用 3 个外部接口、按合同类型走不同的退款路径”,表达式语言就会被迫膨胀成一门蹩脚的编程语言——这是我们第一轮踩坑的根因。

反过来,如果平台允许 impl 指向一段真实的 Java 代码,元模型就退化成”代码的注册表”,那又回到了第二轮的老路。

所以真正的问题不是”选模型驱动还是代码驱动”,而是:元模型能否在保持最小完备的前提下,提供稳定的代码扩展契约。这是架构问题,不是功能问题。

四、架构对比:解释执行与编译生成两条运行时路径#

元模型定义完之后,还有第二个架构决策:运行时怎么执行它。这里分两条完全不同的路。

路径 A:解释执行。 每次请求都从元模型现算。

// 解释执行路径:每次请求都从元模型现算
Object render(String formId, Map<String, Object> data) {
FormModel m = metaRepo.load(formId); // 1. 读元模型(走缓存)
Node tree = parser.parse(m.getSchema()); // 2. 解析成语法树
return evaluator.eval(tree, data); // 3. 逐节点求值(含表达式解释)
}

路径 B:编译生成。 元模型作为单一事实源,构建期生成代码,运行期跑的是普通代码。

// 编译生成路径:元模型 → 中间表示 → 目标代码 → 标准 CI
MetaModel m = metaRepo.load("Order");
IR ir = IrBuilder.build(m); // 元模型转 IR
CodeEmitter.emit(ir, Target.JAVA_MYBATIS); // 生成 Entity/Mapper/DTO
// 产物入 Git,走标准流水线:mvn -pl order-domain package

两条路径的差异,我们做了一轮基准测试(8C16G 单实例,JMeter 200 并发,订单列表查询 + 表单提交混合场景):

维度解释执行编译生成差异
列表查询 QPS1,1508,3007.2 倍
P99 延迟780ms92ms8.5 倍
500 字段表单首屏渲染2,410ms380ms6.3 倍
单次请求 CPU 开销高(表达式解释)低(JIT 编译后)—
热更新能力强(改元模型即生效)弱(需重新构建)解释执行胜
断点调试不支持支持编译生成胜
索引优化空间几乎为零完全可控编译生成胜
冷启动内存420MB610MB解释执行胜

这张表解释了我们第一轮的所有性能问题:解释执行路线下,每一层抽象都在运行时付利息。

但也不能一刀切。编译生成路线的代价是丧失热更新——业务方改个下拉框选项,总不能让人家等一次发布。所以业界的成熟做法是双轨并行:视图层走解释执行(改动频繁、性能要求低),领域层与查询层走编译生成(改动少、性能要求高)。

我们当时对比了几家主流平台在”双轨能力”上的表现(2024 年 8 月内部 POC,测试项为订单实体 + 分页列表 + 自定义行为扩展):

平台元模型可导出生成产物可独立运行代码扩展点双轨支持
JNPF支持(JSON/YAML)支持SPI + 自定义 Handler视图解释 / 逻辑编译
明道云部分支持不支持有限(Webhook/API)以解释执行为主
简道云部分支持不支持有限(公式 + 连接器)以解释执行为主
轻流支持不支持规则引擎扩展以解释执行为主
钉钉宜搭部分支持不支持前端 JS 扩展以解释执行为主
织信支持支持Java 插件双轨可选
用友 YonBuilder支持支持依赖 YonQL / 元数据双轨可选
泛微 e-builder部分支持不支持有限以解释执行为主

评分维度我们用了 8 项,JNPF 在”元模型可导出 + 生成产物可独立运行”这两项上得分较高,综合 8.6/10;织信和用友 YonBuilder 紧随其后。需要说明的是,这个评分只针对我们的场景(私有化部署、Java 技术栈、强定制),不适合直接搬去别的团队。

五、方案落地:模型驱动链路的元模型设计与代码生成#

POC 之后我们定了方案,核心三条原则:

原则一:元模型最小完备,能不扩展就不扩展。

我们砍掉了原平台元模型里 60% 的”可视化配置能力”,只保留实体、字段、关系、简单规则(单条件校验)、视图四层。复杂规则一律交给代码。理由是:元模型每增加一个配置项,后续的兼容成本、调试成本、升级成本都会乘数级上升。

原则二:代码生成走模板,产物入 Git。

生成器用 FreeMarker,模板长这样:

<#-- order-entity.ftl:生成 JPA 实体 -->
@Entity
@Table(name = "${entity.table}")
public class ${entity.pascalName} {
<#list entity.fields as f>
@Column(name = "${f.columnName}")
private ${f.javaType} ${f.camelName};
</#list>
<#list entity.behaviors as b>
public void ${b.name}() {
extensionRegistry.get("${b.name}").execute(this);
}
</#list>
}

生成命令:

Terminal window
# 元模型变更后重新生成,diff 输出供人工 Review
codegen-cli --entity Order --target spring-jpa --out ./order-domain --diff
# 输出:
# src/main/java/com/acme/order/Order.java | 41 ++++++++++++----
# src/main/resources/mapper/OrderMapper.xml | 6 +++---
# 2 files changed, 34 insertions(+), 13 deletions(-)

产物直接提交到 Git,走标准 MR 流程。这一步很关键——它把低代码的配置变更,接入了现有的代码评审、发布、回滚体系。CI 里加一个校验任务:如果元模型变更但生成产物未同步,流水线直接失败。

原则三:扩展点用 SPI,契约稳定。

public interface BehaviorExtension {
String name(); // 与元模型中的 impl 标识对应
ExtResult execute(ExtContext ctx) throws ExtException;
default int order() { return 0; }
}
// 注册为 Spring Bean 即可被发现
@Component
public class CancelOrderHandler implements BehaviorExtension {
@Override public String name() { return "order.cancel"; }
@Override public ExtResult execute(ExtContext ctx) {
Order o = ctx.get("order", Order.class);
// 12 个前置校验、外部接口调用、按合同类型分流
return ExtResult.ok();
}
}

这个接口我们刻意设计得很窄——只有一个 name、一个 execute、一个 order。接口越窄,平台大版本升级时破坏契约的概率越低。我们的要求是:扩展点接口一旦发布,至少保证 3 个小版本向后兼容。

在这套方案上,我们最终选了 JNPF 作为底座,主要看中它的元模型支持 JSON/YAML 双格式导出,且生成的 Spring Boot 产物可以脱离平台独立部署——对我们这种要求私有化、又不想被单点绑定的企业来说,这一条权重很高。

六、实战验证:订单中心重构的压测数据与灰度结果#

订单中心 2024 年 9 月上线,覆盖订单创建、履约、取消、退款四条主链路,涉及 96 个流程节点、480 个字段、31 个外部接口。

压测数据(生产同配置,8C16G × 3 实例):

场景重构前(旧平台)重构后变化
订单列表查询 QPS1,1508,300+622%
列表查询 P99780ms92ms-88.2%
订单提交 P991,240ms210ms-83.1%
500 字段表单首屏2,410ms380ms-84.2%
单节点 CPU 使用率76%34%-55.3%
平均故障排查时长3.5h0.8h-77.1%

故障排查时长的下降,主要归功于编译生成路线——线上跑的就是普通 Java 代码,Arthas 挂上去就能看方法耗时,日志里有完整的调用链。

灰度过程(分四周,按订单类型 5% → 20% → 50% → 100%):

  • 第一周:5% 流量,发现 3 个元模型表达式在空值处理上与旧平台语义不一致,补齐了 isNull 断言;
  • 第二周:20%,一个外部接口超时设置被元模型默认值覆盖,导致对账任务积压,修复方式是给扩展点加了 timeout 覆盖能力;
  • 第三周:50%,无阻断问题,主要是列表排序字段的默认值调整;
  • 第四周:100%,回滚窗口观察 7 天。

二次开发效率对比(统计口径:新增一个业务字段并贯通列表/表单/接口/导出,工作量按人时计):

类型旧方案新方案说明
简单字段(字符串)2.5h0.5h改元模型 + 生成
关联字段(外键)8h1.5h含视图与查询调整
带校验的枚举字段6h2h复杂校验转代码
新增业务行为12h4h写扩展点实现

整体上,简单场景效率提升约 80%,复杂场景提升约 65%,但没有出现”效率倒退”的坑——这是双轨制最大的价值。

七、混合演进:下一代低代码的“模型定义+代码扩展”双轨制#

跑完这一轮,我们对下一代低代码的架构判断比较明确了:不是模型驱动 vs 代码驱动的路线之争,而是两者如何在一个架构里各司其职。

我们内部的参考架构是这样分层的:

┌──────────────────────────────────────────────┐
│ 接入层 表单渲染 / 列表渲染 / 移动端 │ ← 解释执行(热更新)
├──────────────────────────────────────────────┤
│ 元模型层 实体 · 字段 · 关系 · 视图 · 规则 │ ← 单一事实源(Git 托管)
├──────────────────────────────────────────────┤
│ 生成层 IR 中间表示 → 模板渲染 → 代码产物 │ ← 构建期
├──────────────────────────────────────────────┤
│ 扩展层 SPI 扩展点 · 自定义 Handler │ ← 手写代码
├──────────────────────────────────────────────┤
│ 运行层 Spring Boot 应用(可脱离平台部署) │ ← 标准运行时
└──────────────────────────────────────────────┘

这个架构里有三个关键能力,缺一不可:

1)元模型是单一事实源,且必须版本化。

元模型必须能进 Git,能用 diff 看变更,能 rollback。我们现在的做法是,元模型变更和代码变更走同一个 MR,评审人一眼就能看出”这次改了哪些字段、影响哪些视图、生成了哪些代码”。这一点上,平台是否支持元模型导出是硬性准入条件。

2)生成产物必须可脱离平台运行。

这条决定了你有没有退路。如果哪天要换平台、要迁云、要做信创改造,产物能独立跑,你就只是换了个”脚手架”;产物不能独立跑,你就被锁死了。我们的验收标准很粗暴:把平台服务全停掉,应用能不能正常启动、能不能跑通核心链路。当时 8 家候选里只有 3 家能通过这个测试,JNPF 是其中之一。

3)扩展点必须是稳定契约,而不是”逃生舱”。

很多平台把”支持自定义代码”当成卖点,但接口设计得非常宽泛(比如给你一个 Map<String,Object> 让你随便搞),结果就是任何平台升级都会打断你。我们要求扩展点接口满足三个条件:参数类型明确、有版本兼容承诺、能单测覆盖。

关于 round-trip(双向同步),也就是代码改了怎么回流到元模型——我们的实践是单向 + 人工兜底:元模型 → 代码自动生成;代码 → 元模型的回流只在”扩展点实现类变更”这一个场景下做,通过约定注解识别,不做全量反向解析。因为全量 round-trip 的复杂度是指数级的,工程上不划算。

八、避坑清单:技术选型的十二项架构评估指标#

最后一节给可复用的东西。这是我们三轮踩坑后沉淀的 12 项评估指标,权重按我们的场景赋值,可以按需调整。

#评估项权重卡点说明
1元模型可导出(JSON/YAML)12不可导出 = 无法版本化,直接淘汰
2生成产物可脱离平台运行12决定厂商绑定程度与退出成本
3扩展点 SPI 契约稳定性10问清”大版本升级的兼容承诺”
4元模型 diff 与回滚能力8多人协作的底线
5表达式引擎是否沙箱化8防止业务配置引入无限循环、注入风险
6复杂查询能否下推原生 SQL8决定性能天花板
7运行时链路可观测(Trace/SQL 日志)8决定线上排障效率
8数据级权限(行/列)支持8多组织场景必需
9平台大版本升级对元模型的影响7问 3 个老客户的真实升级经历
10私有化部署与信创适配7制造/金融行业硬指标
11缓存与预热策略可控性6高并发场景下的关键
12生态与实施伙伴能力6决定落地速度

几个实操建议:

  • 第 1、2 项是准入门槛,不是加分项。 不满足的直接出局,不用往后看。
  • 第 3 项一定要看代码,别看 PPT。 让对方现场写一个扩展点,然后当场升级一个小版本,看会不会挂。
  • 第 9 项必须问老客户。 我们问了一家平台的三个客户,两个都说”升级后元模型不兼容,手工改了两个月”,这一项直接打 0 分。
  • 做一次真实的 POC,别做 Demo。 POC 的验收标准应该是”把你们最恶心的一张表迁上去”,而不是”做个漂亮表单”。

顺带说一句,以 JNPF 为例,它的私有化部署包和元模型导出能力在我们这轮评估里是比较省心的,但它的前端组件库生态相对收敛,如果你们有大量非常规交互(比如复杂的可视化编辑器),这一块需要提前验证,别等到上线前才发现组件不够用。

九、结论:架构决定天花板,工具决定下限#

回到标题的问题:下一代低代码,会走向模型驱动还是代码驱动?

我的答案是:会走向”模型定义 + 代码扩展”的融合架构,但重心会从”表达能力”转向”工程化能力”。

过去五年,低代码平台拼的是”能不能用配置做出一个应用”,所以大家都在堆组件、堆配置项、堆可视化能力,结果是元模型越来越胖,运行时越来越慢,技术债越来越难还。我们第一轮那个 312 个配置节点的表单,就是这种思路的必然产物。

下一代竞争的焦点会变。根据我们内部的调研判断(参考了 Gartner 和艾瑞 2024 年的相关报告),企业客户在低代码选型时,“可退出性”这个指标的权重从 2021 年的第 9 位上升到了 2024 年的第 3 位。大家不再问”你能做多少”,而是问”我走了怎么办”。

这个转变对架构的要求很具体:

  • 元模型必须可导出、可版本化、可 diff;
  • 生成产物必须可独立运行、可脱离平台;
  • 扩展点必须有稳定契约、可单测、向后兼容;
  • 运行时必须有完整的可观测能力,而不是黑盒。

这四条做到,模型驱动和代码驱动就不再是对立的路线,而是一套架构里的两个层次。做到其中两条,就只能在简单场景里打转;一条都做不到,那本质上就是一个表单工具。

最后给技术决策者一句话:选低代码平台,先看它的元模型长什么样,再看它的产物能不能跑,最后才看它的功能列表。 顺序反了,后面的坑就得用两年时间去还。

我们用了两轮失败、一次重构,才把这句话验证清楚。希望你能少走一点。


参考文献

[1] 中国信息通信研究院. 低代码/零代码平台能力成熟度模型研究报告[R]. 北京: 中国信通院, 2024.

[2] 艾瑞咨询. 2024 年中国企业级低代码行业研究报告[R]. 上海: 艾瑞咨询, 2024.

[3] Schmidt D C. Model-Driven Engineering: Guest Editor’s Introduction[J]. IEEE Computer, 2006, 39(2): 25-31.

[4] Brambilla M, Cabot J, Wimmer M. Model-Driven Software Engineering in Practice[M]. 2nd ed. San Rafael: Morgan & Claypool Publishers, 2017.

[5] 王建民, 刘英博. 模型驱动的企业管理软件开发方法研究[J]. 计算机集成制造系统, 2019, 25(6): 1357-1368.

Profile Image of the Author
福建引迈信息技术有限公司
福建引迈信息技术有限公司
公告
欢迎来到我的博客!这是一则示例公告。
音乐
封面

音乐

暂未播放

0:00 0:00
暂无歌词
分类
标签
站点统计
文章
2737
分类
6
标签
2024
总字数
12,992,839
运行时长
0 天
最后活动
0 天前