2.2rabbitMq基础操作

最新推荐文章于 2022-03-17 12:21:55 发布
最新推荐文章于 2022-03-17 12:21:55 发布
阅读量230 收藏
点赞数
分类专栏： 消息队列 消息队列基础，及其操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c_royi/article/details/86690054
版权

rabbitMq基础操作 并整合 springboot

github：https://github.com/Plumblumpb/messageQueue-.git
rabbitMq文章（可以先观看）：https://blog.csdn.net/c_royi/article/details/86630777

 rabbitMq基础操作

pom.xml文件

<dependency>
   <groupId>com.rabbitmq</groupId>
   <artifactId>amqp-client</artifactId>
   <version>5.4.3</version>
</dependency>
  1.queue模式


生产者

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

/**
 * @Auther: cpb
 * @Date: 2019/1/24 16:01
 * @Description:
 */
public class Producer {
    private final static String QUEUE_NAME = "helloMytest";

    public static void main(String[] args) throws IOException {
        try {
            /**
             * 创建连接连接到MabbitMQ
             */
            ConnectionFactory factory = new ConnectionFactory();
            // 设置MabbitMQ所在主机ip或者主机名
            factory.setHost("localhost");            //factory.setUsername("lp");//factory.setPassword("");// factory.setPort(2088);
            // 创建一个连接
            Connection connection = factory.newConnection();
            // 创建一个频道
            Channel channel = connection.createChannel();
            // 发送的消息
            String message = "hello 你好";

            // 指定一个队列【参数说明：参数一：队列名称，参数二：是否持久化；参数三：是否独占模式；参数四：消费者断开连接时是否删除队列；参数五：消息其他参数】
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            // 往队列中发出一条消息【参数说明：参数一：交换机名称；参数二：路由键名称，参数三：消息的其他属性-routing headers，此属性为MessageProperties.PERSISTENT_TEXT_PLAIN用于设置纯文本消息存储到硬盘；参数四：消息主体】
            for(int i = 0 ; i<10 ; i++) {
                channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            }
            System.out.println(" 消息队列信息：" + message );
            // 关闭频道和连接
            channel.close();
            connection.close();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

消费者

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


/**
 * @Auther: cpb
 * @Date: 2019/1/24 15:53
 * @Description:
 */
public class Customer {
    private static final String QUEUE_NAME ="helloMytest";

    public static void main(String[] argv) throws Exception {
        //建立连接和通道
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        //consumer消费完一条信息后producer才能发送。prefetch
        channel.basicQos(1);
        //声明要消费的队列【参数说明：参数一：队列名称，参数二：是否持久化；参数三：是否独占模式；参数四：消费者断开连接时是否删除队列；参数五：消息其他参数】
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        //回调消费消息
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            }
        };
        //【参数说明：参数一：队列名称，参数二：ack，表示消费者接受完参数mq才能删除消息；参数三：消费者回调函数】
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}
  2.topic模式

exchange类型为：fanout交换器
在这里插入图片描述
生产者


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

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

/**
 * @Auther: cpb
 * @Date: 2019/1/24 16:01
 * @Description:
 */
public class Producer {
    private static final String EXCHANGE_NAME = "logs";

    public static void main(String[] argv) {

        try {
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            //exchange：交换机名称，type:类型，durable：消息是否启用持久化，autoDelete：是否自动删除，internal，argument
            channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

            String message = "测试topic模式";
            //exchange:交换机名称，routing :路由键，
            channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes());
            System.out.println(" [x] Sent '" + message + "'");

            channel.close();
            connection.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

消费者

import com.rabbitmq.client.*;

import java.io.IOException;


/**
 * @Auther: cpb
 * @Date: 2019/1/24 15:53
 * @Description:
 */
public class Customer {
    private static final String EXCHANGE_NAME = "logs";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        //声明交换机名称及其类型
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        //创建随机队列名称
        String queueName = channel.queueDeclare().getQueue();
        //绑定交换机和队列之间的关系；destination：队列名称，source：交换机名称，routing:路由键，map：arguments
        channel.queueBind(queueName, EXCHANGE_NAME, "");

        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            }
        };
        channel.basicConsume(queueName, true, consumer);
    }
}
  3.routing模式

exchange类型：direct交换器
在这里插入图片描述
生产者

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

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

/**
 * @Auther: cpb
 * @Date: 2019/1/24 16:01
 * @Description:
 */
public class Producer {
    private static final String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] argv) {
        try {
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();

            channel.exchangeDeclare(EXCHANGE_NAME, "direct");

            String routing = "delete";
            String message = "测试 delete";

            String routing1 = "insert";
            String message2 = "测试 insert";
            channel.basicPublish(EXCHANGE_NAME, routing, null, message.getBytes());
            System.out.println(" [x] Sent '" + routing + "':'" + message + "'");
            channel.basicPublish(EXCHANGE_NAME, routing1, null, message2.getBytes());
            System.out.println(" [x] Sent '" + routing1 + "':'" + message2 + "'");

            channel.close();
            connection.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

消费者

//消费者1
public class Customer1 {
    private static final String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        //随机生成队列名称
        String queueName = channel.queueDeclare().getQueue();
        //声明交换机名称和类型
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        //绑定插入队列
        channel.queueBind(queueName,EXCHANGE_NAME,"insert");
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + envelope.getRoutingKey() + "':'" + message + "'");
            }
        };
        channel.basicConsume(queueName, true, consumer);
    }
}


//消费者2
public class Customer2 {
    private static final String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        //随机生成队列名称
        String queueName = channel.queueDeclare().getQueue();
        //声明交换机名称和类型
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        //绑定删除队列
        channel.queueBind(queueName,EXCHANGE_NAME,"delete");


        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + envelope.getRoutingKey() + "':'" + message + "'");
            }
        };
        channel.basicConsume(queueName, true, consumer);
    }
}
  4.topics模式

exchange类型：topic交换器
在这里插入图片描述
生产者

public class Producer {

    private static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] args) throws IOException {
        try {
            ConnectionFactory factory = new ConnectionFactory();
            // 设置MabbitMQ所在主机ip或者主机名
            factory.setHost("localhost");            //factory.setUsername("lp");//factory.setPassword("");// factory.setPort(2088);
            // 创建一个连接
            Connection connection = factory.newConnection();
            // 创建一个频道
            Channel channel = connection.createChannel();
            channel.exchangeDeclare(EXCHANGE_NAME, "topic");

            String routingKey = "fruit.colour";
            String message = "Hello orange and black ";

            String routingKey1 = "animal.colour";
            String message1 = "Hello black and rabbit ";

            String routingKey2 = "animal";
            String message2 = "Hello rabbit";



            channel.queueDeclare(routingKey, false, false, false, null);
            channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes());
            System.out.println(" 消息队列信息：" + message );

            channel.queueDeclare(routingKey1, false, false, false, null);
            channel.basicPublish(EXCHANGE_NAME, routingKey1, null, message1.getBytes());
            System.out.println(" 消息队列信息：" + message1 );

            channel.queueDeclare(routingKey2, false, false, false, null);
            channel.basicPublish(EXCHANGE_NAME, routingKey2, null, message2.getBytes());
            System.out.println(" 消息队列信息：" + message2 );





            // 关闭频道和连接
            channel.close();
            connection.close();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

消费者

//消费者1
public class Customer1 {
    private static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        //随机生成队列名称
        String queueName = channel.queueDeclare().getQueue();
        //声明交换机名称和类型
        channel.exchangeDeclare(EXCHANGE_NAME, "topic");
        //绑定插入队列
        channel.queueBind(queueName,EXCHANGE_NAME,"animal");
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + envelope.getRoutingKey() + "':'" + message + "'");
            }
        };
        channel.basicConsume(queueName, true, consumer);
    }
}


//消费者2

public class Customer2 {
    private static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        //随机生成队列名称
        String queueName = channel.queueDeclare().getQueue();
        //声明交换机名称和类型
        channel.exchangeDeclare(EXCHANGE_NAME, "topic");
        //绑定删除队列
        channel.queueBind(queueName,EXCHANGE_NAME,"*.colour");


        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + envelope.getRoutingKey() + "':'" + message + "'");
            }
        };
        channel.basicConsume(queueName, true, consumer);
    }
}
plumblum
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#操作RabbitMQ的完整实例
12-25
一、下载RabbitMQ http://www.rabbitmq.com/install-windows.html 二、下载OTP http://www.erlang.org/downloads 三、安装OTP、RabbitMQ 四、配置RabbitMQ 找到bat的目录 执行相关命令 1.添加用户密码 ...
RabbitMQ高级：内存磁盘的监控
祝我飞黄腾达
03-24 3350
RabbitMQ作为一个异步存储消息的中间件，并不是无休止的疯狂接收消息，消息的可靠性和存储靠的是磁盘和内存，因此我们需要时刻关注服务器的内存空间和磁盘空间 RabbitMQ的内存警告 如下图所示，可以通过图形化界面的Memory一栏，查看RabbitMQ目前内存使用情况 在Memory内存使用空间一栏中，存在2个参数，分别是：76MiB、6.4GiB high watermark 76MiB：RabbitMQ当前已经使用了76MB内存 6.4GiB high wate...
RabbitMQ内存与磁盘管理
weixin_34115824的博客
04-28 1239
2019独角兽企业重金招聘Python工程师标准>>> ...
rabbitmq的基本操作和使用
小飞技术
07-11 462
一、下载 docker pull rabbitmq:3-management 二、启动
RabbitMQ基础概念详细介绍
woailuohui的专栏
08-14 9008
RabbitMQ简介 AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。RabbitMQ是一个开源的AMQP实现，服务器端用Erl...
RabbitMq 最全的性能调优笔记
weixin_34062469的博客
09-11 8608
RabbitMq 性能调优笔记 [TOC] 避免雷区 要避免流控机制触发 服务端默认配置是当内存使用达到40%，磁盘空闲空间小于50M，即启动内存报警，磁盘报警；报警后服务端触发流控（flowcontrol）机制。 一般地，当发布端发送消息速度快于订阅端消费消息的速度时，队列中堆积了大量的消息，导致报警，就会触发流控机制。 触发流控机制...
Python操作rabbitMQ的示例代码
09-19
主要介绍了Python操作rabbitMQ的示例代码，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
RabbitMQ入门操作手册.pdf
12-11
RabbitMQ是一个开源的AMQP实现，服务器端用...用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗，成为主流mq使用之一，因为使用Erlang语言 天生抗并发的性质，所以RabbitMQ技术必须掌握。
RabbitMQ基本概念和使用
01-30
RabbitMQ是一个消息代理，核心原理：发送消息，接收消息...首先通过一个非常简单的”helloworld“例子介绍如何使用RabbitMQ，然后再介绍其涉及的基本概念并对交换机和队列多做点介绍。本例非常简单——发送一个消息”h
RabbitMQ学习——基本概念
日积月累，天道酬勤
12-05 335
AMQP 高级消息队列协议(Advanced Message Queuing Protocl,AMQP) 具有现代特性的二进制协议。是一个提供统一消息服务的应用层标准高级消息队列协议， 是应用层协议的一个开放标准，为面向消息的中间件设计的。 AMQP协议模型 Server(Broker): 接受客户端的连接，实现AMQP实体服务 Connection:连接，应用程序与Broker的网络连接 C...
rabbitMQ后台操作
qq_30442413的博客
07-18 1156
1.队列的创建        2.在java中操作队列的时候需要的参数 3. 两种清除方式  
RabbitMQ基础操作命令
Noonebirdyou的博客
01-21 6253
RabbitMQ基础操作命令
RabbitMQ的基本使用
qq_54936371的博客
02-25 1862
RabbitMQ是一个开源的消息代理和队列服务器，用来通过普通协议在完全不同的应用之间共享数据，RabbitMQ是使用Erlang语言来编写的，并且RabbitMQ是基于AMQP协议的。 一、消息队列 1、MQ：Message Queue释义 服务之间最常见的通信方式是直接调用彼此来通信,消息从一端发出后立即就可以达到另一端,称为即时消息通讯(同步通信) 消息从某一端发出后,首先进入一个容器进行临时存储,当达到某种条件后,再由这个容器发送给另一端,称为延迟消息通讯(异步通信) 2、消息队列特点.
RabbitMQ消息队列入门篇（环境配置+Java实例+基础概念）
weixin_30480651的博客
01-09 1339
一、消息队列使用场景或者其好处 消息队列一般是在项目中，将一些无需即时返回且耗时的操作提取出来，进行了异步处理，而这种异步处理的方式大大的节省了服务器的请求响应时间，从而提高了系统的吞吐量。 在项目启动之初来预测将来项目会碰到什么需求，是极其困难的。消息队列在处理过程中间插入了一个隐含的、基于数据的接口层，两边的处理过程都要实现这一接口。这允许你独立的扩展或修改两边的处理过...
rabbitmq简单使用
星月IWJ
11-23 244
下载Erlang，地址：http://www.erlang.org/download/otp_win32_R15B.exe ，双击安装即可（首先装） 下载RabbitMQ，地址：http://www.rabbitmq.com/releases/rabbitmq-server/v3.3.4/rabbitmq-server-3.3.4.exe，双击安装即可 下载rabbit-client.
RabbitMQ教程(安装与使用详解,Spring集成)
热门推荐
鸟哥哥的专栏
12-26 50万+
RabbitMQ教程，面试题。消息队列(MQ)，本质是个队列，队列中存放的内容是message。MQ用于不同进程Process/线程Thread之间通信。本文介绍RabbitMQ的使用。RabbitMQ实战教程。
RabbitMQ使用方法最详细攻略
DreamsArchitects的博客
03-17 3317
本文内容主要包括： 1. RabbitMQ的安装部署 2. AMQP架构 3. RabbitMQ的通信方式 4. RabbitMQ整合SpringBoot 5. RabbitMQ保证消息可靠性 6. RabbitMQ死信队列和延时交换机 7. RabbitMQ集群高可用
Flink Watermark 机制浅析(透彻)
weixin_34233421的博客
06-03 5661
2019独角兽企业重金招聘Python工程师标准>>> ...
RabbitMQ（三）HelloWorld入门程序
diweikang的博客
08-02 611
了解了RabbitMQ的基本概念之后我们来写一个简单的入门程序HelloWorld。一个producer发送消息，一个接收者接收消息，并在控制台打印出来。如下图： 发送端：Send.java 连接到RabbitMQ（此时服务需要启动），发送一条数据，然后退出。 package com.kang.mq; import com.rabbitmq.client.Channel; import...
rabbitmq 命令行操作
最新发布
08-10
RabbitMQ是一个流行的消息代理中间件，它通过AMQP（高级消息队列协议）实现了消息的传递。在命令行中，你可以使用RabbitMQ提供的命令行工具来执行一些基本的操作。以下是一些常用的RabbitMQ命令行操作： 1. 启动RabbitMQ服务器： ``` rabbitmq-server ``` 2. 停止RabbitMQ服务器： ``` rabbitmqctl stop ``` 3. 列出所有队列： ``` rabbitmqctl list_queues ``` 4. 创建一个队列： ``` rabbitmqctl add_queue <queue_name> ``` 5. 删除一个队列： ``` rabbitmqctl delete_queue <queue_name> ``` 6. 发布消息到队列： ``` rabbitmqadmin publish routing_key=<routing_key> payload=<message> exchange=<exchange_name> ``` 7. 从队列中获取消息： ``` rabbitmqadmin get queue=<queue_name> ``` 8. 创建一个交换机： ``` rabbitmqadmin declare exchange name=<exchange_name> type=<exchange_type> ``` 9. 绑定队列到交换机： ``` rabbitmqadmin declare binding source=<source_exchange> destination=<destination_queue> routing_key=<routing_key> ``` 这些是一些基本的RabbitMQ命令行操作，它们可以帮助你在命令行中进行队列、交换机和消息的管理。请注意，你需要安装并正确配置RabbitMQ服务器和命令行工具才能执行这些操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值