MongoDB on Liangweidong's blog

MongoDB 实战：Windows 安装、用户与权限配置

Wed, 15 Sep 2021 00:00:00 +0800

为什么写这篇：MongoDB 的用户体系跟 MySQL 完全不同——user@host 不存在，取而代之的是 用户对库的 role（dbOwner、readWrite、read）。本文整理 MongoDB 6.0 在 Windows 上的安装 + 启用 auth + 给特定库建账号的完整流程。

适用读者：第一次部署 MongoDB、需要做用户管理的运维 / 后端。

前置知识：会用 mongosh 客户端、了解文档型数据库概念。

1. MongoDB 6.0 Windows 安装

1.1 下载

官方地址：https://www.mongodb.com/try/download/community
直链示例：https://fastdl.mongodb.org/windows/mongodb-windows-x86_64-6.0.5-signed.msi

1.2 安装

安装向导里两个关键点：

数据目录：建议改成非系统盘（如 <MONGO_INSTALL_DIR>\data）
日志目录：建议单独放（如 <MONGO_INSTALL_DIR>\log）

默认安装路径：C:\Program Files\MongoDB\Server\6.0\bin

1.3 验证

1
2
3


# PowerShell
& "C:\Program Files\MongoDB\Server\6.0\bin\mongod.exe" --version
# db version v6.0.5

2. auth 启用前：建 root 账号

关键约束：MongoDB 启用 auth 之前必须先建超级管理员账号，否则启用后无人能登录——这跟 MySQL 8.0 改密码插件时的注意事项类似。

2.1 进入 admin 库

1
2


mongosh
# 或老版本：mongo

1

use admin

2.2 创建超级管理员

1
2
3
4
5


db.createUser({
 user: "admin",
 pwd: "{{REDACTED}}",
 roles: ["root"]
})

root role 是 MongoDB 内置的最高权限角色，可以做任何操作。

2.3 验证（仍在 admin 库）

1
2


db.auth("admin", "{{REDACTED}}")
// 返回 1 = 成功

3. 给特定库建独立账号

生产最佳实践：每个应用库都有独立的 dbOwner 账号——这样即使某个库账号泄露，攻击者也只能动一个库。

3.1 进入目标库

1
2
3


use kuaibao
// 注意 use kuaibao 不需要 kuaibao 库已存在
// 但创建账号前要先 use 进来

3.2 创建库级账号

1
2
3
4
5
6
7


db.createUser({
 user: "kb",
 pwd: "{{REDACTED}}",
 roles: [
 { role: "dbOwner", db: "kuaibao" }
 ]
})

dbOwner 包含的权限：

操作	能否做
read / write 数据	✓
create / drop collection	✓
create / drop index	✓
建账号、改密码	✓（限本库）
跨库读写	✗

4. 启用 auth 验证模式

4.1 编辑配置文件

1
2
3
4


# C:\Program Files\MongoDB\Server\6.0\bin\mongod.cfg

security:
 authorization: enabled

4.2 重启 MongoDB 服务

1
2
3
4


# 服务方式
Restart-Service MongoDB

# 或任务管理器 → 服务 → MongoDB → 重启

4.3 验证 auth 已生效

1

mongosh

1
2
3


use kuaibao
show collections
// 应该报错：not authorized on kuaibao to execute command

1
2
3
4


db.auth("kb", "{{REDACTED}}")
// 返回 1 = 验证成功
show collections
// 现在能正常显示了

重要：用 db.auth() 之前必须先 use <库名>——auth 是对当前库生效的。

5. Navicat 连接报错的排错

5.1 启用 auth 后 Navicat 连不上

现象：输入正确账号密码后报错 “auth failed” 或 “command listDatabases not allowed”。

原因：用 kb 账号登录但想 list 所有库——而 kb 只有 kuaibao 库的 dbOwner 权限。

修法：

方法 1：在 Navicat 里只勾选 kuaibao 库（连接属性 → Databases → 只勾需要的）
方法 2：用 admin（root）账号登录——能看所有库

5.2 老版本 MongoDB 客户端连接

MongoDB 5.0+ 启用了 SCRAM-SHA-256 认证，老客户端（MongoDB 4.2 之前的）连不上。修法：

升级客户端到 4.2+
或临时改成 SCRAM-SHA-1（不推荐，安全性下降）

5.3 Navicat 的 authSource

Navicat 连接 MongoDB 时，authSource 默认是 admin——意思是"用 admin 库验证身份"。如果你的用户是建在 kuaibao 库里，必须改：

1

连接属性 → Advanced → Authentication source: kuaibao

否则用 kb/{{REDACTED}} 登录会被当成"在 admin 库找 kb 用户"——找不到。

5.4 连接超时

mongodb://10.0.0.10:27017 连不上，先看三件事：

防火墙：27017 端口是否开放
bindIp：默认 127.0.0.1——只允许本机连，远程需要改 0.0.0.0
服务启动：Windows 服务 MongoDB Server 是否在 Running

1
2
3
4


# mongod.cfg
net:
 port: 27017
 bindIp: 0.0.0.0 # 监听所有网卡

6. MongoDB 用户体系速查

6.1 内置角色

角色	权限范围	适用
`root`	所有库 + 所有操作	超级管理员
`dbAdmin`	库 schema、索引、统计	DBA
`dbOwner`	dbAdmin + readWrite + 建账号	应用库账号
`readWrite`	读写数据	普通应用
`read`	只读	BI 报表
`userAdmin`	只能建/改账号	权限管理员
`clusterAdmin`	整个集群	集群 DBA

6.2 角色继承

MongoDB 的 role 是叠加的——可以一次给多个 role：

1
2
3
4
5
6
7
8
9


db.createUser({
 user: "report",
 pwd: "{{REDACTED}}",
 roles: [
 { role: "read", db: "kuaibao" },
 { role: "read", db: "log_center" },
 { role: "readWrite", db: "report_tmp" }
 ]
})

6.3 跨库只读

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// 跨 5 个库都只读
db.createUser({
 user: "bi_user",
 pwd: "{{REDACTED}}",
 roles: [
 { role: "read", db: "kuaibao" },
 { role: "read", db: "log_center" },
 { role: "read", db: "user_center" },
 { role: "read", db: "order_center" },
 { role: "read", db: "goods_center" }
 ]
})

6.4 修改用户密码

1
2
3
4
5
6


// 改当前库用户
db.changeUserPassword("kb", "{{NEW_REDACTED}}")

// 改其他库用户（需要先 use 过去）
use admin
db.changeUserPassword("admin", "{{NEW_REDACTED}}")

6.5 删除用户

1
2


use kuaibao
db.dropUser("kb")

6.6 查看所有用户

1
2


use admin
db.system.users.find().pretty()

常见坑

坑 1：use 库与 createUser 的关系

1
2
3
4


use some_db
db.createUser({...}) // 创建的是 some_db 里的用户
// 用户名是 some_db 里的，但 username 还是 'kb'
// 登录时需要 authSource=some_db

坑 2：root 账号登录后想看所有库

1
2
3
4
5


// 必须用 admin 库验证
use admin
db.auth("admin", "{{REDACTED}}")
show dbs
// 这次能列出所有

坑 3：enable auth 后忘了 admin 密码

修法：临时关闭 auth → 重建账号 → 再开 auth。

1
2
3


# mongod.cfg
security:
 # authorization: enabled # 注释掉

1

Restart-Service MongoDB

1
2
3
4


mongosh
use admin
db.createUser({ user: "admin", pwd: "{{NEW_REDACTED}}", roles: ["root"] })
// 退出

1
2


security:
 authorization: enabled  # 重新开启

1

Restart-Service MongoDB

坑 4：MongoDB 6.0 默认不再绑定 localhost

6.0 起默认 bindIp: localhost——只能本机连。远程连接必须改 0.0.0.0。

MongoDB vs MySQL 用户体系对比

维度	MySQL	MongoDB
账号格式	`user@host`	`user` + `authSource`
权限粒度	全局 / 库 / 表 / 列	库 / collection
跨库权限	一次 GRANT 给多个库	role 数组里列多个库
角色继承	自定义	内置 role + 自定义 role
改密码	`ALTER USER`	`db.changeUserPassword`
忘记 root	`skip-grant-tables`	临时关 auth
客户端默认 auth	库是 `mysql`	库是 `admin`

下一步

MySQL 实时同步 Canal / Debezium：见《MySQL 实时同步实战》
PostgreSQL + TimescaleDB：见《PostgreSQL 实战》
国产数据库人大金仓：见《人大金仓实战》

2024+ 视角：MongoDB 7.0 / 8.0 与 AI 时代

MongoDB 7.0 关键变化

可恢复的删除：误删的 collection 可在"可恢复删除窗口"内 db.coll.restoreCollection() 救回
加密查询（Queryable Encryption）：字段级加密 + 支持 $eq / $range 等范围查询——以前只能完全密文，2024+ 平衡了"安全 + 可查"
分片集群自动负载均衡：Balancer 引入"区域感知"，跨地域部署延迟降 20%

MongoDB 8.0（2024-08 GA）核心新特性

复合通配符索引（Compound Wildcard Indexes）：一个索引覆盖整个文档结构——以前需要为每种字段组合建索引
时序集合（Time Series Collections）增强：内置降采样、压缩，替代 InfluxDB 不少场景
MongoDB Vector Search GA：与 Atlas 集成，支持 $vectorSearch 聚合阶段——直接对标 pgvector

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// 8.0 向量检索示例
db.embeddings.aggregate([
 {
 $vectorSearch: {
 index: "vector_index",
 path: "embedding",
 queryVector: [0.1, 0.2, ...],
 numCandidates: 100,
 limit: 5
 }
 }
])

角色体系的 2024+ 演进

MongoDB 7.0+ 引入 Built-in Roles for Time Series / Atlas Stream Processing——按需细粒度授权：

角色	适用
`readAnyDatabase`	跨库只读
`readWriteAnyDatabase`	跨库读写
`dbAdmin` 扩展	时序集合管理
`backup` / `restore`	备份恢复专用

mongosh 替代 mongo 客户端

2022 年起 mongo 官方标记为 deprecated，生产环境必须用 mongosh：

1
2
3
4
5
6
7
8


# 装 mongosh
brew install mongosh # macOS
# 或下载解压
wget https://downloads.mongodb.com/compass/mongosh-2.3.0-linux-x64.tgz

# 旧习惯 → 新习惯
mongo --host 10.0.0.10 # ❌ 已废弃
mongosh "mongodb://10.0.0.10:27017/admin" # ✅

安全 2024+ 新基线

强制 TLS：所有连接必须 tls=true，明文连接官方弃用
SCRAM-SHA-256 默认：SCRAM-SHA-1 已废弃，2025 后将移除
审计日志结构化：auditLog 写 JSON，可直接对接 ELK

替代品对比（2024+ 视角）

场景	MongoDB	替代品
通用文档库	MongoDB 8.0	Couchbase / Amazon DocumentDB
时序数据	MongoDB 8.0 TS Collections	InfluxDB 3.x / TimescaleDB
向量检索	MongoDB VS	pgvector / Milvus / Qdrant
端边端轻量	不用	SQLite + sqlite-vec
图数据	不擅长	Neo4j / Memgraph

实战建议（2024+）

云上选 Atlas / DocumentDB——自建运维成本高，云原生是企业首选
关键业务加 Vector Search——RAG / 推荐系统用 MongoDB 一站式搞定
schema validation 必开——MongoDB 灵活但要"灵活得有纪律"
审计 + 加密 2024+ 是合规硬要求

MongoDB 与 Mosquitto：NoSQL 与 MQTT 消息中间件 Docker 部署实战

Sun, 15 Dec 2019 00:00:00 +0800

关系型数据库解决"业务核心数据"（订单、用户、账户），但物联网 / 实时消息 / 文档型数据这些场景，传统 RDBMS 反而显得笨重：JSON 文档要拆成多张表、消息上行要支持 publish/subscribe、时序数据要写一条立刻收一条。MongoDB（文档数据库）+ Mosquitto（MQTT broker）就是这个组合的"老搭档"——前者存灵活结构的数据，后者负责把设备/客户端消息实时收上来。这篇文章把这两个在 Docker 里的部署、配置、客户端连接一次性说清楚。

阅读对象：做 IoT 网关、需要落地 JSON 设备数据；做聊天/推送需要轻量消息中间件；想给应用加 publish/subscribe 能力的后端工程师。 覆盖范围：MongoDB 4.x 容器启动、admin 库认证、连接字符串、备份恢复；Eclipse Mosquitto 配置文件、密码文件、客户端工具（MQTTBox）。

一、为什么是 MongoDB + Mosquitto

场景	关系型数据库	MongoDB	MQTT
设备上报 JSON 文档	拆多张表，麻烦	直接存 BSON，灵活	上行通道
实时控制指令下发	轮询，延迟高	不擅长	pub/sub，毫秒级
设备状态变更通知	触发器 + 轮询	Change Stream	天然支持
一台服务器几万台设备	撑不住	水平分片	百万级连接
数据查询分析	强	中（聚合管道）	不存数据

典型组合：设备 → Mosquitto（MQTT broker）→ 业务后端消费 → 写入 MongoDB → 前端 / BI 查询。Mosquitto 是"水管"，MongoDB 是"水池"。

二、MongoDB 4.x 容器化

2.1 拉取与启动

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


# 拉镜像
docker pull mongo:4.4.5-bionic

# 用 docker compose 启动（推荐）
cat << 'EOF' > docker-compose.yml
version: '3'
services:
 mongo:
 image: mongo:4.4.5-bionic
 container_name: mongo
 restart: always
 ports:
 - "27017:27017"
 volumes:
 - /home/docker/mongo/data:/data/db
 - /home/docker/mongo/conf:/data/configdb
 environment:
 MONGO_INITDB_ROOT_USERNAME: admin
 MONGO_INITDB_ROOT_PASSWORD: {{REDACTED}}
 command: ["--auth"]
EOF

docker-compose up -d

关键参数：

command: ["--auth"] 开启访问控制（不带 --auth 等于"裸奔"，任意客户端可读写）

MONGO_INITDB_ROOT_USERNAME/PASSWORD：初始化 root 账号（仅在首次启动未挂载数据时生效）

2.2 mongo.conf 配置示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


# /home/docker/mongo/conf/mongo.conf
storage:
 dbPath: /data/db
 journal:
 enabled: true

systemLog:
 destination: file
 path: /var/log/mongodb/mongod.log
 logAppend: true

net:
 port: 27017
 bindIp: 0.0.0.0

processManagement:
 fork: true
 pidFilePath: /var/run/mongodb.pid

security:
 authorization: enabled

2.3 客户端连接字符串

1

mongodb://admin:{{REDACTED}}@internal.example.com:27017/?authSource=admin

元素	说明
`mongodb://`	协议
`admin:{{REDACTED}}`	账号:密码（脱敏占位）
`internal.example.com:27017`	宿主机 + 端口
`?authSource=admin`	认证库（root 账号必须在 admin 库认证）

2.4 常见坑

重启后 admin 密码失效：旧版 MongoDB 镜像在 data 卷有数据时不会重新执行 init 脚本。要重置密码：先不带 --auth 启动 → 进 mongo shell 改 admin.system.users → 重启。
时区：MongoDB 存的是 UTC，前端展示时按业务时区（Asia/Shanghai）+ 8 小时。
大文档 16MB 上限：单文档超过 16MB 会写入失败，IoT 大数据要拆成多条或改用 GridFS。

三、Eclipse Mosquitto（MQTT Broker）

Mosquitto 是 Eclipse 基金会维护的轻量级 MQTT broker，单机能撑百万级连接（取决于内存和 fd 上限），是 IoT 领域的"事实标准"。

3.1 拉取与启动

1

docker pull eclipse-mosquitto

3.2 目录结构

1
2
3


/mosquitto/data # 持久化数据
/mosquitto/log # 日志
/mosquitto/config # 配置 + 密码文件

宿主机创建这三个目录并赋权：

1
2
3


mkdir -p /mosquitto/{data,log,config}
chmod -R 755 /mosquitto
chmod -R 777 /mosquitto/log

3.3 配置文件 `mosquitto.conf`

1
2
3
4
5
6
7


persistence true
persistence_location /mosquitto/data/
log_dest file /mosquitto/log/mosquitto.log

# 关闭匿名模式（生产环境必开）
allow_anonymous false
password_file /mosquitto/config/pwfile.conf

3.4 创建密码文件

1
2
3
4
5
6
7


touch /mosquitto/config/pwfile.conf
chmod -R 755 /mosquitto/config/pwfile.conf

# 在容器内执行（不要在宿主机直接编辑，会被容器覆盖）
docker exec -it <container_id> bash
mosquitto_passwd -b /mosquitto/config/pwfile.conf hangge 123
# -b 表示非交互式（用户名 hangge 密码 123，生产请用强密码）

3.5 启动容器

1
2
3
4
5
6


docker run -it \
 -p 1883:1883 -p 9001:9001 \
 -v /mosquitto/config/mosquitto.conf:/mosquitto/config/mosquitto.conf \
 -v /mosquitto/data \
 -v /mosquitto/log \
 eclipse-mosquitto

端口说明：

1883：MQTT 默认 TCP 端口（明文）

9001：WebSocket 端口（前端订阅用）

8883：MQTT over TLS（加密）—— 启动时再加 -p 8883:8883 并配置证书

3.6 客户端连接

工具	平台	用途
MQTTBox	Chrome 扩展 / 桌面	测试用，支持 publish + subscribe + 多种协议
MQTTX	跨平台桌面（Mac/Win/Linux）	EMQ 出品，UI 现代，推荐
mosquitto_sub/pub	CLI	服务端调试，脚本化测试
Paho	Java/Python/JS 库	应用集成

MQTTBox 连接示例：

1
2
3
4
5
6
7
8


Protocol: mqtt://
Host: internal.example.com
Port: 1883
Username: hangge
Password: 123
Client ID: mqttbox_001
Topic: iot/sensor/temperature
QoS: 1

命令行测试：

1
2
3
4
5
6
7
8


# 订阅
mosquitto_sub -h internal.example.com -p 1883 \
 -u hangge -P 123 -t "iot/#" -v

# 发布
mosquitto_pub -h internal.example.com -p 1883 \
 -u hangge -P 123 -t "iot/sensor/temperature" \
 -m '{"value": 25.6, "ts": 1700000000}'

四、IoT 落地架构示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


[设备/传感器] [前端 / 业务系统]
 │ publish ▲ subscribe
 ▼ │
┌─────────────┐ consume ┌─────────┐ │ 写入
│ Mosquitto │ ────────► │ 后端服务 │ ──┘
│ (1883/8883) │ │ (Spring │ MongoDB
└─────────────┘ │ Boot) │ ┌──────────┐
 └─────────┘ │ Mongo │
 │ Cluster │
 └──────────┘

组件	作用	选型提示
设备端 SDK	paho / mqtt.js / NanoMQ	嵌入式选 C SDK
Broker	Mosquitto / EMQX / VerneMQ	单机 Mosquitto，集群 EMQX
消费后端	Spring Boot / Node.js	设备量大考虑 EMQX Rule Engine 直接落库
持久化	MongoDB / InfluxDB / TimescaleDB	文档型选 MongoDB，时序选时序库

五、扩展阅读

MongoDB 官方镜像：hub.docker.com/_/mongo
Eclipse Mosquitto 镜像：hub.docker.com/_/eclipse-mosquitto
MQTTBox 下载：workswithweb.com
EMQX 文档：emqx.io（百万级连接考虑）
Paho 客户端库：eclipse.org/paho

Spring Boot 文件操作实战：URL 代理下载 + GridFS 大文件存储

Wed, 20 Jun 2018 00:00:00 +0800

Spring Boot 文件操作实战：URL 代理下载 + GridFS 大文件存储

背景与价值

Spring Boot 项目中常见的文件场景：

场景 1：内网文件代理下载。A 系统对外暴露，B 系统在内网跑 MinIO 等对象存储。A 需要把 B 的文件地址代理出去给外网用户。
场景 2：大文件存储。100MB+ 的文件、PDF、视频不能用 MySQL BLOB（性能差），改用 MongoDB GridFS 分片存储。

本文给出两个场景的完整代码方案。

场景 1：URL 代理中转下载

1. 架构

1
2
3
4
5


用户浏览器
 ↓ http://A_HOST:8080/file/test/xxx.mp3
A 系统（外网）
 ↓ http://B_HOST:9000/test/xxx.mp3
B 系统（内网 MinIO，不对外）

问题：如果 A 把 B 的 URL 直接返回给用户，用户无法访问 B（B 在内网）。

方案：A 解析 /file/xxx 路径 → A 自己用 HttpURLConnection 去 B 下载 → A 把字节流转发给用户。

2. 核心工具类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62


public class FileOperateUtil {

 private static final Logger log = LoggerFactory.getLogger(FileOperateUtil.class);

 /**
 * URL 文件代理中转
 * @param response Servlet 响应
 * @param address 内网真实下载地址
 * @param contentType MIME 类型（null 自动判断）
 * @param fileName 下载文件名
 */
 public static void proxyUrlFile(HttpServletResponse response, String address,
 String contentType, String fileName) throws IOException {
 InputStream inputStream = null;
 ServletOutputStream outputStream = null;
 HttpURLConnection httpURLConnection = null;

 try {
 // 1. 连接内网真实地址
 URL url = new URL(address);
 httpURLConnection = (HttpURLConnection) url.openConnection();
 httpURLConnection.setConnectTimeout(5000);
 httpURLConnection.setReadTimeout(30000);
 httpURLConnection.connect();

 int code = httpURLConnection.getResponseCode();
 if (code != 200) {
 response.setStatus(HttpServletResponse.SC_NOT_FOUND);
 return;
 }

 inputStream = httpURLConnection.getInputStream();
 outputStream = response.getOutputStream();

 // 2. 设置响应头
 if (contentType != null) {
 response.setContentType(contentType);
 } else {
 response.setContentType("application/octet-stream");
 }
 if (fileName != null) {
 String encoded = new String(fileName.getBytes("utf-8"), "ISO8859-1");
 response.setHeader("Content-disposition", "attachment; filename=\"" + encoded + "\"");
 }

 // 3. 流式转发（1024 字节 buffer）
 byte[] buffer = new byte[1024];
 int len;
 while ((len = inputStream.read(buffer)) != -1) {
 outputStream.write(buffer, 0, len);
 }
 outputStream.flush();
 } catch (Exception e) {
 log.error("Proxy URL File error, address={}", address, e);
 throw e;
 } finally {
 if (inputStream != null) inputStream.close();
 if (outputStream != null) outputStream.close();
 if (httpURLConnection != null) httpURLConnection.disconnect();
 }
 }
}

3. Controller 暴露

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


@RestController
public class FileProxyController {

 /**
 * 通用文件代理接口
 * @param url 内网真实 URL
 * @param fileName 下载文件名
 */
 @GetMapping("/file/proxy")
 public void proxy(@RequestParam("url") String url,
 @RequestParam(value = "fileName", required = false) String fileName,
 HttpServletResponse response) throws IOException {
 FileOperateUtil.proxyUrlFile(response, url, null, fileName);
 }
}

4. 替代方案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


// ✅ 方案 B：Spring 5+ Resource 方式
@GetMapping("/file/proxy2")
public ResponseEntity<Resource> proxy2(@RequestParam String url) throws IOException {
 URL urlObj = new URL(url);
 InputStreamResource resource = new InputStreamResource(urlObj.openStream());
 return ResponseEntity.ok()
 .contentType(MediaType.APPLICATION_OCTET_STREAM)
 .body(resource);
}

// ✅ 方案 C：直接 redirect（适用于 B 系统本身能对外）
@GetMapping("/file/redirect")
public ResponseEntity<Void> redirect(@RequestParam String url) {
 return ResponseEntity.status(302)
 .header("Location", url)
 .build();
}

5. 实战坑

坑 1：大文件 OOM

1
2
3
4
5
6
7
8
9


// ❌ 错误：把整个文件读进内存
byte[] data = inputStream.readAllBytes();
response.getOutputStream().write(data);

// ✅ 正确：流式 1024 字节 buffer 转发
byte[] buffer = new byte[1024];
while ((len = inputStream.read(buffer)) != -1) {
 outputStream.write(buffer, 0, len);
}

坑 2：Content-Length 缺失导致下载速度慢

1
2


// 主动设置 Content-Length（浏览器可显示进度条）
response.setContentLengthLong(httpURLConnection.getContentLengthLong());

坑 3：中文文件名乱码

1
2


// 文件名 UTF-8 → ISO8859-1 编码（HTTP Header 只支持 ASCII）
String encoded = new String(fileName.getBytes("utf-8"), "ISO8859-1");

坑 4：Nginx 反代超时

如果 A 在 Nginx 后面，Nginx 默认 proxy_read_timeout 60s 会切断长文件传输：

1
2
3
4
5
6


location /file/ {
 proxy_pass http://A_BACKEND;
 proxy_read_timeout 600s; # 10 分钟
 proxy_send_timeout 600s;
 proxy_buffering off; # 关闭缓冲，支持流式
}

场景 2：MongoDB GridFS 大文件存储

1. 适用场景

单文件 > 16MB（MySQL BLOB 不合适）
文件数量大（百万级），需要分布式存储
不想引入 MinIO / HDFS 额外组件

2. 依赖

1
2
3
4


<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

1
2
3
4
5


spring:
 data:
 mongodb:
 uri: mongodb://{{MONGO_USER}}:{{MONGO_PASSWORD}}@{{MONGO_HOST}}:27017/files
 database: files

3. GridFS 存储原理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


文件 > 16MB 自动分片存储：

fs.files collection:
 {
 _id: ObjectId("..."),
 filename: "video.mp4",
 length: 524288000, // 总大小
 chunkSize: 261120, // 单 chunk 255KB
 uploadDate: ISODate("..."),
 md5: "abc123..."
 }

fs.chunks collection:
 { files_id: ObjectId("..."), n: 0, data: BinData(...) } // chunk 0
 { files_id: ObjectId("..."), n: 1, data: BinData(...) } // chunk 1
 ...

4. Service 层

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


@Service
public class GridfsService {

 @Autowired
 private MongoDbFactory mongoDbFactory;

 /**
 * 上传文件
 */
 public String save(MultipartFile file) throws IOException {
 GridFS gridFS = new GridFS(mongoDbFactory.getDb());

 try (InputStream in = file.getInputStream()) {
 GridFSInputFile gridFile = gridFS.createFile(in);
 gridFile.setFilename(file.getOriginalFilename());
 gridFile.setContentType(file.getContentType());
 gridFile.save();

 return gridFile.getId().toString(); // 返回 ObjectId
 }
 }

 /**
 * 按 ID 查询
 */
 public GridFSDBFile getById(String id) {
 GridFS gridFS = new GridFS(mongoDbFactory.getDb());
 return gridFS.findOne(new BasicDBObject("_id", new ObjectId(id)));
 }

 /**
 * 删除
 */
 public void remove(String id) {
 GridFS gridFS = new GridFS(mongoDbFactory.getDb());
 gridFS.remove(new ObjectId(id));
 }

 /**
 * 分片查询（分页展示文件列表）
 */
 public List<GridFSDBFile> listByFilename(String filename, int skip, int limit) {
 GridFS gridFS = new GridFS(mongoDbFactory.getDb());
 return gridFS.find(filename == null ? new BasicDBObject()
 : new BasicDBObject("filename", filename))
 .skip(skip)
 .limit(limit)
 .toList();
 }
}

5. Controller 层

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


@RestController
public class FileController {

 @Autowired
 private GridfsService gridfsService;

 @PostMapping("/file/upload")
 public Map<String, Object> upload(@RequestParam("file") MultipartFile file) throws IOException {
 String id = gridfsService.save(file);

 Map<String, Object> result = new HashMap<>();
 result.put("id", id);
 result.put("name", file.getOriginalFilename());
 result.put("size", file.getSize());
 result.put("url", "/file/download/" + id);
 return result;
 }

 @GetMapping("/file/download/{id}")
 public void download(@PathVariable String id, HttpServletResponse response) throws IOException {
 GridFSDBFile file = gridfsService.getById(id);
 if (file == null) {
 response.setStatus(HttpServletResponse.SC_NOT_FOUND);
 return;
 }

 response.setContentType(file.getContentType());
 response.setContentLengthLong(file.getLength());
 response.setHeader("Content-Disposition",
 "attachment; filename=\"" +
 new String(file.getFilename().getBytes("utf-8"), "ISO8859-1") + "\"");

 try (OutputStream out = response.getOutputStream()) {
 file.writeTo(out);
 }
 }

 @DeleteMapping("/file/{id}")
 public Map<String, Object> delete(@PathVariable String id) {
 gridfsService.remove(id);
 return Map.of("success", true, "id", id);
 }
}

6. Spring Boot 3.x 用 Spring Data MongoDB 4.x 替代

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


@Service
public class GridfsServiceV2 {

 @Autowired
 private GridFsTemplate gridFsTemplate;
 @Autowired
 private GridFsOperations gridFsOperations;

 public String save(MultipartFile file) throws IOException {
 DBObject metaData = new BasicDBObject();
 metaData.put("uploadUser", "anonymous");
 GridFSFile gridFile = gridFsTemplate.store(
 file.getInputStream(),
 file.getOriginalFilename(),
 file.getContentType(),
 metaData
 );
 return gridFile.getObjectId().toString();
 }

 public void download(String id, HttpServletResponse response) throws IOException {
 GridFSFile gridFile = gridFsOperations.findOne(
 new Query(Criteria.where("_id").is(new ObjectId(id)))
 );
 if (gridFile == null) {
 response.setStatus(HttpServletResponse.SC_NOT_FOUND);
 return;
 }

 response.setContentType(gridFile.getMetadata().get("_contentType").toString());
 response.setContentLengthLong(gridFile.getLength());

 try (OutputStream out = response.getOutputStream()) {
 gridFsOperations.getResource(gridFile).getInputStream().transferTo(out);
 }
 }
}

7. 实战坑

坑 1：Spring Boot 3.x 不再使用 MongoDbFactory

com.mongodb.gridfs.GridFS API 在 Spring Data MongoDB 4.x 中被移除，改用 GridFsTemplate + GridFsOperations。

坑 2：GridFS 单文档 16MB 限制的真相

MongoDB BSON 单文档限制 16MB
GridFS 自动分片：文件 > 16MB 自动拆成 255KB 的 chunk 存储
GridFS 适合任意大小文件（KB 到 GB）

坑 3：分片集群下 GridFS 性能

GridFS 用 fs.files + fs.chunks 两个 collection，推荐对 fs.chunks.files_id + n 建复合索引：

1

db.fs.chunks.createIndex({ files_id: 1, n: 1 });

坑 4：删除文件后磁盘不释放

GridFS 删除只是删除 fs.files 和 fs.chunks 文档，MongoDB 不会立即归还磁盘。需在主节点上执行 db.runCommand({ compact: "fs.chunks" }) 释放空间（运维慎用）。

坑 5：上传大文件超时

1
2
3
4
5
6
7
8


spring:
 servlet:
 multipart:
 max-file-size: 500MB  # 单文件最大
 max-request-size: 500MB
 data:
 mongodb:
 uri: mongodb://...?socketTimeoutMS=60000&connectTimeoutMS=10000

Nginx 也需要配置 client_max_body_size 500m; 和 proxy_read_timeout。

方案选型

场景	推荐方案
小文件 < 16MB	MySQL BLOB / OSS / MinIO
大文件 16MB-1GB	MongoDB GridFS（轻量、零运维）
视频 / 备份 > 1GB	MinIO / S3（对象存储、CDN 友好）
实时流媒体	ZLMediaKit + go2rtc（专用流媒体）
跨外网文件下载	Spring URL 代理（A 系统转发 B 系统）

前置知识与下一步

前置：

Spring Boot 基础
HTTP 协议（响应头、流式传输）
MongoDB 基础（可选）

下一步：

用 MinIO 替代 GridFS（专业对象存储）
断点续传：前端切片 + 后端合并，避开单文件上传限制
CDN 加速：OSS / MinIO + CDN 域名降源站压力

小结

两个场景都是企业级常见需求：

URL 代理下载：用 HttpURLConnection + Servlet 流式转发，避开 A→B 内网穿透限制
GridFS 大文件：MongoDB 自动分片（255KB/chunk），适合 16MB-1GB 范围

关键注意点：

URL 代理必须流式转发（不要 readAllBytes 全部读进内存）
GridFS 在 Spring Boot 3.x 改用 GridFsTemplate API
大文件链路全栈（Spring + Nginx + MongoDB）都要调超时参数

2024+ 视角：MinIO / S3 主导的大文件时代

对象存储是 2024+ 的"正确答案"

2024 之后，MinIO / S3 / OSS 已成为大文件存储的事实标准——GridFS 仅在"不想引入额外组件"的小型项目里用。

1
2
3
4
5
6
7


// Spring Boot 3.x + MinIO（生产推荐）
@Dependency
<dependency>
 <groupId>io.minio</groupId>
 <artifactId>minio-java</artifactId>
 <version>8.5.10</version>
</dependency>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


@Service
public class MinioService {

 @Autowired
 private MinioClient minioClient;

 public String upload(MultipartFile file) throws Exception {
 String objectName = UUID.randomUUID() + "-" + file.getOriginalFilename();

 minioClient.putObject(
 PutObjectArgs.builder()
 .bucket("my-bucket")
 .object(objectName)
 .stream(file.getInputStream(), file.getSize(), -1)
 .contentType(file.getContentType())
 .build()
 );
 return objectName;
 }

 public InputStream download(String objectName) throws Exception {
 return minioClient.getObject(
 GetObjectArgs.builder()
 .bucket("my-bucket")
 .object(objectName)
 .build()
 );
 }

 public String presignedUrl(String objectName, int expirySeconds) throws Exception {
 return minioClient.getPresignedObjectUrl(
 GetPresignedObjectUrlArgs.builder()
 .method(Method.GET)
 .bucket("my-bucket")
 .object(objectName)
 .expiry(expirySeconds)
 .build()
 );
 }
}

预签名 URL（2024+ 推荐方案）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// 上传预签名：客户端直传 MinIO，不经过 Java 后端
String uploadUrl = minioClient.getPresignedObjectUrl(
 PutObjectUrlArgs.builder()
 .bucket("my-bucket")
 .object(objectName)
 .expiry(600) // 10 分钟
 .build()
);

// 客户端拿到 URL 直接 PUT 文件
// curl -X PUT --data-binary @file.mp4 "https://minio.example.com/..."

核心优势：

大文件不经过 Java 后端——降低带宽、内存压力
URL 有时效（默认 10 分钟），防盗链
客户端断点续传：Range: bytes=0-10485759 原生支持

MinIO 2024+ 核心特性

纠删码（Erasure Coding）：12 块盘允许坏 4 块，数据不丢
多云联邦：一份数据跨 AWS S3 / 阿里云 OSS / 腾讯云 COS 自动同步
S3 API 100% 兼容——任何 S3 SDK 都能直接对接
K8s Operator GA——MinIO 集群在 K8s 上的官方部署方案

MinIO vs OSS / S3 / COS 对比

维度	MinIO	AWS S3	阿里云 OSS	腾讯云 COS
部署	自建	云	云	云
成本	硬件成本	按量付费	按量付费	按量付费
性能	极高	极高	高	高
S3 兼容	原生	100%	99%	95%
适合	私有化 / 信创	出海 / 全球	国内 ToB	国内 ToC

大文件上传的 2024+ 范式：客户端直传 + 预签名

1
2
3
4
5
6


1. 客户端 → Java 后端：请求上传 URL
2. Java 后端 → MinIO：申请预签名 URL（10 分钟有效）
3. Java 后端 → 客户端：返回预签名 URL + objectName
4. 客户端 → MinIO：直接 PUT 文件（不经过 Java 后端）
5. 客户端 → Java 后端：通知上传完成
6. Java 后端 → DB：保存文件元数据（objectName、大小、MD5）

优势：Java 后端零带宽消耗——100GB 文件上传也不会压垮应用。

大文件下载的 2024+ 范式：CDN + Range

1
2
3


客户端 → CDN（缓存命中）→ 直接返回
 ↓（未命中）
 MinIO（带 Range 头分片）

1
2
3
4
5
6
7


# Nginx 反代 MinIO，开启 Range 支持
location /files/ {
 proxy_pass http://minio-backend:9000;
 proxy_set_header Range $http_range;
 proxy_buffering off;
 proxy_request_buffering off; # 大文件不缓存请求体
}

2024+ GridFS 的真实定位

GridFS 仍适用的场景：

已经在用 MongoDB，不想引入 MinIO
文件量少（百万级以内）
单文件 < 1GB
团队没人懂 MinIO / S3

不适合：

视频、备份等 GB 级文件
大量小文件（百万级以上）
需要 CDN 加速

实战坑（2024+）

MinIO 在 K8s 上：必须用 distributed 模式（4 节点起步），单节点有数据丢失风险
Nginx 反代 MinIO：必须设 proxy_request_buffering off 否则大文件上传会缓存到磁盘
预签名 URL 时区：MinIO 默认 UTC，签名时系统时区不一致会导致签名失败
Spring Cloud 2024+ 推荐方案：直接用 Spring Cloud AWS / Spring Cloud Alibaba OSS 抽象层，跨云切换零成本

经验补记

MinIO Console（2024+ 改名）：内置管理 UI 替代旧的 mc 命令行
MinIO Bucket Replication：跨集群复制"开箱可用"
Rust 写的：Rustic 是 Rust 写的备份工具，原生支持 S3 / MinIO 目标

MongoDB on Liangweidong's blog

MongoDB 实战：Windows 安装、用户与权限配置

目录

1. MongoDB 6.0 Windows 安装

1.1 下载

1.2 安装

1.3 验证

2. auth 启用前：建 root 账号

2.1 进入 admin 库

2.2 创建超级管理员

2.3 验证（仍在 admin 库）

3. 给特定库建独立账号

3.1 进入目标库

3.2 创建库级账号

4. 启用 auth 验证模式

4.1 编辑配置文件

4.2 重启 MongoDB 服务

4.3 验证 auth 已生效

5. Navicat 连接报错的排错

5.1 启用 auth 后 Navicat 连不上

5.2 老版本 MongoDB 客户端连接

5.3 Navicat 的 authSource

5.4 连接超时

6. MongoDB 用户体系速查

6.1 内置角色

6.2 角色继承

6.3 跨库只读

6.4 修改用户密码

6.5 删除用户

6.6 查看所有用户

常见坑

坑 1：use 库与 createUser 的关系

坑 2：root 账号登录后想看所有库

坑 3：enable auth 后忘了 admin 密码

坑 4：MongoDB 6.0 默认不再绑定 localhost

MongoDB vs MySQL 用户体系对比

下一步

2024+ 视角：MongoDB 7.0 / 8.0 与 AI 时代

MongoDB 7.0 关键变化

MongoDB 8.0（2024-08 GA）核心新特性

角色体系的 2024+ 演进

mongosh 替代 mongo 客户端

安全 2024+ 新基线

替代品对比（2024+ 视角）

实战建议（2024+）

MongoDB 与 Mosquitto：NoSQL 与 MQTT 消息中间件 Docker 部署实战

一、为什么是 MongoDB + Mosquitto

二、MongoDB 4.x 容器化

2.1 拉取与启动

2.2 mongo.conf 配置示例

2.3 客户端连接字符串

2.4 常见坑

三、Eclipse Mosquitto（MQTT Broker）

3.1 拉取与启动

3.2 目录结构

3.3 配置文件 mosquitto.conf

3.4 创建密码文件

3.5 启动容器

3.6 客户端连接

四、IoT 落地架构示例

五、扩展阅读

Spring Boot 文件操作实战：URL 代理下载 + GridFS 大文件存储

Spring Boot 文件操作实战：URL 代理下载 + GridFS 大文件存储

背景与价值

场景 1：URL 代理中转下载

1. 架构

2. 核心工具类

3. Controller 暴露

4. 替代方案

5. 实战坑

场景 2：MongoDB GridFS 大文件存储

1. 适用场景

2. 依赖

3. GridFS 存储原理

4. Service 层

5. Controller 层

6. Spring Boot 3.x 用 Spring Data MongoDB 4.x 替代

7. 实战坑

方案选型

前置知识与下一步

3.3 配置文件 `mosquitto.conf`