AvatarYinDesk

后端 & 工程学习全景图

从 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 项目实战

拿订单或支付场景串一遍完整链路:

  1. 下单写库 + 写本地消息表(同一个事务)。
  2. 定时任务或 CDC 把消息投递到 Kafka。
  3. 下游消费做库存扣减、通知、积分,全部按幂等设计。
  4. 加监控:lag 告警、失败重试队列、死信 topic。
  5. 压测一次,观察分区数与消费者数量的关系。

自检清单

  • 消费者提交 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 IGNOREMySQL 特性写法简单依赖唯一索引可容忍静默失败
ON DUPLICATE KEYMySQL 特性支持更新逻辑语法较复杂存在则更新场景

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、搜广推等)》(这里的话 后端或者运维的项目都能做)

  1. 支付项目(首推,做了很复杂的熔断、降级、支付、分布式对账)https://github.com/jeequan/jeepay
  2. 复杂SaaS erp项目:https://gitee.com/zhijiantianya/yudao-cloud 有工作流、iot、im、crm等。总体来说能学到很多东西 非常复杂。
  3. 更轻量的支付系统:https://github.com/dromara/dax-pay(时间少优先看这个吧 但是不许想着走捷径)
  4. 分布式日志系统:https://github.com/fayechenlong/plumelog
  5. 分布式数据流引擎:https://github.com/apache/inlong(这个难度太高了 有信心 想提升自己再看吧)
  6. 美团开源监控、告警平台: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。

上线

  • 我们就不讲简单的发布了(那种直接把新版本的代码部署到机器上的),我们来聊两个比较有含金量的:

    • 蓝绿发布(懒的自己写了 给豆包解释贴这里吧):

      • 蓝绿发布是零停机全量上线部署方案,核心是维持两套配置完全一致的生产集群(蓝环境、绿环境):
      • 蓝环境:承载正式流量,运行线上稳定旧版本
      • 绿环境:闲置备用,用来部署新版本、全量验证 通过负载均衡 / 网关一键切换全量流量完成上线;新版本故障直接切回旧集群,实现秒级回滚。

      优点

      1. 真正零停机发布,用户无感知升级;
      2. 回滚成本极低,仅修改路由配置,秒级止损,是重大版本、核心业务首选;
      3. 新旧环境物理隔离,不会出现滚动发布的新旧实例共存、接口兼容错乱问题;
      4. 备用集群可直接用作容灾备份。
    • 灰度发布:这一套东西,如果说未来要去做基建、devops、云原生的,可以好好看看实现方式,业务开发了解即可。

      • 我copy也懒得copy了。。。。

Part 2 分布式数据一致性

OK,进入到网上垃圾八股最多的内容。

说到这块的内容,铺天盖地的:

  • CAP
  • BASE
  • Seata
  • 2PC
  • TCC

并不是说这些东西、理论没有意义。这些东西对于自己长远提升很有意义。但问题在于这套理论基本没有太好的落地场景,国内百分之九十九的大厂业务也不会用这套东西。

点名某字母培训班,天天扯那个B Seata。纯粹的没上过班。

我先直接讲结论:

大厂至少百分之九十九的业务,用的都是最终一致性,傻逼才用强一致。

2PC、TCC 全程锁住资源,库存、订单、支付链路并发直接打不动,电商大促、直播下单完全扛不住。要么服务线程池打满,要么数据库连接池打满。轻则阻塞所有请求,重则直接打崩机器。

那怎么办?扩机器么?机器可比人贵多了,运维成本、机房维护成本,折旧成本。

所以我们选择最终一致性,是技术成本,机器成本,实现成本,吞吐性各方因素下最终做的妥协。ROI最高的方案。

只要我们保证一件事:数据账一定要对得上!!

绝对红线:最终落账必须持平,订单总额 = 支付总额 - 退款总额,出库数量 = 订单发货数量。

总之你记住一句话,大多数业务都有一定时间窗口的容忍度,不需要强一致,只要数据可追溯,有凭据。最终的数据账对得上就行。定时任务、消息重试。最终在数据维度、业务维度一致即可。

放了这么多屁,我们直接来一个实战场景看看吧:

数据最终一致性 实战

我们简单想像一个场景,你在开发一个小区物业系统,这个物业系统涵盖了缴费、水电记录查询、单元管理等等功能。

由于有缴费功能,所以我们需要对接三方的支付SDK,这里就拿微信支付举例。

支付流程:前端点击支付->传给后端订单号(在前置订单生成接口就已经生成)、openID(微信同一小程序/公众号纬度下,用户的唯一标识)->后端调用微信支付API,入参:notify_url(回调地址,这个很核心,会单独讲),支付金额、微信交易号、商户号等->微信支付完毕->回调notify_url->后端感知到支付完成->更新订单状态(支付完成)->发放对应的权益(比如发放电费额度、水费额度等)。

最核心的地方 回调

我们先来理解回调这个概念是做什么的。

同步调用接口

先说我们平时的接口,假如一条接口把整条业务全做了,比如从订单号生成->支付->权益发放。我们没有做流程、产品适用维度的拆分,就是一个接口全做了。

用银行取钱来比喻:

场景1:简单的取钱

  1. 你把银行卡、取钱申请递给柜员
  2. 柜员全程当场处理:核验余额、扣款、给现金
  3. 整个过程你站在窗口不能走,处理完立刻拿到钱走人

场景2:大额取现需要审批,柜员没法当场给你钱。

你总不可能一直在柜台等着吧,等着人家找行长,找老板,走复杂的审批,评估。你这条线程不能一直卡在这个流程上吧。

  1. 提交取钱申请,银行收下单据,给你一张回执单(prepay_id),让你先回家等着
  2. 银行内部审批、出款完成之后,主动给你预留手机号打电话(调用你的 notify_url 接口),告诉你钱已经处理好了
  3. 你接到电话,登记确认,完成后续操作

对应微信支付逻辑

  1. 后端下单拿到支付凭证,用户去微信付款
  2. 微信扣款完成,主动请求你的回调接口通知结果
  3. 你接收通知更新订单、发放权益

这种方式,本质上是将同步调用,阻塞等待的重任务,拆成了异步任务。

我不在那里傻等你处理完请求,我给你一个回调接口,你做完你手上的事调我的回调接口通知我,我再去做我手里的事(比如取了钱狠狠的去happy,这个节点必须依赖前置的取钱节点)。

假如说我们不用回调,我们接口就要一直等微信返回。或者我们不想等微信返回,我们要保持吞吐量,保留我们宝贵的线程资源。另一种方式就是调完接口就断开。然后开个新的轮询任务,隔三差五去查下微信的api,这笔支付有没有成功。这样太浪费性能、时间了。

这就是回调,一句话总结:不用你持续主动轮询查询结果,业务方处理完成后主动推送结果,节省轮询带宽与服务压力。

那如果回调丢了呢?

回调丢了的话,微信那边是会重试的,但是是阶梯式重试。

直接看这里吧:

相关文档:《Jeepay 支付系统学习指南 V2 - 从需求到落地》

以上基于定时任务、消息队列等方式做数据最终一致性的方案,才是企业开发最主流的方案。而不是强一致性。

Part 3 数据兼容问题

Part 4 幂等幂等 幂等到底是什么啊

Part 5 微服务到底是什么

Part 6 设计模式 高内聚 低耦合

(注:内容由 AI 生成)

最后编辑于

On this page