后端开发 on Zampo Blog

PostgreSQL 真正厉害的，不是性能，而是它把最后一道权限判断留在了数据库里

Fri, 17 Apr 2026 09:33:20 +0800

我越来越觉得，很多团队的安全问题，不是前面没做，而是最后收得不够。

浏览器有隔离，接口有鉴权，服务上了 HTTPS，机器放在内网里，日志和审计也配了。可等请求真的落到 PostgreSQL，后端连过去的，还是一个几乎什么都能做的高权限角色。

前面一层一层都像样，最后这一跳却像没上锁。

这也是我最近看 PostgreSQL 安全这条视频时，最有感触的一点：PostgreSQL 真正厉害的，不是它默认很安全，也不只是它功能多，而是它把最后一道权限判断留在了数据库里。

你以为自己会用 PostgreSQL，其实你只是会写 SQL

Mon, 13 Apr 2026 17:18:00 +0800

很多开发者天天在用 PostgreSQL，但只要你追问三个问题，场面就会立刻安静下来：它为什么并发强？为什么崩了还能恢复？为什么 JSONB、大文本这些大字段没把系统拖死？

如果这些问题你平时很少认真想过，那你多半还停留在“会用 PostgreSQL”的表层。说得再狠一点：很多人其实不是理解 PostgreSQL，只是会写 SQL。

PostgreSQL 入门：为什么说它能装下世间万物？

Tue, 07 Apr 2026 12:16:00 +0800

这是世界上最先进的开源关系型数据库。

PostgreSQL 的能力早已超越了传统关系型数据库的范围。现代开发中，为了解决各种问题，各类花哨的工具层出不穷——缓存用 Redis、全文检索用 Elasticsearch、文档存储用 MongoDB、向量数据库用专门的方案、定时任务跑在 K8s 上。

但有时候，仅仅一个 PostgreSQL，就能覆盖大部分后端开发需求。

Redis 最容易踩的 7 个坑，问题往往不在 Redis

Sat, 04 Apr 2026 12:10:00 +0800

很多人觉得 Redis 没什么门槛。

命令不难，接入也快，压测时还总能打出很漂亮的数字。于是项目上线后，大家默认它“应该不会出事”。

但我看过不少 Redis 问题，最后都不是 Redis 自己不行，而是前面的设计太随便：Key 怎么拆，TTL 怎么设，热点怎么扛，内存打满以后怎么办，这些事一开始没想清楚，后面都会用线上故障补课。

我最近刷到一条讲 Redis 避坑的短视频，里面提到的点很典型。我没有照着转写，而是按“线上最容易出事故的顺序”重新整理成这篇文章。

如果你只记一句话，那就是：

Redis 真正危险的坑，大多不是命令层面的，而是设计层面的。

为什么数据库的挑战者们都没好下场

Thu, 02 Apr 2026 21:30:00 +0800

1974 年，IBM 捣鼓出了世界上第一个关系数据库。

50 年过去了，Oracle、MySQL、PostgreSQL 这些 RDB 依然霸榜。年轻程序员嘴上喊着 “SQL 太土”，项目里该用还是用。

有意思的是，每隔几年就冒出一堆"未来数据库"来挑战 RDB 的地位：Key-Value Store、MapReduce、Hadoop、图数据库、向量数据库……

我都用过。所以我知道为什么它们最后都凉了。

Redis：我踩过最贵的坑

Redis 是 KVS 的典型代表，用 Key 找 Value，简单粗暴。

缓存用它，完美。问题是做开发的总有点执念，非要把缓存以外的事情也塞给它。

我当年做物联网项目就载过这个跟头。

当时选 Redis 考虑两个因素：一是物联网系统里大部分是文件，数据库只管组件状态；二是终端用 SD 卡，磁盘 IO 寿命短，想省着用。

结果第三个月就开始出问题了。

物联网环境里，网络和电源都不可靠，随时可能断电断网。每一个组件的状态管理变得极其复杂——在 Redis 上，你要用 Array、Set、HashMap 来描述一个简单的"任务运行状态"，换成 SQLite 的话，一个表加几条 SQL 就搞定了。

最后项目里一半以上的 Bug 都跟这个定制 Redis 数据结构有关。就在写这篇文章的时候，我们还在修一个诡异的 Bug：终端下载视频时遇到网络问题，紧接着又断电，Redis 里的任务信息不完整，视频永远下不下来。

你说这值不值？

为了省 SD 卡那点读写寿命，被折腾了好几年。

第一个 KVS 是 AT&T 在 1979 年发布的，叫 DBM。发明者？又是那个男人。

Hadoop：我学了个寂寞

MapReduce 不是数据库，是 Google 提出的一种分布式数据处理思路。

Map 对应 SQL 里的 WHERE + ORDER BY，Reduce 对应 GROUP BY。说白了就是把 SQL 的逻辑拆到多台服务器上跑。

为什么 PostgreSQL 能超越 MySQL？这是我见过最全面的对比

Thu, 02 Apr 2026 15:47:00 +0800

用了 MySQL 好几年，最近深入研究 PostgreSQL，才发现自己一直在将就。

不是 MySQL 不好，而是 PostgreSQL 在太多地方更胜一筹。这篇文章从四个维度把它说清楚：索引、数据一致性、性能、扩展性。

一、索引：PostgreSQL 的玩法更多

两者的基础索引都是 B+ 树，但 PostgreSQL 的花样也太多了。

聚簇 vs 非聚簇

MySQL（InnoDB）是聚簇索引：数据按主键顺序存在叶子节点上，查主键很快，但非主键字段要先查二级索引再回表查一遍。

PostgreSQL 的所有索引都是非聚簇索引：数据单独存放在堆表里，索引只存指针。主键和普通索引没区别，插入数据直接追加到末尾，不用担心页分裂。

GIN 索引：倒排索引

PostgreSQL 的 GIN 索引简直是 JSON 数据的克星：

1
2


CREATE INDEX idx_attr ON products USING GIN (attributes);
SELECT * FROM products WHERE attributes @> '{"color": "red"}';

一句 @> 操作符就能查包含特定键值对的记录。MySQL 根本不支持。

GiST 索引：什么都能索引

GiST 是一个索引框架，任何数据类型实现了接口就能用。

地理坐标、时间范围、IP 区间……这些用 PostgreSQL 原生的 daterange 加上 GiST 索引，查询重叠和距离效率极高。

1

SELECT * FROM reservations WHERE daterange '[2026-01-08,2026-01-13]' @> '2026-01-10'::date;

MySQL 也不行。

Node.js后端开发完整指南

Sat, 10 Feb 2024 10:30:00 +0800

Node.js让JavaScript不再局限于浏览器，成为了全栈开发的强大工具。今天分享Node.js后端开发的完整学习路径。

🚀 Node.js基础

什么是Node.js

Node.js是一个基于Chrome V8引擎的JavaScript运行环境，让JavaScript能够在服务器端运行。

核心特性：

🔄 事件驱动：非阻塞I/O模型
⚡ 高性能：适合I/O密集型应用
📦 NPM生态：丰富的第三方包
🌐 跨平台：Windows、macOS、Linux

环境搭建

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


# 安装Node.js（推荐使用nvm管理版本）
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
nvm install node
nvm use node

# 验证安装
node --version
npm --version

# 创建项目
mkdir my-node-app
cd my-node-app
npm init -y

📊 Express框架入门

快速开始

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


const express = require('express');
const app = express();
const port = 3000;

// 中间件
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// 路由
app.get('/', (req, res) => {
 res.json({ message: 'Hello World!' });
});

app.listen(port, () => {
 console.log(`服务器运行在 http://localhost:${port}`);
});

中间件系统

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


// 日志中间件
const logger = (req, res, next) => {
 console.log(`${new Date().toISOString()} - ${req.method} ${req.url}`);
 next();
};

// 错误处理中间件
const errorHandler = (err, req, res, next) => {
 console.error(err.stack);
 res.status(500).json({ error: 'Something went wrong!' });
};

// 应用中间件
app.use(logger);
app.use('/api', apiRoutes);
app.use(errorHandler);

路由设计

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


const router = express.Router();

// RESTful API设计
router.get('/users', getAllUsers); // 获取所有用户
router.get('/users/:id', getUserById); // 获取单个用户
router.post('/users', createUser); // 创建用户
router.put('/users/:id', updateUser); // 更新用户
router.delete('/users/:id', deleteUser); // 删除用户

// 路由处理函数
const getAllUsers = async (req, res) => {
 try {
 const users = await User.find();
 res.json(users);
 } catch (error) {
 res.status(500).json({ error: error.message });
 }
};

module.exports = router;

🗄️ 数据库集成

MongoDB + Mongoose

 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


const mongoose = require('mongoose');

// 连接数据库
mongoose.connect('mongodb://localhost:27017/myapp', {
 useNewUrlParser: true,
 useUnifiedTopology: true
});

// 定义Schema
const userSchema = new mongoose.Schema({
 name: {
 type: String,
 required: true,
 trim: true
 },
 email: {
 type: String,
 required: true,
 unique: true,
 lowercase: true
 },
 password: {
 type: String,
 required: true,
 minlength: 6
 },
 createdAt: {
 type: Date,
 default: Date.now
 }
});

// 密码加密中间件
userSchema.pre('save', async function(next) {
 if (!this.isModified('password')) return next();
 
 const bcrypt = require('bcrypt');
 this.password = await bcrypt.hash(this.password, 12);
 next();
});

const User = mongoose.model('User', userSchema);

数据库操作

 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


// 创建用户
const createUser = async (userData) => {
 try {
 const user = new User(userData);
 await user.save();
 return user;
 } catch (error) {
 throw error;
 }
};

// 查询用户
const findUsers = async (filter = {}) => {
 return await User.find(filter)
 .select('-password')
 .sort({ createdAt: -1 });
};

// 更新用户
const updateUser = async (id, updateData) => {
 return await User.findByIdAndUpdate(
 id, 
 updateData, 
 { new: true, runValidators: true }
 );
};

🔐 身份验证与授权

JWT身份验证

 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


const jwt = require('jsonwebtoken');
const bcrypt = require('bcrypt');

// 生成JWT Token
const generateToken = (userId) => {
 return jwt.sign({ userId }, process.env.JWT_SECRET, {
 expiresIn: '7d'
 });
};

// 登录功能
const login = async (req, res) => {
 try {
 const { email, password } = req.body;
 
 // 查找用户
 const user = await User.findOne({ email });
 if (!user) {
 return res.status(401).json({ error: '邮箱或密码错误' });
 }
 
 // 验证密码
 const isMatch = await bcrypt.compare(password, user.password);
 if (!isMatch) {
 return res.status(401).json({ error: '邮箱或密码错误' });
 }
 
 // 生成token
 const token = generateToken(user._id);
 
 res.json({
 message: '登录成功',
 token,
 user: {
 id: user._id,
 name: user.name,
 email: user.email
 }
 });
 } catch (error) {
 res.status(500).json({ error: error.message });
 }
};

认证中间件

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


const authenticate = async (req, res, next) => {
 try {
 const token = req.header('Authorization')?.replace('Bearer ', '');
 
 if (!token) {
 return res.status(401).json({ error: '访问被拒绝，需要token' });
 }
 
 const decoded = jwt.verify(token, process.env.JWT_SECRET);
 const user = await User.findById(decoded.userId);
 
 if (!user) {
 return res.status(401).json({ error: '用户不存在' });
 }
 
 req.user = user;
 next();
 } catch (error) {
 res.status(401).json({ error: 'Token无效' });
 }
};

// 使用认证中间件
app.use('/api/protected', authenticate);

📝 API设计最佳实践

RESTful API规范

 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


// 统一响应格式
const sendResponse = (res, statusCode, data, message) => {
 res.status(statusCode).json({
 success: statusCode < 400,
 message,
 data,
 timestamp: new Date().toISOString()
 });
};

// API版本控制
app.use('/api/v1', v1Routes);
app.use('/api/v2', v2Routes);

// 参数验证中间件
const validateUser = (req, res, next) => {
 const { name, email, password } = req.body;
 
 if (!name || !email || !password) {
 return sendResponse(res, 400, null, '缺少必要参数');
 }
 
 if (password.length < 6) {
 return sendResponse(res, 400, null, '密码长度至少6位');
 }
 
 next();
};

分页和排序

 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


const getPaginatedUsers = async (req, res) => {
 try {
 const page = parseInt(req.query.page) || 1;
 const limit = parseInt(req.query.limit) || 10;
 const sort = req.query.sort || 'createdAt';
 const order = req.query.order === 'asc' ? 1 : -1;
 
 const skip = (page - 1) * limit;
 
 const users = await User.find()
 .select('-password')
 .sort({ [sort]: order })
 .skip(skip)
 .limit(limit);
 
 const total = await User.countDocuments();
 
 res.json({
 users,
 pagination: {
 currentPage: page,
 totalPages: Math.ceil(total / limit),
 totalItems: total,
 itemsPerPage: limit
 }
 });
 } catch (error) {
 res.status(500).json({ error: error.message });
 }
};

🔧 实用工具和中间件

环境配置

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


// .env文件
const dotenv = require('dotenv');
dotenv.config();

// config/database.js
module.exports = {
 development: {
 url: process.env.DEV_DB_URL,
 options: {
 useNewUrlParser: true,
 useUnifiedTopology: true
 }
 },
 production: {
 url: process.env.PROD_DB_URL,
 options: {
 useNewUrlParser: true,
 useUnifiedTopology: true,
 ssl: true
 }
 }
};

文件上传

 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


const multer = require('multer');
const path = require('path');

// 配置存储
const storage = multer.diskStorage({
 destination: (req, file, cb) => {
 cb(null, 'uploads/');
 },
 filename: (req, file, cb) => {
 const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
 cb(null, file.fieldname + '-' + uniqueSuffix + path.extname(file.originalname));
 }
});

const upload = multer({
 storage,
 limits: { fileSize: 5 * 1024 * 1024 }, // 5MB
 fileFilter: (req, file, cb) => {
 const allowedTypes = /jpeg|jpg|png|gif/;
 const extname = allowedTypes.test(path.extname(file.originalname).toLowerCase());
 const mimetype = allowedTypes.test(file.mimetype);
 
 if (mimetype && extname) {
 return cb(null, true);
 } else {
 cb(new Error('只允许上传图片文件'));
 }
 }
});

// 使用文件上传
app.post('/api/upload', upload.single('image'), (req, res) => {
 if (!req.file) {
 return res.status(400).json({ error: '没有文件上传' });
 }
 
 res.json({
 message: '文件上传成功',
 filename: req.file.filename,
 path: req.file.path
 });
});

日志系统

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


const winston = require('winston');

const logger = winston.createLogger({
 level: 'info',
 format: winston.format.combine(
 winston.format.timestamp(),
 winston.format.errors({ stack: true }),
 winston.format.json()
 ),
 transports: [
 new winston.transports.File({ filename: 'logs/error.log', level: 'error' }),
 new winston.transports.File({ filename: 'logs/combined.log' })
 ]
});

if (process.env.NODE_ENV !== 'production') {
 logger.add(new winston.transports.Console({
 format: winston.format.simple()
 }));
}

module.exports = logger;

🧪 测试

单元测试

 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


const request = require('supertest');
const app = require('../app');

describe('User API', () => {
 describe('POST /api/users', () => {
 it('should create a new user', async () => {
 const userData = {
 name: 'Test User',
 email: 'test@example.com',
 password: 'password123'
 };
 
 const response = await request(app)
 .post('/api/users')
 .send(userData)
 .expect(201);
 
 expect(response.body.user.name).toBe(userData.name);
 expect(response.body.user.email).toBe(userData.email);
 });
 
 it('should return 400 if required fields are missing', async () => {
 const response = await request(app)
 .post('/api/users')
 .send({})
 .expect(400);
 
 expect(response.body.success).toBe(false);
 });
 });
});

🚀 部署和优化

PM2进程管理

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


# 安装PM2
npm install -g pm2

# 启动应用
pm2 start app.js --name "my-app"

# 集群模式
pm2 start app.js -i max

# 监控
pm2 monitor

# 日志查看
pm2 logs

性能优化

 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


// 启用gzip压缩
const compression = require('compression');
app.use(compression());

// 设置安全headers
const helmet = require('helmet');
app.use(helmet());

// 限制请求频率
const rateLimit = require('express-rate-limit');
const limiter = rateLimit({
 windowMs: 15 * 60 * 1000, // 15分钟
 max: 100 // 限制每个IP 100次请求
});
app.use(limiter);

// 缓存
const redis = require('redis');
const client = redis.createClient();

const cache = (duration) => {
 return async (req, res, next) => {
 const key = req.originalUrl;
 const cached = await client.get(key);
 
 if (cached) {
 return res.json(JSON.parse(cached));
 }
 
 res.sendResponse = res.json;
 res.json = (body) => {
 client.setex(key, duration, JSON.stringify(body));
 res.sendResponse(body);
 };
 
 next();
 };
};

📊 推荐学习资源

📚 书籍推荐

《Node.js实战》 - 全面的Node.js指南
《深入浅出Node.js》 - 朴灵著，深入理解Node.js原理

🔧 实用工具

Postman - API测试工具
MongoDB Compass - 可视化数据库管理
VS Code - 最佳Node.js开发环境

📦 常用包推荐

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


{
 "dependencies": {
 "express": "^4.18.2",
 "mongoose": "^6.8.0",
 "bcrypt": "^5.1.0",
 "jsonwebtoken": "^8.5.1",
 "dotenv": "^16.0.3",
 "cors": "^2.8.5",
 "helmet": "^6.0.1",
 "compression": "^1.7.4"
 },
 "devDependencies": {
 "nodemon": "^2.0.20",
 "jest": "^29.3.1",
 "supertest": "^6.3.3"
 }
}

💡 总结

Node.js后端开发的核心要点：

Python学习笔记：从入门到进阶

Sat, 20 Jan 2024 09:15:00 +0800

最近开始系统学习Python，记录一下学习过程中的收获和思考。

为什么选择Python

Python作为一门简洁优雅的编程语言，有以下几个优势：

🐍 语法简洁 - 接近自然语言，容易理解
📚 丰富的库 - 拥有庞大的第三方库生态
🔬 应用广泛 - Web开发、数据分析、AI、自动化等
👥 社区活跃 - 学习资源丰富，问题容易解决

基础语法学习

变量和数据类型

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


# 基本数据类型
name = "Python学习者"
age = 25
height = 175.5
is_student = True

# 列表和字典
languages = ["Python", "JavaScript", "Java"]
person = {
 "name": "张三",
 "age": 30,
 "skills": ["Python", "数据分析"]
}

控制流程

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


# 条件判断
score = 85
if score >= 90:
 grade = "优秀"
elif score >= 80:
 grade = "良好"
else:
 grade = "一般"

# 循环
for language in languages:
 print(f"我正在学习 {language}")

# 列表推导式
squares = [x**2 for x in range(10)]

常用库介绍

1. NumPy - 数值计算

1
2
3
4
5
6
7
8
9


import numpy as np

# 创建数组
arr = np.array([1, 2, 3, 4, 5])
matrix = np.array([[1, 2], [3, 4]])

# 数学运算
result = np.sum(arr)
mean_value = np.mean(arr)

2. Pandas - 数据处理

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


import pandas as pd

# 读取数据
df = pd.read_csv('data.csv')

# 数据清洗
df_clean = df.dropna() # 删除空值
df_unique = df.drop_duplicates() # 删除重复值

# 数据分析
summary = df.describe()
grouped = df.groupby('category').sum()

3. Matplotlib - 数据可视化

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


import matplotlib.pyplot as plt

# 简单图表
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]

plt.figure(figsize=(8, 6))
plt.plot(x, y, marker='o')
plt.title('示例图表')
plt.xlabel('X轴')
plt.ylabel('Y轴')
plt.show()

项目实战经验

1. 网络爬虫项目

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


import requests
from bs4 import BeautifulSoup

def crawl_news(url):
 response = requests.get(url)
 soup = BeautifulSoup(response.text, 'html.parser')
 
 articles = soup.find_all('article')
 news_data = []
 
 for article in articles:
 title = article.find('h2').text.strip()
 content = article.find('p').text.strip()
 news_data.append({
 'title': title,
 'content': content
 })
 
 return news_data

2. 数据分析项目

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


import pandas as pd
import matplotlib.pyplot as plt

def analyze_sales_data(file_path):
 # 读取销售数据
 df = pd.read_csv(file_path)
 
 # 按月份统计销售额
 monthly_sales = df.groupby('month')['sales'].sum()
 
 # 可视化
 plt.figure(figsize=(10, 6))
 monthly_sales.plot(kind='bar')
 plt.title('月度销售额统计')
 plt.ylabel('销售额')
 plt.xticks(rotation=45)
 plt.tight_layout()
 plt.show()
 
 return monthly_sales

学习心得

1. 实践为主

理论学习很重要，但更重要的是动手实践。每学习一个概念，都要写代码验证。