微服务和 Monorepo
软件业的人乐于做这样的事 —— 找一些词汇,并把它们引申到大量微妙而又互相矛盾的意义,例如“架构” —— 《Patterns of Enterprise Application Architecture》
# 微服务系统概述
现阶段的代码优化,一个就是单体项目的微服务改造,再一个就是设计模式的优化
微服务并不是什么高级货,软件实施的重点在于如何合理的切割、划分模块,微服务只是一种手段,其核心的思想应当收敛于 DDD
- 按层次划分,例如文库的控制面 - 策略层 - 基础层,以此来实现一个统一但解耦的系统,每层又通过不同的微服务进行实现(分层架构)
- 按功能划分,例如 AnyDev 将控制面、定时服务、Daemon 功能等拆为小仓开发,再按 mono 大仓组合,每个小仓是一个微服务(组合架构)
# 云原生系统概述
SOA、分布式和微服务系统
- SOA(Service Oriented Architecture):面向服务架构,相比于微服务的设计粒度更大,通常指系统之间的耦合,参与方通常在个位数或十几个
- 分布式系统:多服务通过网络协同工作,微服务的个数通常能达到上百个,整个系统对外表现为整体,核心特点为去中心化、并发性、容错能力、扩展性
- 微服务系统:分布式系统的一种实现形式,一种模块化思想的实践,本质上通过 HTTP 或其他网络协议进行通讯来实现,核心在于服务拆分、服务之间调用和服务管理
一般通过成熟的微服务框架或组件解决现成的分布式问题,实现快速开发
- Spring Cloud
- Spring Cloud Alibaba
- Dubbo
- RPC(GRPC、TRPC)
云计算背景下,软件、平台和基础设施都被视作服务 Service
- SaaS:Software as a Service 软件即服务
- Paas:Platform as a Service 平台即服务
- IaaS:Infrastructure as a Service 基础设施即服务
云原生是一种很抽象的概念,与传统单体服务相比,存在思想上的设计差异,我暂时理解为一种主体但协作的设计理念,虽然定义不仅相同,但云原生系统总是包含以下关键词
- 微服务:模块化开发
- 容器化:跨平台、弹性部署、高可用容灾
- DevOps:开发运维一体
- 持续交付:用模块化 + “小步快跑”代替瀑布开发
# 单体项目改造
原有 OJ 系统,各模块相互独立,通过 API 接口和分包的方式实现协作
- 负责核心业务的后端模块
- 负责校验结果的判题模块
- 负责编译执行代码的可复用代码沙箱
基于 Spring Cloud Alibaba + Nacos + Dubbo + Higress 对单体项目进行重构。如何进行改造?从业务需求出发
- 用户登录功能:需要改造为分布式登录,使用 Redis 分布式 Session 存储登录用户信息
- 有没有用到单机锁?如有需要改造为分布式锁
- 有没有用到本地缓存?改造为分布式缓存(Redis)
- 需不需要用到分布式事务?比如操作多个库
于是将项目划分为,各服务共用同一套 DB 数据源
- 用户服务
- 题目服务
- 判题服务
- 公共模块
各个服务的业务能力保持不变,接口保持不变,只是调用关系发生改变,从内部调用变成 RPC 调用,前端的请求地址从 1 个变成 4 个
- Nacos 注册中心
- Dubbo 通信框架
- Sentinel 熔断降级
- Seata 分布式事务
- RocketMQ 消息队列
注意 Spring Cloud Alibaba、Spring Cloud 和 Spring Boot 的对应版本:版本发布说明-阿里云Spring Cloud Alibaba官网 (opens new window)
SCA 最佳实践
1. Spring Cloud Gateway:网关
2. Nacos:服务注册和配置中心
3. Sentinel:熔断限流
4. Seata:分布式事务
5. RocketMQ:消息队列,削峰填谷
6. Docker:使用 Docker 进行容器化部署
7. Kubernetes:容器化部署
2
3
4
5
6
7
很多时候,像点赞这种高频操作(是 / 否),实际上并没有直接进行写 DB,而是丢给消息队列或 Redis 去处理,前端查缓存处理
# 微服务开发实践
# 微服务中间件
度子的微服务组件(因为很多时候会对文档进行索引,所以会用到 ES)
- GDP 微服务框架:包含 RPC 调用和 Streaming 流式调用,后者被用作 AI 流式对话(包括 Planner 框架和 MCP 的流式返回)
- Sula 配置中心:等同于 Nacos
- DB:MySQL 持久化和 Redis 缓存
- ES 索引和 BOS 对象存储
- NMQ 消息队列
腾子的微服务组件,其实都大差不差,有需求才会驱动轮子制造
- TRPC:远程调用框架
- Taihu 太湖:网关
- Rainbow 七彩:配置的统一管理与灰度
- PolarisMesh 北极星:服务治理中心,类 Nacos
- DB:MySQL(GORM)和 Redis
- UDNS 域名分配
- TAT 命令下发
- TDMQ 分布式消息队列
# 微服务注册流程
一个微服务接口的实现、注册和调用流程,从前端到 admin 接口到下游的 web-server 服务
proto 层:admin_server.proto:新增 admin 接口
web-server 后端
- services/devops.go 新增 DevopsService.DevopsEnvStop
- business/devops.go 新增 DevopsController.StopEnv
admin 后端
- services/env_devops_service.go 新增 AdminDevopsService.StopEnv
- business/devops.go 新增 DevopsController.StopEnv
admin-app 前端
- codev-service/src/adminApi/api.ts 新增 stopEnv 后端 url,以及接口 batchStopEnv 定义并导出
- 修改 codev-admin-app/src/views/devops/nodeManager.vue 前端样式,新增批量休眠按钮以及每个数据行后新增休眠环境按钮,二者均调用 batchStopEnv 接口
# Protobuf
Protobuf(Protocol Buffers)是 Google 开发的一种语言中立、平台无关、可扩展的结构化数据序列化格式,用于自动化生成模板代码,例如 DTO 数据结构和 RPC 接口
通过 proto 定义 po 数据结构和接口,并通过 protobuf 命令一键生成 pb.go 文件,例如
- admin-server.proto:新增批量休眠接口,复用了批量操作的入参 BatchEnvIdsReq 和规范出参 AdminEmptyRsp
// @alias=/admin/devops/env/stopEnv 批量关闭环境
rpc StopEnv(BatchEnvIdsReq) returns(AdminEmptyRsp) {}
2
- web-server.proto:新增接口和入参出参
// @alias=/devops/env/stop 运维操作休眠环境
rpc DevopsEnvStop(DevopsEnvStopReq) returns (DevopsEnvStopRsp) {}
message DevopsEnvStopReq {
repeated string envIds = 1;
}
message DevopsEnvStopRsp {
int32 code = 1;
string message = 2;
Data data = 3;
message Data {
repeated string errorEnvIds = 1;
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
通过 trpc 命令指定 proto 文件构建成套的 pb 文件,包括
*.proto*.pb.go*.trpc.go*.pb.validate.go*_mock.go
# 微服务组件
每个微服务组件都是在解决一个分布式问题
# Nacos 配置中心
管理微服务的通信资源 → 注册并暴露云函数
Nacos 是一个中心化的配置中心,用于微服务的接口注册和配置统计管理
- 对于业务方而言,配置中心的使用是透明的,使用 Nacos 和使用 Eureka 都是打微服务名称
引入 Nacos 客户端依赖并配置
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
<version>2022.0.0.0</version> <!-- 根据 Spring Cloud 版本选择 -->
</dependency>
2
3
4
5
server:
port: 8081
spring:
application:
name: user-service
cloud:
nacos:
discovery:
server-addr: localhost:8848 # Nacos 服务器地址
namespace: public # 命名空间(默认 public)
group: DEFAULT_GROUP # 分组(默认 DEFAULT_GROUP)
2
3
4
5
6
7
8
9
10
11
12
在主类中启动 Nacos 注册服务
@SpringBootApplication
@EnableDiscoveryClient // 启用服务注册与发现(兼容 Nacos)
public class UserServiceApplication {
public static void main(String[] args) {
SpringApplication.run(UserServiceApplication.class, args);
}
}
2
3
4
5
6
7
8
一个正常的Controller层代码
@RestController
@RequestMapping("/users")
class UserController {
// 查询用户
@GetMapping("/{id}")
public User getUser(@PathVariable Long id) {
return userService.get(id);
}
}
2
3
4
5
6
7
8
9
进行微服务注册
@FeignClient(name = "user-service") // 服务名需与目标服务在 Nacos 中的名称一致
public interface UserServiceClient {
@GetMapping("/{id}}")
User getUserById(@PathVariable Long userId);
}
2
3
4
5
当前项目user-service的接口就被注册在地址为localhost:8848的 Nacos 中
# CAP 原则
CAP 原则:一致性(Consistency)、可用性(Availability)和分区容忍性(Partition Tolerance)不可兼得
什么是一致性、可用性和分区容忍性
- 一致性:所有节点在同一时间看到的数据相同
- 可用性:每个请求都能得到响应(即使部分节点故障),但不保证是最新数据
- 分区容忍性:指系统能够处理网络分区(节点间通信中断)的情况,即使部分节点无法通信,系统仍能正常运行
CAP 理论的核心是:一个分布式系统不可能同时很好的满足一致性,可用性和分区容错性这三个需求,要么 CA 要么 CP 要么 AP
- CA:单点集群,满足一致性,可用性的系统,通常缺失可扩展性
- CP:满足一致性,分区容忍性的系统,通常性能略低
- AP:满足可用性,分区容忍性的系统,通常一致性要求略低
在分布式环境中,网络分区是不可避免的(必须要 P),故分布式系统的设计中,变成了 AP 和 CP 系统的选择
- CA 是单点集群,不支持分区
通常而言,要满足一致性就要牺牲一定的性能,CP 的性能会逊于 AP,但具体使用什么架构一定是从业务出发,例如
- 网飞(Netflex)开源的注册中心 Eureka 是一个典型的 CP 系统,因为他更注重实时性(视频流)
- 而在支付场景,一定是一致性大于实时性,故而阿里开源的 Nacos 必然要能够满足 AP 原则(Nacos 可以在 CP 和 AP 之间切换)
# Dubbo RPC 框架
RPC(Remote Procedure Call),远程过程调用,RPC 框架封装了底层的网络通信、序列化和反序列化,使远程接口本地调用化
- MCP 的调用本质上也是一种 RPC,只不过用的是 Json 2 协议,通常微服务的 RPC 基于 TCP 或 HTTP
Dubbo 是阿里开源的 RPC 框架,基于 TCP 的 Hessian 2 协议,性能明显优于 HTTP
- 基于 Netty 实现
- 支持负载均衡、服务降级、熔断、限流等功能
- 支持多种注册中心(如 Zookeeper、Nacos)
- 支持 Dubbo 协议、HTTP、REST 等协议
- 支持分布式事务解决方案(如 Seata)
注册中心挂了之后,Dubbo 还能访问到服务吗?分情况,如果之前调用过,Dubbo 会把服务地址缓存在本地,再次调用时不会访问注册中心,这里会存在一致性的问题
RPC 框架选择
- 简单的 HTTP 请求,选择 WebClient(异步或流式场景),Spring Boot 4 新引入了 HTTP Service Clients
- 负载均衡和声明式 HTTP 调用,选择 OpenFeign,内置了 Ribbon 做负载均衡
- 如果需要高性能的 RPC 调用和更强的服务管理能力,选择 Dubbo / gRPC
总的来说,基于 TCP 的协议(Dubbo 和 gRPC HTTP2),效率会明显高于使用 HTTP 的 Feign
# NIO 和 Netty
NIO 和 Netty 是很多 RPC 的底层组件
NIO(New Input/Output) 是 Java 1.4 引入的一组用于提供非阻塞输入输出的 API,核心是事件驱动
- 监听器监听特定事件,事件发生时,控制器将其广播到每一个监听器
- 例如消息队列的一对多模型,实际上也是一种事件驱动,消费者监听并处理特定队列的生产
Netty 是一个封装了 Java NIO 的底层网络通信组件,Netty 高性能的关键在于
- 线程池 + 事件驱动
- 零拷贝技术 Zero Copy
- 池化内存
- TCP 粘包 / 拆包处理
# Higress 网关
网关的常见用途:权限控制、路由、负载均衡、限流
一个请求的基本路径:LB → Gateway → Server
我更倾向于用后端去做权限校验,而不是网关层,故而网关的作用更多是路由、负载均衡和限流,类似于一个更高级更全面的 Nginx 管理
- 实际中也确实如此,真正的用户权限在后端鉴权(因为用户权限落在后端 DB 中),但网关也负责一部分的鉴权,例如是否携带必要的请求头,请求来源是否合法等等过滤
# Sentinel 限流熔断组件
阿里开源的熔断降级解决方案
限流、熔断和服务降级是三种常用的系统稳定性策略,通常我们说为了保证系统的可用性会把限流、降级、熔断一把梭
- 降级:服务端出现问题,客户端降级使用 FallbackMethod 方法,返回一个友好的提示,而不至于忙等
- 熔断:达到一定条件后(比如请求故障率达到 60%),直接拒绝服务
- 限流:比如点对点消息队列缓慢消费请求,大家排队,一秒钟 N 个,有序进行,秒杀高并发等操作,严禁一窝蜂的过来拥挤
熔断(Circuit Breaker):电路保险丝,在分布式系统中,熔断机制包括两部分,一是检测服务是否故障,二是在超过阈值时自动阻止请求,以防止系统崩溃
熔断器的三种状态
- 关闭(Closed):服务正常运行,请求可以自由通过
- 打开(Open):当错误率达到阈值,熔断器打开,所有请求都会被拒绝,防止系统继续崩溃
- 半开(Half-Open):经过一段时间后,系统尝试放行部分请求进行测试,如果恢复正常,熔断器关闭,否则保持打开状态
例如
@CircuitBreaker(name = "paymentService", fallbackMethod = "fallbackPayment")
public String callPaymentService() {
// 调用远程支付服务
return restTemplate.getForObject("http://payment-service/pay", String.class);
}
// 熔断后的降级方法
public String fallbackPayment(Exception e) {
return "支付服务不可用,请稍后重试";
}
2
3
4
5
6
7
8
9
10
resilience4j.circuitbreaker:
instances:
paymentService:
failureRateThreshold: 50 # 失败率达到 50% 时触发熔断
waitDurationInOpenState: 5000ms # 熔断后 5 秒再尝试恢复
permittedNumberOfCallsInHalfOpenState: 3 # 半开状态时允许 3 个请求进行尝试
2
3
4
5
6
限流(Rate Limiting):限制请求速率,防止单个服务 QPS 过高被拖垮,例如
- 防止流量暴增导致系统崩溃(如双十一购物、秒杀活动)
- 防止恶意攻击(如爬虫、DDoS 攻击)
- 合理分配系统资源,保障 VIP 用户的优先级
Spring Cloud Gateway 内置了基于 Redis 令牌桶算法的限流功能,需要同时引入 Redis 和 Gateway 依赖并进行限流规则配置
什么时候使用熔断?什么时候使用限流?
- 熔断:服务出现错误返回是不被允许的,例如微信支付,如果支付接口故障,启用熔断,显示“支付系统繁忙”,而不能让请求挂着造成未知错误
- 限流:当你的服务流量暴增时,防止服务器资源被耗尽,例如淘宝双十一,高并发限流,防止流量冲垮系统,运行请求在后台“挂着”
简单来说:熔断用于保护服务防止雪崩,是兜底机制;限流用于平稳流量,提供稳定性
# Seata 事务与隔离组件
阿里开源的分布式事务解决方案
什么是事务?事务是指一组操作的逻辑单元,这些操作要么全部成功,要么全部失败,事务具有四个基本特性(ACID)
- 原子性:事务中的所有操作要么全部完成,要么全部不做
- 一致性:事务执行前后,数据库必须保持一致性状态
- 隔离性:并发执行的事务之间互不干扰
- 持久性:一旦事务提交,其结果是永久性的,即使系统崩溃也不会丢失
在 Spring 中,可用@Transactional 声明事务,直接在 Service 层对应的方法上进行注解,即可完成一次事务的编写
@Transactional只能修饰 public 方法@Transactional不能自身调用,比如方法 A 和 B 都在 UserService 类中,如果在 A 中调用 B 方法,即使 B 方法有@Transactional修饰,这个事务也不会生效,这和 Java 的动态代理机制有关
例如网银系统的一次 SQL 数据库事务写入
@Deprecated
@Transactional
@Override
public int doWithdrawal(TransactionDTO transactionDTO) {
int r = accountMapper.updateBalanceById(transactionDTO.getMyAccount(), transactionDTO.getAmount().negate());
log.info(transactionDTO.toString());
Transaction transaction = new Transaction(transactionDTO.getMyAccount(),
0L,
transactionDTO.getName(),
"外部账户",
transactionDTO.getAmount(),
"用户取款",
r == 1 ? 0 : 1);
return transactionMapper.insertTransaction(transaction);
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
其中
@Transactional(timeout = 5):设置超时,单位秒,超过时间未完成则回滚@Transactional(readOnly = true):只读事务中不能执行写操作,否则会抛出异常- 事务回滚规则:默认情况下,
@Transactional回滚的是 RunTimeException,如果需要特殊要求,需要指定@Transactional(rollbackFor = {IOException.class, SQLException.class}):回滚 I/O 和 SQL 异常@Transactional(noRollbackFor = {NullPointerException.class}):不回滚空指针异常
常见的事务隔离级别,以@Transactional为例,其 isolation 属性用于定义事务的隔离级别
| 隔离级别 | 防止脏读 | 防止不可重复读 | 防止幻读 |
|---|---|---|---|
| read uncommitted | ✗ | ✗ | ✗ |
| read committed | ✓ | ✗ | ✗ |
| repeatable read (MySQL 默认) | ✓ | ✓ | 部分 ✓(间隙锁) |
| serializable | ✓ | ✓ | ✓ |
@Transactional(isolation = Isolation.REPEATABLE_READ)
public void methodB() {
// 在可重复读隔离级别下执行
}
2
3
4
# 事务读写事故
脏读
- 读到了写过程中的临时数据
- 给写加锁,写时不能读
不可重复读
- 例如,在一个事务中,前后重复读同一数据,数据存在改变,说明读的时候有人在写
- 给读加锁,读时不能写
幻读:针对”数据表“层面的事故
- 假设我们给数据加了上述的读写锁(读时不写,写时不读),但这里的粒度只针对于这条数据,也就是说,在范围查表的时候,有可能出现同一事务的两次
count(*)返回不一样的结果(第一次读之后有人在往表里豪数据) - 对整个数据表加读写锁,彻底串行执行,效率极低
修改丢失
- ABA 问题,前后两次写,都根据同一源状态进行变更,后一次写覆盖了前一次写的提交,并且第一次写在 DB 中完全没有记录
- 对同一条数据写互斥
# 多阶段提交
一般而言,解决分布式事务会用到以下几种机制
2PC:两阶段提交,将事务的提交过程分为资源准备和资源提交两个阶段,并且由事务协调者来协调所有事务参与者,如果准备阶段所有事务参与者都预留资源成功,则进行第二阶段的资源提交,否则事务协调者回滚资源
3PC:三阶段提交协议,是二阶段提交协议的改进版本,三阶段提交有两个改动点
- 在协调者和参与者中都引入超时机制
- 在第一阶段和第二阶段中插入一个准备阶段,保证了在最后提交阶段之前各参与节点的状态是一致的
TCC:另一种分布式事务处理方法,它的名称来自于其三个阶段Try, Confirm, Cancel,这种方法主要用于处理在分布式系统中,多个服务需要协同完成一项操作时的一致性问题
# ES 搜索引擎
模糊查询、全文搜索、语义搜索及关键词搜索的区别?
ES 是什么?一个基于 Lucene 的分布式搜索和分析引擎,主要用于全文检索和日志分析,例如百度文库的文档需要支持全文搜索和语义搜索,就是用的 ES 索引,返回文档 id,控制面再从 BOS 里取内容
- ES 的快速索引核心在于倒排索引和 BM25 算法 (opens new window)
- ES 的数据一致性基于 Raft 算法,这个算法在很多地方看到过,例如 K8s 里 etcd 的选主
本质上 ES 就是在做存储,要么是索引,要么是内容
- 一种就是像文库做文档的索引,当一个搜索引擎在用
- 另一种就是做 DB,比如日志系统,直接用 ES 作为日志的落盘点,典型的就是 ELK 栈,包括华子的 SkyWalking 用的也是 ES
ELK(Elastic Stack),是以 ElasticSearch 为核心的技术栈,广泛应用在日志数据分析、实时监控等领域
- 数据可视化:Kibana
- 数据索引和存储:Elasticsearch
- 数据清晰:Logstash、Beats
日志数据流向
日志数据 ➡️ FileBeat ➡️ Kafka ➡️ Logstash ➡️ Elasticsearch ➡️ Kibana
DSL 是 elasticsearch 提供的JSON风格的请求语句,用来操作 elasticsearch,实现 CRUD,类似于 SQL
ES 的索引库和文档
- 索引库就是数据表定义
- 文档就是数据行
例如一个 /hotel 的索引库,以 json 的格式通过 PUT /hotel 命令入库(create table)
{
"mappings": {
"properties": {
"id": {
"type": "keyword"
},
"name":{
"type": "text",
"analyzer": "ik_max_word",
"copy_to": "all"
},
"address":{
"type": "keyword",
"index": false
},
"price":{
"type": "integer"
},
"score":{
"type": "integer"
},
"brand":{
"type": "keyword",
"copy_to": "all"
},
"city":{
"type": "keyword",
"copy_to": "all"
},
"starName":{
"type": "keyword"
},
"business":{
"type": "keyword"
},
"location":{
"type": "geo_point"
},
"pic":{
"type": "keyword",
"index": false
},
"all":{
"type": "text",
"analyzer": "ik_max_word"
}
}
}
}
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
而 /hotel/1 这样的文档就对应一个个具体的酒店,他以 /hotel 规定的 Json 格式(Scheme)存储数据
{
"id": "1",
"name": "如家精选酒店(北京王府井店)",
"address": "北京市东城区王府井大街88号",
"price": 499,
"score": 92,
"brand": "如家",
"city": "北京",
"starName": "四星级",
"business": "王府井商业区",
"location": {
"lat": 39.915,
"lon": 116.397
},
"pic": "https://example.com/images/homeinns_wangfujing.jpg",
"all": "如家精选酒店 北京王府井店 四星级 如家 北京"
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Elasticsearch Clients | Elastic (opens new window):在 Spring 中引入 ES Client 依赖,通过远程 DSL 操作 ES 库
# Monorepo 架构
带你了解更全面的 Monorepo - 优劣、踩坑、选型带你了解更全面的 Monorepo,本文涵盖了 Monoreo - 掘金 (opens new window)
简单来说,就是单仓库多模块,与之对应的是 Multirepo,多仓库多模块。这样做的明显优势就是代码更为集中,可以避免代码分散导致的重复劳动
- 可看到相关项目全貌,编码非常方便
- 依赖调试方便,依赖包迭代场景下,借助工具自动联合编译
- 依赖包管理共用,不需要重复占用磁盘空间
- CI / CD 也可以集中配置