spring整合rabbitMQ各种模式,TTL死信高级特性

已于 2022-07-04 10:03:20 修改
阅读量254 收藏
点赞数
分类专栏： rabbitMq 文章标签： java-rabbitmq rabbitmq spring
于 2022-07-01 14:35:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45352783/article/details/125554173
版权

文章目录


源码及安装包已上传到csdn, 下载地址:https://download.csdn.net/download/weixin_45352783/85862706

基本配置

创建两个项目,方便后期测试在这里插入代码片
在这里插入图片描述
cus: 消费者
pus: 生产者

pom文件

    <dependencies>
        <!-- web 方便测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- rabbitMQ -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
    </dependencies>

application.properties
生产者和消费者只有端口不同就不贴两次了

server.port=9091
# 应用名
spring.application.name=springboot-rabbitmq
# rabbitmq配置信息
# ip
spring.rabbitmq.host=127.0.0.1
# 端口
spring.rabbitmq.port=5672
# 用户名
spring.rabbitmq.username=admin
# 密码
spring.rabbitmq.password=admin
# 配置虚拟机
spring.rabbitmq.virtual-host=/
# 消息开启手动确认
spring.rabbitmq.listener.direct.acknowledge-mode=manual

work模式

在这里插入图片描述
这是rabbitMQ官网给的work_queues的图例

生产者添加配置文件

import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @authoer:xianyu
 * @createDate:2022/7/1
 * @description:
 */
@Configuration
public class RabbitmqConfig {

    /**
     * 配置一个工作模型队列
     * @return
     */
    @Bean
    public Queue queueWork1() {
        return new Queue("queue_work");
    }
}

添加controller方便测试

import com.xianyu.pro.service.RabbitmqService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @authoer:xianyu
 * @createDate:2022/7/1
 * @description:
 */
@RestController
public class RabbitmqController {
    @Autowired
    private RabbitmqService rabbitmqService;

    @RequestMapping("/sendWork")
    public Object sendWork() {
        rabbitmqService.sendWork();
        return "发送成功...";
    }
}

service


import com.xianyu.pro.service.RabbitmqService;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @authoer:xianyu
 * @createDate:2022/7/1
 * @description:
 */
@Service
public class RabbitmqServiceImpl implements RabbitmqService {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Override
    public void sendWork() {
        for (int i = 0; i < 10; i++) {
            //消息一次性发送
            rabbitTemplate.convertAndSend("queue_work","测试work模型: " + i);
        }
    }
}

启动,发送测试

在这里插入图片描述

在rabbitMQ的控制台已经可以看到消息
在这里插入图片描述

编写消费者

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @authoer:xianyu
 * @createDate:2022/7/1
 * @description:
 */
@Component
public class WorkReceiveListener {

    @RabbitListener(queues = "queue_work")
    public void receiveMessage(String msg) {
        // 只包含发送的消息
        System.out.println("1接收到消息：" + msg);

    }

    @RabbitListener(queues = "queue_work")
    public void receiveMessage2(String msg) {
        // 包含所有的信息
        System.out.println("2接收到消息：" + msg);
    }

}

启动消费者

在这里插入图片描述
已完成消费
在这里插入图片描述
控制台上可以看到队列也没有消息了

发布订阅模式

Publish/Subscribe模式
在这里插入图片描述
这里用到了交换机Exchange,就是紫色的X

work一个队列里面的消息,被竞争消费,发布订阅模式互补干扰
比如生产者发布了10条消息,有两个消费者,work模式可能就是一个消费者消费5条,发布订阅模式就是每个消费者都能消费10条

修改RabbitmqConfig


import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @authoer:xianyu
 * @createDate:2022/7/1
 * @description:
 */
@Configuration
public class RabbitmqConfig {

    /**
     * 配置一个工作模型队列
     * @return
     */
    @Bean
    public Queue queueWork1() {
        return new Queue("queue_work");
    }

    /**
     * 准备一个交换机
     * @return
     */
    @Bean
    public FanoutExchange exchangeFanout() {
        return new FanoutExchange("exchange_fanout");
    }

    /**
     * 声明两个队列
     * @return
     */
    @Bean
    public Queue queueFanout1() {
        return new Queue("queue_fanout1");
    }
    @Bean
    public Queue queueFanout2() {
        return new Queue("queue_fanout2");
    }

    /**
     * 将交换机和队列1进行绑定
     * @return
     */
    @Bean
    public Binding bindingExchange1() {
        return BindingBuilder.bind(queueFanout1()).to(exchangeFanout());
    }

    /**
     * 将交换机和队列2进行绑定
     * @return
     */
    @Bean
    public Binding bindingExchange2() {
        return BindingBuilder.bind(queueFanout2()).to(exchangeFanout());
    }

}

添加接口

controller

    @RequestMapping("/sendPublish")
    public Object sendPublish() {
        rabbitmqService.sendPublish();
        return "发送成功...";
    }

service

    /**
     * 发送订阅消息
     */
    void sendPublish();

serviceImpl

    @Override
    public void sendPublish() {
        for (int i = 0; i < 5; i++) {
            rabbitTemplate.convertAndSend("exchange_fanout", "", "测试发布订阅模型：" + i);
        }
    }

在这里插入图片描述
测试,发送成功,查看控制台
在这里插入图片描述
编写消费端

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @authoer:xianyu
 * @createDate:2022/7/1
 * @description:
 */
@Component
public class PublishReceiveListener {

    @RabbitListener(queues = "queue_fanout1")
    public void receiveMsg1(String msg) {
        System.out.println("队列1接收到消息：" + msg);
    }

    @RabbitListener(queues = "queue_fanout2")
    public void receiveMsg2(String msg) {
        System.out.println("队列2接收到消息：" + msg);
    }
}

在这里插入图片描述
接收到消息
在这里插入图片描述
控制台

routing和topics模式

routing模式

在这里插入图片描述
修改RabbitmqConfig配置文件

mport org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @authoer:xianyu
 * @createDate:2022/7/1
 * @description:
 */
@Configuration
public class RabbitmqConfig {

    /**
     * 配置一个工作模型队列
     * @return
     */
    @Bean
    public Queue queueWork1() {
        return new Queue("queue_work");
    }

    /**
     * 准备一个交换机
     * @return
     */
    @Bean
    public FanoutExchange exchangeFanout() {
        return new FanoutExchange("exchange_fanout");
    }

    /**
     * 声明两个队列
     * @return
     */
    @Bean
    public Queue queueFanout1() {
        return new Queue("queue_fanout1");
    }
    @Bean
    public Queue queueFanout2() {
        return new Queue("queue_fanout2");
    }

    /**
     * 将交换机和队列1进行绑定
     * @return
     */
    @Bean
    public Binding bindingExchange1() {
        return BindingBuilder.bind(queueFanout1()).to(exchangeFanout());
    }

    /**
     * 将交换机和队列2进行绑定
     * @return
     */
    @Bean
    public Binding bindingExchange2() {
        return BindingBuilder.bind(queueFanout2()).to(exchangeFanout());
    }


    /**
     * routing交换机
     * @return
     */
    @Bean
    public DirectExchange exchangeRouting() {
        return new DirectExchange("exchange_routing");
    }

    /**
     * routing队列1
     * @return
     */
    @Bean
    public Queue queueRouting1() {
        return new Queue("queue_routing1");
    }

    /**
     * routing队列2
     * @return
     */
    @Bean
    public Queue queueRouting2() {
        return new Queue("queue_routing2");
    }

    @Bean
    public Binding bindingRouting1() {
        return BindingBuilder.bind(queueRouting1()).to(exchangeRouting()).with("error");
    }
    @Bean
    public Binding bindingRouting2() {
        return BindingBuilder.bind(queueRouting2()).to(exchangeRouting()).with("info");
    }


}

在这里插入图片描述

在交换机绑定队列是添加routingKey,这里是自定义字符串
添加接口

    @RequestMapping("/sendRouting")
    public Object sendRouting() {
        rabbitmqService.sendRouting();
        return "发送成功...";
    }

service

    /**
     * 发送routing消息
     */
    void sendRouting();

serviceImpl

    @Override
    public void sendRouting() {
        for (int i = 0; i < 5; i++) {
            rabbitTemplate.convertAndSend("exchange_routing", "error", "测试routing模型,error：" + i);
            rabbitTemplate.convertAndSend("exchange_routing", "info", "测试routing模型,info：" + i);
        }
    }

消费端添加监听

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @authoer:xianyu
 * @createDate:2022/7/1
 * @description:
 */
@Component
public class RoutingReceiveListener {

    @RabbitListener(queues = "queue_routing1")
    public void receiveMsg1(String msg) {
        System.out.println("消费者1接收到：" + msg);
    }

    @RabbitListener(queues = "queue_routing2")
    public void receiveMsg2(String msg) {
        System.out.println("消费者2接收到：" + msg);
    }

}

postman测试
在这里插入图片描述
消费端打印
在这里插入图片描述
这里消费者1只接收到了error,消费者2只接收到了info

topics模式

routing和topics类似,topics可以理解为使用 * # 通配符的routing
在这里插入图片描述

topic里面的通配符,*表示一个单词,#表示多个

修改RabbitmqConfig 配置文件


import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @authoer:xianyu
 * @createDate:2022/7/1
 * @description:
 */
@Configuration
public class RabbitmqConfig {

    /**
     * 配置一个工作模型队列
     * @return
     */
    @Bean
    public Queue queueWork1() {
        return new Queue("queue_work");
    }

    /**
     * 准备一个交换机
     * @return
     */
    @Bean
    public FanoutExchange exchangeFanout() {
        return new FanoutExchange("exchange_fanout");
    }

    /**
     * 声明两个队列
     * @return
     */
    @Bean
    public Queue queueFanout1() {
        return new Queue("queue_fanout1");
    }
    @Bean
    public Queue queueFanout2() {
        return new Queue("queue_fanout2");
    }

    /**
     * 将交换机和队列1进行绑定
     * @return
     */
    @Bean
    public Binding bindingExchange1() {
        return BindingBuilder.bind(queueFanout1()).to(exchangeFanout());
    }

    /**
     * 将交换机和队列2进行绑定
     * @return
     */
    @Bean
    public Binding bindingExchange2() {
        return BindingBuilder.bind(queueFanout2()).to(exchangeFanout());
    }


    /**
     * routing交换机
     * @return
     */
    @Bean
    public DirectExchange exchangeRouting() {
        return new DirectExchange("exchange_routing");
    }

    /**
     * routing队列1
     * @return
     */
    @Bean
    public Queue queueRouting1() {
        return new Queue("queue_routing1");
    }

    /**
     * routing队列2
     * @return
     */
    @Bean
    public Queue queueRouting2() {
        return new Queue("queue_routing2");
    }

    @Bean
    public Binding bindingRouting1() {
        return BindingBuilder.bind(queueRouting1()).to(exchangeRouting()).with("error");
    }
    @Bean
    public Binding bindingRouting2() {
        return BindingBuilder.bind(queueRouting2()).to(exchangeRouting()).with("info");
    }

    /**
     * topic交换机
     * @return
     */
    @Bean
    public TopicExchange exchangeTopic() {
        return new TopicExchange("exchange_topic");
    }

    /**
     * topic队列1
     * @return
     */
    @Bean
    public Queue queueTopic1() {
        return new Queue("queue_topic1");
    }
    /**
     * topic队列2
     * @return
     */
    @Bean
    public Queue queueTopic2() {
        return new Queue("queue_topic2");
    }

    /**
     * 绑定topic队列和交换机
     * @return
     */
    @Bean
    public Binding bindingTopic1() {
        return BindingBuilder.bind(queueTopic1()).to(exchangeTopic()).with("topic.#");
    }
    @Bean
    public Binding bindingTopic2() {
        return BindingBuilder.bind(queueTopic2()).to(exchangeTopic()).with("topic.*");
    }

}

添加controller

    @RequestMapping("/sendTopic")
    public Object sendTopic() {
        rabbitmqService.sendTopic();
        return "发送成功...";
    }

service

    /**
     * 发送topic消息
     */
    void sendTopic();

serviceImpl

	@Override
    public void sendTopic() {
        for (int i = 0; i < 5; i++) {
            rabbitTemplate.convertAndSend("exchange_topic", "topic.hello", "测试topic模型,hello：" + i);
            rabbitTemplate.convertAndSend("exchange_topic", "topic.hello.word", "测试topic模型,hello_word：" + i);
        }
    }

启动,postman测试
在这里插入图片描述
在这里插入图片描述
编写消费者


import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @authoer:xianyu
 * @createDate:2022/7/1
 * @description:
 */
@Component
public class TopicReceiveListener {

    @RabbitListener(queues = "queue_topic1")
    public void receiveMsg1(String msg) {
        System.out.println("消费者1接收到：" + msg);
    }

    @RabbitListener(queues = "queue_topic2")
    public void receiveMsg2(String msg) {
        System.out.println("消费者2接收到：" + msg);
    }
}

启动测试
在这里插入图片描述
可以看到消费者1能接收到所有的消息,消费者2只能接收到hello,不能接收hello.word作为routingKey的消息

rabbitMQ的几种基础用法到这里就说完了

rabbitMQ 3种消息确认机制

# 消息开启手动确认 手动确认后队列才会删除消息
spring.rabbitmq.listener.direct.acknowledge-mode=manual
# 不用确认,消费端接收到消息后,队列中删除
spring.rabbitmq.listener.direct.acknowledge-mode=none
# 自动模式,根据报错信息来判断是否删除消息,较麻烦,实际使用也很少
spring.rabbitmq.listener.direct.acknowledge-mode=auto

消息的确认投递和确认消费

后续再补充

TTL队列

死信队列

一般来说，producer 将消息投递到 broker 或者直接到queue 里了，consumer 从 queue 取出消息
进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有
后续的处理，就变成了死信，有死信自然就有了死信队列。
为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息
消费发生异常时，将消息投入死信队列中.

死信的来源

消息 TTL 过期
队列达到最大长度(队列满了，无法再添加数据到 mq 中)
消息被拒绝(basic.reject 或 basic.nack)并且 requeue=false.

代码架构图
在这里插入图片描述
RabbitmqConfig配置文件中添加业务交换机,业务队列,死信队列

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

/**
 * @authoer:xianyu
 * @createDate:2022/7/1
 * @description:
 */
@Configuration
public class RabbitmqConfig {

    /**
     * 配置一个工作模型队列
     *
     * @return
     */
    @Bean
    public Queue queueWork1() {
        return new Queue("queue_work");
    }

    /**
     * 准备一个交换机
     *
     * @return
     */
    @Bean
    public FanoutExchange exchangeFanout() {
        return new FanoutExchange("exchange_fanout");
    }

    /**
     * 声明两个队列
     *
     * @return
     */
    @Bean
    public Queue queueFanout1() {
        return new Queue("queue_fanout1");
    }

    @Bean
    public Queue queueFanout2() {
        return new Queue("queue_fanout2");
    }

    /**
     * 将交换机和队列1进行绑定
     *
     * @return
     */
    @Bean
    public Binding bindingExchange1() {
        return BindingBuilder.bind(queueFanout1()).to(exchangeFanout());
    }

    /**
     * 将交换机和队列2进行绑定
     *
     * @return
     */
    @Bean
    public Binding bindingExchange2() {
        return BindingBuilder.bind(queueFanout2()).to(exchangeFanout());
    }


    /**
     * routing交换机
     *
     * @return
     */
    @Bean
    public DirectExchange exchangeRouting() {
        return new DirectExchange("exchange_routing");
    }

    /**
     * routing队列1
     *
     * @return
     */
    @Bean
    public Queue queueRouting1() {
        return new Queue("queue_routing1");
    }

    /**
     * routing队列2
     *
     * @return
     */
    @Bean
    public Queue queueRouting2() {
        return new Queue("queue_routing2");
    }

    @Bean
    public Binding bindingRouting1() {
        return BindingBuilder.bind(queueRouting1()).to(exchangeRouting()).with("error");
    }

    @Bean
    public Binding bindingRouting2() {
        return BindingBuilder.bind(queueRouting2()).to(exchangeRouting()).with("info");
    }

    /**
     * topic交换机
     *
     * @return
     */
    @Bean
    public TopicExchange exchangeTopic() {
        return new TopicExchange("exchange_topic");
    }

    /**
     * topic队列1
     *
     * @return
     */
    @Bean
    public Queue queueTopic1() {
        return new Queue("queue_topic1");
    }

    /**
     * topic队列2
     *
     * @return
     */
    @Bean
    public Queue queueTopic2() {
        return new Queue("queue_topic2");
    }

    /**
     * 绑定topic队列和交换机
     *
     * @return
     */
    @Bean
    public Binding bindingTopic1() {
        return BindingBuilder.bind(queueTopic1()).to(exchangeTopic()).with("topic.#");
    }

    @Bean
    public Binding bindingTopic2() {
        return BindingBuilder.bind(queueTopic2()).to(exchangeTopic()).with("topic.*");
    }


    // 声明业务Exchange
    @Bean
    public FanoutExchange businessExchange() {
        return new FanoutExchange("business_exchange");
    }

    // 声明死信Exchange
    @Bean
    public DirectExchange deadLetterExchange() {
        return new DirectExchange("dead_letter_exchange");
    }

    // 声明业务队列A
    @Bean
    public Queue businessQueueA() {
        Map<String, Object> args = new HashMap<>(2);
        args.put("x-dead-letter-exchange", "dead_letter_exchange");
        args.put("x-dead-letter-routing-key", "dead_letter_queuea_routing_key");
        return QueueBuilder.durable("business_queueA").withArguments(args).build();
    }

    // 声明业务队列B
    @Bean
    public Queue businessQueueB() {
        Map<String, Object> args = new HashMap<>(2);
        args.put("x-dead-letter-exchange", "dead_letter_exchange");
        args.put("x-dead-letter-routing-key", "dead_letter_queueb_routing_key");
        return QueueBuilder.durable("business_queueB").withArguments(args).build();
    }

    // 声明死信队列A
    @Bean
    public Queue deadLetterQueueA() {
        return new Queue("dead_letter_queueA");
    }

    // 声明死信队列B
    @Bean
    public Queue deadLetterQueueB() {
        return new Queue("dead_letter_queueB");
    }

    // 声明业务队列A绑定关系
    @Bean
    public Binding businessBindingA() {
        return BindingBuilder.bind(businessQueueA()).to(businessExchange());
    }

    // 声明业务队列B绑定关系
    @Bean
    public Binding businessBindingB() {
        return BindingBuilder.bind(businessQueueB()).to(businessExchange());
    }

    // 声明死信队列A绑定关系
    @Bean
    public Binding deadLetterBindingA() {
        return BindingBuilder.bind(deadLetterQueueA()).to(deadLetterExchange()).with("dead_letter_queuea_routing_key");
    }

    // 声明死信队列B绑定关系
    @Bean
    public Binding deadLetterBindingB() {
        return BindingBuilder.bind(deadLetterQueueB()).to(deadLetterExchange()).with("dead_letter_queueb_routing_key");
    }


}

在这里插入图片描述
参数map的key是固定的,在RabbitMQ控制台中能够看到
在这里插入图片描述
添加controller方便测试

    @RequestMapping("/sendDead")
    public Object sendDead() {
        rabbitmqService.sendDead();
        return "发送成功...";
    }

service

    /**
     * 测试死信队列
     */
    void sendDead();

serviceImpl

    @Override
    public void sendDead() {
        rabbitTemplate.convertSendAndReceive("business_exchange", "", "测试死信队列");
    }

消费端代码实现


import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * @authoer:xianyu
 * @createDate:2022/7/1
 * @description:
 */

@Component
public class BusinessMessageReceiver {

    @RabbitListener(queues = "business_queueA")
    public void receiveA(Message message, Channel channel) throws IOException {
        String msg = new String(message.getBody());
        boolean ack = true;
        try {
            //手动制造异常
            int i=1/0;
        } catch (Exception e){
            ack = false;
        }
        if (!ack){
            //拒绝消息,并不放回队列
            channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, false);
        } else {
            //确认消息
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        }
    }

    @RabbitListener(queues = "business_queueB")
    public void receiveB(Message message, Channel channel) throws IOException {
        System.out.println("收到业务消息B：" + new String(message.getBody()));
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }
}

在这里插入图片描述
这里basicNack方法第三个参数:是否重回队列,false否,如果绑定了死信队列,就会进入死信队列

这里只展示者一种进入死信队列的方式,其他的后续补充

不吃糯玉米
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用FreeSwitch的hangup命令拒绝一个INVITE请求时，指定INVITE的响应码。
jkkj1630的专栏
05-11 258
假设在FreeSwitch的dialplan中使用hangup命令拒绝一个呼叫时，默认使用480响应码来拒绝一个INVITE消息。当然，FreeSwitch支持使用hangup的参数来决定使用指定的响应码来回复INVITE消息。FreeSwitch自带一些指定的响应码，如果想增加自己的响应码，可修改FreeSwitch代码来增加自己的响应码。
Spring RabbitMQ死信机制原理实例详解
08-24
Spring RabbitMQ 死信机制原理实例详解 Spring RabbitMQ 死信机制是指在消息队列中，消息没有被及时消费的机制。这种机制可以提高系统的稳定性，当消息消费失败后，消息进入死信队列，可以对消息进行补偿，达到...
Springboot整合RabbitMQ
weixin_49076273的博客
06-02 1万+
一、Springboot整合RabbitMQ的代码实现 1.引入Springboot整合RabbitMQ的依赖 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> &l
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4508
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
SpringBoot整合实现RabbitMQ
weixin_39956506的博客
01-30 4584
RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。创建2个springboot项目，一个 mq-rabbitmq-producer（生产者），一个mq-rabbitmq-consumer（消费者）。rabbitmq配置类：配置Exchange、Queue、以及绑定交换机。rabbitmq配置类：配置Exchange、Queue、以及绑定交换机。
springboot整合RabbitMQ 消费者消息接收确认
kevin的博客
04-18 1万+
一，消息接收确认 1.ACK机制：消息确认机制 1.作用： 确认消息是否被消费者消费，消息通过ACK机制确认是否被正确接收，每个消息都要被确认。 默认情况下，一个消息被消费者正确消费就会从队列中移除 2.ACK确认模式 AcknowledgeMode.NONE ：不确认 1. 默认所有消息消费成功，会不断的向消费者推送消息 2. 因为rabbitMq认为所有消息都被消费成功，所以队列中不在存...
freeswitch通过limit限制cps
求真得真的博客
11-23 1299
freeswitch在业务开发中有极大的便利性，因为fs内部实现了很多小功能，这些小功能组合在一起，通过拨号计划就可以实现很多常见的业务功能。在voip云平台的开发中，我们经常会碰到资源的限制，有外部线路资源方面的，也有voip平台内部资源方面。根据资源的实际情况，对呼叫做限制，包括cps（每秒呼叫数，call per second）和capacity（呼叫容量），使用fs自带的limit接口，可以很方便的实现需求。limit接口很灵活，可以根据具体场景设置不同的限制规则和多重规则。
sprngboot整合 rabbitMQ
11-15
sprngboot整合 rabbitMQ MQ的作用 流量消峰 ，应用解耦，异步处理 rabbitMq 五种模式 简单模式：一个生产者，一个消费者 工作模式：一个生产者，多个消费者 发布订阅模：又叫无路由键交换机模式，队列绑定到交换机...
SpringBoot集成RabbitMQ的方法(死信队列)
08-26
SpringBoot集成RabbitMQ的方法(死信队列) SpringBoot集成RabbitMQ的方法是指使用SpringBoot框架集成RabbitMQ消息队列的方法，RabbitMQ是一种基于AMQP协议的开源消息队列软件。该方法可以实现消息的异步处理，提高...
springboot整合stream使用rabbitmq作为消息中间件
12-13
当我们谈论"SpringBoot整合stream使用rabbitmq作为消息中间件"时，我们涉及的关键技术点主要包括Spring Boot的Stream模块、RabbitMQ的使用以及它们如何协同工作来实现高效的微服务通信。 Spring Boot Stream模块是...
Rabbitmq与Spring整合
05-02
本文将深入探讨如何将RabbitMQ与Spring框架整合，以实现高效、可靠的通信。 首先，让我们了解RabbitMQ的基本概念。RabbitMQ是基于AMQP（Advanced Message Queuing Protocol）协议的开源消息队列系统，它提供了一个...
SpringBoot集成RabbitMQ消息队列搭建与ACK消息确认入门
热门推荐
屎壳郎情调-成长日记
05-30 4万+
1.Windows下安装RabbitMQ的步骤详解+图解（erlang+RabbitMQ）2.SpringBoot集成RabbitMQ参考文章1.RabbitMQ介绍RabbitMQ是实现AMQP（高级消息队列协议）的消息中间件的一种，最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。RabbitMQ主要是为了实现系统之间的双向解耦而实现的。当生产者大量...
Springboot整合RabbitMQ详解
AhangA的博客
11-30 1万+
RabbitMQ 文章目录RabbitMQRabbitMQ的特点AMQPAMQP模型消息确认AMQP是一个可编程的协议RabbitMQ安装Windows10安装步骤Spring整合AMQP官方中文文档GitHup翻译文档Spring AMQP主要对象类及作用Spring AMQP主要参数Springboot整合AMQP消费端监听相关注解@RabbitListener注意事项@RabbitHandler@Payload@Header，@Headers快速入门RabbitMQ结构介绍成员虚拟主机vhost特性v
SpringBoot如何整合RabbitMQ
ShuSheng007的程序人生
07-23 1万+
好久没有写博客了，终日忙于生计，真是人过30不如狗啊，但写点什么好呢？想想当年自己入门时候那痛苦的经历，还是写点优质实用的入门文章吧，既满足了自己好为人师的本性，也能给后辈提供一些帮助。今天咱们就来聊聊springboot整合rabbitmq的那些事吧。SpringBoot的风头之盛不多说了，我是在2016年首次接触springboot的，当时自己要写个APP，后台采用了springboot。当时还真是个新鲜事物，没想到以后几年的发展犹如黄河泛滥，一发不可收拾…rabbitmq官网https。...
SpringBoot 集成 RabbitMQ
爱笑的boy的博客
03-04 8428
SpringBoot 集成 RabbitMQ
springboot整合rabbitmq集群配置并实现消息确认
qq837993702的博客
12-03 4458
一，集群环境搭建 见文章： Linux安装rabbitMq及elrang环境_qq837993702的博客-CSDN博客 RabbitMQ 集群环境搭建_qq837993702的博客-CSDN博客 二、pom文件配置 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId&gt
SpringBoot简单整合RabbitMQ
m0_46619764的博客
01-11 633
1. 引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 2. 配置ymal spring: rabbitmq: host: 192.16
Spring boot整合RabbitMQ
一个还在上学的程序缘
11-30 466
目录： 一、RabbitMQ简介   RabbitMQ安装不必我多说，linux和windows环境下都可以安装，我是在windows环境下进行安装的，安装RabbitMQ之前需要先安装Erlang，因为Rabbit MQ 是建立在Erlang OTP平台上，而且安装Erlang 时要注意安装的RabbityMQ 所依赖的Erlang版本。   RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而且支持跨平台。
SpringBoot 集成RabbitMQ 各种模式超详细版
华星详谈的博客
12-03 4779
在前文中，我们通过RabbitMQ原生态的API方式了解到了RabbitMQ 是怎样实现消息的发送、接收、手动签收配置、各种模式的具体实现方式等。接下来我们将以与SpringBoot注解...
rabbitmq实现ttl和死信队列
最新发布
10-11
RabbitMQ可以通过设置消息的TTL（Time-To-Live）来控制消息的有效期，在消息过期后可以将其路由到死信交换器中，从而实现死信队列功能。 具体实现步骤如下： 1. 创建两个交换器：普通交换器和死信交换器。 2. 将...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值