RabbitMQ消息队列（一）

最新推荐文章于 2024-06-24 20:50:35 发布
最新推荐文章于 2024-06-24 20:50:35 发布
阅读量1.7k 收藏 2
点赞数 1
分类专栏： RabbitMQ Java 文章标签： rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a67879431/article/details/121139965
版权

RabbitMQ消息队列中间件

直接安装在Linux上

启动服务

systemctl start rabbitmq-server
查看服务状态

systemctl status rabbitmq-server
停止服务

systemctl stop rabbitmq-server
开机启动服务

systemctl enable rabbitmq-server

一、消息队列介绍

1. 同步调用和异步调用

  • 同步调用
    • A服务调用B服务，需要等待B服务执行完毕的返回值，A服务才可以继续往下执行
    • 同步调用可以通过REST和RPC完成
      • REST：Ribbon，Feign
      • RPC：Dubbo
  • 异步调用
    • A服务调用B服务，A无需等待B服务的执行结果
    • 通过消息队列实现异步调用

2. 消息队列概念

  • MQ全称为Message Queue,消息队列（MQ）是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。
  • 消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如远程过程调用的技术。排队指的是应用程序通过队列来通信。队列的使用除去了接收和发送应用程序同时执行的要求。
image-20211029144609415

3. 常见消息队列中间件

  • RabbitMQ、ActiveMQ、RocketMQ、Kafka
    • RabbitMQ 稳定可靠,数据一致,支持多协议,有消息确认,基于erlang语言
    • Kafka 高吞吐,高性能,快速持久化,无消息确认,无消息遗漏,可能会有有重复消息,依赖于zookeeper,成本高.
    • ActiveMQ 不够灵活轻巧,对队列较多情况支持不好.
    • RocketMQ 性能好,高吞吐,高可用性,支持大规模分布式，协议支持单一

二、RabbitMQ

1. RabbitMQ介绍

  • RabbitMQ是一个在AMQP基础上完成的，可复用的企业消息系统。他遵循Mozilla Public License开源协议。
  • AMQP，即Advanced Message Queuing Protocol, 一个提供统一消息服务的应用层标准高级消息队列协议,是应用层协议的一个开放标准,为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同的开发语言等条件的限制。Erlang中的实现有 RabbitMQ等。
  • 主要特性：
    • 保证可靠性：使用一些机制来保证可靠性，如持久化、传输确认、发布确认
    • 灵活的路由功能
    • 可伸缩性：支持消息集群，多台RabbitMQ服务器可以组成一个集群
    • 高可用性：RabbitMQ集群中的某个节点出现问题时队列任然可用
    • 支持多种协议
    • 支持多语言客户端
    • 提供良好的管理界面
    • 提供跟踪机制：如果消息出现异常，可以通过跟踪机制分析异常原因
    • 提供插件机制：可通过插件进行多方面扩展

2. 通过docker安装rabbitmq

2.1 Erlang安装

参考地址：https://www.erlang-solutions.com/downloads/

wget https://packages.erlang-solutions.com/erlang-solutions-2.0-1.noarch.rpmrpm -Uvh erlang-solutions-2.0-1.noarch.rpm

yum install -y erlang

erl -v

安装socat

yum install -y socat

2.2 安装dokcer

（1）yum 包更新到最新
yum update
（2）安装需要的软件包， yum-util 提供yum-config-manager功能，另外两个是devicemapper驱动依赖的
yum install -y yum-utils device-mapper-persistent-data lvm2
（3）设置yum源为阿里云
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
（4）安装docker
yum install docker-ce -y
（5）安装后查看docker版本
docker -v
 (6) 安装加速镜像
 sudo mkdir -p /etc/docker
 sudo tee /etc/docker/daemon.json <<-'EOF'
 {
"registry-mirrors": ["https://0wrdwnn6.mirror.aliyuncs.com"]
 }
 EOF
 sudo systemctl daemon-reload
 sudo systemctl restart docker

docker相关命令

# 启动docker：
systemctl start docker
# 停止docker：
systemctl stop docker
# 重启docker：
systemctl restart docker
# 查看docker状态：
systemctl status docker
# 开机启动：  
systemctl enable docker
systemctl unenable docker
# 查看docker概要信息
docker info
# 查看docker帮助文档
docker --help

2.3 安装rabbitmq

docker run -di --name myrabbit -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=admin -p 15672:15672 -p 5672:5672 -p 25672:25672 -p 61613:61613 -p 1883:1883 rabbitmq:management

启动安装在docker中的RabbitMQ

  • docker ps -a

    查看所有的docker容器

  • docker start CONTAINER ID

    CONTAINER ID是在docker ps -a中显示出的容器的CONTAINER ID

  • docker ps

    查看已启动的容器

三、 RabbitMQ用户管理

1. 逻辑结构

  • 用户
  • 虚拟主机
  • 队列

image-20211028211418242

2. 用户管理

2.1 用户级别

  • 超级管理员administrator,可以登录控制台,查看所有信息,可以对用户和策略进行操作
  • 监控者monitoring,可以登录控制台,可以查看节点的相关信息,比如进程数,内存磁盘使用情况
  • 策略制定者policymaker ,可以登录控制台,制定策略,但是无法查看节点信息
  • 普通管理员 management 仅能登录控制台
  • 其他, 无法登录控制台,一般指的是提供者和消费者

2.2 添加用户（命令模式）

  • docker ps
#进入容器
docker exec -it d2dd40da7056 /bin/bash

  • 添加/配置用户test 设置密码为test

    rabbitmqctl add_user test test

    如果不是通过docker安装rabbitmq，则需要在rabbitmq的sbin目录下执行./rabbitmqctl add_user test test

  • 设置用户权限

    #设置admin为administrator级别
rabbitmqctl set_user_tags test administrator

2.3添加用户（web方式）

  • 浏览器访问：http://47.113.192.192/:15672/ (使用guest guest 登录, guest 具有最高权限,只能在本机登录；先使用命令行创建一个用户)
image-20211028213947236

2.4 添加虚拟主机

image-20211028223536826

2.5 用户绑定虚拟主机

image-20211028223908936

四、RabbitMQ工作模式

1. 消息队列的模式

参考文档：http://www.rabbitmq.com/getstarted.html

1.1 简单模式

简单模式就是生产者将消息发到队列,消费者从队列中取消息,一条消息对应一个消费者

一个队列只有一个消费者

image-20211029101621867

1.2 工作模式

Work模式就是一条消息可以被多个消费者尝试接收,但是最终只能有一个消费者能获取
image-20211029110943819

1.3 订阅模式

一条消息可以被多个消费者同时获取

生产者将消息发送到交换机,消费者将自己对应的队列注册到交换机

当发送消息后所有注册了队列的消费者都可以收到消息

image-20211029104941481

在这里插入图片描述

1.4 路由模式

生产者将消息发送到了type为direct模式的交换机

消费者的队列在将自己绑定到路由的时候会给自己绑定一个key

只有生产者发送对应key格式的消息时，相应队列才会收到消息

在这里插入图片描述

五、RabbtiMQ交换机和队列管理

1. 创建队列

image-20211029112654441

2. 创建交换机

image-20211029114011508

3. 交换机绑定队列

进入交换机ex1

image-20211029114430370

在模式为fanout的交换机ex1上绑定两个队列queue1,queue2

image-20211029115136783

六、在普通Maven应用中使用MQ

RabbitMQ消息队列模式

image-20211029153437183

1. 简单模式

1.1 消息生产者

  • 创建Maven 项目

  • 添加RabbitMQ连接需要的依赖

    <dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>4.10.0</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.25</version>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.9</version>
</dependency>

  • 创建日志配置文件 log4j.properties

    log4j.rootLogger=DEBUG,A1 log4j.logger.com.taotao = DEBUG 
log4j.logger.org.mybatis = DEBUG
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss,SSS} [%t] [%c]-[%p] %m%n

  • 创建MQ连接帮助类

    import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class ConnectionUtil {

    public static Connection getConnection() throws IOException, TimeoutException {
        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2.在工厂对象中设置MQ的连接信息（ip,port,virtualhost,username,password）
        factory.setHost("47.113.192.192");
        factory.setPort(5672);
        factory.setVirtualHost("host1");
        factory.setUsername("admin");
        factory.setPassword("admin");
        //3.通过工厂对象获取与MQ的连接
        Connection connection = factory.newConnection();
        return connection;
    }
}

  • 消息生产者发送消息

    import com.eicoma.mq.utils.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class SendMsg {

    public static void main(String[] args) throws IOException, TimeoutException {
        String msg = "Hello RabbitMQ";

        Connection connection = ConnectionUtil.getConnection(); //相当于JDBC中的数据库连接
        Channel channel = connection.createChannel();   //相当于JDBC的statement

        //定义队列(在Java代码中新建一个MQ队列)
        //参数1：定义的队列名
        //参数2：队列中的数据是否选择持久化
        //参数3：是否排外（当前队列是否为当前连接所私有）
        //参数4：自动删除（当此队列的连接数为0时，此队列会销毁（无论队列中是否还有数据））
        //参数5：设置当前队列的参数
        //channel.queueDeclare("queue7",false,false,false,null);

        //参数1：交换机名称（此处为简单模式，没有交换机）
        //参数2：目标队列名称
        //参数3：设置当前这条消息的属性（如设置过期时间）
        //参数4：消息的内容
        channel.basicPublish("","queue1",null,msg.getBytes());
        System.out.println("发送" + msg);

        channel.close();
        connection.close();
    }
}

1.2 消息消费者

  • 消息消费者接收消息

    import com.eicoma.mq.utils.ConnectionUtil;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class ReceiveMsg {

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //body就是从队列中获取的数据
                String msg = new String(body);
                System.out.println("接收的数据是：" + msg);
            }
        };

        channel.basicConsume("queue1",true,consumer);
    }
}

2. 工作模式

2.1 消息生产者

  • 消息生产者发送消息

    import com.eicoma.mq.utils.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import java.io.IOException;
import java.util.Scanner;
import java.util.concurrent.TimeoutException;

public class SendMsg {

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("请输入消息：");
        Scanner scanner = new Scanner(System.in);
        String msg = null;
        while(!"quit".equals(msg = scanner.nextLine())){
            Connection connection = ConnectionUtil.getConnection(); //相当于JDBC中的数据库连接
            Channel channel = connection.createChannel();   //相当于JDBC的statement

            //定义队列(在Java代码中新建一个MQ队列)
            //参数1：定义的队列名
            //参数2：队列中的数据是否选择持久化
            //参数3：是否排外（当前队列是否为当前连接所私有）
            //参数4：自动删除（当此队列的连接数为0时，此队列会销毁（无论队列中是否还有数据））
            //参数5：设置当前队列的参数
            //channel.queueDeclare("queue7",false,false,false,null);

            //参数1：交换机名称（此处为工作模式，没有交换机）
            //参数2：目标队列名称
            //参数3：设置当前这条消息的属性（如设置过期时间）
            //参数4：消息的内容
            channel.basicPublish("","queue2",null,msg.getBytes());
            System.out.println("发送" + msg);

            channel.close();
            connection.close();
        }
    }
}

2.2 消息消费者

  • 消息消费者接收消息

    • consumer1
    import com.eicoma.mq.utils.ConnectionUtil;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class ReceiveMsg {

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //body就是从队列中获取的数据
                String msg = new String(body);
                System.out.println("consumer1接收的数据是：" + msg);
            }
        };

        channel.basicConsume("queue2",true,consumer);
    }
}
    • consumer2
    import com.eicoma.mq.utils.ConnectionUtil;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class ReceiveMsg {

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //body就是从队列中获取的数据
                String msg = new String(body);
                System.out.println("consumer2接收的数据是：" + msg);
            }
        };

        channel.basicConsume("queue2",true,consumer);
    }
}

3. 订阅模式

3.1 消息生产者

  • 消息生产者发送消息
import com.eicoma.mq.utils.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import java.io.IOException;
import java.util.Scanner;
import java.util.concurrent.TimeoutException;

public class SendMsg {

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("请输入消息：");
        Scanner scanner = new Scanner(System.in);
        String msg = null;
        while(!"quit".equals(msg = scanner.nextLine())){
            Connection connection = ConnectionUtil.getConnection(); //相当于JDBC中的数据库连接
            Channel channel = connection.createChannel();   //相当于JDBC的statement
            //参数1：交换机名称
            //参数2：目标队列名称
            //参数3：设置当前这条消息的属性（如设置过期时间）
            //参数4：消息的内容
            channel.basicPublish("ex1","",null,msg.getBytes());
            System.out.println("发送" + msg);

            channel.close();
            connection.close();
        }
    }
}

3.2 消息消费者

  • 消息消费者接收消息

    • consumer1
    import com.eicoma.mq.utils.ConnectionUtil;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class ReceiveMsg {

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //body就是从队列中获取的数据
                String msg = new String(body);
                System.out.println("consumer1接收的数据是：" + msg);
            }
        };

        channel.basicConsume("queue3",true,consumer);
    }
}
    • consumer2
    import com.eicoma.mq.utils.ConnectionUtil;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class ReceiveMsg {

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //body就是从队列中获取的数据
                String msg = new String(body);
                System.out.println("consumer2接收的数据是：" + msg);
            }
        };

        channel.basicConsume("queue4",true,consumer);
    }
}

4. 路由模式

4.1 消息生产者

  • 消息生产者发送消息
import com.eicoma.mq.utils.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import java.io.IOException;
import java.util.Scanner;
import java.util.concurrent.TimeoutException;

public class SendMsg {

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("请输入消息：");
        Scanner scanner = new Scanner(System.in);
        String msg = null;
        while(!"quit".equals(msg = scanner.nextLine())){
            Connection connection = ConnectionUtil.getConnection(); //相当于JDBC中的数据库连接
            Channel channel = connection.createChannel();   //相当于JDBC的statement

            //参数1：交换机名称
            //参数2：目标队列名称,但由于这里有交换机，因此该参数为Key
            //参数3：设置当前这条消息的属性（如设置过期时间）
            //参数4：消息的内容
            if(msg.startsWith("a")){
                channel.basicPublish("ex2","a" ,null,msg.getBytes());
            }else if(msg.startsWith("b")){
                channel.basicPublish("ex2","b" ,null,msg.getBytes());
            }
            System.out.println("发送" + msg);

            channel.close();
            connection.close();
        }
    }
}

4.2 消息消费者

  • 消息消费者接收消息

    • consumer1
    import com.eicoma.mq.utils.ConnectionUtil;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class ReceiveMsg {

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //body就是从队列中获取的数据
                String msg = new String(body);
                System.out.println("consumer1接收的数据是：" + msg);
            }
        };

        channel.basicConsume("queue5",true,consumer);
    }
}
    • consumer2
    import com.eicoma.mq.utils.ConnectionUtil;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class ReceiveMsg {

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //body就是从队列中获取的数据
                String msg = new String(body);
                System.out.println("consumer2接收的数据是：" + msg);
            }
        };

        channel.basicConsume("queue6",true,consumer);
    }
}

七、在SpringBoot中使用MQ

SpringBoot可以完成自动配置和依赖注入，通过Spring直接获取RabbitMQ的连接对象

1. 消息生产者

  • 相关依赖

    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</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>

  • 配置applicaiton.yml

    server:
  port: 9001

spring:
  application:
    name: producer
  rabbitmq:
    host: 47.113.192.192
    port: 5672
    virtual-host: host1
    username: admin
    password: admin

  • 生产者发送消息

    import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;

@Service
public class TestService {

    @Resource
    private AmqpTemplate amqpTemplate;

    public void senMsg(String msg){
            //1.发送消息到队列
            amqpTemplate.convertAndSend("queue1",msg);
        
            //2.发送消息到交换机（订阅交换机）
            amqpTemplate.convertAndSend("ex1","",msg);
        
            //3.发送消息到交换机（路由交换机）
            amqpTemplate.convertAndSend("ex2","a",msg);
            amqpTemplate.convertAndSend("ex2","b",msg);
    }
}

2. 消息消费者

  • 添加依赖

  • 配置yml

    server:
  port: 9002

spring:
  application:
    name: producer
  rabbitmq:
    host: 47.113.192.192
    port: 5672
    virtual-host: host1
    username: admin
    password: admin

  • 消费者接收消息

    import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;

@Service
@RabbitListener(queues = {"queue1"})
public class ReceiveMsgService {

    @RabbitHandler
    public void receiveMsg(String msg){
        System.out.println("接收msg:" + msg);
    }
}
Eicoma
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
RabbitMQ 消息队列
weixin_43813267的博客
12-29 471
1.什么是rabbitMQ RabbitMQ是一个由erlang开发的AMQP（Advanced Message Queue 高级消息队列协议 ）的开源实现，能够实现异步消息处理 RabbitMQ是一个消息代理：它接受和转发消息。 你可以把它想象成一个邮局：当你把你想要发布的邮件放在邮箱中时，你可以确定邮差先生最终将邮件发送给你的收件人。在这个比喻中，RabbitMQ是邮政信箱，邮局和邮递员。 R...
RabbitMQ-消息队列
weixin_40108868的博客
08-01 95
RabbitMQ是基于AMQP协议的一款消息管理系统，是部署最广泛的开源消息中间件，是最受欢迎的开源消息中间件之一官网http官方教程httpAMQP（advancedmessagequeuingprotocol）在2003年时被提出，最早用于解决金融领不同平台之间的消息传递交互问题。顾名思义，AMQP是一种协议，更准确的说是一种binarywire-levelprotocol（链接协议）。这是其和JMS的本质差别，AMQP不从API层进行限定，而是直接定义网络交换的数据格式。总结。......
rabbitmq初学之连接测试
leihui_2009的专栏
06-12 5731
最近在搞接口，需要用到rabbitmq，在公司搞了一个下午还是连接不上，后来细看了英文说明，测试连接成功，得出如下报错几点。我用的安装包：otp_win64_17.0.exe（erlang vm）和rabbitmq-server-3.3.1.exe 最后测试成功。连接的代码片段如下   com.rabbitmq.client.ConnectionFactory factory = new com....
消息队列（一）-- RabbitMQ入门（4）
qq_32091929的博客
07-25 293
即使是持久化的消息，在被写入磁盘的同时也会在内存中驻留一份备份。消费者在消费MQ 中的消息时，MQ 已经把消息发送给消费者，消费者在给 MQ 返回 ack 时网络中断，故MQ 未收到确认消息，该消息会重新发给其他消费者，或网络重新连接后再次发给该消费者，但是实际上该消息已被消费过了，造成消费者重复消费同一条消息。引入镜像队列（Mirror Queue）的机制，可以将队列镜像到集群中的其他 Broker 节点之上，如果集群中的一个节点失效了，队列能自动地切换到镜像中的另一个节点上，保证服务的可用性。
【消息队列】六万字长文详细带你RabbitMQ从入门到精通
最新发布
Hanson的博客
06-24 437
六万字长文深入了解RabbitMQ，从基础到精通
安装配置RabbitMQ（启动SSL）及测试案例
weixin_44366773的博客
12-01 2569
安装配置RabbitMQ（启动SSL）及测试案例一. RabbitMQ依赖环境及其安装1. 在Ubuntu中下载安装SSL2. 在ubuntu中安装RabbitMQ服务2.1 下载安装Erlang2.2 下载安装RabbitMQ服务二. RabbitMQ服务配置1. 开启RabbitMQ web端管理界面2. 配置监听支持SSL的端口2.1 生成证书2.2 修改RabbitMQ的配置文件（开启SSL）三. 简单测试RabbitMQ(支持SSL)是否配置成功3.1 验证RabbitMQ服务端是否配置成功3.2
RabbitMQ消息确认机制
ruiguang21的博客
11-22 5158
RabbitMQ消息确认机制
RabbitMq消息队列指南.docx
07-05
消息队列MQ，全称Message Queue，是一种在应用程序之间用于通信的技术，主要功能是作为生产者与消费者之间的缓冲。在消息队列模型中，生产者不断地向队列中发布消息，而消费者则从队列中获取并处理这些消息。这种...
rabbitMQ 消息队列 Demo
10-18
在本"rabbitMQ 消息队列 Demo"中，我们可以通过一系列示例来深入理解RabbitMQ的核心功能和用法。 1. **01HelloWorld** 这是RabbitMQ入门的经典示例，它展示了最基础的消息发布与消费过程。生产者发送一个简单的...
RabbitMQ消息队列组件安装包
06-15
rabbitMQ组件
RabbitMQ延迟队列及消息延迟推送实现详解
08-25
RabbitMQ 延迟队列及消息延迟推送实现详解 RabbitMQ 延迟队列及消息延迟推送实现详解是指在 RabbitMQ 中实现消息延迟推送的功能，即在指定的时间后推送消息到目标队列中。这种机制在实际应用中非常有价值，如在淘宝...
C# .Net RabbitMQ消息队列发送和接收实例程序
04-21
在本文中，我们将深入探讨如何使用C# .NET 6.0和RabbitMQ.Client.Dll库来实现RabbitMQ的消息队列发送和接收。RabbitMQ是一个流行的开源消息代理，它遵循Advanced Message Queuing Protocol (AMQP)标准，允许不同系统...
RabbitMQ笔记
chen772209的博客
09-30 363
RabbitMQ笔记 第一种模型：直连模型： 一个生产者对应一个消费者 第二种模型：work queue： 一个生产者对应多个消费者： 这多个消费者默认是采用均分的策略来消费消息的。 但是也是可以通过一些设置来达到能者多劳的功能的。这个设置看那个笔记即可。 第三种模型：fanout（广播模型）： 实现了一条消息能被多个消费者消费 可以有多个消费者（每个消费者都绑定一个临时队列） 每个消费者有自己的queue（队列） 每个队列都要绑定到exchange（交换机） 生产者发送消息，=只能发送给交换机，交换机来
检查RabbitMQ状态
LFfootprint的博客
03-27 2万+
1、安装rabbitMQ前需要先安装Erlang 2、检查RabbitMQ运行状态 打开命令行命令行,进入RabbitMQ的安装目录: cd D:\Program Files\RabbitMQ\rabbitmq_server-3.7.13\sbin 输入 rabbitmqctl status 3、配置可视化RabbitMQ管理界面 运行命令行窗口cmd 输入命令rabbitmq-plugins...
springboot 启动时校验rabbitmq是否连接成功
不靠谱助手的博客
04-29 488
springboot 启动时校验rabbitmq是否连接成功
RabbitMQ初级篇：生产者与消费者关系、消息确认机制（ACK）、交换器与队列进行消息路由和存储
weixin_45198167的博客
05-10 1910
RabbitMQ中的消息确认机制，即ACK（Acknowledgement），是为了确保消息成功地从生产者传递到消费者。消费者处理完一个消息后，需要向RabbitMQ服务器发送一个ACK信号，告知服务器该消息已收到且处理完毕，允许服务器删除这个消息。如果在消费者处理消息过程中发生异常或宕机，由于已经发送了ACK信号，服务器将认为消息已被处理，从而导致消息丢失。生产者将消息发送到交换器，交换器根据消息的路由键将其放入相应的队列中，最后消费者从队列中获取并处理这些消息。，并为消费者准备好消息以进行消息消费。
RabbitMQ基本操作
michael_linux的博客，一个小小小学生。滴水穿石，步步为营，只为那刹那芳华。
05-09 2520
1、linux安装rabbitmq 2、windows安装rabbitmq 3、rabbitMq相关名词概念 4、
在IDEA中更改项目名（project）
热门推荐
a67879431的博客
04-09 3万+
在IDEA中更改项目名步骤 步骤 在File — Projects Structure中选择Project一栏，修改Project name，这里我将Test修改为someTest 2. 打开该项目所在的文件夹，将项目文件夹名称由Test更改为someTest 3. 回到IDEA中，发现项目消失了，不着急，我们按照File — Projects Structure，打开窗口后我切换到Modules一栏，在右侧的Sources一栏中，点击右侧标红的目录的小叉 4. 点击Add Content Roo
Java中静态成员及常量池的存储位置
a67879431的博客
04-08 3290
文章目录Java中，静态成员的存储位置JDK1.8以前JDK1.8以后Java中，常量池的存储位置JDK1.6及以前JDK1.7JDK1.8以后 Java中，静态成员的存储位置 JDK1.8以前 在JDK1.8以前，静态成员存储在方法区（永久代）中，此时方法区的实现叫做永久代 JDK1.8以后 在JDK1.8以后，永久代被移除，此时方法区的实现更改为元空间，但由于元空间主要用于存储字节码文件.class，因此静态成员的存储位置从方法区更改到了堆内存中 Java中，常量池的存储位置 JDK1.6及以前 在JD
RabbitMQ 消息队列应用开发指南
RabbitMQ 是一个开源的消息代理，实现了 AMQP 协议。近几年来，其 popularity 不断增长。最初，只有少数敢于尝试的公司使用 RabbitMQ，但现在越来越多的公司发现了 RabbitMQ 的优点，以及使用消息队列在软件工程中的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值