Rabbitmq整合SpringBoot

已于 2023-12-10 23:40:58 修改
阅读量39 收藏
点赞数 1
分类专栏： java 文章标签： rabbitmq java
于 2021-10-10 17:22:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45678613/article/details/120689048
版权

AMQP

         AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在。

        AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。RabbitMQ是一个开源的AMQP实现，服务器端用Erlang语言编写。用于在分布式系统中存储转发消息。

Topic模式

（主题模式/通配符模式）

TopicExchange

主题交换机，这个交换机其实跟直连交换机流程差不多，但是它的特点就是在它的路由键和绑定键之间是有规则的。

通配符使用规则

Topic 类型与 Direct 相比，都是可以根据 RoutingKey 把消息路由到不同的队列。
只不过 Topic 类型 Exchange 可以让队列在绑定 Routingkey 的时候使用通配符！

* (星号)用来表示一个单词 (必须出现的,不多不少)

# (井号)用来表示任意数量（零个或多个）单词
使用举例：

有如下三个队列：

队列 Q1 绑定键为 *.TT.*
队列 Q2 绑定键为  TT.#
队列 Q3 绑定键为  TT.*

使用方法：

如果一条消息携带的路由键为 A.TT.B，那么队列Q1将会收到；
如果一条消息携带的路由键为 TT.AA.BB，那么队列Q2将会收到；
如果一条消息携带的路由键为 TT.AA，那么队列Q2、Q3将会收到；

添加依赖

<!--rabbitmq-->
<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.1.2</version>
</dependency>

生产者

关闭自动确认：能者多劳

public class Producer {

    //队列名称
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    //交换机名称
    private static final String EXCHANGE_TOPICS_INFORM = "exchange_topics_inform";
	//短信RoutingKey
    private static final String ROUTINGKEY_SMS = "inform.sms";
    //邮件RoutingKey
    private static final String ROUTINGKEY_EMAIL = "inform.email";

    public static void main(String[] args) {

        //连接
        Connection connection = null;
        //通道
        Channel channel = null;

        try {

            //连接工厂
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("127.0.0.1");
            factory.setPort(5672);
            factory.setUsername("guest");
            factory.setPassword("guest");
            //rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务器
            factory.setVirtualHost("/");

            //创建与RabbitMQ服务的TCP连接
            connection = factory.newConnection();

            //创建与Exchange的通道,每个链接可以创建多个链接,每个通道到表一个会话任务
            channel = connection.createChannel();

            //声明交换机
            channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);

            /***
             * 声明队列，如果Rabbit中没有此队列将自动创建
             * param1:队列名称
             * param2:队列是否持久化(重启MQ服务，队列不会消失)
             * param3:队列是否独占此连接
             * param4:队列不再使用时是否自动删除此队列
             * param5:队列附加参数
             */
            channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
            channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
            
            //交换机绑定队列
            channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_TOPICS_INFORM,ROUTINGKEY_SMS);
            channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_TOPICS_INFORM,ROUTINGKEY_EMAIL);

            //发送短信
            for (int i=1; i<5; i++){

                String message = "第 " +i+ " 条短信";

                /**
                 * 消息发布方法
                 * param1：Exchange的名称，如果没有指定，则使用Default Exchange
                 * param2:routingKey,消息的路由Key，是用于Exchange（交换机）将消息转发到指定的消息队列
                 * param3:消息包含的属性（与消费者属性保持一致）
                 *	（设置为MessageProperties.PERSISTENT_TEXT_PLAIN作用：消息持久化，重启MQ消息依然存在）
                 * param4:消息体
                 */
                channel.basicPublish(EXCHANGE_TOPICS_INFORM,"inform.sms",null,message.getBytes());

                System.out.println("发送: "+message+"    路由RoutingKey名称: "+ROUTINGKEY_SMS);

            }

            //发送邮件
            for (int i=1; i<5; i++){

                String message = "第 " +i+ " 封邮件";

                channel.basicPublish(EXCHANGE_TOPICS_INFORM,"inform.email",null,message.getBytes());

                System.out.println("发送: "+message+"    路由RoutingKey名称: "+ROUTINGKEY_EMAIL);

            }
            
            //发送短信和邮件
            for (int i=1;i<5;i++){ 
                
                String message = "第 " +i+ " 个短信和邮件";
                
                channel.basicPublish(EXCHANGE_TOPICS_INFORM, "inform.sms.email", null, message.getBytes());

                System.out.println("发送: "+message+"    路由RoutingKey名称: inform.sms.email");
            
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {

            try {
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }

            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

    }

}

短信消费者

public class SMSConsumer {

    //队列名称
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    //交换机
    private static final String EXCHANGE_TOPICS_INFORM = "exchange_topics_inform";
    //短信routingKey(可使用通配符)
    private static final String ROUTINGKEY_SMS = "inform.#.sms.#";

    public static void main(String[] args) throws IOException, TimeoutException {

        //创建一个与MQ的链接,连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setVirtualHost("/");

        //创建与RabbitMQ服务的TCP连接
        Connection connection = factory.newConnection();

        //创建与Exchange的通道,每个链接可以创建多个链接,每个通道到表一个会话任务
        Channel channel = connection.createChannel();

        //声明交换机
        channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);

        //声明队列
        channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);

        //交换机绑定ssm队列
        /**
         * 参数1：queue：队列的名字。
         * 参数2：exchange：交换器的名字。
         * 参数3：routingKey：用于绑定的路由键(inform.#表示接收短信和邮件)。
         */
        channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_TOPICS_INFORM,ROUTINGKEY_SMS);

        //一次只接受一条未确认的消息
        channel.basicQos(1);
        
        //定义消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            
            /***
             * 消费者接收消息调用此方法
             * @param consumerTag 消费者的标签，在channel.basicConsume()去指定
             * @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志 (收到消息失败后是否需要重新发送)
             * @param properties
             * @param body
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                            AMQP.BasicProperties properties, byte[] body) throws IOException {

                //手动确认消息
                channel.basicAck(envelope.getDeliveryTag(),false);
                
                //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //交换机
                String exchange = envelope.getExchange();
				//路由key
                String routingKey = envelope.getRoutingKey();
                //消息内容
                String message = new String(body,"utf-8");
                System.out.println("短信消费者接收消息： "+message+"    routingKey: "+ROUTINGKEY_SMS);
                
                try {
                    Thread.sleep(9000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        };
        
		/***
         * 监听队列
         * 参数String queue, boolean autoAck,Consumer callback
         * 参数明细
         * 1、队列名称
         * 2、是否自动回复，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置 为false则需要手动回复
         * 3、消费消息的方法，消费者接收到消息后调用此方法
         */
        channel.basicConsume(QUEUE_INFORM_SMS,true,defaultConsumer);

    }

}

邮件消费者

public class EmailConsumer {

    //队列名称
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    //交换机
    private static final String EXCHANGE_TOPICS_INFORM = "exchange_topics_inform";
    //短信routingKey(可使用通配符)
    private static final String ROUTINGKEY_EMAIL = "inform.#.email.#";

    public static void main(String[] args) throws IOException, TimeoutException {

        //创建一个与MQ的链接,连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setVirtualHost("/");

        //创建与RabbitMQ服务的TCP连接
        Connection connection = factory.newConnection();

        //创建与Exchange的通道,每个链接可以创建多个链接,每个通道到表一个会话任务
        Channel channel = connection.createChannel();

        //声明交换机
        channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);

        //声明队列
        channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);

        //交换机绑定email队列
        /**
         * 参数1：queue：队列的名字。
         * 参数2：exchange：交换器的名字。
         * 参数3：routingKey：用于绑定的路由键(inform.#表示接收短信和邮件)。
         */
        channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_TOPICS_INFORM,ROUTINGKEY_EMAIL);

        //定义消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            
            /***
             * 消费者接收消息调用此方法
             * @param consumerTag 消费者的标签，在channel.basicConsume()去指定
             * @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志 (收到消息失败后是否需要重新发送)
             * @param properties
             * @param body
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                            AMQP.BasicProperties properties, byte[] body) throws IOException {

                //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //交换机
                String exchange = envelope.getExchange();
				//路由key
                String routingKey = envelope.getRoutingKey();
                //消息内容
                String message = new String(body,"utf-8");
                System.out.println("邮件消费者接收消息： "+message+"    routingKey: "+ROUTINGKEY_EMAIL);

            }
        };
        
		/***
         * 监听队列
         * 参数String queue, boolean autoAck,Consumer callback
         * 参数明细
         * 1、队列名称
         * 2、是否自动回复，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置 为false则需要手动回复
         * 3、消费消息的方法，消费者接收到消息后调用此方法
         */
        channel.basicConsume(QUEUE_INFORM_EMAIL,true,defaultConsumer);

    }

}

整合SpringBoot

添加依赖pom.xml

<dependency> 
    <groupId>org.springframework.boot</groupId> 
    <artifactId>spring‐boot‐starter‐amqp</artifactId> 
</dependency> 
<dependency> 
    <groupId>org.springframework.boot</groupId> 
    <artifactId>spring‐boot‐starter‐test</artifactId> 
</dependency>

配置文件application.yml

server:
  prot: 44000
spring:
  application:
    name: test-rabbitmq-producer
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtualHost: /

启动类

@SpringBootApplication
public class App {

    public static void main(String[] args) {
        SpringApplication.run(App.class,args);
    }
}

定义RabbitConfig类

配置Exchange、Queue、及绑定交换机。(配置Topic交换机)

//配置Topic交换机
@Configuration
public class RabbitmqConfig {

    //队列名称
    public static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    public static final String QUEUE_INFORM_SMS = "queue_inf orm_sms";
    //交换机名称
    public static final String EXCHANGE_TOPICS_INFORM = "exchange_topic_inform";

    //交换机配置
    @Bean(EXCHANGE_TOPICS_INFORM)
    public Exchange EXCHANGE_TOPICS_INFORM(){
        //durable(true)持久化，消息队列重启后交换机仍然存在
        return ExchangeBuilder.topicExchange(EXCHANGE_TOPICS_INFORM).durable(true).build();
    }

    //声明队列
    @Bean(QUEUE_INFORM_EMAIL)
    public Queue QUEUE_INFORM_EMAIL(){
        Queue queue = new Queue(QUEUE_INFORM_EMAIL);
        return queue;
    }
    //声明队列
    @Bean(QUEUE_INFORM_SMS)
    public Queue QUEUE_INFORM_SMS(){
        Queue queue = new Queue(QUEUE_INFORM_SMS);
        return queue;
    }

    //绑定队列到交换机
    @Bean
    public Binding BINDING_QUEUE_INFORM_EMAIL(@Qualifier(QUEUE_INFORM_EMAIL) Queue queue, @Qualifier(EXCHANGE_TOPICS_INFORM) Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("inform.#.email.#").noargs();
    }
    @Bean
    public Binding BINDING_QUEUE_INFORM_SMS(@Qualifier(QUEUE_INFORM_SMS) Queue queue, @Qualifier(EXCHANGE_TOPICS_INFORM) Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("inform.#.sms.#").noargs();
    }

}

消费者

使用@RabbitListener注解监听队列。

//消费者
@Component
public class ReceiveHandler {

    //监听email队列
    @RabbitListener(queues = {RabbitmqConfig.QUEUE_INFORM_EMAIL})
    public void receive_email(String msg, Message message, Channel channel){
        System.out.println("消息内容： "+msg);
    }

    //监听SMS队列
    @RabbitListener(queues = {RabbitmqConfig.QUEUE_INFORM_SMS})
    public void receive_sms(String msg,Message message,Channel channel){
        System.out.println(msg);
    }

}

生产者

测试类

//生产者
@SpringBootTest
@RunWith(SpringRunner.class)
public class Producer {

    @Autowired
    RabbitTemplate rabbitTemplate;

    @Test
    public void testSendByTopics(){

        for (int i=1; i<5; i++){
            String message = "第 " +i+ " 条短信";
            rabbitTemplate.convertAndSend(RabbitmqConfig.EXCHANGE_TOPICS_INFORM,"inform.sms.email",message);
            System.out.println("发送: "+message);
        }

    }

}

学成项目使用到RabbitMQ

配置类 RabbitMQConfig

定义RabbitmqConfig类，配置Exchange、Queue、及绑定交换机。

@Configuration
public class RabbitMQConfig {
    //添加选课任务交换机
    public static final String EX_LEARNING_ADDCHOOSECOURSE = "ex_learning_addchoosecourse";

    //添加选课消息队列
    public static final String XC_LEARNING_ADDCHOOSECOURSE = "xc_learning_addchoosecourse";

    //完成添加选课消息队列
    public static final String XC_LEARNING_FINISHADDCHOOSECOURSE = "xc_learning_finishaddchoosecourse";

    //添加选课路由key
    public static final String XC_LEARNING_ADDCHOOSECOURSE_KEY = "addchoosecourse";
    //完成添加选课路由key
    public static final String XC_LEARNING_FINISHADDCHOOSECOURSE_KEY = "finishaddchoosecourse";

    /**
     * 交换机配置
     * @return the exchange
     */
    @Bean(EX_LEARNING_ADDCHOOSECOURSE)
    public Exchange EX_DECLARE() {
        return ExchangeBuilder.directExchange(EX_LEARNING_ADDCHOOSECOURSE).durable(true).build();
    }

    //声明队列
    @Bean("xc_learning_addchoosecourse")
    public Queue Queue_xc_learning_addchoosecourse(){
        Queue queue = new Queue(XC_LEARNING_ADDCHOOSECOURSE,true,false,true);
        return queue;
    }

    //声明队列
    @Bean("xc_learning_finishaddchoosecourse")
    public Queue QUEUE_DECLARE() {
        Queue queue = new Queue(XC_LEARNING_FINISHADDCHOOSECOURSE,true,false,true);
        return queue;
    }
    /**
     * 绑定队列到交换机 .
     * @param queue    the queue
     * @param exchange the exchange
     * @return the binding
     */
    @Bean
    public Binding binding_queue_media_addchoosecourse(@Qualifier("xc_learning_addchoosecourse") Queue queue,@Qualifier(EX_LEARNING_ADDCHOOSECOURSE) Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with(XC_LEARNING_ADDCHOOSECOURSE_KEY).noargs();
    }

    @Bean
    public Binding binding_queue_media_processtask(@Qualifier("xc_learning_finishaddchoosecourse") Queue queue, @Qualifier(EX_LEARNING_ADDCHOOSECOURSE) Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(XC_LEARNING_FINISHADDCHOOSECOURSE_KEY).noargs();
    }

}

接收信息

/**
 * 接收选课任务
 */
@RabbitListener(queues = {RabbitMQConfig.XC_LEARNING_ADDCHOOSECOURSE})
public void receiveChoosecourseTask(XcTask xcTask, Message message, Channel channel) throws
    IOException {
    LOGGER.info("receive choose course task,taskId:{}",xcTask.getId());
    //接收到 的消息id
    String id = xcTask.getId();
    //添加选课
    try {
        String requestBody = xcTask.getRequestBody();
        Map map = JSON.parseObject(requestBody, Map.class);
        String userId = (String) map.get("userId");
        String courseId = (String) map.get("courseId");
        String valid = (String) map.get("valid");
        Date startTime = null;
        Date endTime = null;
        SimpleDateFormat dateFormat = new SimpleDateFormat("YYYY‐MM‐dd HH:mm:ss");
        if(map.get("startTime")!=null){
            startTime =dateFormat.parse((String) map.get("startTime"));
        }
        if(map.get("endTime")!=null){
            endTime =dateFormat.parse((String) map.get("endTime"));
        }
        //添加选课
        ResponseResult addcourse = learningService.addcourse(userId, courseId,
                                                             valid,startTime, endTime,xcTask);
        //选课成功发送响应消息
        if(addcourse.isSuccess()){
            //发送响应消息
            rabbitTemplate.convertAndSend(RabbitMQConfig.EX_LEARNING_ADDCHOOSECOURSE,
                                          RabbitMQConfig.XC_LEARNING_FINISHADDCHOOSECOURSE_KEY, xcTask );
            LOGGER.info("send finish choose course taskId:{}",id);
        }
    } catch (Exception e) {
        e.printStackTrace();
        LOGGER.error("send finish choose course taskId:{}", id);
    }
}


任凭弱水三千，我只取一瓢饮。红尘滚滚，奈何不了一往情深。人欲横流，唯简单笃定不乱一心。
王大神在这呢
关注
专栏目录
Springboot 整合RabbitMq ，用心看完这一篇就够了
默默不代表沉默
09-04 49万+
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建............
RabbitMQ与SpringBoot整合详解
vanGogh的博客
11-17 6616
一、前言   本文章总体简介，会采用Docker下载安装RabbitMQ，详细介绍RabbitMQ优缺点及其相关技术知识点，SpringBoot作为整合学习的基础架构。看完本片文章，你会了解消息队列RabbitMQ，你会使用消息队列RabbitMQ。 二、消息队列   当第一次出现在我脑中这个词语时，我会问自己什么时消息队列？我做的项目为什么没有消息队列？我做的项目可以用消息队列么？如果可以用消息队列这要怎么使用消息队列？消息队列能解决项目什么问题？等等问题会出现在我的脑海…，然而我将会在面文章中对自己慢慢
RabbitMQ整合Springboot
weixin_72388638的博客
06-22 1748
消息队列
RabbitMQ整合SpringBoot
qwq1518346864的博客
06-18 234
RabbitMQ整合SpringBoot 一.RabbitMQ整合SpringBoot（手动ack） 1.创建SpringBoot工程 2.导入依赖 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp&l...
【RabbitMQ】RabbitMQ整合SpringBoot案例
weixin_45618869的博客
08-18 733
1：创建生产者工程：sspringboot-rabbitmq-fanout-producer。2：创建消费者工程：springboot-rabbitmq-fanout-consumer。启动测试，此时进入mq的web页面，查看交换机和队列是否绑定上了，查看是否有队列消息。在这之前提前开好服务器，并且启动mq的服务，可参考上面的链接。向所有队列中都加入10条消息—说明交换机和队列绑定没问题。3：引入spring-boot-rabbitmq的依赖。5：查看和观察web控制台的状况。4：进行消息的分发和测试。
消息队列RabbitMQ 整合 springboot，带确认机制和退回机制
weixin_44934104的博客
04-15 2156
确认机制方案： —— 图来自于尚硅谷的截图 1、配置文件： publisher-confirm-type=correlated：发布消息成功到交换器后会触发回调方法 spring.rabbitmq.host=127.0.0.1 spring.rabbitmq.port=5672 spring.rabbitmq.username=guest spring.rabbitmq.password=guest spring.rabbitmq.publisher-confirm-type=correlated spr
rabbitmq整合springboot---消费者工程
牧xin的博客
05-26 314
消费者工程 application.yml文件配置rabbitmq相关信息 创建消息处理类,用于接收队列中的消息并进行处理 搭建测试项目 maven工程的pom文件 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version&
RabbitMq整合Springboot超全实战案例+图文演示+源码自取
暗武逢天的博客
12-01 4622
RabbitMQ是一种开源的消息队列软件，它实现了高级消息队列协议（AMQP），提供了可靠的消息传递机制以及支持分布式应用程序之间的通信。RabbitMQ支持多种编程语言，如Java、Python、Ruby、PHP等等，并且可以在不同的操作系统上运行，如Windows、Linux、Mac OS等。
RabbitMQ整合Springboot使用
亦然哥哥的博客
07-22 229
fanout模式 整体核心 01 目标 使用springboot完成rabbitmq的消费模式-Fanout 02 在配置文件中配置RabbitMq的相关信息 # 配置rabbitmq服务 spring: rabbitmq: username: guest password: guest virtual-host: / host: localhost port: 5672 03 注解方式对RabbitMq进行管理 首先，我们能够确定上面的订单业务，需要至少
【RabbitMQ】SpringBoot整合RabbitMQ
p_fly的博客
08-16 619
对于RabbitMQ的开发,Spring方法提供了更为方便的操作.Spring官网介绍: Spring AMQPRabbitMQ官网介绍: RabbitMQ tutorial - "Hello World!"
RabbitMQ整合SpringBoot综合应用
06-19
本篇主要讨论如何将RabbitMQ与SpringBoot进行整合，实现一个综合应用。 首先，RabbitMQ是一个基于AMQP（Advanced Message Queuing Protocol）协议的开源消息代理，它允许应用程序之间发送和接收消息，而无需两者...
RabbitMQ整合Springboot 学习包及相关安装软件
03-24
本文将详细介绍如何整合RabbitMQ与Spring Boot，以及相关的安装步骤。 首先，我们需要安装Erlang环境，因为RabbitMQ是基于Erlang语言开发的。Erlang是一种并发性极强的编程语言，适用于构建分布式系统。下载并安装...
RabbitMQ替换默认端口
CodeV的博客
10-29 262
（注意，这里必须要关闭rabbitmq，直接执行第三步会报错：Killing not allowed - living nodes in database.）前提：客户通过漏洞扫描，发现rabbitmq中的erlang是默认端口4369，出于安全的考虑，需要将erlang的端口修改为其他的端口。修改后让配置生效 source /etc/profile。5.重新启动rabbitmq （epmd会自动启动）1.查看默认erlang的默认端口。这里端口修改成5000为例子。2.关闭rabbitmq。
RabbitMQ几大应用问题
最新发布
2301_77053417的博客
10-30 614
所以幂等性保障，就是可以正确的处理相同重复的消息。当消费者收到消息后，就可以根据唯一ID判断该消息是否已经被消费过，如果已经被消费观过，则可以不做处理，进而可以避免重复消费的问题。消费者消费完成后没有及时对消息进行确认，或者确认丢失，MQ可能认为消息未发送成功进而重试，也会导致消息处理的顺序性问题。当存在多个消费者的时候，消息被哪一个消费者消费是不确定的，也可能并行处理，就会导致消息的顺序性无法保证。消息积压，指的是在消息队列中，待处理的消息数量超过了消费者的处理能力，导致消息在队列中不断堆积的现象。
消息队列-RabbitMQ
杜小帅的博客
10-28 527
消息队列-RabbitMQ-CSDN博客输入默认的用户密码会显示权限不够,我们继续操作创建一个用户。
【面试】RabbitMQ有哪些消息模型
王佑辉的博客
10-26 554
2.消息的发送者（Producer）将消息发送到队列中，消息的接收者（Consumer）从队列中获取消息并消费。2.消息发送者将消息发送到交换机中，并指定一个主题，消息接收者可以根据主题进行订阅，只接收他们感兴趣的消息。1.消息的发送者将消息发送到交换机（Exchange）中，交换机将消息广播给绑定到它的所有队列。1.类似于发布/订阅模型，但可以根据消息的特定主题（Topic）进行订阅。2.客户端发送请求消息到队列中，服务端消费请求消息并返回响应消息给客户端。2.每个消息可以被多个消费者接收。
【rabbitmq】RabbitMQ中的交换机有哪些类型
王佑辉的博客
10-27 440
2.特点：使用模式匹配来路由消息，路由键和绑定键都支持通配符*（表示一个词）和#（表示一个或多个词）。2.特点：根据完全匹配的路由键（Routing Key）将消息路由到绑定的队列。4.路由规则：消息会被转发到与该交换机绑定的所有队列上，类似于子网广播。2.特点：采用广播模式，将接收到的消息分发给所有绑定到该交换机的队列。4.绑定规则：使用模式匹配的绑定键，例如*.info或#.error。3.应用场景：适用于需要广播消息的场景，例如实时消息发布。3.应用场景：适用于需要根据消息的特定属性进行路由的场景。
【rabbitmq】绑定死信队列示例
王佑辉的博客
10-27 471
1.正常队列绑定死信交换机和死信routing_key，正常队列中的消息在特殊情况下变为死信时，将死信通过绑定的死信交换机转移到死信队列中。3.这里演示的是10秒未消费的消息，进入死信队列。3.RabbitMQConfig配置类。2.消息10秒后过期，进入死信队列。
rabbitmq高级特性（1）：消息确认，持久性，发送方确认和重试机制
2301_77053417的博客
10-27 1004
这里的消息确认机制，指的是消费者对消息的确认，而不是生产者。（1）背景缘由当消费者把消息发送出去后，就会把消息删除。如果消费者这边处理消息成功，则相安无事；但是如果处理异常，消息也就会丢失。所以就需要设置消费者的消息确认模式（2）消息确认的机制消息确认机制分为两个大类：自动确认和手动确认手动确认又分为三种模式：肯定确认、否定确认、否定批量确认对于rabbitmq的操作有两种，我们主要介绍第二种直接使用amqb提供的包（RabbitMQ Java Client库）使用spring集成进来的。
rabbitmq整合springboot实战
08-18
在Spring Boot中整合RabbitMQ可以使用Spring AMQP库来简化操作。下面是一个简单的RabbitMQ和Spring Boot的实战示例： 1. 添加依赖：在`pom.xml`文件中添加以下依赖： ```xml <groupId>org.springframework.boot ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值