RabbitMQ的使用以及整合到SpringBoot中

已于 2023-03-04 23:52:53 修改
阅读量298 收藏
点赞数 1
分类专栏： 中间件 文章标签： java-rabbitmq rabbitmq spring boot
于 2023-03-04 23:52:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45525848/article/details/129341175
版权
本文详细介绍了RabbitMQ的基本使用，包括如何在SpringBoot中集成RabbitMQ实现简单模式、工作模式、订阅模式和路由模式。通过这些模式展示了消息队列如何处理高并发和海量数据，以及如何进行异步解耦和削峰填谷。文中还给出了详细的代码示例，涵盖了生产者和消费者的创建以及不同模式下的消息发送与接收。
摘要由CSDN通过智能技术生成

RabbitMQ的使用以及整合到SpringBoot中

一、比较：

(1)、传统请求服务器：

在这里插入图片描述

(2)、通过MQ去操作数据库：

在这里插入图片描述

通过MQ去操作数据库，从而达到削峰的效果；

问题现象：

(1)、海量数据；
(2)、高并发；
解决方法:
  其中最为代表的解决方法：流量削峰-----》使用MQ

二、常见的中间件：

前端：nginx
后端数据库：Mycat
消息中间件：RocketMQ  Kafka-----》Kafka应用在大数据领域容易掉消息

三、MQ应用场景：

(1)、异步解耦：
		同步：比如用洗衣机洗衣服的时候，洗衣机洗完衣服了，你才能干别的事。没有洗完，你不能干别的事；
		异步就是洗衣机洗衣服的时候同时我们该干嘛干嘛；
(2)、削峰填谷。

(3)、消息分发。

四、RabbitMQ 的组成：

在这里插入图片描述

过程：

在这里插入图片描述

五、基础使用：

开发中使用：

只需要：
(1)创建生产者----->生产消息
(2)创建消费者---------》消费消息
就可以了

平常使用步骤：

（1）对于生产者：
       //1.创建一个连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置RabbimtMQ 的IP地址
        connectionFactory.setHost("localhost");
        //3.通过连接工厂创建连接对象
        Connection connection = connectionFactory.newConnection();
        //4.通过连接对象创建连接通道
        Channel channel = connection.createChannel();
        //5.创建并设置队列属性
        channel.queueDeclare("QUEUE_HELLOWORD", false, false, false, null);、
           /**
           queueDeclare中参数：
               (1)第一个参数：队列名称；
               (2)第二个参数：队列是否要持久化，避免重启丢失消息，持久化：即保存到磁盘；
               (3)第三个参数：是否排他性：设置成true时只能在同一个连接对象即当前连接对象中操作，
                            在其他连接对象拿不到对象，一般设置成falsh；
               (4)第四个参数：是否自动删除消息，当指定为true时，没有消费者链接的时候，会把我们的队列删除掉；
               (5)第五个参数：是否要设置一些额外设置，比如 死信队列；               
           */
            
            
        //6.创建消息
        String xiaoxi="这是生成这消息111111";
        //7.发送消息
        channel.basicPublish("","QUEUE_HELLOWORD",null,xiaoxi.getBytes());
			/**
			basicPublish中参数：
			   (1)第一个参数：交换机名称；
               (2)第二个参数：路由 key----》订阅广播模式没有；
               (3)第三个参数：消息属性；
               (4)第四个参数：消息的内容：---》是Byte数组格式传输，其他类型转换为JSON，再转成字符串，再转换Byte数组；   
			*/
        //8.关闭资源
           //1.关闭通道
           channel.close();
           //2.关闭连接对象
        connection.close();
（2）对于消费者：
        //1.创建一个连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置RabbimtMQ 的IP地址
        connectionFactory.setHost("localhost");
        //3.通过连接工厂创建连接对象
        Connection connection = connectionFactory.newConnection();
        //4.通过连接对象创建连接通道
        Channel channel = connection.createChannel();
        //5.创建并设置队列属性
        channel.queueDeclare("QUEUE_HELLOWORD", true, false, false, null);、
           /**
           queueDeclare中参数：
               (1)第一个参数：队列名称；
               (2)第二个参数：队列是否要持久化，避免重启丢失消息，持久化：即保存到磁盘；
               (3)第三个参数：是否排他性：设置成true时只能在同一个连接对象即当前连接对象中操作，
                            在其他连接对象拿不到对象，一般设置成falsh；
               (4)第四个参数：是否自动删除消息，当指定为true时，没有消费者链接的时候，会把我们的队列删除掉；
               (5)第五个参数：是否要设置一些额外设置，比如 死信队列；               
           */
            
         //6.监听消息，消费消息
        channel.basicConsume("QUEUE_HELLOWORD", true, new DeliverCallback() {
            
            @Override
            public void handle(String s, Delivery delivery) throws IOException {
                System.out.printf("接收到消息："+new String(delivery.getBody()));
                //手动签收
                channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
            }
        }, new CancelCallback() {
            @Override
            public void handle(String s) throws IOException {
                System.out.println("11111");
            }
        });


		/**
		basicConsume中参数：
			 (1)第一个参数：队列名称与生产者保持一致；
             (2)第二个参数：是否自动签收 ：true自动；
             (3)第三个参数：是两个匿名函数，第一个：当消息从mq中取出来之后会回调这个DeliverCallback函数
                         中handle方法，消费者就在方法中参数delivery中拿到消息信息进行处理；
                         
                         第二个：当消息从mq消息取消了会回调这个 CancelCallback函数中handle方法。；
		
		
		当第二个参数设置成falsh时：
		      不再自动签收，可设置为手动签收，当消息业务执行成功后再手动签收。
		     channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
		*/

六、MQ常见工作模式：

(1)、简单模式:

在这里插入图片描述

生产者：
package cn.js.hello;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @BelongsProject: RabbitMQ
 * @Author: com.js
 * @CreateTime: 2023-03-03  20:49
 * @Version: 1.0
 * @introduce：
 */

public class PermissTest01 {
    public static void main(String[] args) throws Exception{
        //1.创建一个连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置RabbimtMQ 的IP地址
        connectionFactory.setHost("localhost");
        //3.通过连接工厂创建连接对象
        Connection connection = connectionFactory.newConnection();
        //4.通过连接对象创建连接通道
        Channel channel = connection.createChannel();
        //5.设置队列属性
        channel.queueDeclare("QUEUE_HELLOWORD", false, false, false, null);
        //6.创建消息
        String xiaoxi="这是生成这消息111111";
        //7.发送消息
        channel.basicPublish("","QUEUE_HELLOWORD",null,xiaoxi.getBytes());
        //8.关闭资源
           //1.关闭通道
           channel.close();
           //2.关闭连接对象
        connection.close();
        System.out.println("消息发送完毕");

    }


}
消费者:
package cn.js.hello;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @BelongsProject: RabbitMQ
 * @Author: com.js
 * @CreateTime: 2023-03-03  21:37
 * @Version: 1.0
 * @introduce：
 */

public class consum {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建一个连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置RabbimtMQ 的IP地址
        connectionFactory.setHost("localhost");
        //3.通过连接工厂创建连接对象
        Connection connection = connectionFactory.newConnection();
        //4.通过连接对象创建连接通道
        Channel channel = connection.createChannel();
        //5.设置队列属性
        channel.queueDeclare("QUEUE_HELLOWORD", false, false, false, null);
        //监听消息，消费消息
        channel.basicConsume("QUEUE_HELLOWORD", true, new DeliverCallback() {
            @Override
            public void handle(String s, Delivery delivery) throws IOException {
                System.out.printf("接收到消息："+new String(delivery.getBody()));
            }
        }, new CancelCallback() {
            @Override
            public void handle(String s) throws IOException {
                System.out.println("11111");
            }
        });

    }
}

(2)、工作模式（work）

在这里插入图片描述

生产者：
package cn.js.work;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

/**
 * @BelongsProject: RabbitMQ
 * @Author: com.js
 * @CreateTime: 2023-03-03  20:49
 * @Version: 1.0
 * @introduce：
 */

public class WorkTest01 {
    public static void main(String[] args) throws Exception{
        //1.创建一个连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置RabbimtMQ 的IP地址
        connectionFactory.setHost("localhost");
        //3.通过连接工厂创建连接对象
        Connection connection = connectionFactory.newConnection();
        //4.通过连接对象创建连接通道
        Channel channel = connection.createChannel();
        //5.设置队列属性
        channel.queueDeclare("QUEUE_Work", true, false, false, null);

        for(int i=0 ;i<20 ;i++){
            //6.创建消息
            String xiaoxi="这是生产者生成的消息"+" "+i;
            //7.发送消息
            channel.basicPublish("","QUEUE_Work",null,xiaoxi.getBytes());

        }
        //8.关闭资源
           //1.关闭通道
           channel.close();
           //2.关闭连接对象
        connection.close();
        System.out.println("消息发送完毕");

    }


}
消费者1：
package cn.js.work;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @BelongsProject: RabbitMQ
 * @Author: com.js
 * @CreateTime: 2023-03-03  21:37
 * @Version: 1.0
 * @introduce：
 */

public class consum1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建一个连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置RabbimtMQ 的IP地址
        connectionFactory.setHost("localhost");
        //3.通过连接工厂创建连接对象
        Connection connection = connectionFactory.newConnection();
        //4.通过连接对象创建连接通道
        Channel channel = connection.createChannel();
        //轮巡 一次一个
        channel.basicQos(1);
        //5.设置队列属性
        channel.queueDeclare("QUEUE_Work", true, false, false, null);

        try {
            Thread.sleep(2000);

            //监听消息，消费消息  改为不是自动签收
            channel.basicConsume("QUEUE_Work", false, new DeliverCallback() {
                @Override
                public void handle(String s, Delivery delivery) throws IOException {
                    System.out.println("消费者1：接收到消息："+new String(delivery.getBody()));
                    //同时设置手动签收
                    channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);

                }
            }, new CancelCallback() {
                @Override
                public void handle(String s) throws IOException {
                    System.out.println("11111");
                }
            });

        } catch (InterruptedException e) {
            e.printStackTrace();

        }


    }
}
消费者2：
package cn.js.work;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @BelongsProject: RabbitMQ
 * @Author: com.js
 * @CreateTime: 2023-03-03  21:37
 * @Version: 1.0
 * @introduce：
 */

public class consum2 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建一个连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置RabbimtMQ 的IP地址
        connectionFactory.setHost("localhost");
        //3.通过连接工厂创建连接对象
        Connection connection = connectionFactory.newConnection();
        //4.通过连接对象创建连接通道
        Channel channel = connection.createChannel();
        //轮巡 一次一个
        channel.basicQos(1);
        //5.设置队列属性
        channel.queueDeclare("QUEUE_Work", true, false, false, null);

        try {
            Thread.sleep(1000);

            //监听消息，消费消息
            channel.basicConsume("QUEUE_Work", true, new DeliverCallback() {
                @Override
                public void handle(String s, Delivery delivery) throws IOException {
                    System.out.println("消费者1：接收到消息："+new String(delivery.getBody()));


                }
            }, new CancelCallback() {
                @Override
                public void handle(String s) throws IOException {
                    System.out.println("11111");
                }
            });

        } catch (InterruptedException e) {
            e.printStackTrace();

        }


    }
}

(3)、订阅模式：

在这里插入图片描述

交换机类型：
(1).广播---》fanout
(2).定向-----》Direct
(3).通配符-----》Topic
步骤：
订阅模式与其他模式的区别？
生产者:
在第五步的时候：
    创建交换机：
     channel.exchangeDeclare("03-pubsub1","fanout");
	/**
	exchangeDeclare参数：
	    1.交换机名称
	    2.交换机类型
	*/
在发送消息的时候：
    给交换机指定名称；

消费者：
  前五步与上述生产者的前五步一样，
         第六步，创建队列。
                //1.创建队列
               String queue = channel.queueDeclare().getQueue();

        第七步，绑定队列与交换机。
              channel.queueBind(queue,"03-pubsub1","");

             queueBind参数：
               1.队列名称。
               2.交换机名称。
               3.路由 KEY 和生产者发消息的第二个参数相同。

 或者：
 //第六步，创建队列并设置属性。
  channel.queueDeclare("队列名称",true,false,false,null);
 //第七步，绑定队列与交换机。
 channel.queueBind("队列名称","03-pubsub1","");

两者都是为了创建队列并获取队列名称
生产者：
package cn.js.pubsub3;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.MessageProperties;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @BelongsProject: RabbitMQ
 * @Author: com.js
 * @CreateTime: 2023-03-04  13:38
 * @Version: 1.0
 * @introduce：
 */

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

        //1.创建一个连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置RabbimtMQ 的IP地址
        connectionFactory.setHost("localhost");
        //3.通过连接工厂创建连接对象
        Connection connection = connectionFactory.newConnection();
        //4.通过连接对象创建连接通道
        Channel channel = connection.createChannel();
        //5.创建设置交换机
        channel.exchangeDeclare("03-pubsub1","fanout");
            //6.创建消息
            String xiaoxi="这是生产者生成的消息";
            //7.发送消息
            channel.basicPublish("03-pubsub1","", MessageProperties.PERSISTENT_TEXT_PLAIN,xiaoxi.getBytes());


        //8.关闭资源
        //1.关闭通道
        channel.close();
        //2.关闭连接对象
        connection.close();
        System.out.println("消息发送完毕");

    }

    }
消费者1：
package cn.js.pubsub3;

import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @BelongsProject: RabbitMQ
 * @Author: com.js
 * @CreateTime: 2023-03-03  21:37
 * @Version: 1.0
 * @introduce：
 */

public class consum1 {
    public static void main(String[] args) throws Exception {
        //1 创建一个连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2 设置 rabbititmq ip 地址
        connectionFactory.setHost("localhost");
        //3 创建 Conection 对象
        Connection connection = connectionFactory.newConnection();
        //4 创建 Chanel
        Channel channel = connection.createChannel();
        //5 创建交换机设置交换机属性
        channel.exchangeDeclare("03-pubsub1","fanout");
        //6.创建队列设置队列属性
        String queue = channel.queueDeclare().getQueue();
        //7.绑定队列与交换机
        channel.queueBind(queue,"03-pubsub1","");
        //8.使用 chanel 去 rabbitmq 中去取消息进行消费
        /**
         * 第一个参数：队列名称
         * 第二个参数：是否自动签收
         */
        channel.basicConsume(queue, true, new DeliverCallback() {
            /**
             * 当消息从 mq 中取出来了会回调这个方法
             * 消费者消费消息就在这个 handle中去进行处理
             */
            public void handle(String consumerTag, Delivery message) throws IOException {
                System.out.println("消费者 1 消息内容为：" + new String(message.getBody()));
            }
        }, new CancelCallback() {
            /**
             * 当消息取消了会回调这个方法
             * @param consumerTag
             * @throws IOException
             */
            public void handle(String consumerTag) throws IOException {
                System.out.println("1111");
            }
        });
    }
}
消费者2：
package cn.js.pubsub3;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @BelongsProject: RabbitMQ
 * @Author: com.js
 * @CreateTime: 2023-03-03  21:37
 * @Version: 1.0
 * @introduce：
 */

public class consum2 {
    public static void main(String[] args) throws Exception {
        //1.创建一个连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();

        //设置RabbimtMQ 的IP地址
        connectionFactory.setHost("localhost");
        //3.通过连接工厂创建连接对象
        Connection connection = connectionFactory.newConnection();
        //4.通过连接对象创建连接通道
        Channel channel = connection.createChannel();
        //5.设置交换机
        channel.exchangeDeclare("03-pubsub1","fanout");
        String queue = channel.queueDeclare().getQueue();
        //6.绑定交换机与队列
        channel.queueBind(channel.queueDeclare().getQueue(), "QUEUE_propub", "");
        channel.queueBind(queue,"03-pubsub1","");            //7.监听消息，消费消息  改为不是自动签收
        channel.basicConsume(queue, true, new DeliverCallback() {
            @Override
            public void handle(String s, Delivery delivery) throws IOException {
                System.out.println("消费者2：接收到消息：" + new String(delivery.getBody()));

            }
        }, new CancelCallback() {
            @Override
            public void handle(String s) throws IOException {
                System.out.println("11111");
            }
        });



    }
}

（4)、路由模式：

在这里插入图片描述

注意：
队列和交换机的绑定已经是不能任意绑定了。而是指定一个路由key只有队列的key和消息的key一致才会接收到消息
交换机类型设置为Direct
步骤和订阅模式相同。：
1.只是在生产者发送消息时指定一个key。
2.消费者绑定队列的时候也配置一个key,两者一样。
3.当两者相同时，消费者才能拿到消息进行消费。
生产者：
package cn.js.Routing;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @BelongsProject: RabbitMQ
 * @Author: com.js
 * @CreateTime: 2023-03-04  20:12
 * @Version: 1.0
 * @introduce：
 */

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

        //1.创建一个连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置RabbimtMQ 的IP地址
        connectionFactory.setHost("localhost");
        //3.通过连接工厂创建连接对象
        Connection connection = connectionFactory.newConnection();
        //4.通过连接对象创建连接通道
        Channel channel = connection.createChannel();
        //5.设置交换机
        channel.exchangeDeclare("04-Routing", BuiltinExchangeType.DIRECT);
        //6.创建消息
        String xiaoxi="这是Routing生产者生成的消息";
        //7.发送消息
        channel.basicPublish("04-Routing","info",null,xiaoxi.getBytes());


        //8.关闭资源
        //1.关闭通道
        channel.close();
        //2.关闭连接对象
        connection.close();
        System.out.println("消息发送完毕");


    }
}
消费者1：
package cn.js.Routing;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @BelongsProject: RabbitMQ
 * @Author: com.js
 * @CreateTime: 2023-03-04  20:15
 * @Version: 1.0
 * @introduce：
 */

public class Routingconsum01 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1 创建一个连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2 设置 rabbititmq ip 地址
        connectionFactory.setHost("localhost");
        //3 创建 Conection 对象
        Connection connection = connectionFactory.newConnection();
        //4 创建 Chanel
        Channel channel = connection.createChannel();
        //5 创建交换机

        channel.exchangeDeclare("04-Routing",BuiltinExchangeType.DIRECT);
        //6.创建队列设置队列属性
        String queue = channel.queueDeclare().getQueue();
        //7.绑定队列与交换机
        channel.queueBind(queue, "04-Routing", "info");
        channel.queueBind(queue, "04-Routing", "error");
        channel.queueBind(queue, "04-Routing", "warning");
        //8使用 chanel 去 rabbitmq 中去取消息进行消费
        /**
         * 第一个参数：队列名称
         * 第二个参数：是否自动签收
         */
        channel.basicConsume(queue, true, new DeliverCallback() {
            /**
             * 当消息从 mq 中取出来了会回调这个方法
             * 消费者消费消息就在这个 handle中去进行处理
             */
            public void handle(String consumerTag, Delivery message) throws IOException {
                System.out.println("消费者 1 消息内容为：" + new String(message.getBody()));
            }
        }, new CancelCallback() {
            /**
             * 当消息取消了会回调这个方法
             * @param consumerTag
             * @throws IOException
             */
            public void handle(String consumerTag) throws IOException {
                System.out.println("1111");
            }
        });
    }


}
消费者2：
package cn.js.Routing;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @BelongsProject: RabbitMQ
 * @Author: com.js
 * @CreateTime: 2023-03-04  20:15
 * @Version: 1.0
 * @introduce：
 */

public class Routingconsum02 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1 创建一个连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2 设置 rabbititmq ip 地址
        connectionFactory.setHost("localhost");
        //3 创建 Conection 对象
        Connection connection = connectionFactory.newConnection();
        //4 创建 Chanel
        Channel channel = connection.createChannel();
        //5 创建交换机

        channel.exchangeDeclare("04-Routing",BuiltinExchangeType.DIRECT);
        //6.创建队列设置队列属性
        String queue = channel.queueDeclare().getQueue();
        //7.绑定队列与交换机

        channel.queueBind(queue, "04-Routing", "error");
        channel.queueBind(queue, "04-Routing", "warning");
        //8.使用 chanel 去 rabbitmq 中去取消息进行消费
        /**
         * 第一个参数：队列名称
         * 第二个参数：是否自动签收
         */
        channel.basicConsume(queue, true, new DeliverCallback() {
            /**
             * 当消息从 mq 中取出来了会回调这个方法
             * 消费者消费消息就在这个 handle中去进行处理
             */
            public void handle(String consumerTag, Delivery message) throws IOException {
                System.out.println("消费者 2 消息内容为：" + new String(message.getBody()));
            }
        }, new CancelCallback() {
            /**
             * 当消息取消了会回调这个方法
             * @param consumerTag
             * @throws IOException
             */
            public void handle(String consumerTag) throws IOException {
                System.out.println("1111");
            }
        });

    }

}

（4)、通配符模式：

步骤：
1、生产者和路由模式生产者相同，定义一个路由key 交换机类型设置为TOPic 如 emp.save
2、在消费者上绑定队列时，可以使用通配符 如 emp.*
生产者：
package cn.js.Topic;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @BelongsProject: RabbitMQ
 * @Author: com.js
 * @CreateTime: 2023-03-04  20:42
 * @Version: 1.0
 * @introduce：
 */

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

        //1.创建一个连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置RabbimtMQ 的IP地址
        connectionFactory.setHost("localhost");
        //3.通过连接工厂创建连接对象
        Connection connection = connectionFactory.newConnection();
        //4.通过连接对象创建连接通道
        Channel channel = connection.createChannel();
        //5.设置交换机
        channel.exchangeDeclare("05-Topic", BuiltinExchangeType.TOPIC);
        //6.创建消息
        String xiaoxi1="这是Routing生产者生成的消息order1.save";
        String xiaoxi2="这是Routing生产者生成的消息order1.delete";
        String xiaoxi3="这是Routing生产者生成的消息order1.insert";
        //7.发送消息
        channel.basicPublish("05-Topic","order1.save",null,xiaoxi1.getBytes());
        channel.basicPublish("05-Topic","order1.delete",null,xiaoxi2.getBytes());
        channel.basicPublish("05-Topic","order1.insert",null,xiaoxi3.getBytes());

        //8.关闭资源
        //1.关闭通道
        channel.close();
        //2.关闭连接对象
        connection.close();
        System.out.println("消息发送完毕");
    }

}
消费者：
package cn.js.Topic;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @BelongsProject: RabbitMQ
 * @Author: com.js
 * @CreateTime: 2023-03-04  20:45
 * @Version: 1.0
 * @introduce：
 */

public class Topicconsum01 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1 创建一个连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2 设置 rabbititmq ip 地址
        connectionFactory.setHost("localhost");
        //3 创建 Conection 对象
        Connection connection = connectionFactory.newConnection();
        //4 创建 Chanel
        Channel channel = connection.createChannel();
        //5 创建交换机

        channel.exchangeDeclare("05-Topic",BuiltinExchangeType.TOPIC);
        //6.创建队列设置队列属性
        String queue = channel.queueDeclare().getQueue();
        //7.绑定队列与交换机
        channel.queueBind(queue, "05-Topic", "order1.*");

        //8使用 chanel 去 rabbitmq 中去取消息进行消费
        /**
         * 第一个参数：队列名称
         * 第二个参数：是否自动签收
         */
        channel.basicConsume(queue, true, new DeliverCallback() {
            /**
             * 当消息从 mq 中取出来了会回调这个方法
             * 消费者消费消息就在这个 handle中去进行处理
             */
            public void handle(String consumerTag, Delivery message) throws IOException {
                System.out.println("消费者 1 消息内容为：" + new String(message.getBody()));
            }
        }, new CancelCallback() {
            /**
             * 当消息取消了会回调这个方法
             * @param consumerTag
             * @throws IOException
             */
            public void handle(String consumerTag) throws IOException {
                System.out.println("1111");
            }
        });
    }


}

七、SpringBoot整合MQ

1、步骤(简单模式)：

1.导入依赖，配置yml文件
2.生产者：
    SpringBoot已经将MQ封装好了：
       直接使用：
       @Autowired
       private RabbitTemPlate rabbitTemPlate;
       
       发送消息：
        rabbitTemPlate.convertAndsend();
      convertAndsend中参数：
      1.交换机名称
      2.队列名称
      3.消息内容
      
      
3.消费者：
  定义一个消费者类，多个消费者就定义多个消费者类
  
 @Component
public class QueueListener {

    @RabbitListener(queuesToDeclare = @Queue("boot_queue"))
    public void receiveMsg(String msg, @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag, Channel channel){
        System.out.println("收到消息:"+msg);
    }
}
生产者：
package cn.js.controller;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @BelongsProject: SpringBootMQ
 * @Author: com.js
 * @CreateTime: 2023-03-04  21:16
 * @Version: 1.0
 * @introduce：
 */
@RestController
@RequestMapping("/get")
public class producerController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/hello/{msg}")
    public String HelloTest(@PathVariable("msg") String msg){
        System.out.println(msg);
       rabbitTemplate.convertAndSend("","hello",msg);

        return "发送成功";
    }

}
消费者：
package cn.js.compert;

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

/**
 * @BelongsProject: SpringBootMQ
 * @Author: com.js
 * @CreateTime: 2023-03-04  22:01
 * @Version: 1.0
 * @introduce：
 */

@Component
public class Consumer {
    @RabbitListener(queuesToDeclare = @Queue("hello"))
    public void consum(String msg){
        System.out.println("消费者收到消息："+msg);
    }

}

2、集成工作模式：

步骤：
1.生产者和简单模式一样不用东动
2.消费者中配置yml文件：
    （1）.签收模式 （手动签收）
    （2）.轮巡分配
    
    spring.rabbitmq.listener.simple.acknowledge-mode=manual
    spring.rabbitmq.listener.simple.prefetch=1
    
3.在消费者类中方法上面的参数中添加
@Component
public class Worker {
    @RabbitListener(queuesToDeclare = @Queue("boot_worker"))
      public void receiveMsg(String msg, @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag, Channel channel) throws IOException {
        System.out.println("工作者1:"+msg);
        channel.basicAck(deliveryTag,false);
    }

}
生产者：
package cn.js.controller;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @BelongsProject: SpringBootMQ
 * @Author: com.js
 * @CreateTime: 2023-03-04  21:16
 * @Version: 1.0
 * @introduce：
 */
@RestController
@RequestMapping("/get")
public class producerController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

  

    @GetMapping("/work/{msg}")
    public String workTest(@PathVariable("msg") String msg){
        System.out.println(msg);
        for(int i= 0;i<20;i++){
            rabbitTemplate.convertAndSend("","boot_worker","msg:"+i);
        }

        return "发送成功";
    }
}
消费者1
package cn.js.compert.work;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * @BelongsProject: SpringBootMQ
 * @Author: com.js
 * @CreateTime: 2023-03-04  22:23
 * @Version: 1.0
 * @introduce：
 */
@Component
public class workconsum1 {

    @RabbitListener(queuesToDeclare = @Queue("boot_worker"))
    public void receiveMsg(String msg, @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag, Channel channel) throws IOException {
        System.out.println("工作者1:"+msg);
        channel.basicAck(deliveryTag,false);
    }
}
消费者2:
package cn.js.compert.work;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * @BelongsProject: SpringBootMQ
 * @Author: com.js
 * @CreateTime: 2023-03-04  22:23
 * @Version: 1.0
 * @introduce：
 */
@Component
public class workconsum {
    @RabbitListener(queuesToDeclare = @Queue("boot_worker"))
    public void receiveMsg(String msg, @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag, Channel channel) throws IOException {
        System.out.println("工作者2:"+msg);
        channel.basicAck(deliveryTag,false);
    }
}

3、集成订阅模式：

步骤：
1.生产者：
   指定交换机：定义交换机名称
   注意此模式生产者没有队列
2.消费者：
  在消费者方法上：                            //value:队列名称
  @RabbitListener(bindings = @QueueBinding(value = @Queue,exchange = @Exchange(name = "boot_pubsub",type = "fanout")))
  加上：exchange = @Exchange(name = "boot_pubsub",type = "fanout")//绑定定交换机，以及交换机类型 广播模式
生产者：
package cn.js.controller;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @BelongsProject: SpringBootMQ
 * @Author: com.js
 * @CreateTime: 2023-03-04  21:16
 * @Version: 1.0
 * @introduce：
 */
@RestController
@RequestMapping("/get")
public class producerController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/PubSub/{msg}")
    public String PubSub(@PathVariable("msg") String msg){
        System.out.println(msg);

            rabbitTemplate.convertAndSend("PubSub","",msg);


        return "发送成功";
    }
}
消费者1：
package cn.js.compert.PubSub;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

/**
 * @BelongsProject: SpringBootMQ
 * @Author: com.js
 * @CreateTime: 2023-03-04  22:38
 * @Version: 1.0
 * @introduce：
 */
@Component
public class PubSubconsum1 {
    @RabbitListener(bindings =
    @QueueBinding(value = @Queue,exchange = @Exchange(name = "PubSub",type = "fanout")))

    public void receiveMsg(String msg, @Header(AmqpHeaders.DELIVERY_TAG)long deliveryTag, Channel channel) throws Exception {
        System.out.println("收到消息1:"+msg);
        channel.basicAck(deliveryTag,false);
    }
}
消费者2：
package cn.js.compert.PubSub;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

/**
 * @BelongsProject: SpringBootMQ
 * @Author: com.js
 * @CreateTime: 2023-03-04  22:38
 * @Version: 1.0
 * @introduce：
 */
@Component
public class PubSubconsum2 {
    @RabbitListener(bindings =
            @QueueBinding(value = @Queue,exchange = @Exchange(name = "PubSub",type = "fanout")))

    public void receiveMsg(String msg, @Header(AmqpHeaders.DELIVERY_TAG)long deliveryTag, Channel channel) throws Exception {
        System.out.println("收到消息2:"+msg);
        channel.basicAck(deliveryTag,false);
    }
}

4、集成路由模式

步骤：
1.生产者：
   1.生产者指定路由Key
   2.此模式生产者没有队列，交换机类型设置为Direct

2.消费者：
    在消费者方法的注解上指定路由Key要与生产者路由Key相同，也可以配置多个路由key
    
 @RabbitListener(bindings = @QueueBinding(value = @Queue(name = "boot_rounting_queue01"),

            exchange = @Exchange(name = "boot_rounting_exchange",type = "direct"),

            key = {"error","info"}//-------》配置多个路由key
    ))
生产者：
package cn.js.controller;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @BelongsProject: SpringBootMQ
 * @Author: com.js
 * @CreateTime: 2023-03-04  21:16
 * @Version: 1.0
 * @introduce：
 */
@RestController
@RequestMapping("/get")
public class producerController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/Routing/{msg}/{key}")
    public String Routing(@PathVariable("msg") String msg,@PathVariable("key") String key){
        System.out.println(msg);
        System.out.println(key);
        rabbitTemplate.convertAndSend("Routing",key,msg);


        return "发送成功";
    }
}
消费者1：
package cn.js.compert.Routing;


import com.rabbitmq.client.Channel;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * @BelongsProject: SpringBootMQ
 * @Author: com.js
 * @CreateTime: 2023-03-04  22:56
 * @Version: 1.0
 * @introduce：
 */
@Component
public class Routingconsum1 {
    @RabbitListener(bindings =
    @QueueBinding(
            value = @Queue,
            exchange =@Exchange(value = "Routing",type = "direct"),
            key = {"info","error"}))

    public void consumer(String msg, @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag, Channel channel) throws IOException {

        System.out.println("消费者 1-消息内容为：" + msg);
        channel.basicAck(deliveryTag,true);
    }
}
消费者2：
package cn.js.compert.Routing;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * @BelongsProject: SpringBootMQ
 * @Author: com.js
 * @CreateTime: 2023-03-04  22:56
 * @Version: 1.0
 * @introduce：
 */
@Component
public class Routingconsum2 {

    @RabbitListener(bindings =
    @QueueBinding(
            value = @Queue,
            exchange =@Exchange(value = "Routing",type = "direct"),
            key = {"info","error"}))

    public void consumer(String msg, @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag, Channel channel) throws IOException {

        System.out.println("消费者 2-消息内容为：" + msg);
        channel.basicAck(deliveryTag,true);
    }
}

5、集成通配符模式

步骤：
1.和路由模式一样，只是在消费者中绑定路由key，是以通配符的方式绑定；
2.交换机类型设置为Topic
生产者：
package cn.js.controller;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @BelongsProject: SpringBootMQ
 * @Author: com.js
 * @CreateTime: 2023-03-04  21:16
 * @Version: 1.0
 * @introduce：
 */
@RestController
@RequestMapping("/get")
public class producerController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/Topic/{msg}/{key}")
    public String Topic(@PathVariable("msg") String msg,@PathVariable("key") String key){
        System.out.println(msg);
        System.out.println(key);
        rabbitTemplate.convertAndSend("Topic",key,msg);


        return "发送成功";
    }
}
消费者1：
package cn.js.compert.Topic;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * @BelongsProject: SpringBootMQ
 * @Author: com.js
 * @CreateTime: 2023-03-04  22:23
 * @Version: 1.0
 * @introduce：
 */
@Component
public class Topicconsum1 {
    @RabbitListener(bindings =
    @QueueBinding(
            value = @Queue,
            exchange =@Exchange(value = "Topic",type = "topic"),
            key = {"emp.save"}))

    public void receiveMsg(String msg, @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag, Channel channel) throws IOException {
        System.out.println("Topic工作者2:"+msg);
        channel.basicAck(deliveryTag,false);
    }
}
消费者2：
package cn.js.compert.Topic;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * @BelongsProject: SpringBootMQ
 * @Author: com.js
 * @CreateTime: 2023-03-04  22:23
 * @Version: 1.0
 * @introduce：
 */
@Component
public class Topicconsum2 {
    @RabbitListener(bindings =
    @QueueBinding(
            value = @Queue,
            exchange =@Exchange(value = "Topic",type ="topic"),
            key = {"emp.save"}))

    public void receiveMsg(String msg, @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag, Channel channel) throws IOException {
        System.out.println("Topic工作者2:"+msg);
        channel.basicAck(deliveryTag,false);
    }
}

代码地址：

整合代码

北执南念
关注
专栏目录
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
SpringBoot基于RabbitMQ实现死信队列 (SpringBoot整合RabbitMQ实战篇)
莫等闲 白了少年头 空悲切
04-24 2027
消息超时的两种方式是？给队列设置ttl属性，进入队列后超过ttl时间的消息变为死信给消息设置ttl属性，队列接收到消息超过ttl时间后变为死信如何实现发送一个消息20秒后消费者才收到消息？给消息的目标队列指定死信交换机将消费者监听的队列绑定到死信交换机发送消息时给消息设置超时时间为20秒每一项技术深挖都是一个庞大的体系，学海无涯，共勉。
RabbitMQ 相关整合实战项目（完结）
HUJIAXIN的博客
09-17 973
RabbitMQ 整合 PD 商城实战项目流程总结 一、订单流量削峰（解耦） 简单模式，若多添加几个消费者则用工作模式。 导入商城项目 将 step5 课前资料里面 /elasticsearch/pd商城.zip 解压。 第二层目录下 pd-web 文件夹解压到 rabbitmq 工程目录下面。 修改 pom.xml 文件中的 SpringBoot 版本为 2.3.2.RELEASE（可拖拽至 idea 内更改）。 在 rabbitmq 工程中导入模块（若之前在 idea 内更改则可以直接
Springboot整合RabbitMQ并使用
秃头的博客
03-06 3695
创建交换机(Exchange)、队列(Queue)和建立绑定关系(Binding) `direct`：会将消息发送给路由键必须完全匹配的队列中。 `@RabbitListener`：可以标注在类和方法上 (监听哪些队列) `@RabbitHandler`：只能标注在方法上 (重载区别不同的消息) `fanout`：会将消息发送给所有绑定的队列中，不管路由键是否匹配。 `topic`：主体模式其实就是在路由模式的基础上，支持了对key的通配符匹配
SpringBoot 整合RabbitMQ项目安装搭建
不想成为大佬的菜鸟不是好菜鸟的博客
10-26 901
RabbitMQ安装、下载、springboot搭建整合，实现生产、消费
RabbitMQ消息模型及springboot整合RabbitMQ
m0_74418365的博客
11-19 655
RabbitMQ提供了6种消息模型，但是第6种其实是RPC，并不是MQ，因此不予学习。那么也就剩下5种。但是其实3、4、5这三种都属于订阅模型，只不过进行路由的方式不同producer------------->queue----------------->|多consumer|能者多劳:如何防止消息堆积：多consumer + 能者多劳。
RabbitMQ基础入门教程（从安装到SpringBoot整合）
yuan_boss的博客
07-09 777
本篇博客从安装到基本的使用，安装方式包括有linux安装，docker安装，到SpringBoot整合，涵盖了多种消息队列模式，比如direct，fanout，headers，topic模式，内容涉及多个思考
RabbitMQ镜像集群搭建及Springboot整合使用
m0_46189412的博客
11-04 1581
在任意一台rabbitmq上面增加交换机和队列，另一台会自动同步。主机1：192.168.111.100。主机2：192.168.111.101。两台主机提前安装好docker备用。springboot项目。第一台服务器重启为主节点。第二台服务器加入到主节点。docker相关知识。
Springboot整合RabbitMQ最简单demo
07-11
Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.
SpringBoot整合RabbitMQ.zip
06-29
SpringBoot整合RabbitMQ的详细过程 **1.该篇博文首先讲述了交换机和队列之间的绑定关系** ①direct、②fanout、③topic **2.然后讲消息的回调** 四种情况下，确认触发哪个回调函数： ①消息推送到server，但是在...
SpringBoot 项目优雅实现 Excel 导入导出功能
weixin_44421461的博客
09-06 435
点击上方“Java基基”，选择“设为星标”做积极的人，而不是积极废人！每天14:00更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Sharding-JDBC 和 MyCAT 源码解析作业调度中间件 Elast...
【SpringBoot学习12】springboot整合rocketMQ，kafka
一个正在努力学习的iter
04-14 1045
文章目录1. RocketMQ工作模式2. 安装rocketMQ3. springboot整合rocketMQ3.1 导入springboot整合RocketMQ的starter3.2 添加核心配置3.3 使用RocketMQTemplate操作RocketMQ3.4 设置消息监听器3.5 总结4. 安装kafka5. springboot整合kafka5.1 导入springboot整合Kafka的starter5.2 添加核心配置5.3 使用KafkaTemplate操作Kafka5.4 设置消息监听器
MQ---- springboot+ kafka+rocketMQ
weixin_64035205的博客
10-28 1098
springboot+kafka+mongodb+rocketMQ
Springboot初步使用RabbitMQ
热门推荐
Ron_的博客
01-29 1万+
RabbitMQ消息队列 1.2.消息队列（MQ） 1.2.1.什么是消息队列 解耦、削峰填谷、异步 消息队列，即MQ，Message Queue。 消息队列是典型的：生产者、消费者模型。生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，这样就实现了生产者和消费者的解耦。 结合前面所说的问题： 商品服务对商品增删改以后，无需去操作索引库或静态页面，只是发送一条消息，也不关心消息被谁接收。 搜索服务服务接收消息，去处
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4802
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
RabbitMQ（二）Springboot整合及使用
fox_bert的博客
09-26 3517
一、RabbitMQ的重要概念 RabbitMQ是一种基于amq协议的消息队列，本文主要记录一下使用spring-boot-starter-amqp操作 rabbitmq。 a) 虚拟主机(vhost) 虚拟主机：一个虚拟主机持有一组交换机、队列和绑定。虚拟主机的作用在于进行权限管控，rabbitmq默认有一个虚拟主机"/"。可以使用rabbitmqctl add_vhost命令添加虚...
【RocketMQ】整合SpringBoot
Small ink的博客
08-08 2462
另一个区别是消费失败时的处理不同，有序消费模式返回ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT后，消费者会立马消费这条消息，而使用并发消费模式，返回ConsumeConcurrentlyStatus.RECONSUME_LATER后，要过好几秒甚至十几秒才会再次消费。顾名思义，有序消费模式是按照消息的顺序进行消费，但是除此之外，我发现和并发消费模式还有很大的区别的。并发消费模式则不会无限消费，而且消费失败后不会马上再消费。......
JSD-2204-(业务逻辑开发)-续消息队列-Kafka-RabbitMQ-Day15
TheNewSystrm的博客
09-07 970
JSD-2204-(业务逻辑开发)-续消息队列-Kafka-RabbitMQ-Day15
项目整合Rabbitmq
望山。
10-26 838
1.拼多商城整合 rabbitmq 当用户下订单时,我们的业务系统直接与数据库通信,把订单保存到数据库中 当系统流量突然激增,大量的订单压力,会拖慢业务系统和数据库系统 我们需要应对流量峰值,让流量曲线变得平缓,如下图 订单存储的解耦 为了进行流量削峰,我们引入 rabbitmq 消息队列,当购物系统产生订单后,可以把订单数据发送到消息队列;而订单消费者应用从消息队列接收订单消息,并把订单保存到数据库 这样,当流量激增时,大量订单会暂存在rabbitmq中,而订单消费者可以从容地从消息队列慢慢接收订单,
rabbitmq 整合到springboot publisher-returns 配置已废弃
最新发布
09-15
在Spring Boot整合RabbitMQ时，如果你遇到`publisher-returns`配置已被废弃的情况，这意味着在较新版本的Spring Boot中，原有的配置方法不再推荐使用。为了实现消息的返回机制，你需要采用新的配置方法。 消息返回（Publisher Returns）机制是指当消息被RabbitMQ服务器拒绝或者因无法路由到任何队列而无法投递时，能够将消息返回给发布者。在Spring AMQP或者Spring Boot AMQP中，这通常通过实现`RabbitTemplate`的`ReturnCallback`接口来完成。 以下是一个简化的例子来展示如何在Spring Boot中配置RabbitMQ以使用消息返回机制： 1. 首先，你需要在Spring Boot应用的配置文件中（比如`application.properties`或`application.yml`），配置RabbitMQ的相关属性。 ```properties # application.properties spring.rabbitmq.host=localhost spring.rabbitmq.port=5672 spring.rabbitmq.username=guest spring.rabbitmq.password=guest ``` 2. 然后，配置`RabbitTemplate`以使用消息返回机制： ```java import org.springframework.amqp.rabbit.core.RabbitTemplate; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class RabbitConfig { @Bean public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) { RabbitTemplate template = new RabbitTemplate(connectionFactory); template.setMandatory(true); // 设置为true时，如果交换机无法根据规则路由消息，才会触发返回机制 template.setReturnCallback((message, replyCode, replyText, exchange, routingKey) -> { System.out.println("消息被退回，退回原因：" + replyText); System.out.println("原始消息内容：" + new String(message.getBody())); }); return template; } } ``` 在这段代码中，我们创建了一个`RabbitTemplate`的Bean，并设置了`mandatory`属性为`true`。这意味着如果消息无法路由到任何队列，将会触发返回机制。同时，我们通过`setReturnCallback`方法设置了返回回调，以便在消息被退回时执行相应的操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

北执南念

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值