后端 & 工程学习全景图
从 L1 到 L5 的后端工程能力路线,含并发、缓存、消息队列与分布式取舍
关于配图
原文中的截图均为飞书 / 豆包临时链接,已失效,本站只保留文字内容。
⛱️ 本文档面向的是「工程」侧的学习路线。包含但不限于:
- 业务工程
- 搜推工程
- 广告工程
- Agent工程
- 中间件工程
- devops工程
- 大数据工程
- 基础设施工程
本颜色代表知识性概念,个人建议深入的问AI,一定要做到理解的(面试需要你的这些知识储备)。
本文档主要面向快速学习,以最小的试错路径成本达到求职的最远可达能力。
一切面向就业、实习为主,对于就业来说,深入的、低投入回报比的概念我都会省去。
我所有提到的东西,都可以直接问AI,没必要看视频教程(浪费时间)
学习的过程中 把AI用起来
我个人的学习&工作workflow:claude code梳理->lark cli写成文档、绘图->开工/学习->总结->加入个人理解、语料->文档输出、语言输出
最后,由于我是Java出身,内容我尽量会抽象泛化,但是会有百分之十到二十的内容还是离不开Java。注意甄别阅读。
这里贴一张经常被问的问题 回答下后端学习上最爱问的一个问题:要不要学Java
前言&水平定位
阅读本文的人,请自己先检查自己的Level,根据Level选择性的阅读下文:
- L1:无任何语言等基础。
- L2:具备一定语言基础,无后端基础(接口、Mysql、HTTP请求等)。
- L3:具备后端、Mysql,框架等基础,能写出最简单的增删改查基础。(前端同学走全栈也应该到这里)
- L4:具备最简单的中间件能力,缓存(Redis),消息队列等。使用过Redis做缓存,消息队列发送消息。但不深入理解Redis、MQ等中间件的架构设计、设计思想、使用场景等。
- L5:具备后端最基础的能力,掌握数据库、接口通信、Redis、MQ,并且对于所学技术栈的架构与思想已经有一定的了解。但对于微服务、分布式架构,以及更深层的复杂业务没有理解。依旧停留在单体curd。
- L6:具备分布式能力,做过复杂的大型项目(至少3个以上不同的部门要对接),参与过复杂业务如:电商、广告、履约、交易、归因、外部多平台对接、ERP、定制化WorkFlow等。
- L7:能够独立阅读prd,出具技术方案,在某一单一领域能负责从需求拆解->技术方案设计->coding->验证闭环->持续迭代的能力。
L1 小白
-
此时无任何语言基础,个人建议:node.js、Java、Golang、pyhton、C++任选一个即可。
-
如果犹豫、纠结,可以直接选Java,Java是国内目前最大的盘子(互联网、ERP、TOG、MES等)。
-
AI时代,语法学习成本很低,初期选哪个都无所谓。后期都很好转。
-
你需要学到什么程度?哪些可以跳过?
- 变量、逻辑运算。
- 能读懂最基础的for、while、if、else等。
- 面向对象编程。
- 基础的数据结构,如Map、ArrayList、LinkedList、Tree等。
- 语言的特性,如Java的反射、动态代理、文件IO,可以放到后面用到在学。
- 算法可以投入一两天的时间做几道最简单最简单的题(比如水仙花)。锻炼下手搓能力。
不同语言的细分区别
- Golang更多会做基础设施、中间件等。如网关、缓存、RPC框架等。对性能的追求更高,语法也更简洁。当下大多数公司,无论是做业务还是搭基础设施(devops),只要有性能需求的,基本都会上Golang。如B站、抖音、腾讯(半Golang半C++)等。
- Java,互联网后端的半壁江山(过去是PHP),由阿里、电商、支付等把Java带到了一个新的高度。你现在用的app、网站里面,百分之七八十都是Java搭的后端。Java的生态更成熟,组件更多。最主要是用的公司多,所以并不是说Java多好用,多牛逼。本质上是技术历史的演变,中国互联网的发展,所以导致Java的岗位最多。Java并没有太突出的地方(除了生态),所以相对来说,Java一般用来写电商、物流、广告等业务。而字节、B站选Golang,因为Golang性能更高(支持短视频、直播、IM等更追求高性能的业务)
- node.js,轻量化。小公司会用,更多的时候搭配全栈,移动、出海等业务,以及外企公司用得最多。
- python,有更多跟llm相关的框架,以及数据、爬虫等。但其实无所谓,个人觉得可以跟Java放到一个定位。
- C++。除了鹅是以C++为主要后端语言。其他情况下,C++能做的方向:基础设施、中间件(同Golang)。上位机方向(制造业后端)。游戏服务端方向(C++最多的就业方向,要求也低,我没有游开基础,春招拿了15k的淘米游开后端offer)。
L2 有一定语言基础
Part 1 Mysql
-
无需多言,数据持久化是后端的基石,直接向Mysql进军吧,你需要掌握到的程度:
- 建表语句。
- CURD(增删改查)。
- 索引。
- 事务。
- 隔离级别。
-
更复杂的东西可以后面看,能学会写简单的sql足以。
Part 2 后端框架
- 我们怎么把机械化的数据库的操作提高效率呢?答案是把经常用的语句封起来,用代码把重复的工作自动化。
- 要求:学习对应语言对应的后端框架 如SpringBoot(Java),Django、Flask(Python)。
- 能通过框架封装简单的CURD能力。做一个最简单的demo出来。
Part 3 API&HTTP
- 理解什么是API(接口),这基本上是互联网百分之99的软件相互通信的基石和范式。
- 理解什么是HTTP请求,你写的后端服务的接口基本都是通过HTTP请求访问的。以及相比TCP、UDP,他们的区别,适用场景是什么。
part 4 部署
- 理解本地ip,localhost,端口号等概念。理解maven等概念。
- 能够自己部署自己写的demo,mysql等。能用postman、curl(优先这个吧)调用自己写的API。
总的来说 这个阶段 你需要快速理解什么是接口,你写的代码怎么被别人调用,怎么走到数据库。
相关文档:《后端开发全链路实战指南 - HTTP请求到数据库CRUD》
L3 具备一定的后端基础者
- 这个阶段,已经能做出简单的CURD,并且能够搭起功能闭环的项目如:图书管理系统、班级管理系统、苍穹外卖、黑马点评等。
- 此时接下来的学习方向:并发编程、缓存、消息队列、复杂SQL语句等。
Part 1 缓存
-
这里没什么好说的,用得最多的就是Redis。你需要学习(最好自己手写一次,我下面写的面试都很爱很爱问,未来你工作开发也会经常接触)的:
-
缓存的基本使用。
-
旁路缓存,数据库一致性,延迟双删,读写锁更新缓存。
-
缓存穿透、击穿、雪崩。自己能够写出对应的解决方案。
-
了解IO多路复用模型、数据结构、数据持久化等。
-
SETNX,分布式锁、LUA脚本等(自己写一遍分布式锁)。
- 锁误删。
- 锁超时。
- 锁续期。
-
-
个人建议,把黑马点评过一遍就好。高级篇一定要看。
-
相关文档:《Redis》
Part 2 消息队列(以 Kafka 为主线)
- 御三家:RabbitMQ、RocketMQ、Kafka。建议主学 Kafka:分区日志这套模型通用性最强,吞吐上限高,学透之后再看 RocketMQ 的事务消息、延迟消息只是增量;RabbitMQ 的交换机路由属于另一套模型,暂时不投入。
阶段 1 核心模型
- 本地起单节点 KRaft,4.x 已不需要 ZooKeeper:
services:
kafka:
image: apache/kafka:4.0.0
ports: ["9092:9092"]
environment:
KAFKA_NODE_ID: 1
KAFKA_PROCESS_ROLES: broker,controller
KAFKA_LISTENERS: PLAINTEXT://:9092,CONTROLLER://:9093
KAFKA_CONTROLLER_QUORUM_VOTERS: 1@kafka:9093
KAFKA_CONTROLLER_LISTENER_NAMES: CONTROLLER
KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT
KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1- 手写消息投递、消息消费(Java 侧用
spring-kafka)。 - Topic / Partition:分区数为什么决定并行度上限,分区能不能随便加。
- Offset:提交早了会丢还是重复?提交晚了又会怎样?
- Consumer Group:同组内一条消息为什么只被一个消费者消费。
- Rebalance:什么会触发,期间消息是丢还是重复。
- Key 分区:相同 key 为什么能保证顺序。
- 理解 partition、broker、副本的角色,以及推拉模型的区别。
阶段 2 可靠性(业务开发真正用得上的部分)
- 不丢:
acks=all+min.insync.replicas至少为 2 + 生产者重试 + 消费端处理成功后再手动提交 offset。 - 不重复:Kafka 只保证"至少一次",幂等要靠业务唯一键 + 去重表或 Redis。
- 顺序:同 key 进同分区,消费端对该分区单线程处理;注意重试会打乱顺序。
- 事务:
transactional.id+read_committed解决的是多条消息的原子性,不解决数据库与消息的一致性。 - 延迟消息:Kafka 原生不支持,用本地消息表 + 定时扫描或时间轮替代(这正是 RocketMQ 的优势项,知道差异即可)。
- 积压:扩分区 + 扩消费者(消费者数不能超过分区数),再考虑降级或丢弃。
阶段 3 原理(决定天花板的部分)
- 顺序写 + 页缓存 + 零拷贝 + 批量压缩,这四个词要能串成一句完整解释。
- 副本同步与 ISR:
acks、min.insync.replicas、leader 选举、unclean 选举的风险。 - 日志存储:segment 分段、索引文件、retention 与 compaction 的区别。
- KRaft 取代 ZooKeeper 后,controller 的职责变化。
- 消费者位移与
__consumer_offsets。
阶段 4 运维与观测
- 看 consumer lag(
kafka-consumer-groups.sh --describe),判断是生产变快还是消费变慢。 - 分区扩容、副本重分配、磁盘满、单分区热点。
- 关键指标:lag、ISR 收缩、请求延迟、磁盘 IO、网络。
阶段 5 生态(Kafka 相对 RocketMQ 的最大优势)
- Kafka Connect:不写代码把 MySQL、ES 的数据同步进 Kafka。
- Kafka Streams:窗口、聚合、state store。
- 与 Flink 对接,理解端到端 exactly-once 的边界。
- 日志链路:Filebeat / Fluent Bit → Kafka → ClickHouse / ES。
阶段 6 项目实战
拿订单或支付场景串一遍完整链路:
- 下单写库 + 写本地消息表(同一个事务)。
- 定时任务或 CDC 把消息投递到 Kafka。
- 下游消费做库存扣减、通知、积分,全部按幂等设计。
- 加监控:lag 告警、失败重试队列、死信 topic。
- 压测一次,观察分区数与消费者数量的关系。
自检清单
- 消费者提交 offset 的时机错了,会丢消息还是重复?
acks=all就一定不丢吗?min.insync.replicas起什么作用?- 分区数从 3 加到 6,历史消息的 key 顺序还保得住吗?
- 消费积压 100 万条,处置顺序是什么?
- Kafka 事务能保证"数据库写成功 + 消息发送成功"吗?为什么不能?
Part 3 深入学习数据库
-
理解索引,常见的索引自己都用一遍。
- 联合索引。
- 唯一索引。
- 前缀索引。
-
熟练掌握Explain语句(可选学习项 面试扯两句 加分)。
-
理解B+树,了解它和跳表、B树这些数据结构,以及他们的区别。
-
理解MVCC、隔离级别。理解幻读、脏读、重复读等。
-
理解冗余字段,数据库设计的三大范式。
Part 4 并发编程
并发编程是一个合格的后端无论如何都绕不开的一环。我这里举个最最最经典的例子:
以下内容完全由claude code + lark cli生成
先读后插(Select-then-Insert)并发问题详解
1. 问题场景
先读后插是一个典型的数据库并发问题:业务需要先查询某条记录是否存在,如果不存在则插入。在高并发场景下,多个请求可能同时读取到"不存在"的结果,导致重复插入。
2. 并发问题演示
3. 问题根因分析
4. 解决方案对比
| 方案 | 实现方式 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|---|
| 唯一索引 | UNIQUE KEY(username) | 简单可靠,数据库层保证 | 需要处理异常 | ✅ 推荐首选 |
| 分布式锁 | Redis SETNX | 业务层控制,灵活 | 性能开销大,复杂度高 | 跨表、跨库场景 |
| 乐观锁 | 版本号/时间戳 | 无锁等待,高性能 | 需要重试机制 | 高并发读多写少 |
| 悲观锁 | SELECT FOR UPDATE | 强一致性保证 | 锁等待,性能差 | 强一致性要求 |
| INSERT IGNORE | MySQL 特性 | 写法简单 | 依赖唯一索引 | 可容忍静默失败 |
| ON DUPLICATE KEY | MySQL 特性 | 支持更新逻辑 | 语法较复杂 | 存在则更新场景 |
5. 方案一:唯一索引(推荐)
代码示例(Java + MyBatis):
// 1. 数据库建表
CREATE TABLE users (
id BIGINT PRIMARY KEY AUTO_INCREMENT,
username VARCHAR(50) NOT NULL,
email VARCHAR(100),
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
UNIQUE KEY uk_username (username) -- 唯一索引
);
// 2. 业务代码
public class UserService {
public Result<Long> register(String username, String email) {
try {
User user = new User();
user.setUsername(username);
user.setEmail(email);
userMapper.insert(user); // 直接插入
return Result.success(user.getId());
} catch (DuplicateKeyException e) {
// 捕获唯一索引冲突异常
return Result.fail("用户名已存在");
}
}
}
6. 方案二:分布式锁
代码示例(Java + Redisson):
public class UserService {
@Autowired
private RedissonClient redisson;
public Result<Long> register(String username, String email) {
String lockKey = "lock:user:" + username;
RLock lock = redisson.getLock(lockKey);
try {
// 尝试加锁,最多等待5秒,锁超时10秒
if (lock.tryLock(5, 10, TimeUnit.SECONDS)) {
// 查询用户是否存在
User exist = userMapper.selectByUsername(username);
if (exist != null) {
return Result.fail("用户名已存在");
}
// 插入新用户
User user = new User();
user.setUsername(username);
user.setEmail(email);
userMapper.insert(user);
return Result.success(user.getId());
} else {
return Result.fail("系统繁忙,请稍后重试");
}
} catch (InterruptedException e) {
return Result.fail("操作被中断");
} finally {
if (lock.isHeldByCurrentThread()) {
lock.unlock(); // 释放锁
}
}
}
}
7. 方案三:悲观锁(SELECT FOR UPDATE)
代码示例(Java + MyBatis):
// MyBatis Mapper
@Select("SELECT * FROM users WHERE username = #{username} FOR UPDATE")
User selectByUsernameForUpdate(String username);
// Service
@Transactional(isolation = Isolation.REPEATABLE_READ)
public Result<Long> register(String username, String email) {
// 加悲观锁查询
User exist = userMapper.selectByUsernameForUpdate(username);
if (exist != null) {
return Result.fail("用户名已存在");
}
User user = new User();
user.setUsername(username);
user.setEmail(email);
userMapper.insert(user);
return Result.success(user.getId());
}
8. 方案四:INSERT IGNORE / ON DUPLICATE KEY UPDATE
代码示例(MySQL):
-- 方式1:INSERT IGNORE(静默失败)
INSERT IGNORE INTO users (username, email)
VALUES ('alice', 'alice@example.com');
-- 方式2:ON DUPLICATE KEY UPDATE(存在则更新)
INSERT INTO users (username, email, created_at)
VALUES ('alice', 'alice@example.com', NOW())
ON DUPLICATE KEY UPDATE
email = VALUES(email),
updated_at = NOW();
-- 方式3:INSERT ... SELECT(先判断)
INSERT INTO users (username, email)
SELECT 'alice', 'alice@example.com'
FROM DUAL
WHERE NOT EXISTS (
SELECT 1 FROM users WHERE username = 'alice'
);
9. 不同隔离级别下的行为差异
10. 实战选型建议
测试环境:MySQL 8.0, 4C8G, InnoDB, 50并发线程
结论:唯一索引方案在性能和简洁性上都是最优选择
11. 常见陷阱与避坑指南
典型错误案例:
// ❌ 错误写法:无任何并发控制
public void register(String username) {
User exist = userMapper.selectByUsername(username);
if (exist == null) { // 竞态条件窗口
User user = new User();
user.setUsername(username);
userMapper.insert(user); // 可能重复插入
}
}
// ✅ 正确写法:依赖唯一索引
public void register(String username) {
try {
User user = new User();
user.setUsername(username);
userMapper.insert(user);
} catch (DuplicateKeyException e) {
throw new BusinessException("用户名已存在");
}
}
-
你可以发现,一个并发问题,有各种各样的解决方案,不同的解决方案也有自己的优劣。
- 实现成本。
- 维护成本。
- 团队理解成本。
- 中间件叠加成本。
- 当前代码改造成本。
-
对于使用什么技术方案,一定是取决于我上面说的成本的,而不是技术多牛逼。
-
能不能理解并发,能不能合理的防住并发,是从coding新手迈向初级工程师的第一道门槛
-
学习建议:相关文档《并发问题与解决方案全景图》
Part 5 其他
-
以下是我推荐你了解的一些概念和技术。仅作个人能力提升或加分项。
-
分布式理论。
- 分布式一致性(这里尽量看最终一致)
- 两军问题。
- 负载均衡。
- CAP理论。
- 拜占庭将军问题。
-
微服务框架
- 配置中心。
- 服务发现。
- 服务注册中心。
- 监控、告警。
- RPC。
-
Agent
- ReAct
- Function Calling
- 上下文工程
- Mcp
- Skill
-
ES
- 倒排索引
- 复杂多参数模糊查询
- ES的统计与聚合
- OLAT & OLTP
-
-
这些东西只看理论是看不懂的,所以我也只是建议了解。真正想学到上面提到的东西的有用的东西,还是要去实际业务场景边干边学。
一些忠告
最后 疯狂的背八股并优先做出简历(用黑马点评、苍穹外卖,可以)。
优先做出简历去投递。边投边学新的项目,把外卖换下去。
一定要早点做完两个项目开始投,投简历你才会发现自己差哪些东西!!!!
不要一直想着学东西,一直打基础。
找工作如追女孩,边追边变好。勇敢,自信的人先享受世界。
L4 初级后端工程师 提升广度与深度
🎼 这个时期是不断提高自己的知识广度的时候(概念性的理解) 同时不断深入工程能力(消息队列、缓存、mysql的各种用法以及复杂业务场景的实现)。
你能做的事:
- 多读paper、blog、公众号等。以及一些优质项目、中间件的源码等。
- 社交,找一个优秀的圈子,每天交流不同的信息。提高认知与思维。
- 学习不同的技术,拓广度(Agent、中间件、前端、框架等等)
- 不断优化自己的简历(可以是更新项目 可以是学新的技术包装上去)。
- 深入回顾过去学的东西(Mysql、Redis、MQ)
-
恭喜你已经具备了初级后端工程师的资质:
- 语言基础
- 简单中间件
- 框架
- http请求
- 数据库
- 简单的接口,CURD请求。
- 能解决简单的并发问题。
- 能将缓存、消息队列,结合在项目中做最简单的使用
-
到了这一步,你需要向以下几个方面开始努力了(都是理解概念 建立认知即可):
Part 1 分布式数据一致性(理解概念即可)。
-
强一致性&最终一致性(这是目前用的最多的 降级、熔断、重试、对账)
- CAP 理论
- BASE 理论
- 为什么强一致不能同时高并发、高可用
- 2PC
- TCC
- SAGA
- 本地消息表
- 事务消息(RocketMQ 事务消息)
-
理解如何在业务失败时作补偿(通过消息、缓存、重试等)
- 数据补偿
- 正向补偿
- 逆向回滚
- 消息重投
- 抛出异常时发送消息
-
理解为什么强一致性的实现成本高,为什么会妥协的"选择"最终一致性
- 数据漂移
- 数据不一致
- 脏数据
- 定时对账
- 全量校验
- 增量校验
- 一致性兜底手段
Part 2 复杂上下游链路中的通信(理解概念即可)。
-
RPC框架、远程调用、请求调用、网关等
- 负载均衡:随机、轮询、最小连接、一致性 hash
- 重试策略:重试次数、退避策略(指数退避)、重试风暴
- 调用链追踪(链路追踪):TraceId、SpanId,排查跨服务故障
- 同步调用、异步调用、异步回调:RPC 两种调用模式
- 网关:API 网关,流量入口,统一鉴权限流
-
超时、限流、熔断、流量分摊等
- 接口超时链传播:上游超时连锁打爆下游,线上经典故障
- 消息解耦:同步转异步,MQ 削峰填谷
Part 3 复杂业务与跨团队协作,多人项目维护。
-
文档编写能力(技术方案)
- 飞书用起来吧 参考我这篇:相关文档《「粉丝群开放」技术方案(1)》
-
学一点黑话
- 对齐、风险、颗粒度
- 排期、里程碑、技术债
- 预发环境、测试环境、生产环境:多套环境
- 边界 case
- 异常分支
- 业务方案重点思考点
-
学一些常用概念,提高沟通效率 降低理解成本:
- 冒烟用例。
- cicd流水线。
- 埋点。
- 白名单(通常是通过Apollo这一类配置中间件去做)
- 蓝绿发布
- 灰度发布
- 回滚
- 单元测试
- 集成测试
Part 4 广度 & 发展方向
-
想办法找个有更复杂的业务的公司。
- 技术栈:至少有5个以上的微服务,用到了MQ、Redis。
- 业务:ERP、MES、SaaS、支付、广告、交易、电商、出海、分销、连接器、CRM、Agent。
- 内部有清晰的职责划分,至少将基础设施和业务开发剥离出来。业务开发专注写业务,有专门的运维、基建团队负责内部的平台工程(部署、中间件、审批、敏捷看板等)。
-
停止看网上烂大街的项目,主动接触开源项目、优质信息源:
-
定期阅读大厂公众号,如:
-
上github看高star项目,最好一周找一个。可以没必要深入的学、coding。用AI直接看代码,梳理出对应的架构、亮点即可。挑一两个亮点深入的去看。
-
同时 多用AI,一定要多尝试,个人建议每个月要投入100块在AI不同用法的尝试上。逐步搭建自己的skill,工作流等。
-
Part 5 提高工程能力
你需要学习以下几个场景的设计(最好自己手撕一遍 可以让ai写出来 自己做一遍)
-
登录:
- 单点登录
- 短信登录
- 扫码登录
-
滑动窗口限流、令牌桶限流。
-
超卖问题,基于乐观锁、悲观锁的不同实现。
-
秒杀场景。
-
支付接口的接入。
-
聊天功能的实现(可以直接去看 box-im)
-
Agent Re&Act 手撕、上下文架构实现。
-
消息重试,重试到最大次数告警(电话告警、短信、飞书/企微/钉钉)
-
监控:做一个可视化的监控 监控部署的项目的CPU负载、应用内存等。并且可以设置阈值,比如cpu负载超过百分之40就告警的功能。
以及 反复的背八股:
确保 以下几个问题你都能倒背如流
- Redis的io多路复用模型是怎么处理网络请求的?
- Redis做分布式锁为什么要用setnx?
- 能给我讲讲MQ的本地消息表吗?
- MQ如果消费失败了怎么办?
- CAS能完全解决并发问题吗?了解过ABA吗?
- MVCC下,可重复读,还会发生幻读吗?为什么?
- Redis 过期 key 删除策略是什么?内存淘汰机制讲一下。
- Redis RDB 和 AOF 优缺点,混合持久化原理是什么
- 什么是消息重复消费,怎么实现幂等?
- MQ 怎么保证消息不丢失?分别从生产者、Broker、消费者三个维度说明。
- InnoDB 聚簇索引和二级索引区别,回表是什么
- update 语句什么时候会走行锁,什么时候升级表锁
- 分布式锁除了 Redis 方案还有哪些?Redis 分布式锁存在什么缺陷,Redlock 了解吗?
- CAP 和 BASE 理论怎么理解,AP 和 CP 怎么取舍。
- 什么是 TCC 事务,和本地消息表、可靠消息最终消息对比优缺点。
如果说上面那些答不出来百分之50以上。我建议你还是先回头反复的背背八股。
不要只顾着广度,注意回头看学过的东西,总结,复盘,注意自己的深度。
Part 6 项目推荐
这个时候 我推荐你做的一些学习项目:
相关文档《后端(支付、微服务、Agent、搜广推等)》(这里的话 后端或者运维的项目都能做)
- 支付项目(首推,做了很复杂的熔断、降级、支付、分布式对账)https://github.com/jeequan/jeepay
- 复杂SaaS erp项目:https://gitee.com/zhijiantianya/yudao-cloud 有工作流、iot、im、crm等。总体来说能学到很多东西 非常复杂。
- 更轻量的支付系统:https://github.com/dromara/dax-pay(时间少优先看这个吧 但是不许想着走捷径)
- 分布式日志系统:https://github.com/fayechenlong/plumelog
- 分布式数据流引擎:https://github.com/apache/inlong(这个难度太高了 有信心 想提升自己再看吧)
- 美团开源监控、告警平台:https://github.com/dianping/cat (夯爆了)
L5 复杂业务&分布式(开始上难度了哦)
💡 到了这一步 能把上面的东西都吃透 你基本已经具备了进入互联网中大厂的能力了(看学历、运气)
这个时候 你基本可以考虑过滤以下类型的公司:
- 做政企业务的公司(除非是用友、亚信这种还能上点消息队列的可以考虑下)
- 做外包业务的公司
- 只有curd的公司
- 给运营商做外包项目的公司
你应该考虑去的公司(互联网业务优先):
ERP/SaaS,如聚水潭、有赞、掌上先机、纵享销客这类卖软件服务的互联网公司。
制造业ERP、MES,比上面的互联网类公司低一等但也勉强够用。
业务涉及到:电商、广告、交易、用户增长、素材投放、商业化、支付、社区、内容运营、音视频上传、安全、风控、Agent、云计算、云服务。
人数不是必须看的,但最好有以下特质:
- 至少有用Redis和MQ。
- 不只是几个简单的微服务,而是把不同的业务拆成不同的域,有多个不同业务方的系统上下游交互。每个域负责自己内部的所有微服务。如电商下的域:商品、交易、支付、营销、CRM、物流、搜广推。
- 前沿的互联网业务。
Part 1 需求开发流程
我们先简单过一遍需求->开发->上线的流程
发现需求
- 发现需求,这里一般是业务老板定方向、产品模式,然后交给下面的产品、运营团队执行。
- 比如老板说,我们这个季度要做社交、帖子的功能。产品、运营调研市场。运营负责制定未来功能上线后的打法,探查用户留存、转化。产品负责做老板、运营、开发之间的桥梁。梳理需求实现方式,平衡交付、技术、项目开发等成本。
- 产品梳理好需求后,通过figma编写prd的原型稿。
- 找到开发,开需求评审会。到处要资源,定开发周期。
需求&技术评审
-
技术过完需求评审后。跟产品扯皮
- 哪些能做哪些不能做。
- 哪些做了花的时间比较久。(平衡项目交付和项目质量)
- 给出对应的排期。
-
开发开始梳理技术方案
-
技术方案选型。
-
数据库。
-
接口。
-
排期。
- 开发周期。
- 联调周期。
- 测试周期。
- 验收时间。
-
开发&联调&提测
-
理出需求排期后,开发开始设计技术方案。我们从后端的角度讲怎么理。
-
首先,你要注意这几件事:
-
涉及到哪些数据库、表。
-
要新增哪些接口。(基本上最重要的就是接口了 前端 测试 上来都先找的这个)
-
后端服务之间有哪些上下游
- 上游:流量入口,比如A服务a接口,被B服务调用,B就是上上游。
- 下游:流量承接者。同样上面的例子,A就是B的下游。
-
业务涉及到哪些链路。
-
发布的时候要注意什么?比如A依赖B的新接口,就应该B先发,A后发。
-
-
写好技术方案的文档后,拉着同组的其他开发(前后端、安全、运维等)、测试,评估技术方案是否合理。
-
评估通过,开始开发。开发->自测(至少确保接口跑通)->联调->冒烟用例跑通(你至少要把所有的交互流程都走通,触发一遍)->提测->测试介入,执行test case。
上线
-
我们就不讲简单的发布了(那种直接把新版本的代码部署到机器上的),我们来聊两个比较有含金量的:
-
蓝绿发布(懒的自己写了 给豆包解释贴这里吧):
- 蓝绿发布是零停机全量上线部署方案,核心是维持两套配置完全一致的生产集群(蓝环境、绿环境):
- 蓝环境:承载正式流量,运行线上稳定旧版本
- 绿环境:闲置备用,用来部署新版本、全量验证 通过负载均衡 / 网关一键切换全量流量完成上线;新版本故障直接切回旧集群,实现秒级回滚。
优点
- 真正零停机发布,用户无感知升级;
- 回滚成本极低,仅修改路由配置,秒级止损,是重大版本、核心业务首选;
- 新旧环境物理隔离,不会出现滚动发布的新旧实例共存、接口兼容错乱问题;
- 备用集群可直接用作容灾备份。
-
灰度发布:这一套东西,如果说未来要去做基建、devops、云原生的,可以好好看看实现方式,业务开发了解即可。
- 我copy也懒得copy了。。。。
-
Part 2 分布式数据一致性
OK,进入到网上垃圾八股最多的内容。
说到这块的内容,铺天盖地的:
- CAP
- BASE
- Seata
- 2PC
- TCC
并不是说这些东西、理论没有意义。这些东西对于自己长远提升很有意义。但问题在于这套理论基本没有太好的落地场景,国内百分之九十九的大厂业务也不会用这套东西。
点名某字母培训班,天天扯那个B Seata。纯粹的没上过班。
我先直接讲结论:
大厂至少百分之九十九的业务,用的都是最终一致性,傻逼才用强一致。
2PC、TCC 全程锁住资源,库存、订单、支付链路并发直接打不动,电商大促、直播下单完全扛不住。要么服务线程池打满,要么数据库连接池打满。轻则阻塞所有请求,重则直接打崩机器。
那怎么办?扩机器么?机器可比人贵多了,运维成本、机房维护成本,折旧成本。
所以我们选择最终一致性,是技术成本,机器成本,实现成本,吞吐性各方因素下最终做的妥协。ROI最高的方案。
只要我们保证一件事:数据账一定要对得上!!
绝对红线:最终落账必须持平,订单总额 = 支付总额 - 退款总额,出库数量 = 订单发货数量。
总之你记住一句话,大多数业务都有一定时间窗口的容忍度,不需要强一致,只要数据可追溯,有凭据。最终的数据账对得上就行。定时任务、消息重试。最终在数据维度、业务维度一致即可。
放了这么多屁,我们直接来一个实战场景看看吧:
数据最终一致性 实战
我们简单想像一个场景,你在开发一个小区物业系统,这个物业系统涵盖了缴费、水电记录查询、单元管理等等功能。
由于有缴费功能,所以我们需要对接三方的支付SDK,这里就拿微信支付举例。
支付流程:前端点击支付->传给后端订单号(在前置订单生成接口就已经生成)、openID(微信同一小程序/公众号纬度下,用户的唯一标识)->后端调用微信支付API,入参:notify_url(回调地址,这个很核心,会单独讲),支付金额、微信交易号、商户号等->微信支付完毕->回调notify_url->后端感知到支付完成->更新订单状态(支付完成)->发放对应的权益(比如发放电费额度、水费额度等)。
最核心的地方 回调
我们先来理解回调这个概念是做什么的。
同步调用接口
先说我们平时的接口,假如一条接口把整条业务全做了,比如从订单号生成->支付->权益发放。我们没有做流程、产品适用维度的拆分,就是一个接口全做了。
用银行取钱来比喻:
场景1:简单的取钱
- 你把银行卡、取钱申请递给柜员
- 柜员全程当场处理:核验余额、扣款、给现金
- 整个过程你站在窗口不能走,处理完立刻拿到钱走人
场景2:大额取现需要审批,柜员没法当场给你钱。
你总不可能一直在柜台等着吧,等着人家找行长,找老板,走复杂的审批,评估。你这条线程不能一直卡在这个流程上吧。
- 提交取钱申请,银行收下单据,给你一张回执单(prepay_id),让你先回家等着
- 银行内部审批、出款完成之后,主动给你预留手机号打电话(调用你的 notify_url 接口),告诉你钱已经处理好了
- 你接到电话,登记确认,完成后续操作
对应微信支付逻辑
- 后端下单拿到支付凭证,用户去微信付款
- 微信扣款完成,主动请求你的回调接口通知结果
- 你接收通知更新订单、发放权益
这种方式,本质上是将同步调用,阻塞等待的重任务,拆成了异步任务。
我不在那里傻等你处理完请求,我给你一个回调接口,你做完你手上的事调我的回调接口通知我,我再去做我手里的事(比如取了钱狠狠的去happy,这个节点必须依赖前置的取钱节点)。
假如说我们不用回调,我们接口就要一直等微信返回。或者我们不想等微信返回,我们要保持吞吐量,保留我们宝贵的线程资源。另一种方式就是调完接口就断开。然后开个新的轮询任务,隔三差五去查下微信的api,这笔支付有没有成功。这样太浪费性能、时间了。
这就是回调,一句话总结:不用你持续主动轮询查询结果,业务方处理完成后主动推送结果,节省轮询带宽与服务压力。
那如果回调丢了呢?
回调丢了的话,微信那边是会重试的,但是是阶梯式重试。
直接看这里吧:
相关文档:《Jeepay 支付系统学习指南 V2 - 从需求到落地》
以上基于定时任务、消息队列等方式做数据最终一致性的方案,才是企业开发最主流的方案。而不是强一致性。
Part 3 数据兼容问题
Part 4 幂等幂等 幂等到底是什么啊
Part 5 微服务到底是什么
Part 6 设计模式 高内聚 低耦合
(注:内容由 AI 生成)
最后编辑于