1742 字

9 分钟

mq学习过程中的疑问复盘

2026-09-18

未分类

无标签

是否借助ai

本次对话复盘总结#

本次对话围绕 Java / Spring AMQP 中的几个核心概念展开：

匿名内部类与嵌套接口
Lambda 表达式
Java Future
SLF4J 日志占位符与异常处理
RabbitMQ ReturnCallback 触发机制

1. `ReturnsCallback` 是类还是方法？为什么里面还能有方法？#

结论#

RabbitTemplate.ReturnsCallback 是一个接口，不是方法。
setReturnsCallback(...) 才是方法。

代码拆解#

1
rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {
2
    @Override
3
    public void returnedMessage(ReturnedMessage returned) {
4
        // ...
5
    }
6
});

部分	说明
`setReturnsCallback`	RabbitTemplate 的方法，用于设置回调
`RabbitTemplate.ReturnsCallback`	定义在 RabbitTemplate 内部的接口
`returnedMessage`	接口中的抽象方法，此处被实现
`new ... { ... }`	匿名内部类，创建接口的实现类对象

关键点#

new 接口() { ... } 是匿名内部类语法。
大括号里写的是接口方法的实现，所以“里面还能有方法”很正常。
等价于先定义一个实现类，再 new 它。

2. 类里面的接口（嵌套接口）#

结论#

Java 允许在类里面定义接口，称为成员接口 / 嵌套接口。

1
public class RabbitTemplate {
2
    public interface ReturnsCallback {
3
        void returnedMessage(ReturnedMessage returned);
4
    }
5
}

特点#

默认隐式 static
即使不写 static，成员接口也是静态的，不依赖外部类对象。
访问需要带外部类名
```
1
RabbitTemplate.ReturnsCallback
```
编译后生成 外部类$内部接口.class
例如 RabbitTemplate$ReturnsCallback.class。
设计好处
- 归属清晰：一看就知道属于 RabbitTemplate
- 避免命名污染
- 方便组织相关代码

常见例子#

Map.Entry 就是定义在 Map 接口内部的嵌套接口。

3. 为什么可以用 Lambda 表达式？#

结论#

因为 ReturnsCallback 是函数式接口——只有一个抽象方法。
Java 8 规定：函数式接口可以用 Lambda 创建实例。

函数式接口定义#

1
public interface ReturnsCallback {
2
    void returnedMessage(ReturnedMessage returned); // 唯一抽象方法
3
}

匿名内部类 → Lambda#

1
// 匿名内部类
2
new RabbitTemplate.ReturnsCallback() {
3
    @Override
4
    public void returnedMessage(ReturnedMessage returned) {
5
        log.error("触发return callback,");
6
        log.debug("exchange: {}", returned.getExchange());
7
    }
8
}
9

10
// Lambda
11
returned -> {
12
    log.error("触发return callback,");
13
    log.debug("exchange: {}", returned.getExchange());
14
}

原理：目标类型推断#

setReturnsCallback(ReturnsCallback callback) 需要 ReturnsCallback 类型，
编译器知道该接口只有一个抽象方法，因此能推断出：

参数类型是 ReturnedMessage
方法体就是 Lambda 的 { ... }

注意#

Lambda 和匿名内部类不完全等价（this 指向不同，底层实现不同）。
只有函数式接口才能用 Lambda。

4. Java 的 Future 是什么？#

一句话#

Future 是 java.util.concurrent 下的接口，表示异步任务的未来结果，类似“取餐号”。

核心方法#

方法	作用
`get()`	阻塞等待结果
`get(timeout, unit)`	超时等待
`isDone()`	任务是否完成
`isCancelled()`	是否取消
`cancel(...)`	尝试取消

基本用法#

1
ExecutorService pool = Executors.newFixedThreadPool(2);
2

3
Future<Integer> future = pool.submit(() -> {
4
    Thread.sleep(1000);
5
    return 42;
6
});
7

8
// 可以先做别的事
9
Integer result = future.get(); // 阻塞取结果

局限性#

获取结果只能阻塞或轮询。
不方便组合多个 Future。
没有回调机制。
异常处理麻烦（ExecutionException）。

增强版：CompletableFuture#

支持链式调用、组合、回调、手动完成、更好的异常处理。

1
CompletableFuture<Integer> cf = CompletableFuture.supplyAsync(() -> 42);
2
cf.thenAccept(r -> System.out.println("结果：" + r));

FutureTask#

FutureTask 同时实现 Runnable 和 Future，可交给线程执行并取结果。

5. `log.error` 为什么第一个没有 `{}` 占位符？#

结论#

因为 SLF4J 对 Throwable（异常） 有特殊处理：
异常作为最后一个参数传入时，会自动打印堆栈，不需要 {}。

两条日志对比#

1
log.error("处理确认结果异常", ex);
2
// ex 是异常，直接作为最后一个参数，自动打印堆栈
3

4
log.error("发送消息失败，收到 nack, reason : {}", result.getReason());
5
// result.getReason() 是普通对象，必须用 {} 占位

SLF4J 参数匹配规则#

先看消息中有几个 {}。
如果最后一个参数是 Throwable，且占位符数量少于参数数量，则该异常不参与占位符填充，专门用于打印堆栈。
剩余参数按顺序填充 {}。

正确写法#

写法	含义
`log.error("消息", ex)`	异常打印堆栈，无需 `{}`
`log.error("消息 {}", obj)`	普通对象用 `{}` 填充
`log.error("消息 {}", ex)`	错误！异常被当普通参数，不打印堆栈
`log.error("消息 {} ", msg, ex)`	`msg` 填充 `{}`，`ex` 打印堆栈

6. ReturnCallback 是怎么触发的？#

一句话#

消息到达 Exchange，但路由不到任何队列，且开启了 mandatory=true，Broker 会把消息退回，Spring AMQP 收到后触发 ReturnsCallback。

与 ConfirmCallback 的区别#

回调	触发时机	关注点
`ConfirmCallback`	消息到达 Exchange（或未到达）	是否成功到交换机
`ReturnsCallback`	到达 Exchange 但路由不到队列	是否成功进队列

触发前提#

消息到达 Exchange，但路由失败
- Exchange 存在
- routingKey 找不到匹配的 Binding
- 没有任何队列接收

必须开启 mandatory 或 publisher-returns

1
spring:
2
  rabbitmq:
3
    publisher-returns: true
4
    template:
5
      mandatory: true

或代码：

1
rabbitTemplate.setMandatory(true);

触发流程#

1
生产者 publish
2
      │
3
      ▼
4
消息到达 Exchange
5
      │
6
      ├── 能路由到队列 ──► 入队，结束（不触发）
7
      │
8
      └── 路由不到队列
9
              │
10
              ├── mandatory=false ──► 丢弃，不触发
11
              │
12
              └── mandatory=true
13
                      │
14
                      ▼
15
            Broker 退回（Basic.Return）
16
                      │
17
                      ▼
18
        Spring AMQP 回调 ReturnsCallback.returnedMessage()

`ReturnedMessage` 包含#

字段	含义
`exchange`	交换机
`routingKey`	路由键
`message`	消息本身
`replyCode`	退回码，如 `312 NO_ROUTE`
`replyText`	退回原因文本

常见不触发原因#

没开 mandatory。
Exchange 不存在（走 ConfirmCallback，ack=false）。
路由成功，正常入队。
只用了 convertAndSend 但没设置 mandatory。
确认机制没开（实际项目常与 publisher-confirm 一起开）。

典型组合使用#

1
rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
2
    if (ack) {
3
        log.info("消息到达交换机成功");
4
    } else {
5
        log.error("消息到达交换机失败：{}", cause);
6
    }
7
});
8

9
rabbitTemplate.setReturnsCallback(returned -> {
10
    log.error("消息路由到队列失败：{}", returned);
11
});

判断逻辑：

Confirm ack=true + 无 Return → 成功到交换机且入队。
Confirm ack=true + 有 Return → 到交换机但路由失败。
Confirm ack=false → 连交换机都没到。

7. 核心要点速查#

主题	核心结论
`ReturnsCallback`	是接口，不是方法；`setReturnsCallback` 才是方法
匿名内部类	`new 接口() { ... }`，就地实现接口方法
嵌套接口	类里面可以定义接口，默认 `static`，用 `外部类.接口` 访问
Lambda	仅函数式接口可用，是匿名内部类的简洁写法
`Future`	异步任务取餐号；`get()` 阻塞取结果；`CompletableFuture` 是增强版
SLF4J 异常	异常作为最后一个参数自动打印堆栈，不加 `{}`；普通参数必须加 `{}`
`ReturnCallback`	消息到 Exchange 但路由失败 + `mandatory=true` → Broker 退回 → 触发回调
`ConfirmCallback`	关注消息是否到达 Exchange；与 ReturnCallback 配合判断消息全链路状态