
Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。
目标岗位:大型加密货币交易所 · 后端(风控方向)
题目数:12 题
重点:Q1-Q3 是你一面弱项(@Transactional),Q4(循环依赖)是大厂高频深挖题
Q1:@Transactional 底层原理
TL;DR
@Transactional = AOP 动态代理拦截方法调用 → TransactionInterceptor 在方法前后织入事务逻辑 → PlatformTransactionManager 管理 Connection 的 autoCommit/commit/rollback。
类比
🎬 电影拍摄:导演喊 "Action!"(begin)→ 演员表演(业务代码)→ 完美则 "Cut!"(commit),演砸了 "NG 重来"(rollback)。@Transactional 就是那个喊 Action 和 Cut 的人。
核心流程
源码核心类(面试说出这三个就够了)
| 类 | 职责 |
|---|---|
| TransactionInterceptor | AOP 拦截器,决定何时开启/提交/回滚事务 |
| PlatformTransactionManager | 事务管理器接口,DataSourceTransactionManager 是其实现 |
| TransactionSynchronizationManager | 用 ThreadLocal 将 Connection 绑定到当前线程,保证同一事务内使用同一连接 |
关键:事务传播靠 ThreadLocal
// 核心代码简化版
public class TransactionSynchronizationManager {
private static final ThreadLocal<Map<Object, Object>> resources = new ThreadLocal<>();
// 将 DB 连接绑定到当前线程
public static void bindResource(Object key, Object value) {
resources.get().put(key, value);
}
// 获取当前线程的 DB 连接 —— 同一事务内保证用同一个连接
public static Object getResource(Object key) {
return resources.get().get(key);
}
}记忆锚
"AOP 代理 → Interceptor 拦截 → Manager 管理 → ThreadLocal 绑定连接"
Q2:@Transactional 的 7 种失效场景
TL;DR
记住这 7 个坑,面试官问"你用 @Transactional 遇到过什么问题?"时直接背出来。
7 种失效
| # | 场景 | 原因 | 解决方案 |
|---|---|---|---|
| 1 | private 方法 | AOP 代理只能拦截 public 方法 | 改为 public |
| 2 | 同类方法调用 | this.method() 不经过代理对象 | 注入自己 / 拆分到另一个 Service |
| 3 | 异常被 catch 吞掉 | Spring 只对 RuntimeException 和 Error 回滚 | 抛出去 / 手动 TransactionAspectSupport.currentTransactionStatus().setRollbackOnly() |
| 4 | 非 RuntimeException(Checked Exception) | 默认不回滚 | @Transactional(rollbackFor = Exception.class) |
| 5 | 多线程 | ThreadLocal 绑定,新线程拿不到同一个 Connection | 不要把事务内的操作丢给线程池 |
| 6 | 存储引擎不支持事务(MyISAM) | 引擎不支持,声明了也没用 | 用 InnoDB |
| 7 | 传播行为设置错误(如 REQUIRES_NEW 导致事务挂起) | 不是失效,而是不符合预期 | 理解 7 种传播行为 |
场景 2 详解:同类调用为什么失效?
@Service
public class UserService {
@Transactional
public void register(User user) {
saveUser(user);
sendWelcomeEmail(user); // ← 同类调用!不经过代理
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void sendWelcomeEmail(User user) {
// 这里的事务其实是 register() 的事务,不是新事务!
}
}修复:注入自己 →
@Autowired private UserService self; self.sendWelcomeEmail(user);
记忆口诀
"私自同类非异常,捕获错误传播乱" —— private / 同(this)类调用 / 非RuntimeException / 异常捕获 / 错误传播行为
Q3:事务传播机制(7 种)
TL;DR
传播机制决定方法 A 有事务时,方法 B 是加入 A 的事务还是另开新事务。最常见的:REQUIRED(加入)、REQUIRES_NEW(新开)、NESTED(嵌套 savepoint)。
7 种传播行为
| 传播行为 | 当前有事务 | 当前无事务 | 典型场景 |
|---|---|---|---|
| REQUIRED(默认) | 加入当前事务 | 新建事务 | 90% 场景 |
| REQUIRES_NEW | 挂起当前事务,新建事务 | 新建事务 | 日志记录——日志事务独立,不随业务回滚 |
| NESTED | 创建 savepoint,嵌套子事务 | 新建事务 | 批量处理——某条失败只回滚这一条的 savepoint |
| SUPPORTS | 加入当前事务 | 非事务执行 | 只读查询 |
| NOT_SUPPORTED | 挂起当前事务,非事务执行 | 非事务执行 | 不需要事务的操作 |
| MANDATORY | 加入当前事务 | 抛异常 | 必须在事务上下文中的操作 |
| NEVER | 抛异常 | 非事务执行 | 禁止在事务中的操作 |
REQUIRES_NEW vs NESTED 的区别
// REQUIRES_NEW:完全独立的事务,外部回滚不影响内部
@Transactional
public void placeOrder() {
saveOrder(); // 外部事务
logService.audit(); // REQUIRES_NEW → 独立事务,外部回滚不影响日志
throw new RuntimeException(); // 外部事务回滚,日志事务已提交
}
// NESTED:子事务通过 savepoint,外部回滚 → 子也回滚
@Transactional
public void batchImport(List<Record> records) {
for (Record r : records) {
try {
importOne(r); // NESTED → 这条失败只回滚这一个 savepoint
} catch (Exception e) {
// 继续下一条
}
}
}| REQUIRES_NEW | NESTED | |
|---|---|---|
| 回滚隔离 | 完全独立 | 外部回滚→子也回滚 |
| 实现依赖 | 独立 Connection | JDBC Savepoint(需数据库支持) |
| 典型场景 | 日志审计 | 批量处理 |
记忆锚
"REQUIRED 加入,REQUIRES_NEW 独立,NESTED 局部回滚"
Q4:Spring 循环依赖 + 三级缓存
TL;DR
Spring 用三级缓存解决单例 Bean 的循环依赖:一级存成品、二级存半成品(提前暴露)、三级存 ObjectFactory。A 和 B 循环依赖时,A 的"半成品引用"先暴露到二级缓存,B 拿到它完成初始化,然后 A 再完成初始化。
类比
🪢 两个人互相等对方先开门:A 说"B 你先开门",B 说"A 你先开门"。三级缓存的方案是:A 先把"门把手"(半成品引用)从门缝递出去,B 抓住把手自己开门进去,然后 A 再关门。关键是 A 没完成初始化前,先把自己的引用暴露出去。
三级缓存
// DefaultSingletonBeanRegistry 中的三个 Map
// 一级缓存:完全初始化好的 Bean(成品)
Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 二级缓存:提前暴露的半成品 Bean(未完成属性注入)
Map<String, Object> earlySingletonObjects = new HashMap<>(16);
// 三级缓存:创建半成品的工厂(用于 AOP 代理)
Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);流程(A ↔ B 循环依赖)
为什么不能用二级缓存?
二级缓存(只有半成品引用)的问题:
如果 A 需要 AOP 代理,那么 B 拿到的应该是 A 的代理对象,而不是原始对象。
三级缓存的 ObjectFactory 可以在"真正需要时"才决定是返回原始对象还是代理对象。
三级缓存 = 延迟创建代理的钩子
构造器注入——循环依赖无解
❌ @Autowired on constructor → Spring 无法解决
因为实例化时就要求传入依赖,无法"先创建半成品"
✅ @Autowired on field/setter → Spring 可以解决
因为实例化完成后再注入依赖,有时间暴露半成品引用
记忆锚
"一级成品,二级半成品,三级工厂,构造器注入无解"
Q5:Spring AOP 原理(JDK 动态代理 vs CGLIB)
TL;DR
AOP = 在不修改源码的情况下,在方法前后插入增强逻辑。JDK 动态代理要求有接口(基于 $Proxy),CGLIB 通过继承生成子类(基于 Enhancer)。Spring Boot 2.x 默认用 CGLIB。
类比
🎭 替身演员:JDK 代理 = 替身需要和原演员一样的身高体型(实现相同接口)。CGLIB = 直接从原演员基因克隆一个(继承),不需要接口。
JDK 动态代理
// 核心:Proxy.newProxyInstance,只能代理接口
public class JdkProxy implements InvocationHandler {
private Object target;
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Before..."); // 前置增强
Object result = method.invoke(target, args); // 调用目标方法
System.out.println("After..."); // 后置增强
return result;
}
}
// 使用
UserService proxy = (UserService) Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(), // ← 必须有接口
new JdkProxy(target)
);CGLIB 代理
// 核心:Enhancer,通过继承生成子类
public class CglibProxy implements MethodInterceptor {
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("Before...");
Object result = proxy.invokeSuper(obj, args); // 调用父类(目标)方法
System.out.println("After...");
return result;
}
}对比
| JDK 动态代理 | CGLIB | |
|---|---|---|
| 机制 | 反射 + 接口代理 | 字节码 + 继承 |
| 要求 | 必须有接口 | 类不能是 final |
| 性能 | 创建快,调用慢(反射) | 创建慢(生成字节码),调用快 |
| 限制 | 只能代理接口方法 | final 方法无法代理 |
| Spring 默认 | Spring Boot 2.x 开始默认 CGLIB | — |
@Transactional 为什么要求 public?
CGLIB 可以代理 protected/default 方法,但 Spring 选择只代理 public。
原因:Spring 设计哲学——事务是"公开契约"的一部分,非 public 方法不应有事务语义。
记忆锚
"JDK 要接口,CGLIB 靠继承,Spring 默认 CGLIB"
Q6:IoC 容器 + Bean 生命周期
TL;DR
Bean 生命周期 = 实例化 → 属性注入 → Aware 回调 → BeanPostProcessor 前置 → init → BeanPostProcessor 后置 → 就绪 → 销毁。
类比
🧬 人的一生:出生(实例化)→ 上学(属性注入)→ 找工作(Aware 感知环境)→ 体检验证(BeanPostProcessor)→ 入职(init)→ 正式工作(就绪)→ 退休注销(destroy)
生命周期 10 步
为什么 BeanPostProcessor 有两个时机?
postProcessBeforeInitialization → init 之前(可以对原始 Bean 做修改)
postProcessAfterInitialization → init 之后(可以返回代理对象!)
@Transactional 的 AOP 代理就是在 PostProcessor 后置阶段生成的。
记忆锚
"实例→注入→感知→前置→init→后置→就绪→销毁"
Q7:如何自定义 Spring Boot Starter?
TL;DR
自定义 Starter = 一个 autoconfigure 模块(含 AutoConfiguration 类 + spring.factories 文件)+ 一个 starter 模块(空 POM,只引入 autoconfigure)。条件注解(@ConditionalOnClass/@ConditionalOnProperty)控制自动装配的触发条件。
类比
📦 麦当劳套餐:单点汉堡/薯条/可乐很麻烦(手动配置 Bean)。套餐把一个汉堡+薯条+可乐打包(Starter),你只要说"来一份巨无霸套餐"(引入一个依赖),全部给你配好。
三步创建
// 步骤 1:创建 AutoConfiguration 类
@Configuration
@ConditionalOnClass({RiskClient.class}) // classpath 有 RiskClient 才生效
@EnableConfigurationProperties(RiskProperties.class) // 绑定配置文件
public class RiskAutoConfiguration {
@Bean
@ConditionalOnMissingBean // 用户没自定义 Bean 才创建默认
public RiskClient riskClient(RiskProperties props) {
return new RiskClient(props.getUrl(), props.getTimeout());
}
}
// 步骤 2:配置属性类
@ConfigurationProperties(prefix = "大型加密货币交易所.risk")
public class RiskProperties {
private String url = "http://localhost:8080";
private int timeout = 5000;
// getters/setters...
}
// 步骤 3:spring.factories 注册
// META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.大型加密货币交易所.starter.RiskAutoConfigurationStarter 模块结构
risk-spring-boot-starter/
├── pom.xml ← 空项目,只声明依赖 autoconfigure 模块
└── (无代码)
risk-spring-boot-autoconfigure/
├── pom.xml
└── src/main/java/
├── RiskAutoConfiguration.java
├── RiskProperties.java
└── META-INF/
└── spring.factories
记忆锚
"AutoConfiguration + spring.factories + @ConditionalOnXxx + 配置属性"
Q8:Spring Boot 自动配置原理
TL;DR
@SpringBootApplication → @EnableAutoConfiguration → AutoConfigurationImportSelector 读取 META-INF/spring.factories 中所有 AutoConfiguration 类 → 根据 @ConditionalOnXxx 条件注解筛选哪些生效。
类比
🔌 USB 即插即用:你插上 U 盘,操作系统自动识别(spring.factories 扫描),加载对应驱动(AutoConfiguration),如果有兼容问题就不加载(@Conditional 条件过滤)。
核心流程
关键条件注解
| 注解 | 条件 | 示例 |
|---|---|---|
@ConditionalOnClass | classpath 中存在指定类 | 有 KafkaTemplate 才加载 Kafka 配置 |
@ConditionalOnMissingBean | 容器中不存在该 Bean | 用户没自定义 DataSource 才用默认 |
@ConditionalOnProperty | 配置文件中存在指定属性 | risk.enabled=true 才加载 |
@ConditionalOnBean | 容器中存在指定 Bean | DataSource 存在才加载 JdbcTemplate |
记忆锚
"spring.factories 注册 → 条件注解过滤 → 自动创建 Bean"
Q9:Spring 中常见设计模式
TL;DR
Spring 本身就是设计模式的最佳实践库。记住 5 个:单例(Bean 默认)、工厂(BeanFactory)、代理(AOP)、观察者(ApplicationEvent)、模板方法(JdbcTemplate)。
| 设计模式 | Spring 中的体现 | 位置 |
|---|---|---|
| 单例 | Bean 默认 scope=singleton | DefaultSingletonBeanRegistry |
| 工厂 | BeanFactory / ApplicationContext | 整个 IoC 容器 |
| 代理 | AOP 动态代理 | JdkDynamicAopProxy / CglibAopProxy |
| 观察者 | ApplicationEvent + @EventListener | 事件发布/订阅 |
| 模板方法 | JdbcTemplate / RestTemplate | doInXxx() 是模板,回调是扩展点 |
| 策略 | Resource 接口不同实现 | ClassPathResource / UrlResource |
| 适配器 | HandlerAdapter | 适配不同类型的 Controller |
| 装饰器 | BeanDefinitionDecorator | — |
面试时怎么说
"Spring 本身就是设计模式的教科书。我最常接触的有:单例——所有 Bean 默认就是单例;工厂——整个 IoC 容器就是一个大工厂;代理——AOP 的核心实现;观察者——事件驱动用 ApplicationEvent;模板方法——JdbcTemplate 定义了 SQL 执行流程,SQL 和参数映射交给子类/回调。"
记忆锚
"单/工/代/观/模" 五个字
Q10:Spring Boot 与 Spring Cloud 的协作关系
TL;DR
Spring Boot = 快速搭建单个微服务(内嵌 Tomcat + 自动配置 + Starter)。Spring Cloud = 微服务治理套件(注册/配置/网关/熔断/链路追踪)。Boot 是 Cloud 的基础,Cloud 解决分布式治理问题。
类比
🏠 装修 vs 物业:Spring Boot = 精装修房子(水电煤全通,拎包入住)。Spring Cloud = 小区物业管理(门禁/快递/维修/监控),你住小区必须先用 Boot 装修好每套房,然后 Cloud 来统一管理整个小区。
分工
Spring Boot 做的事(单服务维度):
- 自动配置:引入依赖即可用
- 内嵌 Server:java -jar 直接跑
- Actuator:健康检查 / metrics
- 外部化配置:application.yml
Spring Cloud 做的事(分布式维度):
- 注册发现:Nacos / Eureka
- 配置中心:Nacos Config / Apollo
- 网关:Spring Cloud Gateway
- 熔断限流:Sentinel / Resilience4j
- 链路追踪:Sleuth + Zipkin / SkyWalking
- 远程调用:OpenFeign / Dubbo
记忆锚
"Boot 装修每套房,Cloud 管理整个小区"
Q11:微服务配置管理 + 动态更新
TL;DR
配置管理 = Nacos / Apollo 集中存储 + 客户端长轮询/推送实时更新。关键:变更后不重启服务,通过 @RefreshScope 或监听器刷新 Bean。
类比
📱 手机系统设置:你改了 Wi-Fi 密码(配置变更),手机自动重连(热更新),不需要重启手机。Nacos/Apollo 就是微服务的"系统设置"。
方案
| 方案 | 机制 | 优点 | 缺点 |
|---|---|---|---|
| Nacos Config | Client 长轮询 → 服务端配置变更 → 推送 | 阿里生态,与 Dubbo/Sentinel 集成 | 强依赖 Nacos 集群 |
| Apollo | Client 定时拉 + 实时推送 | 成熟,UI 好,灰度发布 | 携程系,组件较多 |
| Spring Cloud Config | Git 仓库 + Bus 刷新 | 简单,版本管理好 | 无 UI,动态更新需 MQ |
动态刷新实现
// 方式 1:@RefreshScope —— 配置刷新时重新创建 Bean
@RestController
@RefreshScope
public class RiskController {
@Value("${risk.timeout}")
private int timeout; // Nacos 改了 → /actuator/refresh → 新值生效
}
// 方式 2:监听配置变更事件
@NacosConfigListener(dataId = "risk-config", groupId = "RISK")
public void onConfigChange(String newConfig) {
// 自定义刷新逻辑
}记忆锚
"Nacos 长轮询 + @RefreshScope 热刷新"
Q12:从 0 到 1 设计简易配置中心
TL;DR
配置中心 = 存储(MySQL)+ 缓存(本地内存 + 可选 Redis)+ 推送(长轮询/WebSocket)+ 版本管理(每次变更新增一条记录)+ 灰度(基于 IP/标签的配置覆盖)。
核心功能清单
| 功能 | 实现 |
|---|---|
| 配置存储 | MySQL 表:config(app, env, key, value, version) |
| 客户端缓存 | 启动时全量拉取 → 本地 Map 缓存 |
| 变更推送 | 客户端长轮询(hold 30s)→ 服务端变更则立即返回 → 客户端拉最新配置 |
| 版本管理 | 每次修改变更 version,支持回滚 |
| 灰度发布 | 配置可绑定 IP / 标签,优先匹配灰度规则 |
| 权限审计 | 谁在什么时候改了什么 |
| SDK | 轻量 Java/Go SDK,启动时拉取 + 运行时监听 |
长轮询机制
最小可行产品
表结构 (1 张表):
CREATE TABLE config (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
app VARCHAR(64),
env VARCHAR(16),
config_key VARCHAR(128),
config_value TEXT,
version INT DEFAULT 0,
UNIQUE KEY(app, env, config_key)
);
SDK 核心代码(不到 100 行):
class ConfigClient {
Map<String, String> cache = new ConcurrentHashMap<>();
String serverUrl;
int currentVersion;
void start() {
// 1. 启动时全量拉取
pullAll();
// 2. 后台线程长轮询
new Thread(this::longPoll).start();
}
void longPoll() {
while (true) {
Response r = httpGet(serverUrl + "?version=" + currentVersion, 30000);
if (r.changed) pullAll();
}
}
}
记忆锚
"MySQL 存储 + 本地缓存 + 长轮询推送 + 版本管理"
总结:Spring Boot 面试万能回答框架
问原理 → "它基于 AOP 代理,核心类是 XxxInterceptor,底层用 ThreadLocal 绑定资源"
问失效 → "我遇到过 N 种:private、同类调用、异常被吞、非 RuntimeException..."
问对比 → "JDK 要接口,CGLIB 靠继承,默认 CGLIB。前者创建快调用慢,后者相反"
问生命周期 → "实例→注入→感知→前置→init→后置→就绪→销毁"
问怎么自己实现 → "AutoConfiguration + spring.factories + @Conditional + 属性绑定"
B2 补充:Spring 追问(Q13-Q22)
来自
questions.md:DI/IOC/AOP 基础、Spring Cloud Gateway、Sentinel 原理、@Transactional 深入。
Q13:DI / IOC / AOP 到底是什么意思?
用大白话说
| 概念 | 大白话 | 不用 Spring 时 | 用 Spring 后 |
|---|---|---|---|
| IOC 控制反转 | 你别自己 new 对象了,我帮你创建 | new UserService() | @Autowired UserService |
| DI 依赖注入 | 你需要什么,我自动塞给你 | service.setDao(new UserDao()) | @Autowired 自动注入 |
| AOP 面向切面 | 把散落各处的重复代码(日志/事务/鉴权)集中管理 | 每个方法里写 log.info(...) | @Transactional / @Around |
一句话:IOC 是思想(容器管理对象),DI 是实现(自动装配),AOP 是增强(横切逻辑抽离)。
Q14:@Transactional 底层原理 + 失效场景回顾
本质
AOP 代理。Spring 生成代理对象,在方法调用前后开启/提交/回滚事务。所以:
controller → serviceProxy(代理)→ 开启事务 → service.method() → 提交/回滚
↑
这个代理就是你用 @Autowired 拿到的那个
失效的根本原因:没经过代理!
失效场景速查(详见 B2 Q1-Q3)
1. 同类调用 → this.method() 绕过了代理
2. 方法非 public → CGLIB 无法代理非 public
3. 异常被 try-catch 吞了 → 事务管理器不知道出错了
4. 非 RuntimeException → 默认只回滚 RuntimeException
5. 多线程 → 新线程不受当前事务管理
Q15:Spring Cloud Gateway 做限流和鉴权
TL;DR
Gateway = 所有请求的统一入口(API 网关)。核心:路由(根据 URL 转发到对应服务)→ Filter(请求前后插入逻辑)→ Predicate(匹配条件)。
鉴权怎么做?
@Component
public class AuthFilter implements GlobalFilter {
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
String token = exchange.getRequest().getHeaders().getFirst("Authorization");
if (token == null || !validateToken(token)) {
exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
return exchange.getResponse().setComplete();
}
return chain.filter(exchange);
}
}
// → 所有请求先过这里 → 没 token 的直接返回 401 → 有 token 的继续路由限流怎么做?
spring:
cloud:
gateway:
routes:
- id: risk-service
uri: lb://risk-service
filters:
- name: RequestRateLimiter
args:
redis-rate-limiter.replenishRate: 100 # 每秒补充 100 令牌
redis-rate-limiter.burstCapacity: 200 # 突发最大 200Q16:Sentinel 核心功能和实现原理
TL;DR
Sentinel = 阿里开源的流量治理组件。三大核心:限流(QPS 超过阈值→拒绝)→ 熔断(慢调用/异常比例过高→主动切断)→ 热点防护(针对某个参数的精细化限流)。底层:责任链(ProcessorSlotChain),每个 Slot 是一个检查点。
与 Hystrix 的核心差异
| Hystrix | Sentinel | |
|---|---|---|
| 隔离策略 | 线程池隔离(每个依赖独立线程池) | 信号量隔离(轻量) |
| 限流算法 | 固定窗口 | 滑动窗口(更平滑) |
| 熔断恢复 | 半开状态探测 | 渐进式恢复 |
| 控制台 | Hystrix Dashboard | Sentinel Dashboard(实时修改规则) |
| 规则动态更新 | 重启生效 | 控制台实时下发 |
| 维护状态 | 停止维护 | 活跃 |
记忆锚
"Sentinel = 滑动窗口限流 + 慢调用熔断 + 责任链 + 实时规则,Hystrix 的继承者"
Q17:Nacos 功能 + 配置下发原理
TL;DR
Nacos = 服务发现(谁在线?IP 是什么?)+ 配置中心(动态改配置,不用重启)。配置下发:客户端长轮询(Long Polling),服务端 hold 连接 30s,配置变更立即返回;无变更返回空→客户端重新发起长轮询。
Client → GET /config?dataId=xxx&contentMD5=abc
Server → hold 30s → 有变更?返回新配置+新MD5 : 返回空
Client → 收到变更 → 更新本地文件缓存 → 触发 RefreshEvent → @RefreshScope Bean 重建
Nacos 挂了影响业务吗? 不影响!客户端有本地文件缓存,启动时优先读本地缓存。
Q18:Sentinel 滑动窗口 vs 固定窗口
固定窗口:
→ 每 1s 一个窗口,窗口内 QPS 超限→拒绝
→ 问题:窗口切换瞬间可能流量翻倍
→ 例:0.9s~1.1s 跨两个窗口,两个窗口都只统计一半 → 实际 QPS 可能翻倍
滑动窗口:
→ 把 1s 分成 N 个小格子(如 10 个 100ms 格子)
→ 每个请求落在对应格子里 +1
→ 统计 = 最近 N 个格子的和
→ 问题解决:任何时刻都是"过去 1s 的精确 QPS"
Q19:Netty 长连接复用 vs Undertow 短连接
| Netty | Undertow | |
|---|---|---|
| 性质 | 网络框架(传输层) | Web 服务器(应用层) |
| 连接模型 | 长连接(TCP 连接不释放) | HTTP 短连接(用完即关/Keep-Alive) |
| 适用 | RPC(Dubbo 底层就是 Netty) | HTTP(Spring Boot 默认 Web 容器) |
| 为什么 Dubbo 用长连接? | 服务间高频调用,复用连接省去握手开销 |
记忆锚
"Dubbo 用 Netty 长连接(高频 RPC 复用),Feign 用 HTTP 短连接(每次新 TCP 握手→慢)"
Q20:Dubbo 服务导出流程
Provider 启动 → ServiceBean 初始化 → 调用 export()
→ 1. 创建本地 Invoker(封装实现类)
→ 2. 把 Invoker 导出为 Exporter(绑定端口,启动 Netty Server)
→ 3. 注册到注册中心(Nacos/ZK):我是 xxx 服务,IP=x.x.x.x:20880
→ 4. Consumer 从注册中心发现 → 创建代理 → 调用时通过 Netty 发请求
Q21:SpringBoot 自动配置原理
一句话
@SpringBootApplication → @EnableAutoConfiguration → @Import(AutoConfigurationImportSelector)
→ 扫描所有 spring.factories 文件 → 读取里面的 AutoConfiguration 类
→ 按 @ConditionalOnClass/@ConditionalOnMissingBean 判断要不要加载
→ 加载的 Bean 放入 IOC 容器
怎么自己写一个 starter?
- 写 AutoConfiguration 类(
@Configuration + @Bean) - 写
spring.factories:org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.xxx.MyAutoConfiguration - 加
@ConditionalOnClass等条件注解 - 打包发布
Q22:Spring Bean 生命周期
1. 实例化 (new UserService())
2. 属性注入 (@Autowired 赋值)
3. BeanNameAware.setBeanName("userService")
4. BeanFactoryAware.setBeanFactory(...)
5. @PostConstruct 方法
6. InitializingBean.afterPropertiesSet()
7. 自定义 init-method
8. Bean 就绪,可以使用
9. @PreDestroy / DisposableBean.destroy() → 销毁
总结
DI/IOC/AOP → IOC 是思想(容器管对象),DI 是方式(自动装配),AOP 是增强(横切集中)
@Transactional → AOP 代理 + PlatformTransactionManager + 失效=没走代理
Gateway → 统一入口,Filter 链做鉴权限流
Sentinel → 滑动窗口 + 熔断器 + 责任链 + 实时规则 — Hystrix 的继承者
Nacos → 长轮询推送配置,本地文件缓存兜底,挂了不影响业务
Netty vs 容器 → Netty 长连接给 RPC,Undertow/Tomcat 短连接给 HTTP
下一篇:B3 JVM 原理 + 调优 + Virtual Threads(20 题)