面试题集锦:Spring Boot 与常用组件

面试题集锦:Spring Boot 与常用组件

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 的人。

核心流程

interview spring boot qa · 图 1
interview spring boot qa · 图 1 · 点击查看 SVG 原图

源码核心类(面试说出这三个就够了)

类职责
TransactionInterceptorAOP 拦截器,决定何时开启/提交/回滚事务
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 种失效

#场景原因解决方案
1private 方法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() 的事务,不是新事务!
    }
}
interview spring boot qa · 图 2
interview spring boot qa · 图 2 · 点击查看 SVG 原图

修复:注入自己 → @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_NEWNESTED
回滚隔离完全独立外部回滚→子也回滚
实现依赖独立 ConnectionJDBC 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 循环依赖)

interview spring boot qa · 图 3
interview spring boot qa · 图 3 · 点击查看 SVG 原图

为什么不能用二级缓存?

二级缓存(只有半成品引用)的问题:
  如果 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 步

interview spring boot qa · 图 4
interview spring boot qa · 图 4 · 点击查看 SVG 原图

为什么 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.RiskAutoConfiguration

Starter 模块结构

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 条件过滤)。

核心流程

interview spring boot qa · 图 5
interview spring boot qa · 图 5 · 点击查看 SVG 原图

关键条件注解

注解条件示例
@ConditionalOnClassclasspath 中存在指定类有 KafkaTemplate 才加载 Kafka 配置
@ConditionalOnMissingBean容器中不存在该 Bean用户没自定义 DataSource 才用默认
@ConditionalOnProperty配置文件中存在指定属性risk.enabled=true 才加载
@ConditionalOnBean容器中存在指定 BeanDataSource 存在才加载 JdbcTemplate

记忆锚

"spring.factories 注册 → 条件注解过滤 → 自动创建 Bean"


Q9:Spring 中常见设计模式

TL;DR

Spring 本身就是设计模式的最佳实践库。记住 5 个:单例(Bean 默认)、工厂(BeanFactory)、代理(AOP)、观察者(ApplicationEvent)、模板方法(JdbcTemplate)。

设计模式Spring 中的体现位置
单例Bean 默认 scope=singletonDefaultSingletonBeanRegistry
工厂BeanFactory / ApplicationContext整个 IoC 容器
代理AOP 动态代理JdkDynamicAopProxy / CglibAopProxy
观察者ApplicationEvent + @EventListener事件发布/订阅
模板方法JdbcTemplate / RestTemplatedoInXxx() 是模板,回调是扩展点
策略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 ConfigClient 长轮询 → 服务端配置变更 → 推送阿里生态,与 Dubbo/Sentinel 集成强依赖 Nacos 集群
ApolloClient 定时拉 + 实时推送成熟,UI 好,灰度发布携程系,组件较多
Spring Cloud ConfigGit 仓库 + 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,启动时拉取 + 运行时监听

长轮询机制

interview spring boot qa · 图 6
interview spring boot qa · 图 6 · 点击查看 SVG 原图

最小可行产品

表结构 (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    # 突发最大 200

Q16:Sentinel 核心功能和实现原理

TL;DR

Sentinel = 阿里开源的流量治理组件。三大核心:限流(QPS 超过阈值→拒绝)→ 熔断(慢调用/异常比例过高→主动切断)→ 热点防护(针对某个参数的精细化限流)。底层:责任链(ProcessorSlotChain),每个 Slot 是一个检查点。

与 Hystrix 的核心差异

HystrixSentinel
隔离策略线程池隔离(每个依赖独立线程池)信号量隔离(轻量)
限流算法固定窗口滑动窗口(更平滑)
熔断恢复半开状态探测渐进式恢复
控制台Hystrix DashboardSentinel 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 短连接

NettyUndertow
性质网络框架(传输层)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?

  1. 写 AutoConfiguration 类(@Configuration + @Bean)
  2. 写 spring.factories:org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.xxx.MyAutoConfiguration
  3. 加 @ConditionalOnClass 等条件注解
  4. 打包发布

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 题)