登录
注册
开源
企业版
高校版
搜索
帮助中心
使用条款
关于我们
开源
企业版
高校版
私有云
Gitee AI
NEW
我知道了
查看详情
登录
注册
代码拉取完成,页面将自动刷新
捐赠
捐赠前请先登录
取消
前往登录
扫描微信二维码支付
取消
支付完成
支付提示
将跳转至支付宝完成支付
确定
取消
Watch
不关注
关注所有动态
仅关注版本发行动态
关注但不提醒动态
1
Star
1
Fork
0
独孤九剑
/
Java Learning
代码
Issues
69
Pull Requests
0
Wiki
统计
流水线
服务
Gitee Pages
JavaDoc
PHPDoc
质量分析
Jenkins for Gitee
腾讯云托管
腾讯云 Serverless
悬镜安全
阿里云 SAE
Codeblitz
我知道了,不再自动展开
更新失败,请稍后重试!
Issues
/
详情
移除标识
内容风险标识
本任务被
标识为内容中包含有代码安全 Bug 、隐私泄露等敏感信息,仓库外成员不可访问
消息中间件
待办的
#I8VFNE
独孤九剑
拥有者
创建于
2024-01-11 17:42
**工作模式:** 简单模式,工作队列模式,发布订阅模式,路由模式,主题模式。 **消息确认:** 消息确认可以减少消息丢失(比如网络波动造成消息丢失)。 - 发送端确认:发送消息后使用异步回调,确认消息是否发送成功,发送失败可以重试。 - 队列中消息过期或者消息已满:消息进入死信队列或者丢弃。 - 消费端确认:`basicAck,basicNack,basicReject`. 以 `RabbitMQ` 为例: ``` @Component public class Consumer { @RabbitListener(queuesToDeclare = @Queue("${spring.rabbitmq.queue.name}")) public void handleMessage(Channel channel, @Payload Message message) throws UnsupportedEncodingException { // 消息处理逻辑 String msg = new String(message.getBody(), "UTF-8"); System.out.println("Received message: " + msg); // 配置文件手动确认消息 acknowledge-mode: manual long deliveryTag = message.getMessageProperties().getDeliveryTag(); try { channel.basicAck(deliveryTag, false); } catch (IOException e) { // 消息重试 try { // multiple = false 只拒绝当前消息,requeue = false 放回队列,防止死信 channel.basicNack(deliveryTag, false, true); } catch (IOException ex) { // 消息丢弃 try { channel.basicReject(deliveryTag, false); } catch (IOException exc) { // 异常处理和日志记录 ex.printStackTrace(); } } } } ``` **死信:** 当消息在一个队列中变成死信 (dead message) 之后,它能被重新被发送到另一个交换器中,这个交换器就是 DLX(Dead-Letter-Exchange),绑定 DLX 的队列就称之为死信队列。 导致的死信的几种原因: - 消息被拒(Basic.Reject / Basic.Nack 且 requeue = false) - 消息 TTL 过期。 - 队列满了,无法再添加。 **重复消费(消息一致性)问题:** - 生产者多发送了消息:通过生产者异步消息确认可以避免。 - 一条消息被消费者消费了多次:消费者消费消息后,确认消息途中网络中断,消息依然存在队列里,下次会重复消费。生产者可以设置 `messageId`,消费者消费后,存储到 `redis` 中,下次消费利用幂等性判断是否存在,存在则不再消费。
**工作模式:** 简单模式,工作队列模式,发布订阅模式,路由模式,主题模式。 **消息确认:** 消息确认可以减少消息丢失(比如网络波动造成消息丢失)。 - 发送端确认:发送消息后使用异步回调,确认消息是否发送成功,发送失败可以重试。 - 队列中消息过期或者消息已满:消息进入死信队列或者丢弃。 - 消费端确认:`basicAck,basicNack,basicReject`. 以 `RabbitMQ` 为例: ``` @Component public class Consumer { @RabbitListener(queuesToDeclare = @Queue("${spring.rabbitmq.queue.name}")) public void handleMessage(Channel channel, @Payload Message message) throws UnsupportedEncodingException { // 消息处理逻辑 String msg = new String(message.getBody(), "UTF-8"); System.out.println("Received message: " + msg); // 配置文件手动确认消息 acknowledge-mode: manual long deliveryTag = message.getMessageProperties().getDeliveryTag(); try { channel.basicAck(deliveryTag, false); } catch (IOException e) { // 消息重试 try { // multiple = false 只拒绝当前消息,requeue = false 放回队列,防止死信 channel.basicNack(deliveryTag, false, true); } catch (IOException ex) { // 消息丢弃 try { channel.basicReject(deliveryTag, false); } catch (IOException exc) { // 异常处理和日志记录 ex.printStackTrace(); } } } } ``` **死信:** 当消息在一个队列中变成死信 (dead message) 之后,它能被重新被发送到另一个交换器中,这个交换器就是 DLX(Dead-Letter-Exchange),绑定 DLX 的队列就称之为死信队列。 导致的死信的几种原因: - 消息被拒(Basic.Reject / Basic.Nack 且 requeue = false) - 消息 TTL 过期。 - 队列满了,无法再添加。 **重复消费(消息一致性)问题:** - 生产者多发送了消息:通过生产者异步消息确认可以避免。 - 一条消息被消费者消费了多次:消费者消费消息后,确认消息途中网络中断,消息依然存在队列里,下次会重复消费。生产者可以设置 `messageId`,消费者消费后,存储到 `redis` 中,下次消费利用幂等性判断是否存在,存在则不再消费。
评论 (
0
)
独孤九剑
创建了
任务
独孤九剑
修改了
描述
原值
**工作模式:** 简单模式,工作队列模式,发布订阅模式,路由模式,主题模式。
**消息确认:** 消息确认可以减少消息丢失(比如网络波动造成消息丢失)。
- 发送端确认:发送消息后使用异步回调,确认消息是否发送成功,发送失败可以重试。
- 队列中消息过期或者消息已满:消息进入死信队列或者丢弃。
- 消费端确认:basicAck,basicNack,basicReject。
死信:
新值
**工作模式:** 简单模式,工作队列模式,发布订阅模式,路由模式,主题模式。
**消息确认:** 消息确认可以减少消息丢失(比如网络波动造成消息丢失)。
- 发送端确认:发送消息后使用异步回调,确认消息是否发送成功,发送失败可以重试。
- 队列中消息过期或者消息已满:消息进入死信队列或者丢弃。
- 消费端确认:basicAck,basicNack,basicReject。
```
@Component
public class Consumer {
@RabbitListener(queuesToDeclare = @Queue("${spring.rabbitmq.queue.name}"))
public void handleMessage(Channel channel, @Payload Message message) throws UnsupportedEncodingException {
// 消息处理逻辑
String msg = new String(message.getBody(), "UTF-8");
System.out.println("Received message: " + msg);
// 配置文件手动确认消息 acknowledge-mode: manual
long deliveryTag = message.getMessageProperties().getDeliveryTag();
try {
channel.basicAck(deliveryTag, false);
} catch (IOException e) {
// 消息重试
try {
// multiple = false 只拒绝当前消息,requeue = false 放回队列,防止死信
channel.basicNack(deliveryTag, false, true);
} catch (IOException ex) {
// 消息丢弃
try {
channel.basicReject(deliveryTag, false);
} catch (IOException exc) {
// 异常处理和日志记录
ex.printStackTrace();
}
}
}
}
```
死信:
独孤九剑
修改了
描述
原值
**工作模式:** 简单模式,工作队列模式,发布订阅模式,路由模式,主题模式。
**消息确认:** 消息确认可以减少消息丢失(比如网络波动造成消息丢失)。
- 发送端确认:发送消息后使用异步回调,确认消息是否发送成功,发送失败可以重试。
- 队列中消息过期或者消息已满:消息进入死信队列或者丢弃。
- 消费端确认:
basicAck,basicNack,basicReject。
``
`
@Component
public class Consumer {
@RabbitListener(queuesToDeclare = @Queue("${spring.rabbitmq.queue.name}"))
public void handleMes
s
age(Ch
a
nnel
chann
e
l, @Payload Message message) throws UnsupportedEncodingException {
//
消息处理逻辑
String msg = new String(message.getBody(), "UTF-8");
S
ystem.out.println("Received m
e
ssage: " + msg);
// 配置文件手动确认消息 ack
n
owl
e
dge-mode: m
a
nual
long deliveryT
a
g = message.getMessageProperties().getDeliveryTag();
try {
channel.basicAck(deliveryTag, false);
}
catch (IOException e) {
// 消息重试
try {
// multiple = false 只拒绝当前消息,requeue = false 放回队列,防止死信
channel.basicNack(deliveryTag, false,
true);
}
catch (IOException ex) {
// 消息丢弃
try {
channel.basicReject(deliveryTag, false);
}
catch (IOException exc) {
// 异常处理和日志记录
ex.printStackTrace();
}
}
}
}
```
死信:
新值
**工作模式:** 简单模式,工作队列模式,发布订阅模式,路由模式,主题模式。
**消息确认:** 消息确认可以减少消息丢失(比如网络波动造成消息丢失)。
- 发送端确认:发送消息后使用异步回调,确认消息是否发送成功,发送失败可以重试。
- 队列中消息过期或者消息已满:消息进入死信队列或者丢弃。
- 消费端确认:
`basicAck,basicNack,basicReject`.
以
`
RabbitMQ为` 例:
```
@Component
public class Consumer {
@RabbitListener(queue
s
ToDecl
a
re =
@Queu
e
("${spring.rabbitmq.queue.name}"))
public
void handleMessage(Channel channel, @Payload Message message) throws UnsupportedEncodingException {
// 消息处理逻辑
S
tring msg = new String(messag
e
.getBody(), "UTF-8");
System.out.printl
n
("R
e
ceived mess
a
ge: " + msg);
// 配置文件手动确认消息
a
cknowledge-mode: manual
long deliveryTag = message.getMessageProperties().getDeliveryTag();
try
{
channel.basicAck(deliveryTag, false);
}
catch (IOException e) {
// 消息重试
try
{
// multiple = false 只拒绝当前消息,requeue =
false 放回队列,防止死信
channel.basicNack(deliveryTag, false, true);
}
catch (IOException ex) {
// 消息丢弃
try
{
channel.basicReject(deliveryTag, false);
}
catch (IOException exc) {
// 异常处理和日志记录
ex.printStackTrace();
}
}
}
}
```
死信:
独孤九剑
修改了
描述
原值
**工作模式:** 简单模式,工作队列模式,发布订阅模式,路由模式,主题模式。
**消息确认:** 消息确认可以减少消息丢失(比如网络波动造成消息丢失)。
- 发送端确认:发送消息后使用异步回调,确认消息是否发送成功,发送失败可以重试。
- 队列中消息过期或者消息已满:消息进入死信队列或者丢弃。
- 消费端确认:`basicAck,basicNack,basicReject`.
以 `RabbitMQ
为`
例:
```
@Component
public class Consumer {
@RabbitLis
t
ener(queuesToDeclare = @Queue("${spring.rabbitmq.queue.name}"))
public void handleMessage(Channel channel, @Paylo
a
d Message message) throws Un
s
upportedEncodingException {
//
消息处理逻辑
String ms
g
= new
String(message.getBody(), "UTF-8");
System.out
.
println("Received m
e
ssage: " +
msg);
//
配置文件手动确认消息 acknowledge-mode: manual
long deliv
e
ryTag = message.getMessagePrope
r
ti
e
s().getDeliv
e
ryTag();
try
{
channel.basicAck(deliv
e
ryTag, false);
}
catch (IOException e) {
//
消息重试
try
{
//
multip
l
e = false 只拒绝当前消息,requeue = false 放回队列,防止死信
channel.basicNack(deliv
e
ryTag, false, true);
}
catch (IOException ex)
{
//
消息丢弃
try
{
channel.basicReject(deliv
e
ryTag, false);
}
catch (IOException exc) {
//
异常处理和日志记录
ex.printStackTrace();
}
}
}
}
```
死信:
新值
**工作模式:** 简单模式,工作队列模式,发布订阅模式,路由模式,主题模式。
**消息确认:** 消息确认可以减少消息丢失(比如网络波动造成消息丢失)。
- 发送端确认:发送消息后使用异步回调,确认消息是否发送成功,发送失败可以重试。
- 队列中消息过期或者消息已满:消息进入死信队列或者丢弃。
- 消费端确认:`basicAck,basicNack,basicReject`.
以 `RabbitMQ
` 为
例:
```
@Component
public class Consumer {
@Rabbi
t
Listener(queuesToDeclare = @Queue("${spring.rabbitmq.queue.name}"))
public void handleMessage(Channel channel, @P
a
yload Message message) throw
s
UnsupportedEncodingException {
// 消息处理逻辑
Strin
g
msg =
new String(message.getBody(), "UTF-8");
System
.
out.println("Receiv
e
d message:
" + msg);
// 配置文件手动确认消息 acknowledge-mode: manual
long d
e
liveryTag = message.getMessageP
r
op
e
rties().getD
e
liveryTag();
try {
channel.basicAck(d
e
liveryTag, false);
} catch (IOException e) {
// 消息重试
try {
// mu
l
tiple = false 只拒绝当前消息,requeue = false 放回队列,防止死信
channel.basicNack(d
e
liveryTag, false, true);
} catch (IOException
ex) {
// 消息丢弃
try {
channel.basicReject(d
e
liveryTag, false);
} catch (IOException exc) {
// 异常处理和日志记录
ex.printStackTrace();
}
}
}
}
```
死信:
独孤九剑
修改了
描述
原值
**工作模式:** 简单模式,工作队列模式,发布订阅模式,路由模式,主题模式。
**消息确认:** 消息确认可以减少消息丢失(比如网络波动造成消息丢失)。
- 发送端确认:发送消息后使用异步回调,确认消息是否发送成功,发送失败可以重试。
- 队列中消息过期或者消息已满:消息进入死信队列或者丢弃。
- 消费端确认:`basicAck,basicNack,basicReject`.
以 `RabbitMQ` 为例:
```
@Component
public class Consumer {
@RabbitListener(queuesToDeclare = @Queue("${spring.rabbitmq.queue.name}"))
public void handleMessage(Channel channel, @Payload Message message) throws UnsupportedEncodingException {
// 消息处理逻辑
String msg = new String(message.getBody(), "UTF-8");
System.out.println("Received message: " + msg);
// 配置文件手动确认消息 acknowledge-mode: manual
long deliveryTag = message.getMessageProperties().getDeliveryTag();
try {
channel.basicAck(deliveryTag, false);
} catch (IOException e) {
// 消息重试
try {
// multiple = false 只拒绝当前消息,requeue = false 放回队列,防止死信
channel.basicNack(deliveryTag, false, true);
} catch (IOException ex) {
// 消息丢弃
try {
channel.basicReject(deliveryTag, false);
} catch (IOException exc) {
// 异常处理和日志记录
ex.printStackTrace();
}
}
}
}
```
死信:
新值
**工作模式:** 简单模式,工作队列模式,发布订阅模式,路由模式,主题模式。
**消息确认:** 消息确认可以减少消息丢失(比如网络波动造成消息丢失)。
- 发送端确认:发送消息后使用异步回调,确认消息是否发送成功,发送失败可以重试。
- 队列中消息过期或者消息已满:消息进入死信队列或者丢弃。
- 消费端确认:`basicAck,basicNack,basicReject`.
以 `RabbitMQ` 为例:
```
@Component
public class Consumer {
@RabbitListener(queuesToDeclare = @Queue("${spring.rabbitmq.queue.name}"))
public void handleMessage(Channel channel, @Payload Message message) throws UnsupportedEncodingException {
// 消息处理逻辑
String msg = new String(message.getBody(), "UTF-8");
System.out.println("Received message: " + msg);
// 配置文件手动确认消息 acknowledge-mode: manual
long deliveryTag = message.getMessageProperties().getDeliveryTag();
try {
channel.basicAck(deliveryTag, false);
} catch (IOException e) {
// 消息重试
try {
// multiple = false 只拒绝当前消息,requeue = false 放回队列,防止死信
channel.basicNack(deliveryTag, false, true);
} catch (IOException ex) {
// 消息丢弃
try {
channel.basicReject(deliveryTag, false);
} catch (IOException exc) {
// 异常处理和日志记录
ex.printStackTrace();
}
}
}
}
```
**死信:**
独孤九剑
添加了
Middleware
标签
独孤九剑
修改了
描述
原值
**工作模式:** 简单模式,工作队列模式,发布订阅模式,路由模式,主题模式。
**消息确认:** 消息确认可以减少消息丢失(比如网络波动造成消息丢失)。
- 发送端确认:发送消息后使用异步回调,确认消息是否发送成功,发送失败可以重试。
- 队列中消息过期或者消息已满:消息进入死信队列或者丢弃。
- 消费端确认:`basicAck,basicNack,basicReject`.
以 `RabbitMQ` 为例:
```
@Component
public class Consumer {
@RabbitListener(queuesToDeclare = @Queue("${spring.rabbitmq.queue.name}"))
public void handleMessage(Channel channel, @Payload Message message) throws UnsupportedEncodingException {
// 消息处理逻辑
String msg = new String(message.getBody(), "UTF-8");
System.out.println("Received message: " + msg);
// 配置文件手动确认消息 acknowledge-mode: manual
long deliveryTag = message.getMessageProperties().getDeliveryTag();
try {
channel.basicAck(deliveryTag, false);
} catch (IOException e) {
// 消息重试
try {
// multiple = false 只拒绝当前消息,requeue = false 放回队列,防止死信
channel.basicNack(deliveryTag, false, true);
} catch (IOException ex) {
// 消息丢弃
try {
channel.basicReject(deliveryTag, false);
} catch (IOException exc) {
// 异常处理和日志记录
ex.printStackTrace();
}
}
}
}
```
**死信:**
新值
**工作模式:** 简单模式,工作队列模式,发布订阅模式,路由模式,主题模式。
**消息确认:** 消息确认可以减少消息丢失(比如网络波动造成消息丢失)。
- 发送端确认:发送消息后使用异步回调,确认消息是否发送成功,发送失败可以重试。
- 队列中消息过期或者消息已满:消息进入死信队列或者丢弃。
- 消费端确认:`basicAck,basicNack,basicReject`.
以 `RabbitMQ` 为例:
```
@Component
public class Consumer {
@RabbitListener(queuesToDeclare = @Queue("${spring.rabbitmq.queue.name}"))
public void handleMessage(Channel channel, @Payload Message message) throws UnsupportedEncodingException {
// 消息处理逻辑
String msg = new String(message.getBody(), "UTF-8");
System.out.println("Received message: " + msg);
// 配置文件手动确认消息 acknowledge-mode: manual
long deliveryTag = message.getMessageProperties().getDeliveryTag();
try {
channel.basicAck(deliveryTag, false);
} catch (IOException e) {
// 消息重试
try {
// multiple = false 只拒绝当前消息,requeue = false 放回队列,防止死信
channel.basicNack(deliveryTag, false, true);
} catch (IOException ex) {
// 消息丢弃
try {
channel.basicReject(deliveryTag, false);
} catch (IOException exc) {
// 异常处理和日志记录
ex.printStackTrace();
}
}
}
}
```
**死信:**
当消息在一个队列中变成死信 (dead message) 之后,它能被重新被发送到另一个交换器中,这个交换器就是 DLX(Dead-Letter-Exchange),绑定 DLX 的队列就称之为死信队列。
导致的死信的几种原因:
- 消息被拒(Basic.Reject / Basic.Nack 且 requeue = false)
- 消息 TTL 过期。
- 队列满了,无法再添加。
独孤九剑
修改了
描述
原值
**工作模式:** 简单模式,工作队列模式,发布订阅模式,路由模式,主题模式。
**消息确认:** 消息确认可以减少消息丢失(比如网络波动造成消息丢失)。
- 发送端确认:发送消息后使用异步回调,确认消息是否发送成功,发送失败可以重试。
- 队列中消息过期或者消息已满:消息进入死信队列或者丢弃。
- 消费端确认:`basicAck,basicNack,basicReject`.
以 `RabbitMQ` 为例:
```
@Component
public class Consumer {
@RabbitListener(queuesToDeclare = @Queue("${spring.rabbitmq.queue.name}"))
public void handleMessage(Channel channel, @Payload Message message) throws UnsupportedEncodingException {
// 消息处理逻辑
String msg = new String(message.getBody(), "UTF-8");
System.out.println("Received message: " + msg);
// 配置文件手动确认消息 acknowledge-mode: manual
long deliveryTag = message.getMessageProperties().getDeliveryTag();
try {
channel.basicAck(deliveryTag, false);
} catch (IOException e) {
// 消息重试
try {
// multiple = false 只拒绝当前消息,requeue = false 放回队列,防止死信
channel.basicNack(deliveryTag, false, true);
} catch (IOException ex) {
// 消息丢弃
try {
channel.basicReject(deliveryTag, false);
} catch (IOException exc) {
// 异常处理和日志记录
ex.printStackTrace();
}
}
}
}
```
**死信:** 当消息在一个队列中变成死信 (dead message) 之后,它能被重新被发送到另一个交换器中,这个交换器就是 DLX(Dead-Letter-Exchange),绑定 DLX 的队列就称之为死信队列。
导致的死信的几种原因:
- 消息被拒(Basic.Reject / Basic.Nack 且 requeue = false)
- 消息 TTL 过期。
- 队列满了,无法再添加。
新值
**工作模式:** 简单模式,工作队列模式,发布订阅模式,路由模式,主题模式。
**消息确认:** 消息确认可以减少消息丢失(比如网络波动造成消息丢失)。
- 发送端确认:发送消息后使用异步回调,确认消息是否发送成功,发送失败可以重试。
- 队列中消息过期或者消息已满:消息进入死信队列或者丢弃。
- 消费端确认:`basicAck,basicNack,basicReject`.
以 `RabbitMQ` 为例:
```
@Component
public class Consumer {
@RabbitListener(queuesToDeclare = @Queue("${spring.rabbitmq.queue.name}"))
public void handleMessage(Channel channel, @Payload Message message) throws UnsupportedEncodingException {
// 消息处理逻辑
String msg = new String(message.getBody(), "UTF-8");
System.out.println("Received message: " + msg);
// 配置文件手动确认消息 acknowledge-mode: manual
long deliveryTag = message.getMessageProperties().getDeliveryTag();
try {
channel.basicAck(deliveryTag, false);
} catch (IOException e) {
// 消息重试
try {
// multiple = false 只拒绝当前消息,requeue = false 放回队列,防止死信
channel.basicNack(deliveryTag, false, true);
} catch (IOException ex) {
// 消息丢弃
try {
channel.basicReject(deliveryTag, false);
} catch (IOException exc) {
// 异常处理和日志记录
ex.printStackTrace();
}
}
}
}
```
**死信:** 当消息在一个队列中变成死信 (dead message) 之后,它能被重新被发送到另一个交换器中,这个交换器就是 DLX(Dead-Letter-Exchange),绑定 DLX 的队列就称之为死信队列。
导致的死信的几种原因:
- 消息被拒(Basic.Reject / Basic.Nack 且 requeue = false)
- 消息 TTL 过期。
- 队列满了,无法再添加。
**重复消费问题:**
- 生产者多发送了消息:通过生产者异步消息确认可以避免。
- 一条消息被消费者消费了多次:消费者消费消息后,确认消息途中网络中断,消息依然存在队列里,下次会重复消费。生产者可以设置 `messageId`,消费者消费后,存储到 redis 中,下次消费利用幂等性判断是否存在,存在则不再消费。
独孤九剑
修改了
描述
原值
**工作模式:** 简单模式,工作队列模式,发布订阅模式,路由模式,主题模式。
**消息确认:** 消息确认可以减少消息丢失(比如网络波动造成消息丢失)。
- 发送端确认:发送消息后使用异步回调,确认消息是否发送成功,发送失败可以重试。
- 队列中消息过期或者消息已满:消息进入死信队列或者丢弃。
- 消费端确认:`basicAck,basicNack,basicReject`.
以 `RabbitMQ` 为例:
```
@Component
public class Consumer {
@RabbitListener(queuesToDeclare = @Queue("${spring.rabbitmq.queue.name}"))
public void handleMessage(Channel channel, @Payload Message message) throws UnsupportedEncodingException {
// 消息处理逻辑
String msg = new String(message.getBody(), "UTF-8");
System.out.println("Received message: " + msg);
// 配置文件手动确认消息 acknowledge-mode: manual
long deliveryTag = message.getMessageProperties().getDeliveryTag();
try {
channel.basicAck(deliveryTag, false);
} catch (IOException e) {
// 消息重试
try {
// multiple = false 只拒绝当前消息,requeue = false 放回队列,防止死信
channel.basicNack(deliveryTag, false, true);
} catch (IOException ex) {
// 消息丢弃
try {
channel.basicReject(deliveryTag, false);
} catch (IOException exc) {
// 异常处理和日志记录
ex.printStackTrace();
}
}
}
}
```
**死信:** 当消息在一个队列中变成死信 (dead message) 之后,它能被重新被发送到另一个交换器中,这个交换器就是 DLX(Dead-Letter-Exchange),绑定 DLX 的队列就称之为死信队列。
导致的死信的几种原因:
- 消息被拒(Basic.Reject / Basic.Nack 且 requeue = false)
- 消息 TTL 过期。
- 队列满了,无法再添加。
**重复消费问题:**
- 生产者多发送了消息:通过生产者异步消息确认可以避免。
- 一条消息被消费者消费了多次:消费者消费消息后,确认消息途中网络中断,消息依然存在队列里,下次会重复消费。生产者可以设置 `messageId`,消费者消费后,存储到
redis 中,下次消费利用幂等性判断是否存在,存在则不再消费。
新值
**工作模式:** 简单模式,工作队列模式,发布订阅模式,路由模式,主题模式。
**消息确认:** 消息确认可以减少消息丢失(比如网络波动造成消息丢失)。
- 发送端确认:发送消息后使用异步回调,确认消息是否发送成功,发送失败可以重试。
- 队列中消息过期或者消息已满:消息进入死信队列或者丢弃。
- 消费端确认:`basicAck,basicNack,basicReject`.
以 `RabbitMQ` 为例:
```
@Component
public class Consumer {
@RabbitListener(queuesToDeclare = @Queue("${spring.rabbitmq.queue.name}"))
public void handleMessage(Channel channel, @Payload Message message) throws UnsupportedEncodingException {
// 消息处理逻辑
String msg = new String(message.getBody(), "UTF-8");
System.out.println("Received message: " + msg);
// 配置文件手动确认消息 acknowledge-mode: manual
long deliveryTag = message.getMessageProperties().getDeliveryTag();
try {
channel.basicAck(deliveryTag, false);
} catch (IOException e) {
// 消息重试
try {
// multiple = false 只拒绝当前消息,requeue = false 放回队列,防止死信
channel.basicNack(deliveryTag, false, true);
} catch (IOException ex) {
// 消息丢弃
try {
channel.basicReject(deliveryTag, false);
} catch (IOException exc) {
// 异常处理和日志记录
ex.printStackTrace();
}
}
}
}
```
**死信:** 当消息在一个队列中变成死信 (dead message) 之后,它能被重新被发送到另一个交换器中,这个交换器就是 DLX(Dead-Letter-Exchange),绑定 DLX 的队列就称之为死信队列。
导致的死信的几种原因:
- 消息被拒(Basic.Reject / Basic.Nack 且 requeue = false)
- 消息 TTL 过期。
- 队列满了,无法再添加。
**重复消费问题:**
- 生产者多发送了消息:通过生产者异步消息确认可以避免。
- 一条消息被消费者消费了多次:消费者消费消息后,确认消息途中网络中断,消息依然存在队列里,下次会重复消费。生产者可以设置 `messageId`,消费者消费后,存储到
`redis` 中,下次消费利用幂等性判断是否存在,存在则不再消费。
独孤九剑
修改了
描述
原值
**工作模式:** 简单模式,工作队列模式,发布订阅模式,路由模式,主题模式。
**消息确认:** 消息确认可以减少消息丢失(比如网络波动造成消息丢失)。
- 发送端确认:发送消息后使用异步回调,确认消息是否发送成功,发送失败可以重试。
- 队列中消息过期或者消息已满:消息进入死信队列或者丢弃。
- 消费端确认:`basicAck,basicNack,basicReject`.
以 `RabbitMQ` 为例:
```
@Component
public class Consumer {
@RabbitListener(queuesToDeclare = @Queue("${spring.rabbitmq.queue.name}"))
public void handleMessage(Channel channel, @Payload Message message) throws UnsupportedEncodingException {
// 消息处理逻辑
String msg = new String(message.getBody(), "UTF-8");
System.out.println("Received message: " + msg);
// 配置文件手动确认消息 acknowledge-mode: manual
long deliveryTag = message.getMessageProperties().getDeliveryTag();
try {
channel.basicAck(deliveryTag, false);
} catch (IOException e) {
// 消息重试
try {
// multiple = false 只拒绝当前消息,requeue = false 放回队列,防止死信
channel.basicNack(deliveryTag, false, true);
} catch (IOException ex) {
// 消息丢弃
try {
channel.basicReject(deliveryTag, false);
} catch (IOException exc) {
// 异常处理和日志记录
ex.printStackTrace();
}
}
}
}
```
**死信:** 当消息在一个队列中变成死信 (dead message) 之后,它能被重新被发送到另一个交换器中,这个交换器就是 DLX(Dead-Letter-Exchange),绑定 DLX 的队列就称之为死信队列。
导致的死信的几种原因:
- 消息被拒(Basic.Reject / Basic.Nack 且 requeue = false)
- 消息 TTL 过期。
- 队列满了,无法再添加。
**重复消费
问题:**
- 生产者多发送了消息:通过生产者异步消息确认可以避免。
- 一条消息被消费者消费了多次:消费者消费消息后,确认消息途中网络中断,消息依然存在队列里,下次会重复消费。生产者可以设置 `messageId`,消费者消费后,存储到 `redis` 中,下次消费利用幂等性判断是否存在,存在则不再消费。
新值
**工作模式:** 简单模式,工作队列模式,发布订阅模式,路由模式,主题模式。
**消息确认:** 消息确认可以减少消息丢失(比如网络波动造成消息丢失)。
- 发送端确认:发送消息后使用异步回调,确认消息是否发送成功,发送失败可以重试。
- 队列中消息过期或者消息已满:消息进入死信队列或者丢弃。
- 消费端确认:`basicAck,basicNack,basicReject`.
以 `RabbitMQ` 为例:
```
@Component
public class Consumer {
@RabbitListener(queuesToDeclare = @Queue("${spring.rabbitmq.queue.name}"))
public void handleMessage(Channel channel, @Payload Message message) throws UnsupportedEncodingException {
// 消息处理逻辑
String msg = new String(message.getBody(), "UTF-8");
System.out.println("Received message: " + msg);
// 配置文件手动确认消息 acknowledge-mode: manual
long deliveryTag = message.getMessageProperties().getDeliveryTag();
try {
channel.basicAck(deliveryTag, false);
} catch (IOException e) {
// 消息重试
try {
// multiple = false 只拒绝当前消息,requeue = false 放回队列,防止死信
channel.basicNack(deliveryTag, false, true);
} catch (IOException ex) {
// 消息丢弃
try {
channel.basicReject(deliveryTag, false);
} catch (IOException exc) {
// 异常处理和日志记录
ex.printStackTrace();
}
}
}
}
```
**死信:** 当消息在一个队列中变成死信 (dead message) 之后,它能被重新被发送到另一个交换器中,这个交换器就是 DLX(Dead-Letter-Exchange),绑定 DLX 的队列就称之为死信队列。
导致的死信的几种原因:
- 消息被拒(Basic.Reject / Basic.Nack 且 requeue = false)
- 消息 TTL 过期。
- 队列满了,无法再添加。
**重复消费
(消息一致性)问题:**
- 生产者多发送了消息:通过生产者异步消息确认可以避免。
- 一条消息被消费者消费了多次:消费者消费消息后,确认消息途中网络中断,消息依然存在队列里,下次会重复消费。生产者可以设置 `messageId`,消费者消费后,存储到 `redis` 中,下次消费利用幂等性判断是否存在,存在则不再消费。
展开全部操作日志
折叠全部操作日志
登录
后才可以发表评论
状态
待办的
待办的
进行中
已完成
已关闭
负责人
未设置
标签
Middleware
未设置
标签管理
里程碑
未关联里程碑
未关联里程碑
Pull Requests
未关联
未关联
关联的 Pull Requests 被合并后可能会关闭此 issue
分支
未关联
未关联
master
开始日期   -   截止日期
-
置顶选项
不置顶
置顶等级:高
置顶等级:中
置顶等级:低
优先级
不指定
严重
主要
次要
不重要
参与者(1)
1
https://gitee.com/843294669/learning.git
git@gitee.com:843294669/learning.git
843294669
learning
Java Learning
点此查找更多帮助
搜索帮助
Git 命令在线学习
如何在 Gitee 导入 GitHub 仓库
Git 仓库基础操作
企业版和社区版功能对比
SSH 公钥设置
如何处理代码冲突
仓库体积过大,如何减小?
如何找回被删除的仓库数据
Gitee 产品配额说明
GitHub仓库快速导入Gitee及同步更新
什么是 Release(发行版)
将 PHP 项目自动发布到 packagist.org
评论
仓库举报
回到顶部
登录提示
该操作需登录 Gitee 帐号,请先登录后再操作。
立即登录
没有帐号,去注册