07.2.4.7 uniCloud 云开发
所属:全栈开发面试题库 / 07 端侧与桌面开发 / 07.2 跨平台移动开发 / 07.2.4 uni-app
本节要解决的问题
- uniCloud 的定位是什么,云空间、服务商、云函数、云对象、云数据库、clientDB 之间是什么关系?
- 云函数与云对象的调用方式、上下文、超时与并发模型有何差异?
- 云数据库的 schema、字段类型、索引、权限模型怎么工作?
- clientDB 与 JQL 的查询能力边界在哪里,哪些操作必须走云函数?
- 安全规则(permission)模型如何防住常见越权漏洞?
- 云存储、定时任务、队列、日志、监控、多环境隔离怎么用?
- 计费与配额怎么算,什么时候该从 uniCloud 切到传统后端?
- 与传统后端(Node/Java/Go)的分工边界与选型判断?
版本前提:本节以 uniCloud(阿里云空间 / 腾讯云空间)当前稳定能力为基线描述;具体字段名、计费项、配额、超时阈值、JQL 函数清单随 DCloud 与云服务商更新,凡涉及数值与字段处均标「待确认」,以 uniapp.dcloud.net.cn/uniCloud 官方文档为准。
覆盖范围
| 知识域 | 关键内容 |
|---|---|
| 定位与空间 | 云开发模型、阿里云/腾讯云空间、服务空间、多环境 |
| 云函数与云对象 | 调用方式、context、超时、并发、冷启动 |
| 云数据库 | schema、字段类型、索引、权限、JQL |
| clientDB | 前端直连数据库的边界、安全规则、聚合能力 |
| 云存储与任务 | 上传/CDN/权限、定时触发器、队列 |
| 运维与计费 | 日志、监控、配额、计费、与传统后端选型 |
题号索引
| 题号区间 | 主题 |
|---|---|
| 001-003 | uniCloud 定位、云空间、阿里云/腾讯云差异 |
| 004-006 | 云函数机制、context、超时并发 |
| 007-009 | 云对象、调用方式、与云函数差异 |
| 010-012 | 云数据库 schema、字段类型、索引 |
| 013-015 | clientDB、JQL 能力边界、安全规则 |
| 016-018 | 云存储、定时任务、队列与日志监控 |
| 019-020 | 多环境、计费与传统后端选型综合题 |
07.2.4.7-001 uniCloud 的定位与整体架构是什么?
一句话结论
uniCloud 是 DCloud 提供的 BaaS(Backend as a Service)云开发平台,让 uni-app 前端不写后端服务就能获得云函数、云数据库、云存储、定时任务等能力;它在阿里云或腾讯云之上封装了一套面向 uni-app 的运行时与管理界面。
概念解释
传统开发里前端要写后端 API、数据库、服务器、运维。uniCloud 把这些都托管了:你在 uni-app 工程里写 cloudfunctions/ 目录下的云函数(Node.js)或云对象,上传到云空间;前端通过 uniCloud.callFunction 或客户端 SDK 直接调用;数据库用 MongoDB 类文档模型(阿里云空间)或类 MySQL 文档模型(腾讯云空间),通过 JQL 在前端或云函数里操作。
整体分层是:前端(uni-app/uni-app x)→ uniCloud 网关 → 云函数/云对象运行时 → 云数据库/云存储。开发者不需要管理服务器,只需要写函数与数据库 schema。
原理流程
前端 uni.request / uniCloud.callFunction / clientDB
→ uniCloud 网关(鉴权、路由、限流)
→ 云函数/云对象运行时(Node.js)
→ 云数据库(文档型)/ 云存储(对象存储)
→ 返回结果
代码或图示
工程结构:
uni-app-project/
├── cloudfunctions/ # 云函数/云对象
│ ├── login/index.js
│ └── user/ # 云对象
└── uni-clientdb/ # clientDB schema 与校验
常见误区
- 误区:uniCloud 就是把 Node 后端托管;正解:它还封装了 clientDB、schema 校验、权限规则、云存储等 BaaS 能力,不只是函数托管。
- 误区:uniCloud 只能给 uni-app 用;正解:uniCloud 也支持 H5、App 直连,甚至非 uni-app 前端通过 API 调用(具体方式以官方文档为准)。
追问
- uniCloud 与传统后端最大的差别?答:前端可以直接操作数据库(clientDB),但必须靠 schema 与安全规则兜底,否则会有越权风险。
- 为什么叫"云空间"?答:每个项目在阿里云或腾讯云上有一个独立的服务空间,隔离数据库、存储与函数资源。
07.2.4.7-002 阿里云空间与腾讯云空间有什么差异?
一句话结论
uniCloud 支持两种服务商:阿里云空间(基于阿里云,数据库为 MongoDB 兼容文档模型)与腾讯云空间(基于腾讯云,数据库为类 MySQL 文档模型/CloudBase),两者在数据库语法、计费方式、底层能力上有差异;同一套前端代码通常可以迁移,但 schema 与云函数要按文档适配。
概念解释
阿里云空间是 DCloud 早期主推的方案,云数据库是 MongoDB 风格的文档数据库,JQL 在前端生成 MongoDB 查询;云函数运行在阿里云函数计算上。腾讯云空间是 DCloud 与腾讯云 CloudBase 合作的方案,底层是腾讯云 CloudBase,数据库语法与计费模型跟随腾讯云。
两者差异点:一是数据库方言(MongoDB 操作符 vs 腾讯云文档模型);二是计费方式与免费额度;三是云函数运行时版本与地域;四是部分高级能力(如 clientDB 聚合、触发器)的支持程度。实际选型时要按团队熟悉的云厂商、成本、已有服务来定。
原理流程
选择服务商
├─ 阿里云空间:MongoDB 兼容数据库 + 阿里云函数计算
└─ 腾讯云空间:腾讯云 CloudBase + 腾讯云文档数据库
↓
前端 JQL 语法基本一致,但底层查询与计费按服务商文档核对
代码或图示
| 维度 | 阿里云空间 | 腾讯云空间 |
|---|---|---|
| 底层云厂商 | 阿里云 | 腾讯云 CloudBase |
| 数据库模型 | MongoDB 兼容文档 | 腾讯云文档模型 |
| 计费 | 按阿里云规则 | 按腾讯云规则 |
| 迁移成本 | 同一前端代码可迁,但 schema/函数需适配 | 同左 |
常见误区
- 误区:阿里云与腾讯云空间完全等价;正解:数据库方言、计费、部分高级能力有差异,不能假设无缝切换。
- 误区:uniCloud 是 DCloud 自己的服务器;正解:它跑在阿里云/腾讯云之上,DCloud 做封装。
追问
- 新项目选哪个?答:按团队已有云厂商经验、成本、地域选择;JQL 层面两者基本一致,业务代码可复用。
- 迁移空间要做什么?答:导出数据、改 schema、重新上传云函数、调整环境变量,具体以 DCloud 迁移指南为准。
07.2.4.7-003 什么是服务空间与多环境隔离?
一句话结论
服务空间是 uniCloud 里资源隔离的基本单位(一个空间对应一套独立的数据库、存储、函数);多环境通过创建多个空间(开发/测试/生产)实现隔离,前端在不同环境下连接不同空间 ID。
概念解释
uniCloud 在管理后台可以创建多个服务空间,每个空间有独立的 spaceId、数据库、存储、函数。开发时用开发空间,测试用测试空间,生产用生产空间,避免开发污染生产数据。前端在 manifest.json 或代码里配置当前环境对应的 spaceId,编译时按环境切换。
云函数本身也可以有环境变量,不同空间配置不同的值(如数据库连接、第三方密钥)。这样同一套代码在不同空间运行时,行为与数据完全隔离。
原理流程
三个服务空间:dev / test / prod
├─ 开发:连接 dev spaceId,数据可随意改
├─ 测试:连接 test spaceId,QA 验证
└─ 生产:连接 prod spaceId,真实用户
↓
前端按环境变量切换 spaceId,云函数按空间环境变量读密钥
代码或图示
| 环境 | 用途 | 数据 | 密钥 |
|---|---|---|---|
| dev | 本地开发 | 测试数据 | 测试密钥 |
| test | QA 回归 | 接近生产的数据 | 测试密钥 |
| prod | 线上 | 真实数据 | 生产密钥 |
常见误区
- 误区:开发和生产用同一个空间;正解:会导致开发改数据污染线上,必须多空间隔离。
- 误区:环境切换靠改代码重新发布;正解:通过环境变量/编译参数切换 spaceId,不写死在代码里。
追问
- spaceId 写在哪里?答:在 manifest.json 的 uniCloud 配置里,或在代码里按环境判断(具体字段以官方文档为准)。
- 云函数的环境变量怎么配?答:在 uniCloud 控制台对应空间的云函数配置里设置,不同空间独立。
07.2.4.7-004 云函数的运行机制是什么?
一句话结论
云函数是运行在 uniCloud 托管 Node.js 环境里的无状态函数,前端通过 uniCloud.callFunction 触发,函数接收 event 与 context,执行业务逻辑后返回 JSON;它有冷启动、超时、并发限制,适合做"无状态、短生命周期"的后端逻辑。
概念解释
每个云函数是一个独立目录,入口 index.js 导出 main(event, context)。event 是前端传的参数,context 包含调用信息(如用户 uid、环境信息)。函数执行完 return 一个可序列化对象给前端。
云函数是无状态的:两次调用之间不保留内存状态,需要持久化的数据必须放数据库或存储。它有冷启动:长时间没调用后第一次执行要初始化 Node.js 运行时,延迟较高;之后热调用会复用实例。超时时间通常是几秒到几十秒(具体阈值以官方文档为准,待确认)。
原理流程
前端 uniCloud.callFunction({ name: 'login', data: { code } })
→ 网关鉴权(token)
→ 路由到 login 云函数
→ 冷启动(首次)或复用实例
→ main(event, context) 执行
→ 返回 JSON
→ 函数实例回收/保持待命
代码或图示
// 示意:cloudfunctions/login/index.js
exports.main = async (event, context) => {
const { code } = event;
// 用 code 换 openid,查/建用户,返回 token
return { token: 'xxx', uid: '123' };
};
常见误区
- 误区:云函数可以在内存里存全局状态;正解:实例可能被回收,状态必须持久化到数据库。
- 误区:云函数超时可以无限长;正解:有超时上限,长任务要拆或用队列。
追问
- 冷启动怎么优化?答:保持函数频繁被调用(预热)、减小函数包体积、把重逻辑异步化;具体预热策略以官方能力为准。
- 云函数能跑多久?答:有最大执行时间,超过会被网关中断,具体秒数以当前官方文档为准(待确认)。
07.2.4.7-005 云函数的 context 里有哪些关键信息?
一句话结论
context 携带调用方身份与环境信息,最核心的是 context.UID(已登录用户 ID)与环境信息;云函数通过它识别"是谁在调用",从而做权限判断。
概念解释
前端调用 uniCloud 时如果带了登录态(uni-id 登录后 token),网关会解析 token 并把用户 uid 注入 context.UID。云函数不需要自己再解析 token,直接用 context.UID 就能拿到当前用户。这是 uniCloud 与传统后端最大的差别之一:鉴权由网关完成,业务函数只管业务。
context 还包含空间信息、函数名、调用来源等。开发时要打印 context 确认 uid 是否正确,生产环境不要把敏感 context 字段返回给前端。
原理流程
前端带 token 调用
→ 网关校验 token
→ 解析出 uid
→ 注入 context.UID
→ 云函数 main(event, { UID, ... })
→ 业务用 UID 查数据库
代码或图示
// 示意:context.UID 的使用
exports.main = async (event, context) => {
const uid = context.UID; // 已登录用户 ID,未登录时可能为空
if (!uid) throw new Error('未登录');
const orders = await db.collection('orders').where({ uid }).get();
return orders;
};
常见误区
- 误区:前端传的 uid 可信;正解:前端传的 uid 不可信,必须用 context.UID,否则会越权查别人数据。
- 误区:所有调用都自动有 UID;正解:只有走 uni-id 登录态并带 token 的调用才注入 UID,未登录调用 UID 为空。
追问
- 未登录调用怎么处理?答:函数里判断 context.UID 是否存在,不存在则返回未登录错误。
- context 里还有什么?答:环境信息、函数名、source 等,具体字段以官方文档为准(待确认)。
07.2.4.7-006 云函数的并发与冷启动模型是什么?
一句话结论
云函数按请求自动扩缩容:每个请求可能在一个新实例上执行,同一时间多个请求会并发启动多个实例;长时间无请求实例会被回收,下次请求冷启动;并发上限受服务商配额与配置限制。
概念解释
云函数是事件驱动的:来一个请求就启动(或复用)一个实例跑。热点函数会有多个实例并行处理,冷僻函数在空闲后被回收。这与传统常驻服务不同——你不需要预估实例数,但要承担冷启动延迟与并发上限。
对业务的影响:一是冷启动会让首次调用变慢,需要预热或接受;二是并发上限意味着突发流量可能被限流,要做好降级;三是无状态设计,不能在实例内存里缓存用户会话。
原理流程
请求 1 → 实例 A(冷启动)
请求 2 → 实例 B(冷启动)
请求 3 → 复用实例 A(热调用)
空闲一段时间 → 实例被回收
下次请求 → 再次冷启动
代码或图示
| 现象 | 原因 | 应对 |
|---|---|---|
| 首次调用慢 | 冷启动 | 预热、减小包体 |
| 突发流量报错 | 并发上限 | 扩容配额、队列削峰 |
| 内存状态丢失 | 实例回收 | 状态持久化 |
常见误区
- 误区:云函数比传统服务器省钱就一定省;正解:高频调用时函数计费可能比常驻服务器贵,要按实际流量估算。
- 误区:云函数可以处理长连接/WebSocket;正解:无状态短请求模型不适合长连接,需要其他方案。
追问
- 并发上限怎么查?答:在 uniCloud 控制台看当前空间的配额,具体数值以官方为准(待确认)。
- 怎么预热?答:定时任务或监控探针定期调用热点函数,保持实例热。
07.2.4.7-007 云对象是什么,与云函数有何差异?
一句话结论
云对象是云函数的面向对象封装:一个云对象是一个带多个方法的类,前端通过 obj.method() 直接调用,省去了云函数里 switch(event.action) 的分发代码;它比云函数更适合组织多方法的业务模块。
概念解释
传统云函数里,一个函数文件要自己根据 event 里的 action 分发不同逻辑:if (event.action === 'a') ... else if (event.action === 'b')。云对象把这个模式变成类:导出一个类,每个方法自动成为可调用的端点,前端 uniCloud.importObject('user').getInfo() 直接调。
云对象内部仍然跑在云函数运行时里,本质是一个云函数 + 一层 RPC 封装。它的好处是代码组织清晰、前端调用直观;限制是云对象方法仍受云函数超时与并发限制。
原理流程
云对象代码:
module.exports = {
getInfo() { ... },
updateProfile(data) { ... }
}
前端:
const user = uniCloud.importObject('user')
const info = await user.getInfo()
代码或图示
// 示意:cloudfunctions/user/index.obj.js(云对象)
module.exports = {
async getInfo() {
const uid = this.getCloudFunctionContext().UID; // context 访问方式以官方为准
return await db.collection('users').doc(uid).get();
},
async updateProfile(data) {
// 校验并更新
}
};
常见误区
- 误区:云对象是一种新的运行时;正解:它只是云函数的语法糖,底层还是同一个函数运行时。
- 误区:云对象方法可以互相同步调用不消耗资源;正解:跨云对象调用仍是一次函数调用,有网络与序列化成本。
追问
- 云对象与云函数怎么选?答:多方法业务模块用云对象更清晰;单方法/简单 webhook 用云函数即可。
- 云对象怎么拿 context?答:通过内置 API(如
this.getCloudFunctionContext())访问,具体 API 名以官方文档为准(待确认)。
07.2.4.7-008 云对象的调用方式与前端调用有何差异?
一句话结论
云对象在前端通过 uniCloud.importObject('对象名') 拿到代理对象,然后直接 await obj.method(args) 调用;它返回的就是方法 return 的值,不像云函数要包在 result.result 里。
概念解释
云函数调用返回 { result, errCode, errMsg },业务数据在 result 字段;云对象调用直接返回方法 return 的值(或抛错),前端写法更接近普通函数调用。云对象还支持跨端(前端、其他云函数)调用,以及在云函数里通过 importObject 调用其他云对象。
这种设计减少了样板代码,但要注意:云对象方法仍然是远程调用,不是本地函数,有网络延迟与序列化成本,不能在循环里高频调用来回。
原理流程
前端:
const user = uniCloud.importObject('user')
const info = await user.getInfo()
↓ 实际是一次 RPC 请求
云对象服务端:
getInfo() 执行 → return 值 → 序列化为 JSON → 前端拿到
代码或图示
// 前端:云对象 vs 云函数调用对比
// 云函数:
const res = await uniCloud.callFunction({ name: 'user', data: { action: 'getInfo' } })
const info = res.result
// 云对象:
const user = uniCloud.importObject('user')
const info = await user.getInfo()
常见误区
- 误区:云对象方法是本地执行;正解:仍是远程 RPC,有延迟,不能在前端循环里高频调用。
- 误区:云对象不能在云函数里调;正解:云函数/云对象之间可以互相调用,但跨调用有成本。
追问
- 云对象报错怎么捕获?答:try/catch,错误会被包装成可识别的错误对象,具体错误码以官方文档为准。
- 云对象支持上传文件吗?答:文件上传走云存储,云对象接收文件 ID/URL 处理,不是直接传二进制。
07.2.4.7-009 云函数/云对象能直接操作云数据库吗?
一句话结论
能。云函数与云对象运行时自带 uniCloud.database() 客户端,可以直接操作云数据库,不受 clientDB 的权限规则限制;这是处理"敏感操作、复杂事务、服务端逻辑"的主要入口。
概念解释
前端 clientDB 受 schema 与安全规则约束(防越权),但云函数/云对象运行在服务端,调用数据库时是管理员权限,不受客户端权限规则限制。这意味着:所有敏感操作(改密码、支付、批量写、跨用户查询)都应该放在云函数/云对象里做,前端只调函数,不让前端直接写库。
这种"前端受限 + 服务端全权"的双层模型是 uniCloud 安全的核心:clientDB 方便但要靠规则兜底,云函数安全但要自己写逻辑。
原理流程
前端 clientDB:受 schema permission 约束(谁能读/写什么)
云函数/云对象:管理员权限,可任意操作
↓
敏感逻辑放云函数,前端只传参数
代码或图示
// 云函数里操作数据库(服务端权限)
const db = uniCloud.database();
exports.main = async (event, context) => {
// 不受 clientDB 权限限制,可跨用户查
const list = await db.collection('orders').where({ status: 'paid' }).get();
return list;
};
常见误区
- 误区:云函数里也受 permission 限制;正解:服务端调用是管理员权限,规则不生效。
- 误区:前端 clientDB 够安全就不用云函数;正解:涉及敏感写操作(支付、改密)必须云函数,不能只靠前端规则。
追问
- 云函数里怎么做事务?答:用数据库事务 API(startTransaction),具体语法以数据库类型文档为准。
- 云函数能调外部 HTTP 接口吗?答:能,用 Node.js 的 http/https 或内置 request API,注意出网限制与超时。
07.2.4.7-010 云数据库的 schema 是什么?
一句话结论
schema 是云数据库集合(collection)的结构定义文件,描述字段类型、必填、默认值、校验规则、权限;它既是文档结构约束,也是 clientDB 安全规则与校验的依据。
概念解释
在 uniCloud 里,每个集合对应一个 schema 文件(JSON 格式),放在 uni-clientdb/schema/ 或云函数目录下。schema 里定义:字段名、类型(string/number/boolean/object/array 等)、是否必填、默认值、枚举、正则校验、以及 permission 权限规则(create/read/update/delete 各角色的允许条件)。
schema 的作用有三:一是前端 clientDB 写入时自动校验;二是权限规则让前端只能读/写被允许的数据;三是作为文档结构的自描述,方便团队协作。
原理流程
前端 clientDB 写入
→ 网关加载对应集合的 schema
→ 校验字段类型、必填、正则
→ 检查 permission:当前角色能否 create/read/update/delete
→ 通过 → 写数据库
→ 不通过 → 返回错误
代码或图示
// 示意:schema 片段(字段名与规则以官方文档为准)
{
"bsonType": "object",
"required": ["title", "content"],
"permission": {
"read": "doc.uid == auth.uid",
"create": "doc.uid == auth.uid",
"update": "doc.uid == auth.uid",
"delete": false
},
"properties": {
"title": { "bsonType": "string", "maxLength": 100 },
"content": { "bsonType": "string" },
"uid": { "bsonType": "string" }
}
}
常见误区
- 误区:schema 只是文档;正解:它是运行时校验与权限规则的执行依据,写错会导致越权或正常写入被拒。
- 误区:permission 设成 true 最省事;正解:
read: true意味着任何人都能读全表数据,是严重越权漏洞。
追问
- permission 支持哪些角色?答:auth(已登录)、anonymous(未登录)、以及自定义角色,具体语法以官方文档为准。
- schema 改了要重新上传吗?答:要,schema 改动需重新部署到云空间才生效。
07.2.4.7-011 云数据库的字段类型与索引怎么设计?
一句话结论
字段类型用 BSON 类型(string/number/boolean/object/array/date 等),索引按查询条件建(where、排序、分组字段),联合索引要注意顺序;不合理的索引会拖慢写入,缺失索引会让查询变慢。
概念解释
云数据库是文档型(MongoDB 兼容),每条记录是一个 BSON 文档。字段类型在 schema 里声明,运行时校验。索引用于加速查询:经常作为 where 条件、排序、分组的字段应该建索引;但索引不是越多越好,每个索引都会增加写入成本与存储。
设计经验:一是按高频查询条件建单字段或联合索引;二是联合索引字段顺序按"等值条件在前、范围/排序在后";三是避免在大数组上建索引;四是定期用 explain 分析慢查询(具体工具以数据库控制台为准)。
原理流程
查询 db.collection('orders').where({ uid: 'x', status: 'paid' }).orderBy('create_date', 'desc')
→ 查找是否有匹配索引
├─ 有:走索引,快速定位
└─ 无:全表扫描,数据量大时慢
代码或图示
| 设计点 | 建议 |
|---|---|
| 高频 where 字段 | 建索引 |
| 排序字段 | 与 where 字段建联合索引 |
| 大数组字段 | 谨慎建索引 |
| 低频查询字段 | 不建,避免拖慢写入 |
常见误区
- 误区:所有字段都建索引最快;正解:索引过多会让写入变慢、存储变大,要按查询模式权衡。
- 误区:文档数据库不用考虑索引;正解:数据量大后无索引查询会全表扫描,必须建索引。
追问
- 怎么看慢查询?答:云数据库控制台有慢查询日志或 explain 分析,具体工具以服务商为准。
- 联合索引顺序?答:等值匹配字段在前,范围/排序字段在后,遵循最左前缀原则。
07.2.4.7-012 云数据库与传统 MySQL 数据库的本质差异是什么?
一句话结论
云数据库是文档型(MongoDB 兼容),schema-less 但通过 schema 文件约束,嵌套对象与数组是一等公民;传统 MySQL 是关系型,表结构固定、需要 join、事务严格;两者在建模、查询、扩展方式上差异明显。
概念解释
文档型把一条业务数据(如一个订单 + 订单里的商品列表)存在一个文档里,不需要 join;关系型要拆成订单表、订单商品表,查询时 join。文档型适合业务对象嵌套、迭代快的场景;关系型适合复杂报表、跨表事务、强一致性场景。
uniCloud 选择文档模型的原因是:前端拿到一个对象就能渲染,减少后端组装;但复杂统计、跨表关联、强事务要谨慎设计,必要时走云函数聚合或迁到关系型数据库。
原理流程
文档模型:
order = { _id, uid, amount, items: [{sku, qty, price}], status }
一次读取拿到完整订单
关系模型:
orders(_id, uid, amount, status)
order_items(order_id, sku, qty, price)
查询需要 JOIN
代码或图示
| 维度 | 文档型(云数据库) | 关系型(MySQL) |
|---|---|---|
| 数据结构 | 嵌套文档 | 表 + 行 |
| 关联 | 嵌入或引用 | join |
| schema | 灵活(文件约束) | 严格表结构 |
| 事务 | 单文档强事务,多文档事务有限 | 强事务 |
| 扩展 | 水平扩展容易 | 分库分表复杂 |
常见误区
- 误区:文档型就不用设计 schema;正解:文档型也要在 schema 文件里约束,否则数据会乱。
- 误区:文档型不能做复杂查询;正解:可以聚合(aggregate),但能力与复杂度与 SQL 不同,复杂报表要评估。
追问
- 什么场景必须用关系型?答:强财务对账、跨多表复杂事务、复杂报表统计时,文档模型会吃力。
- uniCloud 能接外部 MySQL 吗?答:云函数里可以通过 Node.js MySQL 库连接外部数据库,但要注意连接池与配额。
07.2.4.7-013 什么是 clientDB,它解决什么问题?
一句话结论
clientDB 是 uniCloud 提供的"前端直接操作数据库"能力:前端用 JQL(JavaScript Query Language)直接增删改查云数据库,后端不写接口;安全性靠 schema 的 permission 规则兜底,适合 CRUD 为主、权限模型清晰的页面。
概念解释
传统模式是前端 → 云函数 API → 数据库,每个列表/表单都要写接口。clientDB 让前端直接 db.collection('orders').where(...).get(),网关在中间做 schema 校验与 permission 检查。这极大减少了后端代码,但前提是权限模型清晰(如"用户只能看自己的数据")。
clientDB 的边界是:它不能处理复杂事务、跨表聚合、服务端敏感逻辑;这些仍要走云函数。滥用 clientDB 直接写敏感操作(如改余额、支付)会有严重安全风险。
原理流程
前端:
const db = uniCloud.database()
const res = await db.collection('orders').where({ uid: auth.uid }).get()
↓
网关:加载 schema → 校验字段 → 检查 permission.read 规则 → 执行查询
代码或图示
// 前端 clientDB 查询示意
const db = uniCloud.database();
const res = await db.collection('articles')
.where({ status: 'published' })
.orderBy('publish_date', 'desc')
.limit(20)
.get();
常见误区
- 误区:clientDB 就是前端直连数据库,不安全;正解:网关在中间做 schema 校验与权限规则,不是裸连。
- 误区:所有操作都可以用 clientDB;正解:敏感写操作必须走云函数,clientDB 只做权限清晰的 CRUD。
追问
- clientDB 与云函数怎么选?答:权限模型清晰的简单 CRUD 用 clientDB,复杂/敏感逻辑用云函数。
- clientDB 能做聚合吗?答:支持 JQL 聚合能力(group/count 等),具体函数清单以官方文档为准。
07.2.4.7-014 JQL 的查询能力与边界是什么?
一句话结论
JQL 是前端类 SQL 的查询语法,支持 where、orderBy、limit、skip、field、聚合(count/group)等;它的边界是:复杂关联、子查询、跨集合事务、服务端强校验必须走云函数,不能全靠 JQL。
概念解释
JQL 的设计目标是"让前端写出接近 SQL 的查询",但它是受限的:一是只在当前集合内查询,跨集合关联要么嵌入文档,要么云函数组装;二是聚合能力有限,复杂统计(多表 join、窗口函数)做不到;三是写操作受 permission 规则限制。
JQL 的典型能力:where 条件匹配、排序、分页、字段投影、count、group by、正则、地理查询(具体支持以文档为准)。超出这些能力就应该写云函数。
原理流程
JQL 调用
→ 网关翻译成数据库查询
→ 应用 permission 过滤
→ 返回结果
复杂需求(跨集合/事务/聚合)
→ 走云函数,用服务端 SDK 操作
代码或图示
| 能力 | JQL 支持 | 备注 |
|---|---|---|
| where 条件 | 支持 | 等值、范围、in、正则 |
| 排序分页 | 支持 | orderBy/skip/limit |
| 字段投影 | 支持 | field() |
| count/group | 支持 | 简单聚合 |
| 跨集合 join | 不支持 | 云函数组装 |
| 多文档事务 | 受限 | 云函数处理 |
常见误区
- 误区:JQL 能替代所有 SQL;正解:它是面向简单 CRUD 的受限语法,复杂场景必须云函数。
- 误区:JQL 返回的是全表数据;正解:permission 规则会自动过滤,前端只能拿到被授权的行。
追问
- JQL 怎么做分页?答:skip + limit,大数据量深分页有性能问题,建议用游标/日期范围分页。
- JQL 能写复杂聚合吗?答:简单 count/group 可以,复杂报表要云函数。
07.2.4.7-015 安全规则(permission)如何防住越权?
一句话结论
permission 在 schema 里声明每个角色对每个集合 create/read/update/delete 的允许条件,网关在执行 JQL 时自动应用规则;正确的规则是"用户只能操作自己的数据",错误配置(如 read: true)会导致全表泄露。
概念解释
permission 规则是表达式,基于 auth.uid(当前用户)与 doc(文档)判断。常见规则:read: "doc.uid == auth.uid"(只能读自己的数据)、create: "doc.uid == auth.uid"(只能创建属于自己的记录)、update: false(禁止前端改)、delete: false(禁止前端删)。
风险点:一是把规则设成 true 让所有人读写全表;二是规则里漏了 doc.uid == auth.uid,导致用户能读别人数据;三是敏感字段(如余额、角色)允许前端 update,被篡改。安全做法是:默认最小权限,敏感字段走云函数更新。
原理流程
前端 JQL 查询
→ 网关拿到当前 auth.uid
→ 执行 schema.permission.read 表达式
├─ 表达式为 true → 允许查询并自动过滤 doc.uid == auth.uid
└─ 表达式为 false → 拒绝
代码或图示
| 规则配置 | 风险 |
|---|---|
read: "doc.uid == auth.uid" |
安全,只能读自己 |
read: true |
高危,全表可读 |
update: true |
高危,任何人可改任意记录 |
update: false |
安全,改必须走云函数 |
常见误区
- 误区:前端传 uid 就能查别人数据;正解:permission 会强制过滤,前端传的 uid 不作为信任依据。
- 误区:permission 只在 clientDB 生效;正解:云函数运行在服务端,不受 permission 约束,敏感操作必须自己校验。
追问
- 怎么审计 permission 配置?答:每个集合的 permission 都要 review,敏感字段(金额、角色、状态)禁止前端直接 update。
- 规则表达式语法?答:基于 JS 表达式,具体可用变量与函数以官方文档为准(待确认)。
07.2.4.7-016 云存储怎么用,权限怎么控制?
一句话结论
云存储是对象存储(类似 OSS/COS),用于存图片、文件;前端通过 uniCloud.uploadFile 上传,拿到 fileID;访问通过 fileID 或 CDN 域名;权限靠存储空间级规则或 fileID 分享控制。
概念解释
云数据库里存的是 fileID(字符串),不是文件本身。上传流程:前端选文件 → uniCloud.uploadFile 传到云存储 → 返回 fileID → 把 fileID 存到数据库。读取时通过 fileID 换 URL 或直接在组件里用 fileID 显示图片。
权限模型:存储空间可以设置公共读/私有;私有文件通过临时签名 URL 访问;敏感文件(身份证、合同)应设为私有,通过云函数签发临时 URL,避免公开泄露。
原理流程
前端选图
→ uniCloud.uploadFile({ filePath, cloudPath })
→ 云存储返回 fileID
→ db.collection('users').doc(uid).update({ avatar: fileID })
→ 其他端通过 fileID 显示图片
代码或图示
| 存储场景 | 权限建议 |
|---|---|
| 公开图片(头像、商品图) | 公共读,CDN 加速 |
| 私有文件(证件、合同) | 私有,云函数签发临时 URL |
| 用户上传内容 | 按业务隔离目录,防覆盖 |
常见误区
- 误区:云存储存数据库里;正解:数据库存 fileID,文件在对象存储里。
- 误区:所有文件都设公共读;正解:敏感文件必须私有,否则任何人猜 URL 就能下载。
追问
- 上传大小有限制吗?答:有上限,具体以官方文档为准(待确认),大文件要分片或直传。
- 云存储 CDN 怎么配?答:在控制台绑定 CDN 域名,具体以服务商文档为准。
07.2.4.7-017 定时任务与队列怎么用?
一句话结论
定时任务(触发器)按 cron 规则定时触发云函数,适合做日结、报表、推送、清理;队列用于异步削峰,把耗时任务从请求链路里拆出来后台跑。
概念解释
定时任务在云函数配置里加一个 cron 表达式(如每天 0 点跑),到点网关自动调用函数。典型场景:每天统计订单、清理过期数据、定时推送、对账。队列则是:请求进来时先写一条队列消息,立即返回,后台 worker 函数消费队列慢慢处理,避免请求超时。
uniCloud 的定时任务配置在控制台或函数配置文件里;队列能力以 DCloud 提供的队列模块或云函数异步实现为准(待确认)。
原理流程
定时任务:
cron 表达式(每天 0 点)→ 网关触发 report 云函数 → 跑报表 → 写数据库
队列:
请求 → 写队列消息 → 立即返回
后台 worker 消费队列 → 处理 → 完成
代码或图示
| 场景 | 方案 |
|---|---|
| 每日报表 | 定时任务 |
| 批量推送 | 定时任务 + 队列 |
| 耗时异步任务 | 队列 |
| 数据清理 | 定时任务 |
常见误区
- 误区:定时任务是前端定时调;正解:在服务端配置 cron,网关自动触发,不依赖前端在线。
- 误区:队列就是云函数里 await;正解:队列要异步化,请求不能等队列处理完。
追问
- 定时任务失败怎么办?答:函数要有重试与日志,失败告警;具体重试策略以官方能力为准。
- 队列怎么保证不丢?答:用可靠的消息队列服务(uniCloud 提供的队列模块或外部 MQ),具体以官方为准。
07.2.4.7-018 日志、监控与运维怎么做?
一句话结论
uniCloud 提供云函数日志(console.log 输出)、调用统计、错误监控;运维要关注:函数调用次数、错误率、冷启动次数、数据库查询量、存储用量;异常时通过日志定位。
概念解释
云函数里 console.log 输出在控制台日志里可见,每次调用都有一条日志(含 event、context、耗时、错误)。控制台能看调用量、错误率、配额使用。监控维度:调用次数趋势、错误率、平均耗时、冷启动次数、数据库读/写次数、存储用量。
实际运维要做:设置配额告警(快到上限时提醒)、错误率告警、慢查询日志;定期review 函数日志排查异常。uniCloud 本身不提供 APM 级别的前端监控,前端错误要自己接 Sentry/前端监控。
原理流程
云函数执行 → console.log 收集 → 控制台日志页可查
↓
控制台统计:调用量 / 错误率 / 耗时 / 配额
↓
异常 → 查日志 → 定位 event/context/堆栈
代码或图示
| 监控项 | 关注点 |
|---|---|
| 调用量与错误率 | 是否突增、是否有报错 |
| 函数耗时 | 是否有慢函数 |
| 数据库读写 | 是否超配额 |
| 存储用量 | 是否超空间 |
| 前端错误 | 需接外部 APM |
常见误区
- 误区:云函数日志会自动保留很久;正解:日志保留期有限,重要日志要持久化或接外部监控。
- 误区:uniCloud 自带前端性能监控;正解:前端监控要自己接,uniCloud 只管函数与服务端。
追问
- 怎么告警?答:控制台配置配额告警,错误率告警能力以官方为准;关键业务可在云函数里主动发通知。
- 日志里能看到敏感信息吗?答:生产环境不要在日志里打印 token、密码、身份证等敏感数据。
07.2.4.7-019 uniCloud 的计费模型是什么,什么时候该迁到传统后端?
一句话结论
uniCloud 按调用次数、数据库读写量、存储用量、出网流量计费,有免费额度;当业务进入高频调用、大数据量、复杂事务或强定制需求时,uniCloud 成本与能力会遇到瓶颈,应评估迁到传统后端(Node/Java/Go + 自建数据库)。
概念解释
uniCloud 计费典型项:云函数调用次数(按百万次)、数据库读/写次数、存储 GB、出网流量。免费额度适合小项目与创业期;业务增长后,高频调用、大表查询、高频读写会让账单上升。
判断迁移的信号:一是云函数调用量巨大,函数计费比常驻服务器贵;二是数据库需要复杂 join、事务、报表,文档模型吃力;三是需要深度定制(特殊中间件、长连接、自定义运维);四是团队有成熟后端能力,不需要 BaaS 抽象。迁移是渐进的:先把敏感/高频逻辑迁到云函数外,再逐步迁数据库。
原理流程
业务初期:uniCloud 快速上线,成本低
↓
业务增长:
├─ 调用量/数据量在免费额度内 → 继续
├─ 账单上升但能力够用 → 优化函数/索引/缓存
└─ 能力瓶颈(复杂事务/长连接/定制)→ 评估迁传统后端
代码或图示
| 阶段 | 推荐 |
|---|---|
| MVP/创业 | uniCloud 快速上线 |
| 增长期 | uniCloud + 优化 |
| 成熟期 | 评估关键链路迁传统后端 |
常见误区
- 误区:uniCloud 永远比自建服务器便宜;正解:高频调用时函数计费会超过常驻服务器,要按实际流量算账。
- 误区:迁传统后端就是重写;正解:可以渐进,先迁热点函数与数据库,保留部分 uniCloud。
追问
- 怎么估算成本?答:在控制台看历史用量 × 单价,预测业务增长后估算。
- 迁传统后端最大的成本?答:数据迁移、API 重写、前端调用层改造、以及双轨运行期间的兼容。
07.2.4.7-020 综合题:一个电商项目,哪些链路走 uniCloud,哪些必须走云函数/传统后端?
一句话结论
按"权限清晰度 + 敏感性 + 复杂度"分层:商品浏览、用户信息、简单 CRUD 走 clientDB;下单、支付、库存、对账、敏感配置走云函数;大促峰值、复杂报表、跨系统对接评估迁传统后端。
概念解释
电商场景典型分层:
- 商品列表、详情、评价:权限清晰(公开读),用 clientDB,配合 schema 规则。
- 用户地址、收藏、足迹:用户只能读写自己的数据,permission 规则可覆盖,clientDB。
- 购物车:写操作但数据敏感,建议云函数(防并发、防越权改数量)。
- 下单:必须云函数,校验库存、算价格、写订单、扣库存(事务)。
- 支付:云函数,对接支付平台回调,验签,更新订单状态。
- 库存:云函数,并发扣减,防止超卖。
- 对账:定时任务,复杂聚合。
- 大促峰值:评估云函数并发上限,必要时加缓存、队列、或迁传统后端。
这种分层让 clientDB 做简单 CRUD 提效,云函数做敏感逻辑兜底,传统后端处理峰值与复杂场景。
原理流程
商品浏览 → clientDB(公开读)
用户中心 → clientDB(permission: uid == auth.uid)
购物车 → 云函数(并发校验)
下单 → 云函数(事务:库存+订单)
支付 → 云函数(回调验签)
对账 → 定时任务
峰值 → 缓存 + 队列 + 评估传统后端
代码或图示
| 链路 | 推荐方式 | 理由 |
|---|---|---|
| 商品列表/详情 | clientDB | 公开读,简单查询 |
| 用户地址/收藏 | clientDB | 权限规则清晰 |
| 购物车 | 云函数 | 并发与数量校验 |
| 下单/支付/库存 | 云函数 | 事务与敏感 |
| 对账/统计 | 定时任务 | 异步聚合 |
| 大促峰值 | 缓存 + 队列 | 防函数并发打满 |
常见误区
- 误区:所有电商逻辑都用 clientDB 最快;正解:下单支付库存必须云函数,clientDB 直接写会有超卖与越权。
- 误区:uniCloud 扛不住大促;正解:通过缓存、队列、限流可以扛住中等流量,超大促才需评估迁移。
追问
- 怎么防超卖?答:库存扣减用原子操作或数据库事务,在云函数里先校验再扣减,不要在前端扣。
- 支付回调怎么处理?答:云函数接收支付平台回调,验签后更新订单状态,不要信任前端传的支付结果。