SYSTEM
框架与中间件 知识文档
src/content/notes/system/04-框架与中间件.md 面向 Java 后端秋招面试 配套思维导图:mindmaps/04-框架与中间件.html
一、Spring
1.1 IoC
- BeanFactory:IoC 容器顶层接口,提供最基本的容器能力,懒加载(getBean 时才实例化)。
- ApplicationContext:BeanFactory 的子接口,预实例化单例(启动时创建),并扩展了国际化、事件发布、资源加载等企业级能力。实际开发几乎都用 ApplicationContext。
- Bean 生命周期:实例化 → 属性填充(populateBean,完成依赖注入)→ 各种 Aware 回调(BeanNameAware/BeanFactoryAware)→ BeanPostProcessor 前置 → 初始化(InitializingBean#afterPropertiesSet + init-method)→ BeanPostProcessor 后置(AOP 代理就在此生成)→ 使用 → 销毁(DisposableBean#destroy + destroy-method)。
// 自定义 BeanPostProcessor,AOP 代理即在此阶段生成
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
if (bean instanceof UserService) {
// 返回代理对象,替换原 bean
return Proxy.newProxyInstance(
bean.getClass().getClassLoader(),
bean.getClass().getInterfaces(),
(proxy, method, args) -> {
System.out.println("before " + method.getName());
return method.invoke(bean, args);
});
}
return bean;
}
}
面试题:Spring Bean 的生命周期? 答:核心五步——实例化、属性赋值、初始化、使用、销毁。其中初始化前后由 BeanPostProcessor 拦截,AOP 代理就在后置处理阶段生成。ApplicationContext 在容器启动时预实例化所有单例 Bean。
1.2 DI
三种注入方式对比:
| 注入方式 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
| 构造注入 | 不可变、可空安全、可在编译期发现依赖 | 参数多时臃肿、循环依赖难处理 | 强依赖 / 必填依赖 |
| Setter 注入 | 灵活、可选依赖、可重新配置 | 可能在使用时为 null | 可选依赖 |
| 字段注入 | 简洁 | 破坏封装、不可变、无法脱离容器测试 | 不推荐 |
@Service
public class OrderService {
private final UserService userService;
// 构造注入(Spring 4.3+ 单构造器可省略 @Autowired)
public OrderService(UserService userService) {
this.userService = userService;
}
}
面试题:构造注入和 Setter 注入哪个更好? 答:官方推荐构造注入——保证依赖不可变、不会出现半初始化状态,且能在编译期发现缺失依赖;循环依赖时构造注入会直接报错,反而能暴露设计问题。Setter 注入适用于可选依赖。字段注入会破坏封装性、难以脱离容器做单元测试,应避免。
1.3 AOP
JDK 动态代理 vs CGLIB:
| 维度 | JDK 动态代理 | CGLIB |
|---|---|---|
| 原理 | 基于接口,Proxy + InvocationHandler | 基于子类继承,生成字节码 |
| 要求 | 目标必须实现接口 | 目标类不能 final,方法不能 final |
| 性能 | 创建快、调用稍慢 | 创建慢、调用快 |
| Spring 选择 | 有接口默认用它 | 无接口 fallback 到 CGLIB |
// JDK 动态代理示例
public class LogInvocationHandler implements InvocationHandler {
private final Object target;
public LogInvocationHandler(Object target) { this.target = target; }
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("[log] before " + method.getName());
Object ret = method.invoke(target, args);
System.out.println("[log] after " + method.getName());
return ret;
}
}
// 使用:Proxy.newProxyInstance(loader, new Class[]{UserService.class}, handler)
5 种通知类型:@Before、@After、@AfterReturning、@AfterThrowing、@Around(最强大,可控制是否执行、修改参数/返回值)。
@Aspect
@Component
public class LogAspect {
@Pointcut("execution(* com.example.service..*.*(..))")
public void servicePointcut() {}
@Around("servicePointcut()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
long start = System.currentTimeMillis();
Object ret = pjp.proceed();
System.out.println(pjp.getSignature() + " cost " + (System.currentTimeMillis() - start) + "ms");
return ret;
}
}
面试题:Spring AOP 用的是 JDK 代理还是 CGLIB? 答:默认策略下,目标类实现了接口用 JDK 动态代理,没有接口则用 CGLIB。可通过
spring.aop.proxy-target-class=true强制全部使用 CGLIB。Spring Boot 2.x 之后默认就是 CGLIB(proxyTargetClass=true),以保证代理对象与目标类一致。
1.4 事务
7 种传播行为:
| 传播行为 | 含义 |
|---|---|
| REQUIRED(默认) | 有事务加入,没有则新建 |
| REQUIRES_NEW | 总是新建,挂起当前事务 |
| NESTED | 嵌套事务(savepoint 回滚点) |
| SUPPORTS | 有则加入,没有就非事务 |
| NOT_SUPPORTED | 非事务执行,挂起当前事务 |
| MANDATORY | 必须有事务,否则抛异常 |
| NEVER | 非事务执行,有事务则抛异常 |
隔离级别:DEFAULT、READ_UNCOMMITTED、READ_COMMITTED(Oracle 默认)、REPEATABLE_READ(MySQL 默认)、SERIALIZABLE。
事务失效场景:
- 自调用:同类中 A 方法直接调用 B 方法,B 上的
@Transactional失效(未经过代理对象)。 - 非 public 方法:默认只对 public 方法生效。
- 异常被 catch 吞掉:代理对象未感知到异常,不回滚。
- rollbackFor 不匹配:默认只回滚 RuntimeException/Error,检查异常不回滚,需
rollbackFor = Exception.class。 - 事务管理器未配置 / 类未被 Spring 管理。
- 传播行为设为 NOT_SUPPORTED / NEVER。
@Service
public class TransferService {
@Transactional(rollbackFor = Exception.class)
public void transfer(Long from, Long to, BigDecimal amount) {
accountDao.debit(from, amount);
accountDao.credit(to, amount);
// 若此处抛 RuntimeException 会回滚 debit+credit
}
// 自调用失效示例
public void batchTransfer() {
// 直接 this 调用,未经代理,事务不生效
this.transfer(1L, 2L, BigDecimal.TEN);
}
}
面试题:@Transactional 什么时候会失效? 答:典型场景——同类内部自调用(绕过代理)、非 public 方法、异常被 catch 吞掉、rollbackFor 未配置导致检查异常不回滚、Bean 未被 Spring 管理、传播行为配置为非事务。自调用的修复方式是注入自身代理对象(
AopContext.currentProxy())或拆分到另一个 Bean。
1.5 Spring MVC 流程
完整流程:
- 请求到达 DispatcherServlet(前端控制器)。
- DispatcherServlet 调用 HandlerMapping 根据 URL 找到对应 Controller 方法(HandlerExecutionChain,含拦截器)。
- 调用 HandlerAdapter 执行 Controller 方法(HandlerAdapter 解决适配问题)。
- Controller 返回 ModelAndView(或被@ResponseBody 拦截直接写响应)。
- ViewResolver 解析逻辑视图名为物理 View。
- View 渲染(模型数据填充),写回响应。
- 拦截器 afterCompletion 逆序执行。
@RestController
@RequestMapping("/user")
public class UserController {
@GetMapping("/{id}")
public User get(@PathVariable Long id) {
return userService.getById(id); // @ResponseBody 由 RequestResponseBodyMethodProcessor 处理,跳过 ViewResolver
}
}
面试题:描述 Spring MVC 的请求处理流程? 答:请求先到 DispatcherServlet 前端控制器,由 HandlerMapping 根据 URL 找到 Controller 方法与拦截器链,再由 HandlerAdapter 执行方法。方法返回 ModelAndView 后,ViewResolver 解析视图名并渲染。若是 REST 接口(@ResponseBody),则由消息转换器直接将返回值写为 JSON,不经过 ViewResolver。整个链路还贯穿拦截器的 preHandle / postHandle / afterCompletion。
二、MyBatis
2.1 #{} vs ${}
#{}:编译为?占位符(PreparedStatement),自动防 SQL 注入,参数值会被转义。${}:直接字符串拼接,无法防注入,用于表名、列名、排序字段等不能加引号的位置。
<!-- 安全:#{userId} 编译为 ? 占位符 -->
<select id="findById" resultType="User">
SELECT * FROM user WHERE id = #{userId}
</select>
<!-- 动态表名/排序必须用 ${} -->
<select id="findByOrder" resultType="User">
SELECT * FROM ${tableName} ORDER BY ${orderField} ${orderDir}
</select>
面试题:MyBatis 中 #{} 和 ${} 的区别? 答:
#{}是预编译占位符,会被替换为?并通过 PreparedStatement 设值,天然防 SQL 注入;${}是字符串直接拼接,存在注入风险,只能用于表名、排序字段等结构位置,且必须对入参做白名单校验。
2.2 一级缓存与二级缓存
- 一级缓存:SqlSession 级别,默认开启,同一 SqlSession 内相同查询直接命中。执行 update/insert/delete 或
clearCache()会清空。 - 二级缓存:Mapper(namespace)级别,需手动开启。SqlSession 关闭(close)时一级缓存内容才放入二级缓存,跨 SqlSession 共享。
- 分布式/多实例场景:二级缓存有一致性问题,生产环境常用 Redis 替代。
<!-- 开启二级缓存:实体需实现 Serializable -->
<cache eviction="LRU" flushInterval="60000" size="512" readOnly="true"/>
面试题:MyBatis 缓存机制? 答:一级缓存是 SqlSession 级别,默认开启,同 Session 内相同查询走缓存,增删改会使其失效;二级缓存是 Mapper 级别,跨 SqlSession 共享,Session close 后数据才进入二级缓存。二级缓存易在多实例出现脏读,生产多使用 Redis 作为分布式缓存替代。与 Spring 整合后一级缓存基本失效(每次调用新建 SqlSession),所以二级缓存或 Redis 更重要。
2.3 插件机制
MyBatis 插件基于责任链 + 动态代理,可拦截四大对象的方法,对 SQL 执行进行增强(分页 PageHelper、慢 SQL 监控、SQL 改写等)。
| 对象 | 作用 | 常见拦截点 |
|---|---|---|
| Executor | 执行 SQL 全流程 | update/query/commit |
| StatementHandler | 处理语句与参数 | prepare/parameterize |
| ParameterHandler | 设置 SQL 参数 | setParameters |
| ResultSetHandler | 处理结果集映射 | handleResultSets |
@Intercepts(@Signature(
type = StatementHandler.class,
method = "prepare",
args = {Connection.class, Integer.class}))
public class SlowSqlPlugin implements Interceptor {
@Override
public Object intercept(Invocation inv) throws Throwable {
long start = System.currentTimeMillis();
Object ret = inv.proceed();
if (System.currentTimeMillis() - start > 500) {
log.warn("slow sql: {} ms", System.currentTimeMillis() - start);
}
return ret;
}
}
面试题:MyBatis 插件能拦截哪些方法? 答:可拦截四大核心对象——Executor(update/query/commit)、StatementHandler(prepare/parameterize)、ParameterHandler(setParameters)、ResultSetHandler(handleResultSets)。原理是责任链 + 动态代理,被拦截方法执行前后可做增强,典型应用是 PageHelper 分页插件。
三、Netty
3.1 ChannelPipeline
- ChannelPipeline 是一个双向链表,串联多个 ChannelHandler。
- 入站(Inbound)事件从 head 向 tail 传播:channelRead、channelActive 等,由 ChannelInboundHandler 处理。
- 出站(Outbound)事件从 tail 向 head 传播:write、bind、read 等,由 ChannelOutboundHandler 处理。
- 编解码器通常是入站解码 + 出站编码成对出现。
public class ServerInitializer extends ChannelInitializer<SocketChannel> {
@Override
protected void initChannel(SocketChannel ch) {
ChannelPipeline p = ch.pipeline();
// 出站 + 入站编解码器
p.addLast(new LengthFieldBasedFrameDecoder(1024, 0, 4, 0, 4));
p.addLast(new StringDecoder());
p.addLast(new StringEncoder());
// 自定义业务处理器
p.addLast(new GameServerHandler());
}
}
面试题:Netty 中入站和出站处理器有什么区别? 答:入站处理器(ChannelInboundHandler)处理”进来的”数据如读取到的字节、连接建立事件,事件从 pipeline 的 head 向 tail 传播;出站处理器(ChannelOutboundHandler)处理”出去的”操作如 write/bind,事件从 tail 向 head 传播。二者可同时存在,编解码器即典型成对组合。
3.2 EventLoopGroup
- Boss Group:专门接收新连接(OP_ACCEPT),通常 1 个线程。
- Worker Group:处理已建立连接的 IO 读写(OP_READ/OP_WRITE)。
- 绑定关系:一个 Channel 在其生命周期内只绑定一个 EventLoop(一个线程),避免多线程并发访问同一 Channel,天然线程安全。
- NioEventLoop 内部持有任务队列,同时处理 IO 事件与普通/定时任务。
EventLoopGroup boss = new NioEventLoopGroup(1);
EventLoopGroup worker = new NioEventLoopGroup(); // 默认 2*CPU 核数
ServerBootstrap b = new ServerBootstrap();
b.group(boss, worker)
.channel(NioServerSocketChannel.class)
.childHandler(new ServerInitializer())
.option(ChannelOption.SO_BACKLOG, 1024)
.childOption(ChannelOption.TCP_NODELAY, true);
面试题:Netty 的线程模型是怎样的? 答:主流用”主从 Reactor”——Boss Group 处理连接接收,Worker Group 处理 IO 读写。关键设计是”一个 Channel 绑定一个 EventLoop 线程”,同一连接所有事件都在同一线程处理,天然无锁。EventLoop 同时跑 IO 事件和任务队列,所以业务不能阻塞 EventLoop,耗时任务应丢到业务线程池。
3.3 ByteBuf
- 堆内 vs 堆外:堆外(DirectBuffer)减少一次内核→用户空间的数据拷贝(零拷贝),适合大流量 IO,但分配/释放代价高。
- 池化:PooledByteBufAllocator 复用内存块,减少 GC 与分配开销,生产推荐开启。
- 引用计数:ByteBuf 实现 ReferenceCounted,用完必须
release(),否则内存泄漏;Netty 提供ResourceLeakDetector检测泄漏。
// 推荐:堆外 + 池化
ByteBuf buf = Unpooled.directBuffer(256);
try {
buf.writeBytes(data);
ctx.writeAndFlush(buf); // 出站时会自动 release
} finally {
// 若未交给 pipeline,需手动 release
}
面试题:Netty 的 ByteBuf 相比 Java NIO ByteBuffer 有什么优势? 答:①读写指针分离(readerIndex/writerIndex),无需 flip 切换;②可自动扩容;③支持堆内/堆外和池化,减少 GC 与零拷贝;④引用计数机制,配合 LeakDetector 防泄漏。ByteBuffer 单一指针、需手动 flip,且无池化。
3.4 编解码器
- 粘包原因:TCP 是流式协议,无消息边界,应用层多条消息可能被合并或拆分。
- LengthFieldBasedFrameDecoder:基于长度字段解决半包/粘包,最常用。
- 解码流程:读长度字段 → 据长度截取一帧完整数据 → 交给下游解码器。
// 协议:[长度(4字节)] [body]
p.addLast(new LengthFieldBasedFrameDecoder(
65535, // 最大帧长
0, // 长度字段偏移
4, // 长度字段长度
0, // 长度调整
4)); // 跳过长度字段本身
面试题:Netty 如何解决粘包拆包? 答:应用层自行定义消息边界。常见方案:固定长度、分隔符、长度字段法(最通用)。Netty 提供对应的解码器——FixedLengthFrameDecoder、DelimiterBasedFrameDecoder、LengthFieldBasedFrameDecoder。后者通过长度字段读取一帧完整数据,是自定义二进制协议最常用的方式。
3.5 IdleStateHandler 心跳
- IdleStateHandler 监控读空闲、写空闲、读写空闲,超时触发 userEventTriggered 事件。
- 服务端常见策略:写空闲发心跳包,读空闲判定客户端掉线并关闭连接。
p.addLast(new IdleStateHandler(60, 30, 0, TimeUnit.SECONDS)); // 读空闲60s 写空闲30s
p.addLast(new ChannelInboundHandlerAdapter() {
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
if (evt instanceof IdleStateEvent) {
IdleState state = ((IdleStateEvent) evt).state();
if (state == IdleState.READER_IDLE) {
ctx.close(); // 客户端掉线
} else if (state == IdleState.WRITER_IDLE) {
ctx.writeAndFlush(new HeartbeatPacket()); // 主动发心跳
}
}
}
});
面试题:Netty 如何实现心跳机制? 答:用 IdleStateHandler 监控读写空闲事件,超时回调 userEventTriggered。服务端通常设读空闲超时来检测客户端掉线(读空闲就 close),写空闲超时主动下发心跳包保活。客户端则反过来,读空闲发心跳、写空闲判定服务端掉线。相比定时轮询,空闲事件驱动更轻量。
四、RabbitMQ / Kafka
4.1 消息模型
- Kafka:Topic → 多个 Partition(分区,有序保证单位)→ Consumer Group 内消费者各消费一个分区,实现负载均衡。
- RabbitMQ:Producer → Exchange(direct/fanout/topic/headers)→ 通过 binding 路由到 Queue → Consumer。
- Kafka 分区数 = 并发度上限,Consumer Group 内消费者数超过分区数则空闲。
面试题:Kafka 的 Consumer Group 和 Partition 有什么关系? 答:一个 Partition 在一个 Consumer Group 内只能被一个消费者消费,从而保证分区内有序;分区数决定并发上限。消费者数 > 分区数时多余消费者空闲;消费者数 < 分区数时一个消费者消费多个分区。Group 间互相独立,各自维护 offset。
4.2 可靠投递
生产者:
- Kafka:
acks=all(所有 ISR 副本确认)+retries重试 + 幂等 producer(enable.idempotence)。 - RabbitMQ:开启 publisher confirm 模式,Broker 写盘后回 ack,失败回调重发。
消费者:
- 关闭自动提交,手动 ack,处理成功再确认。
- 处理失败可 nack + requeue 或进入死信队列。
Broker:
- 持久化消息 + 持久化队列/分区副本(Kafka replication.factor ≥ 3,min.insync.replicas ≥ 2)。
// Kafka 生产者可靠配置
props.put("acks", "all");
props.put("retries", Integer.MAX_VALUE);
props.put("enable.idempotence", "true"); // 幂等,防止重试重复
props.put("max.in.flight.requests.per.connection", "5");
面试题:如何保证消息不丢失? 答:三个环节——①生产者:Kafka 用 acks=all + 重试 + 幂等;RabbitMQ 用 confirm 确认 + 失败回调。②Broker:持久化消息 + 多副本(Kafka 副本因子 ≥3)。③消费者:关闭自动提交,业务处理成功后手动 ack,失败可 requeue 或进死信队列重处理。同时合理设置重试次数和死信兜底。
4.3 顺序消费
- Kafka 分区内天然有序:同一 key 的消息进同一分区,单分区内单消费者串行消费即有序。
- 全局有序需单分区(牺牲并发),实际多按业务 key 分区即可满足”同一业务实体有序”。
- 消费时单线程消费一个分区;若消费速度不足,可在进程内用 Hash 路由让同一 key 落到同一处理线程。
// 按订单ID分区,保证同一订单的事件顺序
ProducerRecord<String, String> record =
new ProducerRecord<>("order-topic", orderId, payload);
producer.send(record);
面试题:如何保证消息顺序消费? 答:Kafka 保证分区内有序,所以把需要顺序的消息用同一 key(如订单ID)路由到同一分区,单消费者消费即可。注意消费者侧不能多线程乱序处理——可按 key hash 分发到进程内不同单线程队列。RabbitMQ 则用一个 Queue + 单消费者保证 FIFO。
4.4 重复消费(幂等性设计)
重复消费来源:网络抖动导致消费者 ack 丢失 → Broker 重投;生产者重试;Rebalance 后 offset 未及时提交。
幂等方案:
- 唯一 ID + 去重表:消费前查去重表,已处理则跳过。
- Redis SETNX:以业务唯一 ID 为 key 标记,带过期时间。
- 数据库唯一约束:利用唯一索引兜底,重复插入抛异常即跳过。
- 状态机:业务状态流转天然幂等(如已支付再收到支付消息直接忽略)。
// 基于唯一ID + Redis SETNX 的幂等消费
String msgId = record.headers().lastHeader("msgId").value();
String key = "consume:" + msgId;
// SETNX 原子标记,NX=不存在才设置,EX=过期
Boolean first = redis.opsForValue().setIfAbsent(key, "1", 24, TimeUnit.HOURS);
if (Boolean.FALSE.equals(first)) {
return; // 已消费过,跳过
}
// 执行业务逻辑(建议本地事务,保证标记与业务一致)
orderService.handle(record.value());
面试题:如何保证消息幂等性? 答:根本原因是网络抖动导致 ack 丢失引发重复投递。常用方案——①业务唯一 ID + 去重表;②Redis SETNX 标记(注意标记与业务要在同一事务/最终一致);③数据库唯一约束兜底;④业务状态机天然幂等(重复收到终态消息直接忽略)。注意区分”至少一次”投递语义下用幂等来达到”精确一次”效果。
本文档配套思维导图:04-框架与中间件.html