RabbitMQ学习教程

最新推荐文章于 2024-03-22 16:38:58 发布
最新推荐文章于 2024-03-22 16:38:58 发布
阅读量416 收藏
点赞数
分类专栏： Java 文章标签： java-rabbitmq rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29928745/article/details/129394911
版权

RabbitMQ学习教程

MQ考察重点：

1、了解过哪些MQ？不同MQ之间有什么区别？
2、使用MQ的目的是什么？(削峰、异步和解耦)
2、RabbitMQ在项目里什么场景下使用的？以及如何使用的？
3、RabbitMQ的延迟队列、死信队列有了解和使用过吗？
4、如何保证消息的可靠性投递？
5、如何避免消息的重复消费？
6、MQ的集群私下里有搭建过吗？

参考文章：

https://file.xdclass.net/note/2021/rabbitmq/%E5%B0%8F%E6%BB%B4%E8%AF%BE%E5%A0%82-RabbitMQ%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0.html

一、MQ的应用场景

核心应用：
1、解耦：用户注册后直接将注册成功返回给前端,发送MQ去处理其它(发送优惠劵、验证合法性等)业务。
2、异步：邮件异步通知(解耦也相当于异步)。
3、削峰：某一个接口单位时间内的并发量过高，可以通过MQ慢慢消费(秒杀)。

在这里插入图片描述在这里插入图片描述

其它应用：
1、两个服务或项目是跨语言或跨平台的，可以通过MQ来解决。
2、分布式事务(最终一致性)(只要保证数据最终是一致的即可，可以有时间上的延迟，也即牺牲时间换空间)：MQ延迟+死信队列实现。

在这里插入图片描述

二、什么是JMS、AMQP、MQTT(引申)

1、JMS：(定义：由Sun公司早期提出的消息标准，是一个Java平台中关于面向消息中间件（MOM）的API，旨在为java应用提供统一的消息操作)->类似于JDBC数据库API连接规范，JMS相当于消息通信API规范(只不过只针对Java语言)

2、AMQP：(定义：在2003年时被提出，最早用于解决金融领不同平台之间的消息传递交互问题,是一种协议)->
(1)AMQP只是一种协议，不是从API层进行限定，而是直接定义网络交换的数据格式。这就使得只要实现了AMQP协议的生产/消费者那就是跨平台的,兼容JMS。
(2)意味着我们可以使用Java的AMQP的provider，同时使用一个python的consumer。
(3)AMQP就好比http，不关心实现的语言，只要大家都按照相应的数据格式去发送报文请求，不同语言的client均可以和不同语言的server链接。

3、MQTT：(定义：消息队列遥测传输)->
(1)计算性能不高的设备不能适应AMQP上的复杂操作,MQTT它是专门为小设备设计的。
(2)MQTT主要是是物联网（IOT）中大量的使用。
(3)简单用户名和密码、不支持安全连接、消息不透明。

在这里插入图片描述

三、不同消息队列之间的对别

业界主流的消息队列：Apache ActiveMQ、Kafka、RabbitMQ、RocketMQ

ActiveMQ：http://activemq.apache.org/

Apache出品，历史悠久，支持多种语言的客户端和协议，支持多种语言Java, .NET, C++ 等

基于JMS Provider的实现

缺点：吞吐量不高，多队列的时候性能下降，存在消息丢失的情况，比较少大规模使用

【主要：吞吐量不高、性能低、问题多 政府老项目用的多】

Kafka：http://kafka.apache.org/

是由Apache软件基金会开发的一个开源流处理平台，由Scala和Java编写。Kafka是一种高吞吐量的分布式发布订阅消息系统，它可以处理大规模的网站中的所有动作流数据(网页浏览，搜索和其他用户的行动)，副本集机制，实现数据冗余，保障数据尽量不丢失；支持多个生产者和消费者

类似MQ，功能较为简单，主要支持简单的MQ功能

缺点：不支持批量和广播消息，运维难度大，文档比较少, 需要掌握Scala

【主要：高吞吐量、海量数据处理、日志采集】

RocketMQ：http://rocketmq.apache.org/

阿里开源的一款的消息中间件, 纯Java开发，具有高吞吐量、高可用性、适合大规模分布式系统应用的特点, 性能强劲(零拷贝技术)，支持海量堆积, 支持指定次数和时间间隔的失败消息重发,支持consumer端tag过滤、延迟消息等，在阿里内部进行大规模使用，适合在电商，互联网金融等领域

基于JMS Provider的实现

缺点：社区相对不活跃，更新比较快，纯java支持

【主要：背靠阿里、性能牛掰、稳定性高、支持业务上的消息重发和延迟消息，java开发 不跨平台的情况下首选！！！】

RabbitMQ：http://www.rabbitmq.com/

是一个开源的AMQP实现，服务器端用Erlang语言编写，支持多种客户端，如：Python、Ruby、.NET、Java、C、用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不错

缺点：使用Erlang开发，阅读和修改源码难度大

【主要：重点 跨平台支持多种客户端、扩展性强、行走在业务层面的MQ，涉及到物联网项目常用】

四 、Docker安装RabbitMQ命令

1、原始安装命令：
docker run -d --name shop_rabbit -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=password -p 15672:15672 -p 5672:5672 --restart=always rabbitmq:3.8.15-management

15672端口：客户端(网页)访问端口
5672端口：服务端通信端口
2、RabbitMQ-Stomp安装命令：
docker exec -it MQ容器id /bin/bash

#执行指令开启web stomp插件
rabbitmq-plugins enable rabbitmq_management rabbitmq_web_stomp rabbitmq_stomp rabbitmq_web_stomp_examples

#查看安装的插件
rabbitmq-plugins list
exit

#将开启了插件的容器提交为基础镜像供后续备用
docker commit 容器ID rabbitmq:stomp

#查看生成的新的镜像
docker images

#删除原来的容器
docker rm -f MQ容器id

docker run -d --name=shop_rabbit -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=password -p 15672:15672 -p 5672:5672 -p 61613:61613 --restart=always rabbitmq:stomp

1、RabbitMQ整合stomp协议：https://www.cnblogs.com/freewsf/p/16493631.html
2、SpringBoot整合stomp协议：https://blog.csdn.net/qq_30285985/article/details/117822255
3、RabbitMQ访问地址：
http://152.136.126.29:15672/

五、RabbitMQ消息队列和核心概念介绍

在这里插入图片描述
说明：

1、部署一个MQ服务节点就是一个【Broker】。
2、一个【Broker】中可以有多个【Virtual host】虚拟主机:存在的目的是对不同“项目”之间的MQ应用隔离。
3、在一个【Virtual host】虚拟主机中包含
	【生产者】、【消费者】：生产消息、消费消息。
	【交换机】、【队列】：通过【BindingKey】(绑定key)进行绑定，【队列】才是存放消息的地方。
	【RoutingKey】路由键：当BindingKey和RoutingKey相匹配时，消息会被打到对应的队列中。
	
	【Connection】连接：是RabbitMQ的socket链接，一个连接上可以有多个channel进行通信。
	【Channel】信道：一条支持多路复用的通道，独立的双向数据流通道，就是发布、订阅、接收消息的具体管道。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

六、RabbitMQ的多种工作模式

  • 对照官网回顾总结

    • https://www.rabbitmq.com/getstarted.html

  • 简单模式(生产者->队列->消费者)

    • 一个生产、一个消费，不用指定交换机，【使用默认交换机】
      在这里插入图片描述
    //生产者
public class Send {
    
    private final static String QUEUE_NAME = "simple_queue";
    
    public static void main(String[] argv) throws Exception {
        
        ConnectionFactory factory = new ConnectionFactory();
        
        factory.setHost("10.211.55.13");
        factory.setUsername("admin");
        factory.setPassword("password");
        factory.setVirtualHost("/dev");
        factory.setPort(5672);
        
        try (   
            //JDK7语法 自动关闭 connnection和channel
                
            //创建连接
            Connection connection = factory.newConnection();
            
            //创建信道
            Channel channel = connection.createChannel()) {
            
            /**
             * 队列名称
             * 持久化配置：mq重启后还在
             * 是否独占：只能有一个消费者监听队列；当connection关闭是否删除队列，一般是false，发布订阅是独占
             * 自动删除: 当没有消费者的时候，自动删除掉，一般是false
             * 其他参数
             * 
             * 队列不存在则会自动创建，如果存在则不会覆盖，所以此时的时候需要注意属性
             */
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            
            String message = "Hello World!";
            
             /**
             * 参数说明：
             * 交换机名称：不写则是默认的交换机，那【路由健需要和队列名称一样才可以被路由】
             * 路由健名称
             * 配置信息
             * 发送的消息数据：字节数组
             */
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
            
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}

    //消费者
public class Recv {

    private final static String QUEUE_NAME = "simple_queue";

    public static void main(String[] argv) throws Exception {
    
        ConnectionFactory factory = new ConnectionFactory();
        
        factory.setHost("10.211.55.13");
        factory.setUsername("admin");
        factory.setPassword("password");
        factory.setVirtualHost("/xdclass1");
        factory.setPort(5672);

        //消费者一般不增加自动关闭
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        //回调方法，下面两种都行
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                
                // consumerTag 是固定的 可以做此会话的名字， deliveryTag 每次接收消息+1
                System.out.println("consumerTag消息标识="+consumerTag);
                
                //可以获取交换机，路由健等
                System.out.println("envelope元数据="+envelope);

                System.out.println("properties配置信息="+properties);

                System.out.println("body="+new String(body,"utf-8"));
            }
        };
        
        channel.basicConsume(QUEUE_NAME,true,consumer);

//        DeliverCallback deliverCallback = (consumerTag, envelop, delivery,properties, msg) -> {
//            String message = new String(msg, "UTF-8");
//            System.out.println(" [x] Received '" + message + "'");
//        };

        //自动确认消息
        //channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> { });
    }
}

  • 工作队列模式

    • 一个生产，多个消费，可以有轮训和公平策略，不用指定交换机，【使用默认交换机】
      在这里插入图片描述
    //生产者
public class Send {

    private final static String QUEUE_NAME = "work_queue";

    public static void main(String[] argv) throws Exception {
        
        ConnectionFactory factory = new ConnectionFactory();
        
        factory.setHost("10.211.55.13");
        factory.setUsername("admin");
        factory.setPassword("password");
        factory.setVirtualHost("/dev");
        factory.setPort(5672);

        try (
            //创建连接
            Connection connection = factory.newConnection();
            
            //创建信道
            Channel channel = connection.createChannel()) {

            /**
             * 队列名称
             * 持久化配置
             * 排他配置
             * 自动删除
             * 其他参数
             */
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            
            //轮训发送 10个
            for(int i=0;i<10;i++){
                String message = "Hello World!"+i;
                
                channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
                
                System.out.println(" [x] Sent '" + message + "'");
            }
        }
    }
}

    //消费者(可以再创建一个相同的类，模拟消费者2)
public class Recv1 {

    private final static String QUEUE_NAME = "work_queue";

    public static void main(String[] argv) throws Exception {
        
        ConnectionFactory factory = new ConnectionFactory();
        
        factory.setHost("10.211.55.13");
        factory.setUsername("admin");
        factory.setPassword("password");
        factory.setVirtualHost("/xdclass1");
        factory.setPort(5672);

        Connection connection = factory.newConnection();
        
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        
        System.out.println(" [*]Waiting for messages. To exit press CTRL+C");

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            
            //模拟消费缓慢
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            String message = new String(delivery.getBody(), "UTF-8");
            
            System.out.println("[x] Received '" + message + "'");

            //手工确认消息消费，不是多条确认
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        };

        //关闭自动确认消息
        channel.basicConsume(QUEUE_NAME, false, deliverCallback, consumerTag -> { });
    }
}

  • 发布订阅模式【不使用默认交换机，则根据交换机类型区分】

    • fanout类型交换机，通过交换机和队列绑定，不用指定绑定的路由健，生产者发送消息到交换机，fanout交换机直接进行转发，消息不用指定routingkey路由健
      在这里插入图片描述
    //生产者
public class Send {

    private final static String EXCHANGE_NAME = "exchange_fanout";

    public static void main(String[] argv) throws Exception {
        
        ConnectionFactory factory = new ConnectionFactory();
        
        factory.setHost("10.211.55.13");
        factory.setUsername("admin");
        factory.setPassword("password");
        factory.setVirtualHost("/dev");
        factory.setPort(5672);

        /**
         * 消息生产者不用过多操作，只需要和交换机绑定即可
         */
        try (
            
            //创建连接
            Connection connection = factory.newConnection();
            
            //创建信道
            Channel channel = connection.createChannel()) {

            //绑定交换机,fanout扇形，即广播类型
            channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.FANOUT);

            String message = "Hello World pub !";
            
            channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes(StandardCharsets.UTF_8));
            
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}

    //消费端（两个节点）
public class Recv1 {

    private final static String EXCHANGE_NAME = "exchange_fanout";

    public static void main(String[] argv) throws Exception {
        
        ConnectionFactory factory = new ConnectionFactory();
        
        factory.setHost("10.211.55.13");
        factory.setUsername("admin");
        factory.setPassword("password");
        factory.setVirtualHost("/dev");
        factory.setPort(5672);

        //消费者一般不增加自动关闭
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        //绑定交换机,fanout扇形，即广播类型
        channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.FANOUT);

        //获取队列（排它队列）
        String queueName = channel.queueDeclare().getQueue();

        //绑定队列和交换机,fanout交换机不用指定routingkey
        channel.queueBind(queueName,EXCHANGE_NAME,"");

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
        };

        //自动确认消息
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
    }
}

  • 路由模式【不使用默认交换机，则根据交换机类型区分】

    • direct类型交换机，通过交换机和队列绑定，指定【绑定的路由健】，生产者发送消息到交换机，交换机根据消息的【路由key】进行转发到对应的队列，消息要指定【routingkey路由健】
      在这里插入图片描述
    • 例子：日志采集系统 ELK
      • 一个队列收集error信息-》告警
      • 一个队列收集全部信息-》日常使用
    public class Send {

    private final static String EXCHANGE_NAME = "exchange_direct";

    public static void main(String[] argv) throws Exception {
        
        ConnectionFactory factory = new ConnectionFactory();
        
        factory.setHost("10.211.55.13");
        factory.setUsername("admin");
        factory.setPassword("password");
        factory.setVirtualHost("/xdclass1");
        factory.setPort(5672);

        /**
         * 消息生产者不用过多操作，只需要和交换机绑定即可
         */
        try (
            
            //创建连接
            Connection connection = factory.newConnection();
            
            //创建信道
            Channel channel = connection.createChannel()) {

            //绑定交换机,直连交换机
            channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.DIRECT);

            String error = "我是错误日志";
            String info = "我是info日志";
            String debug = "我是debug日志";
            
            channel.basicPublish(EXCHANGE_NAME, "errorRoutingKey", null, error.getBytes(StandardCharsets.UTF_8));
            
            channel.basicPublish(EXCHANGE_NAME, "infoRoutingKey", null, info.getBytes(StandardCharsets.UTF_8));
            
            channel.basicPublish(EXCHANGE_NAME, "debugRoutingKey", null, debug.getBytes(StandardCharsets.UTF_8));

            System.out.println("消息发送成功");
        }
    }
}

    //消息消费者（两个节点）
public class Recv1 {

    private final static String EXCHANGE_NAME = "exchange_direct";

    public static void main(String[] argv) throws Exception {
        
        ConnectionFactory factory = new ConnectionFactory();
        
        factory.setHost("10.211.55.13");
        factory.setUsername("admin");
        factory.setPassword("password");
        factory.setVirtualHost("/xdclass1");
        factory.setPort(5672);

        //消费者一般不增加自动关闭
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        //绑定交换机,DIRECT类型
        channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.DIRECT);

        //获取队列
        String queueName = channel.queueDeclare().getQueue();

        //绑定队列和交换机，另外一个节点只绑定一个 errorRoutingKey
        channel.queueBind(queueName,EXCHANGE_NAME,"errorRoutingKey");
        channel.queueBind(queueName,EXCHANGE_NAME,"infoRoutingKey");
        channel.queueBind(queueName,EXCHANGE_NAME,"debugRoutingKey");

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
        };

        //自动确认消息
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
    }
}

  • 通配符模式【不使用默认交换机，则根据交换机类型区分】

    • topic交换机，通过交换机和队列绑定，指定绑定的【通配符路由健】，生产者发送消息到交换机，交换机根据消息的路由key进行转发到对应的队列，消息要指定routingkey路由健

在这里插入图片描述

  • 例子：日志采集系统
    • 一个队列收集订单系统的error日志信息，order.log.error
    • 一个队列收集全部系统的全部级别日志信息, * .log. *
public class Send {

    private final static String EXCHANGE_NAME = "exchange_topic";

    public static void main(String[] argv) throws Exception {
        
        ConnectionFactory factory = new ConnectionFactory();
        
        factory.setHost("10.211.55.13");
        factory.setUsername("admin");
        factory.setPassword("password");
        factory.setVirtualHost("/dev");
        factory.setPort(5672);

        /**
         * 消息生产者不用过多操作，只需要和交换机绑定即可
         */
        try (
            //创建连接
            Connection connection = factory.newConnection();
            
            //创建信道
            Channel channel = connection.createChannel()) {

            //绑定交换机,直连交换机
            channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.TOPIC);

            String error = "我是订单错误日志";
            String info = "我是订单info日志";
            String debug = "我是商品debug日志";
            
            channel.basicPublish(EXCHANGE_NAME, "order.log.error", null, error.getBytes(StandardCharsets.UTF_8));
            
            channel.basicPublish(EXCHANGE_NAME, "order.log.info", null, info.getBytes(StandardCharsets.UTF_8));
            
            channel.basicPublish(EXCHANGE_NAME, "product.log.debug", null, debug.getBytes(StandardCharsets.UTF_8));

            System.out.println("消息发送成功");
        }
    }
}

//消费者1
public class Recv1 {

    private final static String EXCHANGE_NAME = "exchange_topic";

    public static void main(String[] argv) throws Exception {
        
        ConnectionFactory factory = new ConnectionFactory();
        
        factory.setHost("10.211.55.13");
        factory.setUsername("admin");
        factory.setPassword("password");
        factory.setVirtualHost("/dev");
        factory.setPort(5672);

        //消费者一般不增加自动关闭
        Connection connection = factory.newConnection();
        
        Channel channel = connection.createChannel();

        //绑定交换机
        channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.TOPIC);

        //获取队列
        String queueName = channel.queueDeclare().getQueue();

        //绑定队列和交换机，第一个节点
        channel.queueBind(queueName,EXCHANGE_NAME,"order.log.error");

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
        };

        //自动确认消息
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
    }
}

//消费者2
public class Recv2 {

    private final static String EXCHANGE_NAME = "exchange_topic";

    public static void main(String[] argv) throws Exception {
        
        ConnectionFactory factory = new ConnectionFactory();
        
        factory.setHost("10.211.55.13");
        factory.setUsername("admin");
        factory.setPassword("password");
        factory.setVirtualHost("/dev");
        factory.setPort(5672);

        //消费者一般不增加自动关闭
        Connection connection = factory.newConnection();
        
        Channel channel = connection.createChannel();

        //绑定交换机
        channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.TOPIC);

        //获取队列
        String queueName = channel.queueDeclare().getQueue();

        //绑定队列和交换机,第二个节点
        channel.queueBind(queueName,EXCHANGE_NAME,"*.log.*");

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
        };

        //自动确认消息
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
    }
}

七、SpringBoot2.X+SpringAMQP整合RabbitMQ实战【真实场景】

1、spring-boot-starter-amqp 依赖添加
<!--引入AMQP-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
2、yml配置文件修改
#消息队列
spring:
  rabbitmq:
    host: 10.211.55.13
    port: 5672
    virtual-host: /dev
    password: password
    username: admin
3、RabbitMQConfig文件
@Configuration
public class RabbitMQConfig {

    public static final String EXCHANGE_NAME = "order_exchange";
    
    public static final String QUEUE_NAME = "order_queue";
    
    /**
     * 交换机
     * @return
     */
    @Bean
    public Exchange orderExchange() {
        return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
        //return new TopicExchange(EXCHANGE_NAME, true, false);
    }

    /**
     * 队列
     * @return
     */
    @Bean
    public Queue orderQueue() {
        return QueueBuilder.durable(QUEUE_NAME).build();
        //return new Queue(QUEUE_NAME, true, false, false, null);
    }

    /**
     * 交换机和队列绑定关系
     */
    @Bean
    public Binding orderBinding(Queue queue, Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("order.#").noargs();
        //return new Binding(QUEUE_NAME, Binding.DestinationType.QUEUE, EXCHANGE_NAME, "order.#", null);
    }
}
4、消息生产者-测试类
@SpringBootTest
class DemoApplicationTests {

  @Autowired
  private RabbitTemplate template;

  @Test
  void send() {
    template.convertAndSend(RabbitMQConfig.EXCHANGE_NAME,"order.new","新订单来啦1");
  }
}
5、消息消费者
@Component
@RabbitListener(queues = "order_queue")
public class OrderMQListener {

    /**
     * RabbitHandler 会自动匹配 消息类型（消息自动确认）
     * @param msg
     * @param message
     * @throws IOException
     */
    @RabbitHandler
    public void releaseCouponRecord(String msg, Message message) throws IOException {

        long msgTag = message.getMessageProperties().getDeliveryTag();
        System.out.println("msgTag="+msgTag);
        System.out.println("message="+message.toString());
        System.out.println("监听到消息：消息内容:"+message.getBody());
    }
}
一条小帅帅0v0
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
WebSocket整合SpringBoot、SockJS、Stomp、Rabbitmq分布式消息推送
04-28
（1）HTML5 WebSocket、异常重连、心跳检测；（2）SockJS、Stomp、RabbitMQ Stomp消息代理；（3）分别用Nginx和Spring Cloud Gateway实现多实例负载均衡；（4）可靠消息推送（Stomp持久化队列、客户端ACK确认机制）；（5）Java原生、Stomp客户端实现（非浏览器客户端）；（6）Websocket拦截器结合 Spring security、jwt token认证授权；（7）Vue前端版本实现、Java客户端实现；（8）消防物联网平台消息推送案例，需求分析、设计思路、编码实现、效果演示。
RabbitMQstomp插件(基于WebSocket)
种一颗十年前的树
03-14 6964
WebSocket 是基于HTML5的协议 , 可以在浏览器和服务器之间建立一个全双工的通信(客户端可以主动请求服务端, 服务端可以主动推送消息给客户端) ; （1）Ajax 短轮询 Ajax 轮询主要通过页面端的 JS 定时异步刷新任务来实现数据的加载 如果我们使用ajax短轮询方式，需要后端提供方法，通过调用微信支付接口实现根据订单号查询支付状 态的方法（参见查询订单API） 。 前端每间隔三...
主流的消息队列MQ比较，详解MQ的4类应用场景，Java开发从零开始
最新发布
m0_60147147的博客
03-22 767
这样，等真的沉下心来学习，不至于被找资料分散了心神。另外，给大家安排了一波学习面试资料：以上就是本文的全部内容，希望对大家的面试有所帮助，祝大家早日升职加薪迎娶白富美走上人生巅峰！至于被找资料分散了心神。另外，给大家安排了一波学习面试资料：[外链图片转存中…(img-hbnuWutW-1711096727049)][外链图片转存中…(img-7uP38p9i-1711096727049)]以上就是本文的全部内容，希望对大家的面试有所帮助，祝大家早日升职加薪迎娶白富美走上人生巅峰！本文已被。
RabbitMQ开通STOMP通道
李虹柏的博客
08-18 2万+
进入到RabbitMQ安装目录下的sbin文件夹内 Shift加右键进入命令行 执行命令 rabbitmq-plugins enable rabbitmq_web_stomp rabbitmq-plugins enable rabbitmq_web_stomp_examples 成功后重启RabbitMQ &lt;!DOCTYPE HTML&gt; &lt;html...
RabbitMQ插件详解：rabbitmq_web_stomp【RabbitMQ 六】
todoitbo的博客
12-12 3092
本文着重介绍RabbitMQ中的rabbitmq_web_stomp插件，通过讲解STOMP协议和WebSocket的基础知识，深入挖掘这一插件的应用场景和使用方法。通过详细的示例和实际场景的演示，你将了解如何在分布式系统中通过Web STOMP实现高效、实时的消息传递。无论你是消息中间件的新手还是经验丰富的开发者，这篇博客都将为你揭示RabbitMQ Web STOMP的魅力。
副本技能-使用RabbitMQ做即时消息通讯，使用STOMP协议
汉风唐尚的博客
12-23 3137
1.消息通讯的基础环境 技术使用： 后端使用Spring Websocket通讯， 前端使用SocketJS，非长连接，有心跳检测 信息交互使用RabbitMQ的插件Stomp 给RabbitMQ安装Stomp的插件 安装前： 安装后： 安装步骤(我的RabbitMQ是使用的Docker) 1.进入Docker容器RabbitMQ的后台(docker exec -it 容器ID /bin/bash) 2.查看RabbitMQ的插件启用情况(rabbitmq-plugins list) 3.启用Ra
RabbitMQ实战教程资料.zip
06-27
RabbitMQ实战教程PDF，里面有RabbitMQ的安装、使用教程，里面的内容比较基础，适合新手小白学习，入门门槛低，主要涉及一些MQ的API的使用，免费分享给大家了
rabbitmq+PHP教程代码.rar
10-10
rabbitmq+PHP教程代码，学习rabbitMQ第一步，添加友好注释，方便学习，实际代码巩固所学知识
动力节点RabbitMQ教程配套文档分享
07-25
RabbitMQ是一个被广泛使用在生产中的消息中间件，可以应用在异步处理、系统解耦、流量削峰等...通过此课程，您可以学习到消息队列的基本原理，RabbitMQ的常用使用，保证消息的可靠性和幂等性，RabbitMQ集群的搭建等等。
RabbitMQTutorial:这是RabbitMQ的学习教程
05-21
这是RabbitMQ教程的python代码示例
spring boot集成rabbitmq的实例教程
08-28
主要给大家介绍了关于spring boot集成rabbitmq的相关资料，springboot集成RabbitMQ非常简单，文中通过示例代码介绍的非常详细，需要的朋友们可以参考借鉴，下面随着小编来一起学习学习吧。
Websocket Stomp+RabbitMQ实现消息推送
maomao的博客
07-26 2694
Websocket Stomp+RabbitMQ实现消息推送
JS（javascript）连接rabbitMq通过stomp实现消息实时推送
热门推荐
zoboy的博客
10-24 2万+
  消息的实时推送一般有3种方式： Ajax 短轮询 长轮询 WebSocket 双向通信      短轮询的实现是定时异步刷新任务来实现数据的加载，但这种方式实时效果较差，而且对服务端的压力也较大。长轮询的实现是通过 Ajax 机制，但区别于传统的 Ajax 应用，长轮询的服务器端会在没有数据时阻塞请求直到有新的数据产生或者请求超时才返回，之后客户端再重新建立连接获取数据。但长轮询服务端会...
【分布式WebSocket - 4】SpringBoot集成STOMP协议，RabbitMQ为消息代理
叁滴水 的博客
06-11 1653
spring基于内存为代理时，扩容不太方便，一旦服务宕机，内存的消息将全部丢失。因此需要有方便扩容的解决方案。支持STOMP协议的中间件还有`activemq`，但是rabbitmq相对来说更加强大，使用的人更多。
记录rabbitmq工作模式之工作队列模式（work queues）
乖摸摸头的博客
09-10 2300
1、应用场景：对于 任务过重或任务较多情况使用工作队列可以提高任务处理的速度。 2、实现过程 1）首先建立消息的发布者 public class producer01 { //队列名称 private static final String QUEUE = “helloworld”; public static void main(String[] args) { //通过连接工程创建新连接和mq连接 ConnectionFactory factory = new ConnectionFactory();
spring stomp+rabbitmq实现点对点消息推送
qq_41452805的博客
07-11 1534
当前的项目需要用到消息推送这个功能，领导拍板说用stomp+rabbitmq。但是我百度了一下，没找到特别好的博客，特此写篇博客。 先来说说stomp
【Docker】通过Docker部署RabbitMQ并加装Stomp Websocket服务
Kida 的技术小屋（CSDN 版）
02-18 828
1. 通过docker pull rabbitmq:3.7.8-management下载带管理后台的RabbitMQ服务端 2. 在宿主机建立RabbitMQ挂载文件夹 3. 采用命令行的方式启动RabbitMQ Windows docker run -p 15672:15672 \ -p 5672:5672 \ -p 25672:25672 \ -p 15674:15674 \ -p 61613:61613 \ -v D:\software\Docker\data\rabbitmq:/var/lib
RabbitMQ开通STOMP通道，为websocket整合rabbitmq做准备
小哇
03-28 799
进入到RabbitMQ安装目录下的sbin文件夹内 cmd进入 rabbitmq-plugins enable rabbitmq_web_stomp rabbitmq-plugins enable rabbitmq_web_stomp_examples 成功后重启RabbitMQ即可
RabbitMQ消息中间件快速入门
欢迎来到编程小栈
07-19 2148
文章目录一、同步和异步通讯1. 同步通讯2. 异步通讯二、RabbitMQ1. MessageQueue对比2. RabbitMQ快速入门【1】安装与启动【2】基本结构3. 五种消息模型介绍【1】入门案例1）publisher实现2）consumer实现4. SpringAMQP实现【1】Basic Queue 基本消息队列1）消息发送2）消息接收3）测试【2】WorkQueue工作消息队列1）消息发送2）消息接收3）测试4）prefetch提前获取【3】发布订阅三种模式1）Fanout[1] 声明队列和交
rabbitmq中文教程
09-14
RabbitMQ 是一个开源的消息队列系统，它可以用于在应用程序之间传递消息。下面是一个简单的 RabbitMQ 中文教程： 1. 安装 RabbitMQ：你可以从 RabbitMQ 的官方网站下载适合你操作系统的安装包，并按照官方文档的说明进行安装。 2. 启动 RabbitMQ 服务器：安装完成后，你可以启动 RabbitMQ 服务器。在大多数情况下，它会自动启动并运行在默认端口上（5672）。 3. 创建连接：使用你的编程语言（如 Python、Java、JavaScript等）连接到 RabbitMQ 服务器。你需要提供服务器的地址、端口、用户名和密码等信息来建立连接。 4. 创建队列：使用 RabbitMQ 的管理界面或编程语言的客户端库来创建一个队列。队列用于存储消息，应用程序可以通过队列收发消息。 5. 发布消息：使用编程语言的客户端库将消息发布到队列中。你可以指定消息的内容和其他属性。 6. 消费消息：使用编程语言的客户端库从队列中消费消息。你可以注册一个消费者来处理从队列中获取到的消息。 7. 确认消息：在消费消息后，你可以发送确认给 RabbitMQ，表示消息已被处理。RabbitMQ 将从队列中删除已确认的消息。 8. 关闭连接：当你完成所有操作后，记得关闭与 RabbitMQ 的连接。 这只是一个简单的 RabbitMQ 中文教程，你可以根据需要深入学习 RabbitMQ 的更多特性和用法。文档和官方网站上有更详细的教程和示例代码可供参考。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值