简单了解一下RabbitMQ

最新推荐文章于 2024-06-22 12:00:00 发布
最新推荐文章于 2024-06-22 12:00:00 发布
阅读量2.8k 收藏
点赞数
文章标签： java rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45984552/article/details/123608830
版权

目录

一、什么是消息队列

二、AMQP和JMS的区别

三、消息的分发策略：

四、在docker安装rabbitmq

五、五种消息模型

1.第一种模型

 2.第二种模型：work工作

 3.第三种模型：fanout广播  

4.第四种模型：router  direct静态路由

5.第五种模型：Topics动态路由

六、rabbitmq整合springboot

七、Docker搭建rabbitmq集群

一、什么是消息队列


MQ全称为Message Queue，即消息队列。“消息队列”是在消息的传输过程中保存消息的容器。它是典型的：生产者、消费者模型。生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，这样就实现了生产者和消费者的解耦。

消息中间件负责数据传递、存储和消息分发三个部分，数据的存储和分发过程中肯定要遵循某种规范，在tcp/ip 之上建立一种新的协议AMQP

二、AMQP和JMS的区别


MQ是消息通信的模型，并发具体实现。现在实现MQ的有两种主流方式：AMQP、JMS。

区别：

JMS是定义了统一的接口，来对消息操作进行统一；AMQP是通过规定协议来统一数据交互的格式

JMS限定了必须使用Java语言；AMQP只是协议，不规定实现方式，因此是跨语言的。

JMS规定了两种消息模型；而AMQP的消息模型更加丰富

AMQP特性：

1.支持分布式事务的支持，

2.消息的持久化，

3.高性能高可靠的消息优势，

为什么消息中间件不采用HTTP协议呢？

因为消息队列不需要这么复杂，它的请求报文头和响应报文头太过于复杂，影响性能，大部分HTTP协议都是短连接的，在实际的交互过程中，一个请求到响应可能会发生中断，消息中间件可能是一个长期的获取消息的过程，目的是为了保证数据和消息的稳健运行。

总结两点：1.不需要那么复杂，2.需要长连接。

三、消息的分发策略：

消息的队列中有如下的几个角色：

1.生产者

2.消费者

3.存储消息

消息分发策略对比：

发布订阅：

轮询分发（公平）： 不会造成数据倾斜，无论服务器性能怎样，都会是公平的

公平分发（倾斜）：会造成数据倾斜，会根据服务器性能，能者多劳模式，当数据被一个消费者消费，那么剩下的消费者都不会消费这一个消息

重发：保证消息可靠性的一种机制

消息拉取： 

在上面几种策略中rabbitmq都是支持的

kafka追接近底层运行速度高

消息高可用高可靠

无论服务器出现什么问题，服务都不能出现宕机，用集群部署实现高可用

集群模式1.主从共享数据：共享同一块数据空间，在小规模会用到

集群模式2.主从同步部署：会造成消息副本

集群模式3.多住集群同步部署：

集群模式4.：多主集群转发部署

用户级别：

  1. administrator：可以登录控制台、查看所有信息、可以对 rabbitmq进行管理

  2. monitoring：监控者 登录控制台，查看所有信息

  3. policymaker：策略制定者 登录控制台，指定策略

  4. managment 普通管理员 登录控制台

四、在docker安装rabbitmq

docker这项虚拟化容器化技术让我们安装一些环境的时候省去配置环境变量的操作，只需要将端口映射出来，然后去连接即可。安装命令如下

//安装rabbitmq容器
docker pull rabbitmq

//运行rabbitmq的同时将端口映射
docker run -d --hostname my-rabbit --name rabbit -p 15672:15672 -p 5673:5672 rabbitmq

//通过docker ps -a查看部署的mq容器id，在通过 docker exec -it 容器id /bin/bssh 进入容器内部在
运行rabbitmq-plugins enable rabbitmq_management

我这里使用云服务器连接安装的docker，然后在本机上连接rabbitmq，登录名密码没设置的话默认都是guest

五、五种消息模型

环境搭建，导入依赖

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

然后连接封装成一个工具类，减少冗余代码

package rabbitmq.utils;

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

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

public class RabbitmqUtils {
    private static ConnectionFactory connectionFactory;
    static {
         connectionFactory = new ConnectionFactory();
        //2创建连接主机
        connectionFactory.setHost("47.106.123.32");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/xy");  //设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
    }

    public static Connection getConnection()  {

        try {
            return connectionFactory.newConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static void CloseConnection(Channel channel,Connection connection){
        try {
            if (channel != null && channel.isOpen()){
                channel.close();
            }
            if (connection != null &&connection.isOpen()){
                connection.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

1.第一种模型

简单模型 

消费者

package rabbitmq.simple;

import com.rabbitmq.client.*;
import org.junit.Test;
import rabbitmq.utils.RabbitmqUtils;

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

// 消费者
public class Consumer {
    @Test
    public void test() throws IOException, TimeoutException {
       
        Connection connection = RabbitmqUtils.getConnection();
        Channel channel = null;
        channel = connection.createChannel();
             //绑定队列
        channel.queueDeclare("hello",false,false,false,null);
            /**
             * 1.队列名称
             * 2.开始消息的自动确认机制
             * 3.消费时的回调接口
             * 4。队列中取出的消息
             */
            channel.basicConsume("hello",true,new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("new String(body) =" + new String(body));
                }
            });

    }
}

生产者

package rabbitmq.simple;

import com.rabbitmq.client.*;
import org.junit.Test;
import rabbitmq.utils.RabbitmqUtils;

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

// 消费者
public class Consumer {
    @Test
    public void test() throws IOException, TimeoutException {

        Connection connection = RabbitmqUtils.getConnection();
        Channel channel = null;
        channel = connection.createChannel();
             //绑定队列
        channel.queueDeclare("hello",false,false,false,null);
            /**
             * 1.队列名称
             * 2.开始消息的自动确认机制
             * 3.消费时的回调接口
             * 4。队列中取出的消息
             */
            channel.basicConsume("hello",true,new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("new String(body) =" + new String(body));
                }
            });

    }
}

 

 2.第二种模型：work工作

  公平策略，轮询（默认）

主要跟消息确认机制有关，rabbitmq默认的消息确认机制是true

生产者：

package rabbitmq.work_avg;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import rabbitmq.utils.RabbitmqUtils;

import java.io.IOException;

public class Provider {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitmqUtils.getConnection();
        Channel channel = connection.createChannel();
        //通过通道声明队列
        channel.queueDeclare("work",true,false,false,null);
        //生产消息
        for (int i=1; i<=20; i++){
        channel.basicPublish("","work",null,("hello work queue").getBytes());
        }
        //关闭资源
        RabbitmqUtils.CloseConnection(channel,connection);
}}

 消费者1：

package rabbitmq.work_avg;

import com.rabbitmq.client.*;
import rabbitmq.utils.RabbitmqUtils;
import java.io.IOException;

public class Consumer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitmqUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare("work", true, false, false, null);
        for (int i = 1; i <= 20; i++) {
           channel.basicConsume("work",true,new DefaultConsumer(channel){
               @Override
               public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                   System.out.println("消费者1:"+ new String(body));
               }
           });
        }
    }
}

消费者2：

package rabbitmq.work_avg;

import com.rabbitmq.client.*;
import rabbitmq.utils.RabbitmqUtils;
import java.io.IOException;

public class Consumer2 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitmqUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare("work", true, false, false, null);
        for (int i = 1; i <= 20; i++) {
            channel.basicConsume("work",true,new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("消费者2:"+ new String(body));
                }
            });
        }
    }
}

能者多劳模型

我们希望消息消费者消费慢的话少消费一点，消费快的多消费一点，这与消息队列的自动确认机制有关。

生产者：

package rabbitmq.work;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import rabbitmq.utils.RabbitmqUtils;
import java.io.IOException;

public class Provider {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitmqUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare("work",false,false,false,null);

        //生产消息
        for (int i=1;i<=20;i++){
            channel.basicPublish("","work",null,("消费第"+i+"条消息").getBytes());

        }
        RabbitmqUtils.CloseConnection(channel,connection);
    }
}

 消费者1：

package rabbitmq.work;

import com.rabbitmq.client.*;
import rabbitmq.utils.RabbitmqUtils;
import java.io.IOException;

public class Consumer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitmqUtils.getConnection();
        Channel channel = connection.createChannel();
        //告诉通道每一次只消费一个消息
        channel.basicQos(1);
        channel.queueDeclare("work",false,false,false,null);
         //第二个参数：消息自动确认机制 true 消费者自动向rabbitmq足额人消息消费
        channel.basicConsume("work",false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者1:"+new String(body));
                //手动确认，
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });
    }
}

 消费者2：

package rabbitmq.work;

import com.rabbitmq.client.*;
import rabbitmq.utils.RabbitmqUtils;
import java.io.IOException;

public class Consumer2 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitmqUtils.getConnection();
        Channel channel = connection.createChannel();
        //一次只确认一条消息
        channel.basicQos(1);
        channel.queueDeclare("work",false,false,false,null);
        channel.basicConsume("work",false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2:"+new String(body));
                //开启消息手动确认，保证消息不丢失
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });
    }
}

 

 

 

 3.第三种模型：fanout广播  

消费者：

package rabbitmq.fanout;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import rabbitmq.utils.RabbitmqUtils;

import java.io.IOException;

//广播，生产者将消息发送到交换机
public class Provider {
    private static final String message = "hello,rabbitmq";
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitmqUtils.getConnection();
        Channel channel = connection.createChannel();

        //将通道声明指定的交换机  1.交换机名称 2.交换机类型
        channel.exchangeDeclare("fanout","fanout");
        //发送消息
        channel.basicPublish("fanout","",null,message.getBytes());

        //释放资源
        RabbitmqUtils.CloseConnection(channel,connection);
    }
}

生产者：

package rabbitmq.fanout;

import com.rabbitmq.client.*;
import rabbitmq.utils.RabbitmqUtils;

import java.io.IOException;

public class Consumer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitmqUtils.getConnection();
        Channel channel = connection.createChannel();

        //通道绑定交换机  参数一：交换机名称  参数二： 交换机类型
        channel.exchangeDeclare("fanout","fanout");

        //临时队列
        String queue = channel.queueDeclare().getQueue();

        //绑定交换机和队列
        channel.queueBind(queue,"fanout","");

        //消费消息
        channel.basicConsume(queue,true, new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1"+new String (body));
            }
        });
    }
}

 

4.第四种模型：router  direct静态路由

1.Direct（直连），在广播模式中，一条消息会被所有的订阅都消费，在某些场景下，我们希望不同的消息被不同的对象消费，这时就要用到Direct类型的交换机。

生产者：

package rabbitmq.routing.direct;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import rabbitmq.utils.RabbitmqUtils;
import java.io.IOException;

public class Provider {
    public static void main(String[] args) throws IOException {
        String exangename = "log_direct";
        Connection connection = RabbitmqUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(exangename,"direct");
        //交换机路由
        String routingKey = "info";
        channel.basicPublish(exangename,routingKey,null,"这是基于direct模型发布的".getBytes());
        RabbitmqUtils.CloseConnection(channel,connection);
    }
}

 消费者：

package rabbitmq.routing.direct;

import com.rabbitmq.client.*;
import rabbitmq.utils.RabbitmqUtils;
import java.io.IOException;

public class Consumer1 {

        public static void main(String[] args) throws IOException {
            String exangename = "logs_direct";
            Connection connection = RabbitmqUtils.getConnection();
            Channel channel = connection.createChannel();
            //声明交换机
            channel.exchangeDeclare(exangename,"direct");

            //创建队列和交换机绑定
            String queue = channel.queueDeclare().getQueue();

            //临时队列绑定交换机
            channel.queueBind(queue,exangename,"info");

            //获取消息
            channel.basicConsume(queue,true,new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("消费者1"+new String(body));
                }
            });
        }
}

5.第五种模型：Topics动态路由

就是在原有的direct模型上加了通配符的操作  ，极大增强代码可维护性

*匹配一个字符 #匹配多个

生产者

package rabbitmq.routing.topics;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import rabbitmq.utils.RabbitmqUtils;
import java.io.IOException;

public class Provider {
    public static void main(String[] args) throws IOException {
        //获取连接对象
        Connection connection = RabbitmqUtils.getConnection();
        Channel channel = connection.createChannel();
        //声明交换机以及交换机类型
        channel.exchangeDeclare("topics","topic");
        //发布消息
        String routerKey = "user.save";
        channel.basicPublish("topics",routerKey,null,("这里是topic动态路由模型；["+routerKey+"]").getBytes());
        //关闭资源
        RabbitmqUtils.CloseConnection(channel,connection);
    }
}

消费者

package rabbitmq.routing.topics;

import com.rabbitmq.client.*;
import rabbitmq.utils.RabbitmqUtils;
import java.io.IOException;
//   *匹配一个字符   #匹配多个
public class Consumer {
    public static void main(String[] args) throws IOException {
        //获取连接
        Connection connection = RabbitmqUtils.getConnection();
        Channel channel = connection.createChannel();

        //声明交换机以及交换机类型
        channel.exchangeDeclare("topics","topic");
        //创建一个临时队列
        String queue = channel.queueDeclare().getQueue();
        //基于通配符绑定队列和交换机
        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1:"+new String(body));
            }
        });
    }
}

实际上rabbitmq还有RPC和发布订阅这两种模型，不过这里不介绍这两种模型

六、rabbitmq整合springboot

1.环境搭建

<!--        springboot整合rabbitmq-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

 2.配置properties.yml文件

spring:
  rabbitmq:
    host: 47.106.123.32
    port: 5672
    username: guest
    password: guest
    virtual-host: /

 RabbitTemplet用来操作Rabbitmq，简化操作，使用的时候直接在项目中注入即可。

七、Docker搭建rabbitmq集群

1.普通集群（副本集群）

在实际生产中很少用到这种集群架构，无法实现主从同步，只能减缓主节点压力。

2.镜像集群（高可用）

基于普通集群的基础上，搭建镜像集群，保证消息百分百不丢失。镜像集群就是将队列在三个阶段之间设置主从关系，消息在三个节点之间进行自动同步，如果其中一个节点不可用，并不会导致消息丢失或者服务不可用的情况，提升集群整体高可用性。

步骤：

 1.拉取镜像

docker pull rabbitmq:3.7-management

 2.创建映射数据卷目录

mkdir rabbitmqcluster
cd rabbitmqcluster/
mkdir rabbitmq01 rabbitmq02 rabbitmq03

3.创建容器

docker run -d --hostname rabbitmq01 --name rabbitmqCluster01 -v /home/software/rabbitmqcluster/rabbitmq01:/var/lib/rabbitmq -p 15672:15672 -p 5672:5672 -e RABBITMQ_ERLANG_COOKIE='rabbitmqCookie' rabbitmq:3.7-management

docker run -d --hostname rabbitmq02 --name rabbitmqCluster02 -v /home/software/rabbitmqcluster/rabbitmq02:/var/lib/rabbitmq -p 15673:15672 -p 5673:5672 -e RABBITMQ_ERLANG_COOKIE='rabbitmqCookie'  --link rabbitmqCluster01:rabbitmq01 rabbitmq:3.7-management

docker run -d --hostname rabbitmq03 --name rabbitmqCluster03 -v /home/software/rabbitmqcluster/rabbitmq03:/var/lib/rabbitmq -p 15674:15672 -p 5674:5672 -e RABBITMQ_ERLANG_COOKIE='rabbitmqCookie'  --link rabbitmqCluster01:rabbitmq01 --link rabbitmqCluster02:rabbitmq02  rabbitmq:3.7-management

//设置开机自动启动
docker container update --restart=always

 4、容器节点加入集群

进入第一个节点，执行下列命令

docker exec -it rabbitmqCluster01 bash

rabbitmqctl stop_app
rabbitmqctl reset
rabbitmqctl start_app
exit

 接下来，进入第二个rabbitmq节点容器，执行如下命令：

docker exec -it rabbitmqCluster02 bash
rabbitmqctl stop_app
rabbitmqctl reset
rabbitmqctl join_cluster --ram rabbit@rabbitmq01
rabbitmqctl start_app
exit

 紧接着，进入第三个rabbitmq节点容器，执行如下命令：

docker exec -it rabbitmqCluster03 bash
rabbitmqctl stop_app
rabbitmqctl reset
rabbitmqctl join_cluster --ram rabbit@rabbitmq01
rabbitmqctl start_app
exit

最后，实现镜像模式集群。进入rabbitmqCluster01容器中

docker exec -it rabbitmqCluster01 bash

//设置镜像队列策略（在任意一个节点上执行）

rabbitmqctl set_policy ha-all "^" '{"ha-mode":"all"}'

 执行上述操作，这时候 再查看 RabbitMQ Management的overview面板中的Nodes信息，可查看到节点信息。

手写冒泡排序
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
一文理解RabbitMQ
qq_45002918的博客
07-02 188
Rabbit RabbitMQ简介：RabbitMQ是目前应用最广泛的一个基于AMQU规范的消息中间件 RabbitMQ中的重要概念 **Message：**消息，消息是没有名称的，消息由消息头和消息体组成；消息头则由一系列的可选属性组成，这些属性包括routing-key（路由键）、priority（相对于其他消息的优先权）、delivery-mode（指出该消息可能需要持久性存储）等，其中routing-key(路由键)是最重要的一个属性 **Publisher：**消息的生产者，发送者，也是一个向交换
1、RabbitMQ简介
java爱分享
12-22 180
RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而集群和故障转移是构建在开放电信平台(OTP)框架上的。所有主要的编程语言均有与代理接口通讯的客户端库。 Erlang(爱浪)特点： 并发性：Erlang支持超大量级的并发进程，并且不需要操作系统具有并发机制； 分布式：一个分布式Erlang系统是多个...
Rabbitmq工具类，java工具类RabbitmqUtil
10-29
1、java工具类RabbitmqUtil是本人封装好的直接使用 2、常用的方法都在里面 3、改一下初始化配置参数就行
RabbitMQ学习（2）
Hide on bush
07-08 271
RabbitMQ的六大模式：简单模式，工作模式Work Queues，发布确认模式，发布订阅模式（fanout），路由模式（direct）以及主题模式（topic）
RabbitMQ —— 理解及应用场景
最新发布
小蜜蜂vs码农
06-22 1577
RabbitMQ —— 理解及应用场景
RabbitMQ简单使用
qq_38030465的博客
09-28 2242
1.安装： win10安装RabbitMQ 2.使用 2.1简单模式 一个生产者 一个消费者 生产者 public static void main(String[] args)throws Exception { //与mq建立连接 //定义连接工厂 ConnectionFactory connectionFactory=new ConnectionFactory(); //设置服务地址 connectionFactory.
Java RabbitMQUtil
weixin_43865977的博客
09-04 453
Maven依赖： <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.3.RELEASE</version> <relativePath/&gt
rabbitMqUtils
qq_42570684的博客
07-30 1259
package com.bootdo.jiai.util; import com.rabbitmq.client.*; import java.io.IOException; public class ActiveMqUtils { private final static String QUEUE_NAME = "healthQuee"; public static S...
rabbitMQ代码案例 简单入门
10-31
首先，让我们了解一下RabbitMQ的基本概念： 1. **消息队列**：RabbitMQ的核心是消息队列，它负责存储和转发消息。生产者（Producer）将消息发送到队列，消费者（Consumer）从队列中接收并处理消息。队列在生产者和...
简单了解如何在spring中使用RabbitMQ
08-25
首先，需要了解什么是 RabbitMQ。RabbitMQ 是一个基于 AMQP 协议的开源消息中间件，广泛应用于分布式系统中，解决应用解耦、异步消息、流量削锋等问题，实现高性能、高可用、可伸缩和最终一致性架构。 在 Spring 中...
rabbitmq简单java实例
06-27
首先，我们需要了解RabbitMQ的基本概念。在RabbitMQ中，生产者是发送消息的应用，消费者则是接收消息的应用。消息被发送到交换机，交换机根据预设的路由规则将消息分发到队列。队列是消息的临时存储，直到被消费者...
基于RabbitMQ的简单应用(详解)
08-28
【RabbitMQ基础概念】 RabbitMQ是一种开源的消息代理和队列服务器，它实现了Advanced Message ...通过本文的介绍，你可以了解到RabbitMQ的基本概念、应用场景以及如何搭建和使用RabbitMQ环境，为实际开发提供指导。
Springboot整合RabbitMQ简单demo
01-22
首先，我们需要了解RabbitMQ的基本概念。RabbitMQ是一个开源的消息代理和队列服务器，遵循AMQP（Advanced Message Queuing Protocol）协议，提供高可用、高可靠性的消息传递服务。它允许生产者发送消息到队列，而...
RabbitMQ 消息队列学习 (二)
IT_Holmes的博客
05-17 751
1. 工作队列(Work Queues) 消息应答 1.1 什么是 消息应答机制？ 1.2 自动应答 和 手动应答 1.3 消息 自动重新入队 过程原理 1.4 消息 手动应答 代码测验 2. RabbitMQ 持久化 2.1 队列持久化 2.2 消息持久化 3. 不公平分发 策略 4. 预去值 策略 5. 发布确认 5.1 发布确认 过程原理 5.2 开启 发布确认 5.3 单个确认发布 5.4 批量确认发布 5.5 异步确认发布 6. 如何处理异步发布确认的 未确认消息 7. 三种确认发布 对比
RabbitMQ快速入门（详解）
lu__lala的博客
06-22 744
RabbitMQ快速入门，安装到项目运行全套 展示消费者，生产者，轮询效果
RabbitMQ 详解
热门推荐
m0_53067943的博客
05-09 1万+
文章主要对关于RabbitMQ的知识总结
RabbitMqUtil.java
qq 117791303
03-11 147
RabbitMqUtil.java
RabbitMQ 学习（三）---- 连接工具类
rain67的博客
09-17 2385
之前我们写生产者消费者模型的时候，会有很多冗余代码，比如生产者和消费者都需要创建连接工厂、设置连接配置、以及关闭资源等操作。我们打算将这些冗余的操作封装成一个工具类，我们直接调用类得到相关的信息即可，不必每次都写一些连接的配置信息。使用连接工厂，使用单例模式，static只设置一次配置，创建获取连接的方法，创建关闭资源的方法。所以现在，在之前的生产者、消费者Hello World 模型的代码中可以省略很多代码了。
《消息中间件》~ Rabbit工具类 RabbitMQUtil
qq_45928727的博客
08-30 1348
public class RabbitMQUtil { private static ConnectionFactory connectionFactory; static { //创建mq的连接工厂对象 connectionFactory = new ConnectionFactory(); //设置连接rabbit的主机地址 connectionFactory.setHost("192.168.17.156");
rabbitmq的简单使用
08-30
RabbitMQ 是一个开源的消息中间件，它实现了高效、可靠的消息传递机制。下面是 RabbitMQ 的简单使用步骤： 1. 安装 RabbitMQ：你可以从 RabbitMQ 官方网站...你可以深入学习 RabbitMQ 的文档，以了解更多详细信息。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值