五种工作模式和Spring Boot整合RabbitMQ

最新推荐文章于 2024-07-08 09:23:09 发布
最新推荐文章于 2024-07-08 09:23:09 发布
阅读量433 收藏
点赞数 16
文章标签： 开发语言 java spring boot 后端 spring cloud java-rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mildswzc/article/details/134605407
版权

基础工作模式

Mq = 超市 queue 里面的内容 相当于 货物

代码运行完成后信息就没了，被消费了

Ready ： 0

代表消息已经被消费者消费过了

消费者消费消息:

  1. 加jar
 <!-- mq-->
<dependency>
  <groupId>com.rabbitmq</groupId>
  <artifactId>amqp-client</artifactId>
  <version>5.6.0</version>
</dependency>
 <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter</artifactId>
      <version>RELEASE</version>
      <scope>compile</scope>
    </dependency>
  1. 编写代码

思路：先连接mq

创建channel

消费消息

package org.example.test;
import com.rabbitmq.client.*;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class MyTest {
     @Test
    public void aaa() throws IOException, TimeoutException {
        //mq 建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("root");
        connectionFactory.setHost("192.168.44.34");  //mq主机
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("root");
        //管道连接
        Connection connection = connectionFactory.newConnection();
        //创建管道
        Channel channel = connection.createChannel();
        //消费信息
       Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //获取队列里面的消息  body是字节
                //->字符串
                String s = new String(body);
                System.out.println("mq中的消息:"+s);
            }
        };
        channel.basicConsume("test",true,consumer);
    }
}

生产者生产消息

package org.example.Test;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;
    /**
     * @author xiaowu
     */
    public class producer {
        @Test
        public void peoducter()throws IOException, TimeoutException {
            //1.创建工厂
            ConnectionFactory conn=new ConnectionFactory();
            //2.设置参数
            conn.setHost("192.168.44.34");
            conn.setPort(5672);// 5672
            conn.setUsername("root");//
            conn.setPassword("root");
            conn.setVirtualHost("root");
            //3.建理连接
            Connection connection = conn.newConnection();
            //4.创建channel
            Channel channel = connection.createChannel();
            //5.创建 队列
            channel.queueDeclare("hello",true,false,false,null);
            //queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
            /**
             * 对应的参数 queue 队列
             * durable 是都为持久化
             * exclusive
             *   是否独占  一个生产者只有一个消费者
             *   管理连接的时候删除队列
             * autodelete 是都自动删除
             * 参数  null
             *
             */
            //6.发送消息
            /**
             *         basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
             *         参数：
             *             1. exchange：交换机名称。简单模式下交换机会使用默认的 ""
             *             2. routingKey：路由名称
             *             3. props：配置信息
             *             4. body：发送消息数据
             */
            String body="hello rabbit";
            channel.basicPublish("","hello",null,body.getBytes());
            //关闭资源
            //channel.close();
            // connection.close();
        }
}

运行后

内容

在一个队列中如果有多个消费者，那么消费者之间对于同一个消息的关系是竞争的关系。

订阅模式类型☆

订阅模式示例图：

前面2个案例中，只有3个角色：

  • P：生产者，也就是要发送消息的程序
  • C：消费者：消息的接受者，会一直等待消息到来。
  • queue：消息队列，图中红色部分

而在订阅模型中，多了一个exchange角色，而且过程略有变化：

生产者发消息给交换机，交换机将消息路由分发给队列，消费者监听队列接收信息

  • P：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）
  • C：消费者，消息的接受者，会一直等待消息到来。
  • Queue：消息队列，接收消息、缓存消息。
  • Exchange：交换机，图中的X。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有常见以下3种类型：
    • Fanout：广播，将消息交给所有绑定到交换机的队列
    • Direct：定向，把消息交给符合指定routing key 的队列
    • Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列

Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！

例子：

消费者1 将日志的消息打印到控制台

消费者2 将日志的信息保存到数据库

创建一个交换机两个队列

bindings

发布订阅测试

都可消费接收

package org.example.Test;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.junit.jupiter.api.Test;

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

/**
 * @author xiaowu
 */
public class producerEx {
    @Test
    public void peoducter()throws IOException, TimeoutException {
        //1.创建工厂
        ConnectionFactory conn=new ConnectionFactory();
        //2.设置参数
        conn.setHost("192.168.44.34");
        conn.setPort(5672);// 5672
        conn.setUsername("root");//
        conn.setPassword("root");
        conn.setVirtualHost("/root");
        //3.建理连接
        Connection connection = conn.newConnection();
        //4.创建channel
        Channel channel = connection.createChannel();
        //5.创建 队列
        channel.queueDeclare("hello",true,false,false,null);
        //queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
        /**
         * String queue队列名称对应的参数 queue 队列
         * boolean durable 是否持久化
         * boolean exclusive 是否独占
         * boolean autoDelete 是否自动删除
         * Map<String, Object> arguments 参数
         * exclusive
         *   是否独占  一个生产者只有一个消费者
         *   管理连接的时候删除队列
         * autodelete 是都自动删除
         * 参数  null
         */
        //6.发送消息
        /**
         *         basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
         *         参数：
         *             1. exchange：交换机名称。简单模式下交换机会使用默认的 ""
         *             2. routingKey：路由名称
         *             3. props：配置信息
         *             4. body：发送消息数据
         */
//        for (int i = 0; i < 10; i++) {
//            String body="hello rabbit";
//            channel.basicPublish("","test22",null,body.getBytes());
//        }
        /**
         * 发布订阅时
         * 交换机-》fanout
         * 队列-》两个队列
         */
        //1 创建交换机
        /**
         * String exchange,BuiltinExchangeType type, boolean durable
         */
        channel.exchangeDeclare("myex1", BuiltinExchangeType.FANOUT,false);
        //2 创建队列
        channel.queueDeclare("testqiu3",false,false,false,null);
        channel.queueDeclare("testqiu4",false,false,false,null);
        //3 交换机绑定队列String destination , String source , String routingkey
        channel.queueBind("testqiu3","myex1","");
        channel.queueBind("testqiu4","myex1","");
        channel.basicPublish("myex1","",null,"xixixixix".getBytes());
        //关闭资源
        //channel.close();
        // connection.close();
    }
}

测试成功

4. Routing路由模式

4.1 模式说明

路由模式特点：

  • 队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）
  • 消息的发送方在 向Exchange发送消息时，也必须指定消息的 RoutingKey。
  • Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息

图解：

  • P：生产者，向Exchange发送消息，发送消息时，会指定一个routing key。
  • X：Exchange（交换机），接收生产者的消息，然后把消息递交给 与routing key完全匹配的队列
  • C1：消费者，其所在队列指定了需要routing key 为 error 的消息
  • C2：消费者，其所在队列指定了需要routing key 为 info、error、warning 的消息

创建交换机

4.2 代码

在编码上与 Publish/Subscribe发布与订阅模式 的区别是交换机的类型为：Direct，还有队列绑定交换机的时候需要指定routing key。

生产者
public class MyTestExdirect {
    @Test
    public void peoducter()throws IOException, TimeoutException {
        //1.创建工厂
        ConnectionFactory conn=new ConnectionFactory();
        //2.设置参数
        conn.setHost("192.168.44.34");
        conn.setPort(5672);// 5672
        conn.setUsername("root");//
        conn.setPassword("root");
        conn.setVirtualHost("/root");
        //3.建理连接
        Connection connection = conn.newConnection();
        //4.创建channel
        Channel channel = connection.createChannel();
        //5.创建 队列
        channel.queueDeclare("hello",true,false,false,null);
        //queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
        /**
         * String queue队列名称对应的参数 queue 队列
         * boolean durable 是否持久化
         * boolean exclusive 是否独占
         * boolean autoDelete 是否自动删除
         * Map<String, Object> arguments 参数
         * exclusive
         *   是否独占  一个生产者只有一个消费者
         *   管理连接的时候删除队列
         * autodelete 是都自动删除
         * 参数  null
         */
        //6.发送消息
        /**
         *         basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
         *         参数：
         *             1. exchange：交换机名称。简单模式下交换机会使用默认的 ""
         *             2. routingKey：路由名称
         *             3. props：配置信息
         *             4. body：发送消息数据
         */
//        for (int i = 0; i < 10; i++) {
//            String body="hello rabbit";
//            channel.basicPublish("","test22",null,body.getBytes());
//        }
        /**
         * 发布订阅时
         * 交换机-》fanout
         * 队列-》两个队列
         */
        //1 创建交换机
        /**
         * String exchange,BuiltinExchangeType type, boolean durable
         * 交换机为direct的时候 routingkey 是一个具体的值
         */
        channel.exchangeDeclare("exchange_direct_test", BuiltinExchangeType.DIRECT,false);
        //2 创建队列
        channel.queueDeclare("exchange_direct_queue_1",false,false,false,null);
        channel.queueDeclare("exchange_direct_queue_2",false,false,false,null);
        //3 交换机绑定队列String destination , String source , String routingkey
        channel.queueBind("exchange_direct_queue_1","exchange_direct_test","error");
        channel.queueBind("exchange_direct_queue_2","exchange_direct_test","test");
        channel.queueBind("exchange_direct_queue_2","exchange_direct_test","test2");
        //String exchange, String routingKey, AMQP.BasicProperties props, byte[] body
        channel.basicPublish("exchange_direct_test","error",null,"我就测试一下路由模式".getBytes());
        //关闭资源
        //channel.close();
        // connection.close();
    }
}

运行后生成

消费者1
public class Appchangedirect
{
    public static void main( String[] args ) throws IOException, TimeoutException {
        //mq 建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("root");
        connectionFactory.setHost("192.168.44.34");  //mq主机
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/root");
        //管道连接
        Connection connection = connectionFactory.newConnection();
        //创建管道
       Channel channel = connection.createChannel();
        //消费信息
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //获取队列里面的消息  body是字节
                //->字符串
                String s = new String(body);
                System.out.println("mq中的消息:"+s);
            }
        };
        channel.basicConsume("exchange_direct_queue_1",true,consumer);

    }
}

消费成功

总结：

Routing模式要求队列在绑定交换机时要指定routing key，消息会转发到符合routing key的队列。

5. Topics通配符模式（主题模式）

5.1. 模式说明

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

Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert

通配符规则：

#：匹配一个或多个词

*：匹配不多不少恰好1个词 test.* test.insert

举例：

item.#：能够匹配item.insert.abc 或者 item.insert

item.*：只能匹配item.insert

图解：

  • 红色Queue：绑定的是usa.# ，因此凡是以 usa.开头的routing key 都会被匹配到
  • 黄色Queue：绑定的是#.news ，因此凡是以 .news结尾的 routing key 都会被匹配

5.2. 代码

所有的error级别的日志以及订单系统产生的日志全部让队列1接收

error

order.#

生产者
public class MyTestExdirect {
    @Test
    public void peoducter()throws IOException, TimeoutException {
        //1.创建工厂
        ConnectionFactory conn=new ConnectionFactory();
        //2.设置参数
        conn.setHost("192.168.44.34");
        conn.setPort(5672);// 5672
        conn.setUsername("root");//
        conn.setPassword("root");
        conn.setVirtualHost("/root");
        //3.建理连接
        Connection connection = conn.newConnection();
        //4.创建channel
        Channel channel = connection.createChannel();
        //5.创建 队列
        channel.queueDeclare("hello",true,false,false,null);
        //queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
        /**
         * String queue队列名称对应的参数 queue 队列
         * boolean durable 是否持久化
         * boolean exclusive 是否独占
         * boolean autoDelete 是否自动删除
         * Map<String, Object> arguments 参数
         * exclusive
         *   是否独占  一个生产者只有一个消费者
         *   管理连接的时候删除队列
         * autodelete 是都自动删除
         * 参数  null
         */
        //6.发送消息
        /**
         *         basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
         *         参数：
         *             1. exchange：交换机名称。简单模式下交换机会使用默认的 ""
         *             2. routingKey：路由名称
         *             3. props：配置信息
         *             4. body：发送消息数据
         */
//        for (int i = 0; i < 10; i++) {
//            String body="hello rabbit";
//            channel.basicPublish("","test22",null,body.getBytes());
//        }
        /**
         * 发布订阅时
         * 交换机-》fanout
         * 队列-》两个队列
         */
        //1 创建交换机
        /**
         * String exchange,BuiltinExchangeType type, boolean durable
         * 交换机为direct的时候 routingkey 是一个具体的值
         */
        channel.exchangeDeclare("exchange_topic_test", BuiltinExchangeType.TOPIC,false);
        //2 创建队列
        channel.queueDeclare("exchange_topic_queue_1",false,false,false,null);
        channel.queueDeclare("exchange_topic_queue_2",false,false,false,null);
        //3 交换机绑定队列String destination , String source , String routingkey
        channel.queueBind("exchange_topic_queue_1","exchange_topic_test","test.#");
        channel.queueBind("exchange_topic_queue_2","exchange_topic_test","*.aaa");
        channel.queueBind("exchange_topic_queue_2","exchange_topic_test","test.*");
        //String exchange, String routingKey, AMQP.BasicProperties props, byte[] body
        channel.basicPublish("exchange_topic_test","test.aaa",null,"我就测试一下TOPIC模式".getBytes());
        //关闭资源
        //channel.close();
        // connection.close();
    }
}

消费者
public class AppchangeTopicdirect
{
    public static void main( String[] args ) throws IOException, TimeoutException {
        //mq 建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("root");
        connectionFactory.setHost("192.168.44.34");  //mq主机
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/root");
        //管道连接
        Connection connection = connectionFactory.newConnection();
        //创建管道
       Channel channel = connection.createChannel();
        //消费信息
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //获取队列里面的消息  body是字节
                //->字符串
                String s = new String(body);
                System.out.println("mq中的消息:"+s);
            }
        };
        channel.basicConsume("exchange_topic_queue_1",true,consumer);

    }
}

消费成功

测试

总结

Topic主题模式可以实现 Publish/Subscribe发布与订阅模式 和 Routing路由模式 的功能；只是Topic在配置routing key 的时候可以使用通配符，显得更加灵活。

6. 模式总结

RabbitMQ工作模式：

1、简单模式 HelloWorld

一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）

`2、工作队列模式 Work Queue

一个生产者、多个消费者（竞争关系），不需要设置交换机（使用默认的交换机）

3、发布订阅模式 Publish/subscribe

需要设置类型为fanout的交换机，并且交换机和队列进行绑定，当发送消息到交换机后，交换机会将消息发送到绑定的队列

4、路由模式 Routing

需要设置类型为direct的交换机，交换机和队列进行绑定，并且指定routing key，当发送消息到交换机后，交换机会根据routing key将消息发送到对应的队列

5、通配符模式 Topic

需要设置类型为topic的交换机，交换机和队列进行绑定，并且指定通配符方式的routing key，当发送消息到交换机后，交换机会根据routing key将消息发送到对应的队列

Spring Boot整合RabbitMQ

1. 简介

在Spring项目中，可以使用Spring-Rabbit去操作RabbitMQ

尤其是在spring boot项目中只需要引入对应的amqp启动器依赖即可，方便的使用RabbitTemplate发送消息，使用注解接收消息。

一般在开发过程中：

生产者工程：

  1. application.yml文件配置相关信息；
  2. 在生产者工程中编写配置类，用于创建交换机和队列，并进行绑定
  3. 注入RabbitTemplate对象，通过RabbitTemplate对象发送消息到交换机

消费者工程：

  1. application.yml文件配置相关信息
  2. 创建消息处理类，用于接收队列中的消息并进行处理

2.搭建生产者工程（适配类型）

1 添加依赖

修改pom.xml文件内容为如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
​
    <groupId>com.yyl</groupId>
    <artifactId>producer-springboot</artifactId>
    <version>1.0-SNAPSHOT</version>
​
    <!--1. 父工程依赖 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.2</version>
    </parent>
​
    <dependencies>
        <!--2. rabbitmq-->
        <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>
    </dependencies>

</project>

启动类

@SpringBootApplication
public class MqApp
{
    public static void main( String[] args )
    {
        System.out.println( "Hello World!" );
        SpringApplication.run(MqApp.class);
    }
}

2配置RabbitMQ

配置文件

创建application.yml，内容如下：

# 配置RabbitMQ的基本信息  ip 端口 username  password..
spring:
  rabbitmq:
    username: root
    password: root
    host: 192.168.44.34
    virtual-host: /root  #必须以/开头
    port: 5672
mq:
  exchange:
    name:  test_exchange_topic
  queue:
    name1: test_topic_exchange_queue_1
    name2: test_topic_exchange_queue_2

3 配置类

声明交换机

声明队列

交换机和对垒进行绑定

package com.example.config;
import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class TopicMqConfig {
//这行代码使用@Value注解来注入一个名为mq.exchange.name的配置属性值。
// 这个值通常在配置文件（如application.properties或application.yml）中定义。
// 在这个例子中，EXCHANGENAME变量的值将被设置为配置文件中mq.exchange.name属性的值。
    @Value("${mq.exchange.name}")
    private String EXCHANGENAME;
    @Value("${mq.queue.name1}")
    private String QUEUENAME1;
    @Value("${mq.queue.name2}")
    private String QUEUENAME2;
    //1 交换机
    @Bean("ex1")
    public Exchange getExchange(){
        Exchange exchange = ExchangeBuilder.topicExchange(EXCHANGENAME).durable(false).build();
        return exchange;
    }
    //2 队列
    @Bean("queue1")
    public Queue getQueue1(){
        Queue queue = QueueBuilder.nonDurable(QUEUENAME1).build();
        return queue;
    }
    @Bean("queue2")
    public Queue getQueue2(){
        Queue queue = QueueBuilder.nonDurable(QUEUENAME2).build();
        return queue;
    }
    //3 交换机和队列进行绑定
    @Bean("binding1")
    public Binding bindQueueToExchange(@Qualifier("ex1")Exchange exchange,@Qualifier("queue1")Queue queue){
        Binding binding = BindingBuilder.bind(queue).to(exchange).with("*.*").noargs();
        return binding;
    }
    @Bean("binding2")
    public Binding bindQueue2ToExchange(@Qualifier("ex1")Exchange exchange,@Qualifier("queue2")Queue queue){
        Binding binding = BindingBuilder.bind(queue).to(exchange).with("test.#").noargs();
        return binding;
    }
}

4 生产者发布消息：

Starter组件里面封装的类rabbitTemplate

在test文件夹中添加Mytest测试类

package com.example;
import org.junit.jupiter.api.Test;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.context.SpringBootTest;
import javax.annotation.Resource;
@SpringBootTest
public class MyTest {

    @Value("${mq.exchange.name}")
    private String EXCHANGENAME;
    /**
     * mq
     */
    @Resource
    private RabbitTemplate rabbitTemplate;
    @Test
    void sendMsg(){
        rabbitTemplate.convertAndSend(EXCHANGENAME,"test.topic","我就是测试一下spring boot和mq的整合");
    }
}

测试成功

5 消费者消费消息

消费者的服务application.yml和生产者是一样的

只需要监听队列（队列里面只要有消息就开始接收）

项目结构整理如下

监听的配置文件

spring:
  rabbitmq:
    username: root
    password: root
    host: 192.168.44.34
    virtual-host: /root  #????????????/????
    port: 5672
#mq:
#  exchange:
#    name:  test_exchange_topic
#  queue:
#    name1: test_topic_exchange_queue_1
#    name2: test_topic_exchange_queue_2
server:
  port: 8085

监听实现代码

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class ConstumerMessage {
    //监听队列
    @RabbitListener(queues = "test_topic_exchange_queue_2")
    public void aaa(Message message){
        byte[] body = message.getBody();
        String string = new String(body);
        System.out.println("-------:"+string);
    }
}

测试成功

Mildswzc
关注
  • 16
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Spring Boot 整合RabbitMQ
Java 技术专栏，从入门到精通，熟悉企业级开发
11-05 10万+
在业务活动期间，由于用户请求量短时间内剧增，可能导致系统压力过大甚至崩溃。通过消息队列实现请求的缓冲。在高并发场景下，系统可以将请求放入消息队列，然后异步处理这些请求，从而平滑系统的处理负载，确保系统的稳定性。
springboot整合rabbitmq的五种模式示例
liyu121的博客
02-21 309
https://blog.csdn.net/wz6178/article/details/92843468 springboot整合rabbitmq RabbitMQ提供了6种消息模型，但是第6种其实是RPC，并不是MQ，因此不予学习。那么也就剩下5种。 1.基本消息模型：生产者–>队列–>一个消费者 2.work消息模型：生产者–>队列–>多个消费者共同消费 3.订阅模型-Fanout：广播，将消息交给所有绑定到交换机的队列，每个消费者都可以收到同一条消息 4.订阅模型-
SpringBoot整合RabbitMQ mqtt协议实现发布/订阅
qq_42697946的博客
04-03 1331
MQTT（Message Queuing Telemetry Transport）：MQTT是一种轻量级的发布/订阅消息传递协议，设计初衷是用于低带宽、高延迟或不稳定的网络环境中。本篇文章是通过Spring boot 整合 基于Rabbit 实现MQTT 的方式基础上，实现的发布/订阅模式，供大家参考
SpringBoot日常：封装rabbitmq starter组件
最新发布
qq_32590535的博客
07-08 1039
本章内容主要介绍编写一个rabbitmq starter，能够通过配置文件进行配置交换机、队列以及绑定关系等等。项目引用该组件后能够自动初始化交换机和队列，并进行简单通信。 如若有其他需求，可自行扩展，例如消息消费的确认等
Springboot下RabbitMQ 封装实现，支持点对点消息，广播消息、延时消息
lihuajian1024的博客
02-18 6074
如何避免项目中消息队列使用泛滥，大量重复代码和逻辑无处不再，数据跟踪困难，代码维护心累，您可以看看这个小工具。
【RabbitMQ Learning Journey】SpringBoot整合RabbitMQ发布订阅，简单实现
记录开发学习笔记
02-27 554
springboot实现MQ发布订阅模式.（内容来源于蚂蚁课堂） 实现代码： 1.引入amqp依赖，springboot版本是2.0.1.RELEASE <!-- 添加springboot对amqp的支持 --> <dependency> <groupId>org.springframework.boot</groupId> ...
优雅封装RabbitMQ实现动态队列、动态生产者，动态消费者绑定
fu18889708485的博客
04-24 4426
优雅封装RabbitMQ实现动态队列、动态生产者，动态消费者绑定
spring boot整合RabbitMQ（Direct模式）
08-30
springboot集成RabbitMQ非常简单，如果只是简单的使用配置非常少，springboot提供了spring-boot-starter-amqp项目对消息各种...下面通过本文给大家介绍下spring boot整合RabbitMQ（Direct模式）,需要的朋友可以参考下
Spring Boot整合RabbitMQ开发实战详解
08-28
Spring Boot 中整合 RabbitMQ 需要加入依赖 `<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId></dependency>`，然后创建一个配置类 `RabbitMQConfig....
Spring boot整合消息队列RabbitMQ实现四种消息模式（适合新手或者开发人员了解学习RabbitMQ机制）
06-27
本项目基于Spring的AMQP模块，整合流行的开源消息队列中间件rabbitMQ,实现一个向rabbitMQ添加和读取消息的功能。并比较了两种模式：生产者-消费者模式和发布-订阅模式的区别。AMQP作为比JMS更加高级的消息协议，支持...
Spring Boot 整合 RabbitMQ 案例.zip
11-02
Spring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例...
RabbitMQ工具类封装实现
10-26
封装了RabbitMQ的订阅者线程和发布者线程（还有个初始化工厂的连接工具类），另外附加一个安卓的使用demo
springboot使用rabbitmq工具类
03-29
springboot使用rabbitmq工具类,里面包含比较原生的方法,还有一套是我结合springboot框架写的一套方法,里面有两个方法,看情况使用,一般使用框架的方法比较好,因为框架方法时前辈们封装好经过检验的没有问题的方法,自己写的方法比较简陋,参考下原理即可.
SpringBoot2＞05 - 利用RabbitMQ订阅短信任务
cp026la的博客
01-19 786
扯淡： 短信发送的应用场景非常多，在较大的系统中，短信一般作为单独的服务独立运行，而短信发送任务的触发基本有两种方式。1、定时获取Redis中短信发送任务，2、消息中间件订阅短息任务队列。 个人学习总结： 链接：【springboot、springcloud、docker 等，学习目录】 需求：用户注册时输入手机号获取验证码。 RabbitMQ订阅短信： 短信微服务(springbo...
springboot rabbitmq 发布订阅 广播模式
wangjun5159的专栏
12-15 1187
实现发布订阅（广播模式）的关键在于对exchange类型的理解，可参考amqp协议、rabbitmq入门、springboot集成rabbitmq，源码中的类型有如下几种/***//*** routing key和binding key完全匹配*//*** binding key可使用通配符来匹配routing key*//*** 会忽略routing key、binding key，消息发送到绑定exchange的全部queue*//**
Spring Boot整合RabbitMQ之发布与订阅模式
weixin_43360488的博客
08-20 882
的模式中，常用的模式有：简单模式，发布与订阅模式，工作模式，路由模式，主题模式。
springboot+rabbitmq搭建mqtt协议实现订阅发布（亲测9w消息并发）
肌肉金轮的博客
01-14 5468
mqtt，rabbitmq+mqtt，springboot整合rabbitmq搭建mqtt协议
Springboot整合RabbitMQ
热门推荐
weixin_49076273的博客
06-02 1万+
一、Springboot整合RabbitMQ的代码实现 1.引入Springboot整合RabbitMQ的依赖 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> &l
java——spring boot集成RabbitMQ——高级特效——封装消息的元数据
小白龙白龙马的博客
02-26 399
交换机和队列支持持久化。现在我们也需要给消息设计元数据 DeliveryMode 设置为2，表示支持消息的持久化。 ======================================================================================= 接上一边博文。 修改文件： 发送者： package org.example.sender; ...
spring boot整合rabbitmq
08-24
Spring Boot与RabbitMQ的整合可以通过使用Spring AMQP实现。下面是一个简单的步骤： 1. 添加依赖：在`pom.xml`文件中添加以下依赖关系： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值