← 返回学习路线

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。

事务失效场景:

  1. 自调用:同类中 A 方法直接调用 B 方法,B 上的 @Transactional 失效(未经过代理对象)。
  2. 非 public 方法:默认只对 public 方法生效。
  3. 异常被 catch 吞掉:代理对象未感知到异常,不回滚。
  4. rollbackFor 不匹配:默认只回滚 RuntimeException/Error,检查异常不回滚,需 rollbackFor = Exception.class。
  5. 事务管理器未配置 / 类未被 Spring 管理。
  6. 传播行为设为 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 流程

完整流程:

  1. 请求到达 DispatcherServlet(前端控制器)。
  2. DispatcherServlet 调用 HandlerMapping 根据 URL 找到对应 Controller 方法(HandlerExecutionChain,含拦截器)。
  3. 调用 HandlerAdapter 执行 Controller 方法(HandlerAdapter 解决适配问题)。
  4. Controller 返回 ModelAndView(或被@ResponseBody 拦截直接写响应)。
  5. ViewResolver 解析逻辑视图名为物理 View。
  6. View 渲染(模型数据填充),写回响应。
  7. 拦截器 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 未及时提交。

幂等方案:

  1. 唯一 ID + 去重表:消费前查去重表,已处理则跳过。
  2. Redis SETNX:以业务唯一 ID 为 key 标记,带过期时间。
  3. 数据库唯一约束:利用唯一索引兜底,重复插入抛异常即跳过。
  4. 状态机:业务状态流转天然幂等(如已支付再收到支付消息直接忽略)。
// 基于唯一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