罗罗编程学习记录
本页内容 展开查看

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 扛不住大促;正解:通过缓存、队列、限流可以扛住中等流量,超大促才需评估迁移。

追问

  • 怎么防超卖?答:库存扣减用原子操作或数据库事务,在云函数里先校验再扣减,不要在前端扣。
  • 支付回调怎么处理?答:云函数接收支付平台回调,验签后更新订单状态,不要信任前端传的支付结果。