rabbitMq四种模式及同springboot简单整合

最新推荐文章于 2024-05-08 22:42:19 发布
最新推荐文章于 2024-05-08 22:42:19 发布
阅读量171 收藏 1
点赞数
分类专栏： rabbitMq 文章标签： 交换机 队列 rabbitmq java redis
本文详细介绍了RabbitMQ的五种工作模式：简单模式、工作者模式、发布订阅模式、路由模式和主题模式，并提供了Java实现示例。此外，还展示了如何将RabbitMQ与SpringBoot进行整合，使用RabbitTemplate简化消息发送。
摘要由CSDN通过智能技术生成

1. 回顾

RabbitMQ由五种模式:
上篇：https://editor.csdn.net/md/?articleId=116211410
(1)简单模式：特点:只有生产者消费者和队列组成。

2. 工作者模式:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oVm8xnhp-1619660455670)(assets\1618900602190.png)]

特点:
    1. 一个生产者
    2. 由多个消费。
    3. 统一个队列。
    4. 这些消费者之间存在竞争关系。

用处:
    比如批量处理上. rabbitMQ里面积压了大量的消息。

生产者，这里设置的是自动确定模式，所以两个消费者消费的个数一样

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
public class Product {
    public static void main(String[] args)throws  Exception {
        //创建连接工厂 --配置连接信息
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("192.168.31.195");
        //创建连接对象Connection
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //创建队列
        /**
         * String queue, 队列的名称
         * boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
         * boolean exclusive, 是否独占 false
         * boolean autoDelete, 是否自动删除  如果长时间没有发生消息 则自动删除
         * Map<String, Object> arguments 额外参数  先给null
         */
        channel.queueDeclare("queue_work",true,false,false,null);
        //发生消息
        /**
         * String exchange: 交换机的名称 如果没有则使用“” 它回自动采用默认
         * String routingKey, 路由key  如果没有交换机的绑定 使用队列的名称
         * BasicProperties props, 消息的一些额外配置 目前先不加 null
         * byte[] body 消息的内容
         */
        for(int i=0;i<10;i++) {
            String msg = "冯昱凯真帅！！！！！！！！！！！"+i;
            channel.basicPublish("", "queue_work", null, msg.getBytes());
        }
        //生产者这里可以管理资源  消费者不能关闭资源。
        channel.close();
        connection.close();
    }
}

消费者01：

import com.rabbitmq.client.*;

import java.io.IOException;
public class Consumer01 {
    public static void main(String[] args) throws Exception{
        //创建连接工厂 --配置连接信息
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("192.168.31.195");
        //创建连接对象Connection
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //接受消息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer callback=new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //body 接受的信息
                try {
                    Thread.sleep(1000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者01:"+new String(body));
            }
        };
        channel.basicConsume("queue_work",true,callback);
    }
}

消费者02:

import com.rabbitmq.client.*;

import java.io.IOException;
public class Consumer02 {
    public static void main(String[] args) throws Exception{
        //创建连接工厂 --配置连接信息
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("192.168.31.195");
        //创建连接对象Connection
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //接受消息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer callback=new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //body 接受的信息
                try {
                    Thread.sleep(1000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者01:"+new String(body));
            }
        };
        channel.basicConsume("queue_work",true,callback);

    }
}

3. 发布订阅模式（广播模式）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B7rKjukV-1619660455673)(assets\1618901774090.png)]

1. 特点:
    1.一个生产者
    2.多个消费者
    3.多个队列。（永远是队列中拿消息）
    4.交换机 转发消息。

生产者:

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
public class Product {
    public static void main(String[] args)throws  Exception {
        //创建连接工厂 --配置连接信息
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("192.168.31.195");
        //创建连接对象Connection
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //创建队列
        /**
         * String queue, 队列的名称
         * boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
         * boolean exclusive, 是否独占 false
         * boolean autoDelete, 是否自动删除  如果长时间没有发生消息 则自动删除
         * Map<String, Object> arguments 额外参数  先给null
         */
        channel.queueDeclare("ban129_queue_fanout01",true,false,false,null);
        channel.queueDeclare("ban129_queue_fanout02",true,false,false,null);

        //创建交换机
        /**
         * String exchange,交换机的名称
         * BuiltinExchangeType type, 交换机的类型
         * boolean durable:是否持久化
         */
        channel.exchangeDeclare("exchange", BuiltinExchangeType.FANOUT,true);
        /**
         * String queue,  队列名
         * String exchange, 交换机的名称
         * String routingKey:路由key 如果交换机为fanout模式则不需要路由key
         */
        channel.queueBind("queue_fanout01","exchange","");
        channel.queueBind("queue_fanout02","exchange","");
        //发生消息
        /**
         * String exchange: 交换机的名称 如果没有则使用“” 它回自动采用默认
         * String routingKey, 路由key  如果没有交换机的绑定 使用队列的名称
         * BasicProperties props, 消息的一些额外配置 目前先不加 null
         * byte[] body 消息的内容
         */
        for(int i=0;i<10;i++) {
            String msg = "真帅！！！！！！！！！！！"+i;
            channel.basicPublish("exchange", "", null, msg.getBytes());
        }
        //生产者这里可以管理资源  消费者不能关闭资源。
        channel.close();
        connection.close();
    }
}

消费者:

import com.rabbitmq.client.*;

import java.io.IOException;
public class Consumer01 {
    public static void main(String[] args) throws Exception{
        //创建连接工厂 --配置连接信息
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("192.168.31.195");
        //创建连接对象Connection
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //接受消息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer callback=new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //body 接受的信息
                try {
                    Thread.sleep(1000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者01:"+new String(body));
            }
        };
        channel.basicConsume("queue_fanout01",true,callback);

    }
}

注意： 同样名字的交换机但是交换机的类型不同（BuiltinExchangeType type, 交换机的类型），不能一起使用，否则在生产者或者消费端会报错！

还有routingkey如果没有赋值为“ ”，不可以将其设置为null；

4.路由模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6hKQqGq0-1619660455674)(assets\1618904756029.png)]

特点:
    1.一个生产者
    2.多个消费者
    3.多个队列。
    4.交换机 转发消息。
    5.routekey:路由key 只要routekey匹配的消息可以到达对应队列。

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
public class Product {
    public static void main(String[] args)throws  Exception {
        //创建连接工厂 --配置连接信息
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("192.168.31.195");
        //创建连接对象Connection
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //创建队列
        /**
         * String queue, 队列的名称
         * boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
         * boolean exclusive, 是否独占 false
         * boolean autoDelete, 是否自动删除  如果长时间没有发生消息 则自动删除
         * Map<String, Object> arguments 额外参数  先给null
         */
        channel.queueDeclare("queue_direct01",true,false,false,null);
        channel.queueDeclare("queue_direct02",true,false,false,null);

        //创建交换机
        /**
         * String exchange,交换机的名称
         * BuiltinExchangeType type, 交换机的类型
         * boolean durable:是否持久化
         */
        channel.exchangeDeclare("exchange_direct", BuiltinExchangeType.DIRECT,true);
        /**
         * String queue,  队列名
         * String exchange, 交换机的名称
         * String routingKey:路由key 如果交换机为fanout模式则不需要路由key
         */
        channel.queueBind("queue_direct01","exchange_direct","error");


        channel.queueBind("queue_direct02","exchange_direct","info");
        channel.queueBind("queue_direct02","exchange_direct","error");
        channel.queueBind("queue_direct02","exchange_direct","warning");
        //发生消息
        /**
         * String exchange: 交换机的名称 如果没有则使用“” 它回自动采用默认
         * String routingKey, 路由key  如果没有交换机的绑定 使用队列的名称
         * BasicProperties props, 消息的一些额外配置 目前先不加 null
         * byte[] body 消息的内容
         */
        for(int i=0;i<10;i++) {
            String msg = "你们有没有打疫苗！！！！！！！！！！！"+i;
            channel.basicPublish("exchange_direct", "error", null, msg.getBytes());
        }
        //生产者这里可以管理资源  消费者不能关闭资源。
        channel.close();
        connection.close();
    }
}

5. topic主体模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l0DWFwGt-1619660455676)(assets\1618905526157.png)]

1. 绑定按照通配符的模式。
     *: 统配一个单词。
     #: 统配n个单词
例子
hello.orange.rabbit  Q1和Q2都可接到消息

lazy.orange      Q2可接到消息

注意：这里的通配符内容不仅仅局限与图中所给的内容

生产者

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
public class Product {
    public static void main(String[] args)throws  Exception {
        //创建连接工厂 --配置连接信息
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("192.168.31.195");
        //创建连接对象Connection
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //创建队列
        /**
         * String queue, 队列的名称
         * boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
         * boolean exclusive, 是否独占 false
         * boolean autoDelete, 是否自动删除  如果长时间没有发生消息 则自动删除
         * Map<String, Object> arguments 额外参数  先给null
         */
        channel.queueDeclare("queue_topic01",true,false,false,null);
        channel.queueDeclare("queue_topic02",true,false,false,null);

        //创建交换机
        /**
         * String exchange,交换机的名称
         * BuiltinExchangeType type, 交换机的类型
         * boolean durable:是否持久化
         */
        channel.exchangeDeclare("exchange_topic", BuiltinExchangeType.TOPIC,true);
        /**
         * String queue,  队列名
         * String exchange, 交换机的名称
         * String routingKey:路由key 如果交换机为fanout模式则不需要路由key
         */
        channel.queueBind("queue_topic01","exchange_topic","*.orange.*");
       channel.queueBind("queue_topic02","exchange_topic","*.*.rabbit");
        channel.queueBind("queue_topic02","exchange_topic","lazy.#");

        //发生消息
        /**
         * String exchange: 交换机的名称 如果没有则使用“” 它回自动采用默认
         * String routingKey, 路由key  如果没有交换机的绑定 使用队列的名称
         * BasicProperties props, 消息的一些额外配置 目前先不加 null
         * byte[] body 消息的内容
         */
        for(int i=0;i<10;i++) {
            String msg = "你们！！！！！！！！！！！"+i;
            channel.basicPublish("exchange_topic", "lazy.orange.rabbit", null, msg.getBytes());
        }
        //生产者这里可以管理资源  消费者不能关闭资源。
        channel.close();
        connection.close();

    }
}

5. rabbitMQ整合springboot

springboot引入了相关的依赖后，提供一个工具类RabbitTemplate（模板）.封装了上面生产者消费者的发送消息的整个代码流程，使用这个工具类可以发送消息。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UyqTDFUe-1619660455677)(assets\1618910290294.png)]

(1)父工程引入相关的依赖

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <packaging>pom</packaging>
    <modules>
        <module>product</module>
        <module>consumer</module>
    </modules>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.aaa</groupId>
    <artifactId>springboot-rabbit-parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-rabbit-parent</name>
    <description>springboot整合rabbitMQ</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!--rabbitMQ的依赖: 启动类加载。读取配置文件：
           springboot自动装配原理: 引用starter启动依赖时，把对应的自动装配类加载进去，该自动装配类可以读取application配置文件中
           内容。 DispatherServlet
        -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.72</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8Las4avK-1619660455678)(assets/1618921998878.png)]

(2)相应的生产者和消费的配置（文件名一定要是application的名字）

server:
  port: 9999
#rabbit的配置
spring:
  rabbitmq:
    host: 192.168.31.195

（3）生产者

import com.alibaba.fastjson.JSON;
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.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;
@RestController
public class HelloController {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("hello")
    public String hello(){ //业务层
        System.out.println("下单成功");
        //String exchange, String routingKey, Object message
        Map<String,Object> map=new HashMap<>();
        map.put("productId",1);
        map.put("num",10);
        map.put("price",12);
        rabbitTemplate.convertAndSend("exchange","", JSON.toJSONString(map)); //序列化过程
        return "下单成功";
    }
}

消费者监听消息

import com.alibaba.fastjson.JSON;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Map;
@Component
public class MyRabbitListener {

    //队列中存在消息则立即回调该方法
    @RabbitListener(queues = {"queue_fanout01"})
    public void listener(String msg){//参数也可使用Message msg类型，里面包含各种消息类型和内容
        Map map = JSON.parseObject(msg, Map.class);
        System.out.println(map);
    }
  
}
晴空万里藏片云
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ五种模式
07-01
没有1个积分的私聊我哈，我给你免费 消息队列中间件（简称消息中间件）是指利用高效可靠的消息传递机制进行与平台无关的数据交流，并基于数据通信来进行分布式系统的集成。通过提供消息传递和消息排队模型，它可以在分布式环境下提供**应用解耦**(降偶)、**弹性伸缩、冗余存储、流量削峰、异步通信、数据同步等等功能**，其作为分布式系统架构中的一个重要组件，有着举足轻重的地位。 **基本模型： 消息发布者 --> 消息中间件 ---> 消息消费者** 同步调用是 A调用B后阻塞等待，此时A的后续操作是不能进行。异步调用的一种实现方式是引入MQ，A将调用信息发到消息中间件，然后B从消息中间件获取到消息内容执行。此时A不再需要等待B。 这个前提下，**就可以实现异步调用**，**冗余存储**（指可以在MQ中多存一些数据，等待B来消费，MQ可以看作是个缓冲区）、**流量削峰**（如果A的调用请求数量大于B的消费能力，则消息中间件可以通过冗余存储来缓冲，B可以按照以比较慢的速度来处理请求）等等功能。
spring boot整合RabbitMQ（Direct模式）
08-30
springboot集成RabbitMQ非常简单，如果只是简单的使用配置非常少，springboot提供了spring-boot-starter-amqp项目对消息各种支持。下面通过本文给大家介绍下spring boot整合RabbitMQ（Direct模式）,需要的朋友可以...
rabbit的工作模式
qq_53678217的博客
04-21 313
1. 正文 1. 工作者模式: 2. 发布订阅模式 3. 路由模式 4. topic主体模式。 5. Springboot整合rabbitMQ 2. 工作者模式: 特点: 1. 一个生产者 2. 由多个消费。 3. 统一个队列。 4. 这些消费者之间存在竞争关系。 用处: 比如批量处理上. rabbitMQ里面积压了大量的消息。 生产者 package com.ykq.work; import com.rabbitmq.client.Channel; i
rabbitmq 五种模式
Jornici的博客
02-05 2050
1、简单模式 2、工作队列模式 3、发布订阅模式 4、路由模式 5、topic通配符模式
RabbitMQ的五种常见模式
未来的博客
04-21 508
RabbitMQ的五种常见模式 在练习RabbitMQ之前，请确认自己的RabbitMQ已经安装并开启。 1、简单模式 从图上可以看到只有三个角色:   p 【product】: 生产者 发生消息的   红色[queue]: 队列。 存储消息的    C [consumer]: 消费者 消费消息 创建一个maven项目，创建一个消费者和一个生产者。 生产者代码： public class Product { public static void main(String[] args)
RabbitMQ的五种模式:
weixin_54386913的博客
04-22 244
简单模式 生产者 public class Product { public static void main(String[] args) throws Exception { //创建连接工厂--配置连接信息 ConnectionFactory factory =new ConnectionFactory(); factory.setHost("虚拟机id号"); //创建链接对象 Connection conne
springboot+整合rabbitmq的全套代码
09-15
reabbitmq的完整学习 >rabbitMq软件上传到liunx服务器 >RabbitMQ入门 ...>Springboot整合RabbitMQ >SpringBoot整合RabbitMQ(交换机与多个队列绑定) >RabbitMQ-集群搭建>负载均衡-HAProxy 完整链接地址: ...
springBoot整合RabbitMQ案例
04-07
SpringBoot整合RabbitMQ是一个常见的后端开发任务，它涉及到分布式消息传递和Java应用程序的集成。RabbitMQ是一个开源的消息代理和队列服务器，而SpringBoot是基于Spring框架的简化版，提供了快速构建应用程序的方式...
SpringBoot与RabbitMQ整合和对五种队列模式的实现源码
06-21
在本文中，我们将深入探讨如何将SpringBoot框架与RabbitMQ消息队列服务进行整合，以及如何实现五种常见的队列模式。RabbitMQ作为一款强大的开源消息中间件，广泛应用于分布式系统中，用于解耦应用程序，提高系统的可...
springboot整合stream使用rabbitmq作为消息中间件
12-13
当我们谈论"SpringBoot整合stream使用rabbitmq作为消息中间件"时，我们涉及的关键技术点主要包括Spring Boot的Stream模块、RabbitMQ的使用以及它们如何协同工作来实现高效的微服务通信。 Spring Boot Stream模块是...
RabbitMQ的五种模式源码+纯手工打的代码
03-12
RabbitMQ的五种模式源码+纯手工打的代码
rabbitmq各种模式代码及说明
06-19
rabbitmq各种模式代码及说明，下载解压就能启动，集成springboot
RabbitMQ的 五种工作模型
weixin_37862824的博客
11-10 1518
总结：简单模式和工作队列模式，主要是【队列】和【消费者】的关系，一对一、一对多。订阅模式包含：【交换机】和【队列】的关系，【队列】和【消费者】的关系。队列和消费者是1对多时，那么就是采用平均的方式分给多个消费。队列里面的消息只有一个消费者会拿到。
rabbitmq的五种工作模式
qq_35345436的博客
12-07 2663
Rabbitmq常用的五种工作模式
m0_57232638的博客
07-12 559
RabbitMQ常用的五种工作模式
RabbitMQ五大模式轻松理解
风影浪子
06-13 7392
简要概括RabbitMQ工作模式：1、简单模式 HelloWorld 2、工作队列模式 Work Queue 3、发布订阅模式 Publish/subscribe 4、路由模式 Routing 5、通配符模式 Topic
rabbitmq几种工作模式_10分钟认识RabbitMQ的五种工作模式
weixin_39612720的博客
12-07 830
什么是Rabbit让我来免费帮你免费翻译翻译RabbitMQ是一个消息中间件:它接受和转发消息。你可以把它想象成一个邮局:当你把你想要寄的邮件放到一个邮箱里，你可以确定邮递员先生或女士最终会把邮件送到收件人那里。在这个类比中，RabbitMQ是一个邮箱、一个邮局和一个邮递员。RabbitMQ和邮局之间的主要区别在于它不处理纸张，而是接受、存储和转发二进制blob数据消息。五种工作模式打开...
RabbitMQ的五种模式
最新发布
weixin_39311781的博客
05-08 588
简单模式（Simple）：一个生产者，一个消费者。
RabbitMQ.pdf-入门六种工作模式到spring整合springboot整合
《RabbitMQ.pdf-详情》是一个关于RabbitMQ消息队列的详细说明文件，涵盖了从入门六种工作模式到spring整合以及springboot整合的内容。其中包括了RabbitMQ的快速入门指南，以及如何在Java中创建一个生产者和消费者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值