RabbitMQ使用手册

最新推荐文章于 2024-09-02 14:52:52 发布
最新推荐文章于 2024-09-02 14:52:52 发布
阅读量1.1k 收藏 2
点赞数
分类专栏： RabbitMQ 文章标签： RabbitMQ 消息中间件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SuperstarSteven/article/details/114638377
版权

1. RabbitMQ配置

1.1RabbitMQ管理命令行

# 1.服务器启动相关命令行
systemctl start|restart|stop|status rabbitmq-server
# 2.管理命令行
rabbitmqctl help #查看更多命令
# 3.插件管理命令行
rabbitmq-plugins enable|disable|list
1.2 Web管理界面介绍
1.2.1 OverView概览

image-20201114094327707

2. 消息队列模式

第一种模型（直连）

image-20201114094618637

在上图所示的模型中有以下概念

  • P：生产者
  • C：消费者
  • queue：消息队列

1.开发生产者

connection = RabbitmqUtils.getConnection();
channel = connection.createChannel();
/**
 * 参数一：队列名字(不存在会自动创建)、参数二：是否要持久化、
 * 参数三：是否独占队列、参数四：是否自动删除队列
 * 参数五：额外参数
 */
channel.queueDeclare("hello", false, false, false, null);
/**
 * 参数一：交换机名称、参数二：队列名称、
 * 参数三：额外消息设置、参数四：消息具体内容
 */
channel.basicPublish("", "hello", false, false, null, "hello rabbitmq".getBytes());

2.消费者

Connection connection = RabbitMqUtils.getConnection();
Channel channel = connection.createChannel();
//通道绑定队列
channel.queueDeclare("hello",false,false,false,null);
/**
 * 参数一：队列名称、参数二：消息自动确认
 */
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));
    }
});

工具类RabbitMQUtils.java

package com.rabbitmq.study;

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

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

/**
 * @FileName: RabbitMQUtils
 * @Author Steven
 * @Date: 2020/11/14
 */
public class RabbitMQUtils {
    private static ConnectionFactory factory;

    static {
        factory = new ConnectionFactory();
        factory.setHost("xxx.xxx.xxx.xxx");
        factory.setPort(5672);
        factory.setVirtualHost("/cms");
        //这只访问虚拟主机的用户名、密码
        factory.setUsername("ems");
        factory.setPassword("123");

    }

    public static Connection getConnection() {
        try {
            return factory.newConnection();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static void closeChannelAndConn(Channel channel, Connection conn) {
        try {
            if (channel != null) {
                channel.close();
            }
            if (conn != null) {
                conn.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3.参数说明

/**
* 参数一：队列名字(不存在会自动创建)、参数二：是否要持久化、
* 参数三：是否独占队列、参数四：是否自动删除队列
* 参数五：额外参数
*/
channel.queueDeclare("aa", true, false, false, null);

第二种模型（work queue）

image-20201114164419337

work queue，也被称为(task queue),任务模型，多个消费者绑定一个队列共同消费，队列中的消息一旦被消费就会消失，因此消息不回被重复消费

角色：

  • P：生产者，任务发布
  • queue：队列存放消息
  • C1：消费者1，消费消息较慢
  • C2：消费者2，消费消息较快

1.生产者Send.java

Connection connection = RabbitMQUtils.getConnection();
Channel channel = connection.createChannel();
/**
 * 参数一：队列名字(不存在会自动创建)、参数二：是否要持久化、
 * 参数三：是否独占队列、参数四：是否自动删除队列
 * 参数五：额外参数
 */
channel.queueDeclare("work", true, false, false, null);
/**
 * 参数一：交换机名称、参数二：队列名称、
 * 参数三：额外消息设置、参数四：消息具体内容
 */
for (int i = 1; i <=100 ; i++) {
    channel.basicPublish("", "work", false, false, MessageProperties.PERSISTENT_TEXT_PLAIN, (i+"hello rabbitmq").getBytes());
}
RabbitMQUtils.closeChannelAndConn(channel,connection);

2.消费者:Recv1.java

Connection connection = RabbitMQUtils.getConnection();
Channel channel = connection.createChannel();
channel.queueDeclare("work",true,false,false,null);
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));
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});

3.消费者:Recv2.java

Connection connection = RabbitMQUtils.getConnection();
Channel channel = connection.createChannel();
channel.queueDeclare("work",true,false,false,null);
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));
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});

消息确认机制

1.消费者：Recv1.java

Connection connection = RabbitMQUtils.getConnection();
Channel channel = connection.createChannel();
//每次只能消费一个消息
channel.basicQos(1);
channel.queueDeclare("work", true, 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));
        //参数1：确认具体为队列中的那个消息，参数2：是否同时确认多个消息
        channel.basicAck(envelope.getDeliveryTag(),false);
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});

2.消费者：Recv2.java

Connection connection = RabbitMQUtils.getConnection();
Channel channel = connection.createChannel();
//每次只能消费一个消息
channel.basicQos(1);
channel.queueDeclare("work",true,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));
        //参数1：确认具体为队列中的那个消息，参数2：是否同时确认多个消息
        channel.basicAck(envelope.getDeliveryTag(),false);
    }
});

第三种模型(fanout)

fanout：扇出，又称为广播

image-20201116225823129

在广播模式下，消息发送流程

  • 多个消费者
  • 每个消费者都绑定这自己的队列(queue)
  • 每个队列都要绑定到交换机(exchange)上
  • 生产者只将消息发送给交换机
  • 交换机(exchange)决定将消息发送给哪个队列

1.开发生产者：send.java

Connection connection = RabbitMQUtils.getConnection();
Channel channel = connection.createChannel();  
/**
    * 通道声明为交换机
    * 参数1：交换机名称、参数2：交换机类型 fanout:代表广播类型
 */
channel.exchangeDeclare("logs","fanout");
channel.basicPublish("logs","",null,"RabbitMq fanout".getBytes());

2.消费者：Recv.java

channel.exchangeDeclare("logs","fanout");
//创建临时队列
String queueName = channel.queueDeclare().getQueue();
channel.queueBind(queueName,"logs","");
channel.basicConsume(queueName,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));
    }
});

第四种模型(Routing)

1.Routing之订阅模型-Direct(直连)

在fanout模式中，一条消息，会被所有订阅的消费者消费，但在某些情景下，我们希望不同的消息被不同的消费者消费，这时就用到Direct类型的Exchange。

在Direct模型下：

  • 队列与交换机绑定，不能任意绑定，而是指定一个RoutingKey(路由key)
  • 生产者向Exchange(交换机)发送消息时需要指定RoutingKey​(路由key)
  • Exchange不在把消息交给绑定的队列，而是根据消息的Routing Key进行判断，只有当消息中的Routing Key队列中的Routing Key完全一致才会收到消息

流程

image-20201119101017421

图解

  • P：生产者，向exchange发送消息时会指定一个Routing Key
  • X：Exchange(交换机)，接受生产者消息，然后把消息发送给与Routing Key相同的队列
  • C1：消费者，指定需要接受Routing Key为error的消息
  • C2：消费者，指定需要接受Routing key为error、info、warning的消息

1.生产者

Connection connection = RabbitMQUtils.getConnection();
Channel channel = connection.createChannel();
channel.exchangeDeclare("direct.logs", "direct");
String queueName = channel.queueDeclare().getQueue();
String routingKey = "error";
channel.queueBind(queueName, "direct.logs", routingKey);
channel.basicPublish("direct.logs", routingKey, null, (routingKey + " Rabbit Direct").getBytes("utf-8"));
RabbitMQUtils.closeChannelAndConn(channel, connection);

2.消费者-1

channel.exchangeDeclare("direct.logs", "direct");
String queueName = channel.queueDeclare().getQueue();

channel.queueBind(queueName, "direct.logs", "info");
channel.queueBind(queueName, "direct.logs", "warning");
channel.queueBind(queueName, "direct.logs", "error");
channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        System.out.println("Recv1日志：" + new String(body));
    }
});

3.消费者-2

Connection connection = RabbitMQUtils.getConnection();
Channel channel = connection.createChannel();
/**
 * 参数一：交换机名称、参数二：交换机的类型：(direct)直连式
 */
channel.exchangeDeclare("direct.logs", "direct");
/**
 * 声明一个临时队列
 */
String queueName = channel.queueDeclare().getQueue();
/**
 * 参数一：队列名称、参数二：交换机名称、参数三：RoutingKey(路由key)
 */
channel.queueBind(queueName, "direct.logs", "info");
channel.queueBind(queueName, "direct.logs", "warning");
channel.queueBind(queueName, "direct.logs", "error");
channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        System.out.println("Recv1日志：" + new String(body));
    }
});

2.Routing之订阅模型-Topic(直连)

topic类型的exchange与direct相比，都可以根据RoutingKey把消息路由到不同的队列中，只不过topic在绑定队列时RoutingKey可以使用通配符，这种模型RoutingKey一般有一个或多个单词组成多个单词间用“.”分割类如：item.insert

image-20201122103218370 
# 通配符
 *(start):匹配一个单词
 #(start):匹配多个单词
#如:
 hello.*: hello.java、hello.world
 hello.#: hello.java.world

1.生产者：send.java

Connection connection = RabbitMQUtils.getConnection();
Channel channel = connection.createChannel();
// 参数一：交换机名称
channel.exchangeDeclare("topics","topic");
String routingKey="user.save.findAll";
channel.basicPublish("topics",routingKey,null,("RabbitMQ Topic RoutingKey:"+routingKey).getBytes());
RabbitMQUtils.closeChannelAndConn(channel,connection);

2.消费者：Recv.java

Connection connection = RabbitMQUtils.getConnection();
Channel channel = connection.createChannel();
channel.exchangeDeclare("topics","topic");
String queueName = channel.queueDeclare().getQueue();
String routingKey="user.#";
channel.queueBind(queueName,"topics",routingKey);
channel.basicConsume(queueName,true,new DefaultConsumer(channel){
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        System.out.println("RabbitMQ tutorials Topic:"+new String(body));
    }
});

3.SpringBoot整合RabbitMQ

3.1 初始环境单间

1.引入依赖

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

2.在application.yml中添加相关配置

server:
  address: 8080
spring:
  rabbitmq:
    addresses: 47.101.36.177
    username: ems
    password: 123
    virtual-host: /cms
    port: 5672
  application:
    name: rabbitmq-study

RabbitMQ简化操作对象，使用时直接在项目中注入即可

3.2 第一种Hello World模型使用

1.生产者:Send.java

//注入RabbitMQ模板对象
@Autowired
private RabbitTemplate rabbitTemplate;

@Test
public void testHelloWord() {
    rabbitTemplate.convertAndSend("hello","hello world");
}

2.消费者:HelloConsumer.java

@Component
// 持久化，非独占、非自动删除的队列
@RabbitListener(queuesToDeclare = @Queue(value = "hello",durable = "false",autoDelete = "false"))
public class HelloConsumer {
    @RabbitHandler
    public void recive(String message){
        System.out.println("消息队列中的消息："+message);
    }
}

3.3 第二种work queue模型使用

1.生产者：Send.java

@Test
public void testWork(){
    for (int i = 0; i < 10; i++) {
        rabbitTemplate.convertAndSend("work","Work模型");
    }

}

2.消费者：WorkConsumer.java

@Component
public class WorkConsumer {

    @RabbitListener(queuesToDeclare=@Queue("work"))
    public void receive1(String message){
        System.out.println("work model1:"+message);
    }

    @RabbitListener(queuesToDeclare=@Queue("work"))
    public void receive2(String message){
        System.out.println("work model2:"+message);
    }
}

3.4第三种广播模型(fanout)使用

1.生产者：send.java

/**
 * 广播模型fanout
 */
@Test
public void fanoutModel(){
    rabbitTemplate.convertAndSend("logs","","fanout广播模型");
}

2.消费者：FanoutConsumer

@Component
public class FanCoutModel {

    @RabbitListener(bindings = {
            @QueueBinding(value = @Queue,//不指定时，创建临时队列
                    exchange =@Exchange(name = "logs",type = "fanout"))
    })
    public void receive1(String message){
        System.out.println("message1:"+message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(value = @Queue,//不指定时，创建临时队列
                    exchange =@Exchange(name = "logs",type = "fanout"))
    })
    public void receive2(String message){
        System.out.println("message1:"+message);
    }

}

3.5第三种路由(RoutingKey)模型使用

1.生产者：send.java

/**
 * route模式
 */
@Test
public void testRoute(){
    rabbitTemplate.convertAndSend("directs","error","通过路由发送error信息");
}

2.消费者：RouteConsumer.java

@Component
public class RouteConsumer {
    @RabbitListener(bindings = {
            @QueueBinding(value = @Queue,exchange = @Exchange(name = "directs",type = "direct"),
                    key = {"info","error","warning"})
    })
    public void receive1(String message){
        System.out.println("receive1:"+message);
    }
    @RabbitListener(bindings = {
            @QueueBinding(value = @Queue,exchange = @Exchange(name = "directs",type = "direct"),
            key ={"error"})
    })
    public void receive2(String message){
        System.out.println("receive2:"+message);
    }

}

3.6第三种动态路由模型(Topic)使用

1.生产者：send.java

/**
 * topic模式(动态路由)
 */
@Test
public void testTopic(){
    rabbitTemplate.convertAndSend("topics","user.save","topic动态路由模式");
}

2.消费者：TopicConsumer.java

@Component
public class TopicConsumer {

    @RabbitListener(bindings = {
            @QueueBinding(value = @Queue,exchange = @Exchange(
                    value = "topics",type = "topic"
            ),key = {"user.*"})
    })
    public void receive1(String message){
        System.out.println("receive1:"+message);
    }

    @RabbitListener(bindings = {@QueueBinding(value = @Queue,exchange = @Exchange(
            name = "topics",type = "topic"),key = {"user.#"})})
    public void receive2(String message){
        System.out.println("receive2:"+message);
    }
}

4.RabbitMQ集群

4.1集群架构
4.1.1普通集群(副本集群)
Java编程之道
关注
专栏目录
RabbitMQ服务使用手册.doc
01-18
RabbitMQ服务使用手册，详细的介绍了rabbitmq的原理、使用和监控
rabbitMQ使用手册
06-03
关于rabbitMQ的交换机使用方式！便于了解rabbitMQ的使用！
花了3天总结的RabbitMQ实用技巧，有点东西
weixin_50666791的博客
10-14 143
以前看过的关于RabbitMQ核心消息模式的文章都是基于Java API的，最近看了下官方文档，发现这些核心消息模式都可以通过Spring AMQP来实现。于是总结了下RabbitMQ的实用技巧，包括RabbitMQ在Windows和Linux下的安装、5种核心消息模式的Spring AMQP实现，相信对于想要学习和回顾RabbitMQ的朋友都会有所帮助。 简介 RabbitMQ是最受欢迎的开源消息中间件之一，在全球范围内被广泛应用。RabbitMQ是轻量级且易于部署的，能支持多种消息协议。Rabb.
RabbitMQ 应用
最新发布
不能再留遗憾了的博客
09-02 1094
rabbitmq应用
RabbitMQ手册
chengl2015的博客
06-06 220
rabbitmq 学习-1-AMQP介绍 AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准， 为面向消息的中间件设计。 AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。 AMQP在...
RabbitMQ用户指南（RabbitMQ-C）
weixin_34250709的博客
04-13 672
RabbitMQ-C客户端使用说明 rabbitmq-c是一个用于C语言的，与AMQP server进行交互的client库，AMQP协议为版本0-9-1。rabbitmq-c与server进行交互前需要首先进行login操作，在操作后，可以根据AMQP协议规范，执行一系列操作。 这里，根据项目需求，只进行部分接口说明，文后附demo的github地址。   接口描述： amqp_c...
RabbitMQ指南（中）
GarfieldEr007的专栏
08-21 854
原文出处： Listen 在上一篇文章中，介绍了使用RabbitMQ的Hello World例子， 以及如何创建一个work queue。在work queue的例子中每条消息都只会被传递到一个work queue中。 在这篇文章中我们将会学习另一种完全不同的传递消息的方式——每条消息将会被传递给所有的consumer，这种模式一般被称为“发布/订阅”。 发布/订阅(Publish
RabbitMQ介绍+使用手册
qq_43617638的博客
03-11 2668
RabbitMQ在window下的使用方法。
RabbitMq使用手册
12-07
RabbitMq 使用手册 本文档为 RabbitMq 使用手册，介绍了 RabbitMq 的应用场景和开发指导。RabbitMq 是一个由 Erlang 开发的 AMQP（Advanced Message Queue）流行的开源消息队列系统。RabbitMq 的结构图如下： ...
RabbitMQ使用手册V1.0.0.pdf
06-28
它能够实现组件之间的解耦，例如，一个日志系统可以使用RabbitMQ来简化工作，其中不同的消费者可以分别进行消息处理和日志记录，消息分发的工作则由RabbitMQ自动完成。 RabbitMQ的核心概念和特性包括交换机...
rabbitmq 操作手册
12-08
rabbitmq 操作手册
RabbitMQ用户手册
10-12
RabbitMQ用户手册,RabbitMQ默认绑定所有可用的IPv4和IPv6地址，你可以设置该值来只绑定单个地址。 RABBITMQ_NODE_PORT Defaults to 5672. 默认5672端口
RabbitMQ开发中文文档
07-25
RabbitMQ是一个消息服务器。从本质上讲，它接收生产者生产的消息，并发送给消费者。期间，它可以根据用户给定的规则来路由、缓存、持久化这些消息。此文为RabbitMQ的中文翻译文档
rabbitmq使用手册
07-14
以下是RabbitMQ的使用手册： 1. 安装和配置RabbitMQ：可以从RabbitMQ官网下载适合自己系统的安装包，安装完成后需要进行配置，包括设置用户权限、虚拟主机等。 2. RabbitMQ管理界面：RabbitMQ提供了Web管理界面，...
RabbitMQ安装手册
weixin_30840253的博客
09-09 110
1.1 Linux下安装 1.1. 安装Erlang 1.1.1. 添加yum支持 cd /usr/local/src/ mkdir rabbitmq cd rabbitmq wget http://packages.erlang-solutions.com/erlang-solutions-1.0-1.noarch.rpm rpm -Uvh erlang-soluti...
在 Windows 上安装Rabbit MQ 指南
weixin_34220623的博客
11-01 147
rabbitMQ是一个在AMQP协议标准基础上完整的，可服用的企业消息系统。他遵循Mozilla Public License开源协议。采用 Erlang 实现的工业级的消息队列(MQ)服务器。      RabbitMQ的官方站：http://www.rabbitmq.com/        AMQP(高级消息队列协议) 是一个异步消息传递所使用的应用层协议规范，作为线路层协议，而不是API（...
rabbitmq-service用户手册（翻译）
yasi_xi的专栏
03-09 2822
转自：http://www.verydemo.com/demo_c230_i793.html 通过 http://www.rabbitmq.com/manpages.html 可知 RabbitMQ 有5个 General Command ： 1. rabbitmqctl  2. rabbitmq-plugins  3. rabbitmq-server  4. rabbitm
绝对详细的 RabbitMQ 实践操作手册（一）
qq_14817417的博客
02-27 1628
RabbitMQ使用手册（一）基本概念
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值