（一）安装RabbitMQ&概念&命令使用&快速起步

最新推荐文章于 2023-10-07 08:36:53 发布
最新推荐文章于 2023-10-07 08:36:53 发布
阅读量211 收藏
点赞数
分类专栏： # RabbitMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiamaocheng/article/details/104928022
版权

安装RabbitMQ:

RabbitMQ 概念：

命令使用

快速起步

-------------------------

安装RabbitMQ:

windows 下安装教程：

https://blog.csdn.net/zhm3023/article/details/82217222

Linux 下安装：(暂略)

 

交换机概念：

一个图：

 

 

直接交换机器：

交换机和Exchange  连接管道，

交换机定义：

直接交换机通过绑定绑定一个队列，带入那个必须完全匹配，发消息的时候，原来的时候

完全匹配，直接交换机器，

 

主题交换机：

最先的匹配上，topic 交换机：绑定的视乎---tuling,key.*----队列

或者是井号，多个单词，发送消息的时候，带入的那个key和原来的绑定的

key完全匹配，路由队列的。

 

扇形交换机：

 

三种交换机性能上比较：扇形交换机最高，因为不需要字符串比较。

命令使用：

查看查看所有的队列

清除所有的队列：

查看用户：

查看状态：

创建用户：

授予用户权限：

改变用户密码信息：

changer_password zhangsan zhangsan

这些命令也可以在管理控制台完成。

参见相关命令手册：

 

快速起步：

生产端：

package com.tuling.quickstart;

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 RabbitmqProducter {

    public static void main(String[] args) throws IOException, TimeoutException {
        //1:创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();

        //2设置连接工厂的属性
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");

        //3:通过连接工厂创建连接对象
        Connection connection = connectionFactory.newConnection();

        //4:通过连接创建channel
        Channel channel = connection.createChannel();

        //5:通过channel发送消息
        for(int i=0;i<5;i++) {
            String message = "hello--"+i;
           
            channel.basicPublish("","tuling-queue-01",null,message.getBytes());
        }

        //6:关闭连接
        channel.close();
        connection.close();
    }
}

2.消费端：

package com.tuling.quickstart;

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

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


public class RabbitmqConsumer {

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {

        //创建连接工厂
        ConnectionFactory connectionFactory  = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");

        //创建连接
        Connection connection = connectionFactory.newConnection();

        //创建一个channel
        Channel channel = connection.createChannel();

        //声明队列
        String queueName = "tuling-queue-01";
      
        channel.queueDeclare(queueName,true,false,true,null);

        //创建消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        channel.basicConsume(queueName,true,queueingConsumer);

        while (true) {
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            String reserveMsg = new String(delivery.getBody());
            System.out.println("消费消息:"+reserveMsg);
        }
    }
}

结果：

 

直接交换机：

package com.tuling.direct_exchange;

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 DirectExchangeProductor {

    public static void main(String[] args) throws IOException, TimeoutException {

        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2设置连接工厂的属性
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");


        //创建连接
        Connection connection = connectionFactory.newConnection();

        //创建channel
        Channel channel = connection.createChannel();

        //定义交换机名称
        String exchangeName = "tuling.directchange";

        //定义routingKey
        String routingKey = "tuling.directchange.key11111111";

        //消息体内容
        String messageBody = "hello tuling ";
        channel.basicPublish(exchangeName,routingKey,null,messageBody.getBytes());




    }
}

消费者：

package com.tuling.direct_exchange;

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

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


public class DirectExchangeConsumer {

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {

        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2设置连接工厂的属性
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");


        //创建连接
        Connection connection = connectionFactory.newConnection();

        //创建channel
        Channel channel = connection.createChannel();

        String exchangeName = "tuling.directchange";
        String exchangeType = "direct";
        String queueName = "tuling.directqueue";
        String routingKey = "tuling.directchange.key";
        /**
         * 声明一个交换机
         * exchange:交换机的名称
         * type:交换机的类型 常见的有direct,fanout,topic等
         * durable:设置是否持久化。durable设置为true时表示持久化，反之非持久化.持久化可以将交换器存入磁盘，在服务器重启的时候不会丢失相关信息
         * autodelete:设置是否自动删除。autoDelete设置为true时，则表示自动删除。自动删除的前提是至少有一个队列或者交换器与这个交换器绑定，之后，所有与这个交换器绑定的队列或者交换器都与此解绑。
         * 不能错误的理解—当与此交换器连接的客户端都断开连接时，RabbitMq会自动删除本交换器
         * arguments:其它一些结构化的参数，比如：alternate-exchange
         */
        channel.exchangeDeclare(exchangeName,exchangeType,true,false,null);

        /**
         * 声明一个队列
         * durable:表示rabbitmq关闭删除队列
         * autodelete:表示没有程序和队列建立连接 那么就会自动删除队列
         *
         */
        channel.queueDeclare(queueName,true,false,false,null);

        /**
         * 队里和交换机绑定
         */
        channel.queueBind(queueName,exchangeName,routingKey);

        /**
         * 创建一个消费者
         */
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);

        /**
         * 开始消费
         */
        channel.basicConsume(queueName,true,queueingConsumer);

        while (true) {
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            String reciverMessage = new String(delivery.getBody());
            System.out.println("消费消息:-----"+reciverMessage);
        }

    }
}

扇形交换机：

生产者：

package com.tuling.fanout_exchange;

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 FanoutExchangeProductor {

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");


        //创建连接
        Connection connection = connectionFactory.newConnection();

        //创建channel
        Channel channel = connection.createChannel();

        //定义交换机名称
        String exchangeName = "tuling.fanoutexchange";

        //定义routingKey
        String routingKey = "";

        //消息体内容
        String messageBody = "hello tuling ";
        channel.basicPublish(exchangeName,"123",null,"我是第一条消息".getBytes());
        channel.basicPublish(exchangeName,"456",null,"我是第二条消息".getBytes());
        channel.basicPublish(exchangeName,"789",null,"我是第三条消息".getBytes());
    }
}

 

消费者：

package com.tuling.fanout_exchange;

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

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


public class FanoutExchangeConsumer {

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");


        //创建连接
        Connection connection = connectionFactory.newConnection();

        //创建channel
        Channel channel = connection.createChannel();

        //声明交换机
        String exchangeName = "tuling.fanoutexchange";
        String exchangeType = "fanout";
        channel.exchangeDeclare(exchangeName,exchangeType,true,true,null);

        //声明队列
        String quequName = "tuling.fanout.queue";
        channel.queueDeclare(quequName,true,false,false,null);

        //声明绑定关系
        String bingdingStr = "jjsadf";
        channel.queueBind(quequName,exchangeName,bingdingStr);

        //声明一个消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);

        //开始消费
        /**
         * 开始消费
         */
        channel.basicConsume(quequName,true,queueingConsumer);

        while (true) {
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println("接受到消息:"+new String(delivery.getBody()));
        }
    }
}

topic交换机：

生产者：

package com.tuling.topic_exchange;

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 TopicExchangeProductor {

    public static void main(String[] args) throws IOException, TimeoutException {

        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");

        //创建连接
        Connection connection = connectionFactory.newConnection();

        //创建channel
        Channel channel = connection.createChannel();

        //发送消息
        String exchangeName = "tuling.topicexchange";

        String routingKey1 = "tuling.key1";
        String routingKey2 = "tuling.key2";
        String routingKey3 = "tuling.key.key3";

        channel.basicPublish(exchangeName,routingKey1,null,"我是第一条消息".getBytes());
        channel.basicPublish(exchangeName,routingKey2,null,"我是第二条消息".getBytes());
        channel.basicPublish(exchangeName,routingKey3,null,"我是第三条消息".getBytes());
    }
}

消费者：

package com.tuling.topic_exchange;

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

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


public class TopicExchangeConsumer {

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");

        //创建连接
        Connection connection = connectionFactory.newConnection();

        //创建channel
        Channel channel = connection.createChannel();

        //声明交换机
        String exchangeName = "tuling.topicexchange";
        String exchangeType = "topic";
        channel.exchangeDeclare(exchangeName,exchangeType,true,true,null);

        //声明队列
        String quequName = "tuling.topic.queue";
        channel.queueDeclare(quequName,true,false,false,null);

        //声明绑定关系
        String bingdingStr = "tuling.*";
        channel.queueBind(quequName,exchangeName,bingdingStr);

        //声明一个消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);

        //开始消费
        /**
         * 开始消费
         */
        channel.basicConsume(quequName,true,queueingConsumer);

        while (true) {
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println("接受到消息:"+new String(delivery.getBody()));
        }
    }
}

 

参考资料：

https://blog.csdn.net/shaoyunzhe/article/details/96461703

执于代码
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
基于 SpringBoot+Mybatis+Redis+RabbitMQ 秒杀系统.zip
04-08
4. 熟悉RabbitMQ的基本概念，如交换机、队列和绑定，以及如何在Java中使用其API发送和接收消息。 5. 分析项目结构，理解业务流程，如用户请求、秒杀逻辑、订单创建等。 6. 阅读部署教程，学习如何在本地或服务器上...
（1）关于RabbitMq 的 Direct Exchange 直连型交换机
分享日常bug
09-27 1199
在这个界面里面我们可以做些什么？可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。以上这些管理界面的操作在这篇暂时不做扩展描述，我想着重介绍后面实例里会使用到的。根据消息携带的路由键将消息投递给对应队列。大致流程，有一个队列绑定到一个直连交换机上，同时赋予一个路由键 routing key。然后当一个消息携带着路由值为X，这个消息通过生产者发送给交换机时交换机就会根据这个路由值X去寻找绑定值也是X的队列。
RabbitMQ：Exchange的Direct类型的介绍和使用
编程学习者的博客
05-13 1484
1.声明 当前内容用于本人学习和复习RabbitMQ的使用，当前内容主要用于分析和使用Exchange的Direct类型，发现其中的使用方式和具体操作 2.Direct Exchange的介绍 这里主要参考：RabbitMQ的Direct Exchange 直接交换基于消息路由密钥将消息传递到队列。直接交换是消息单播路由的理想选择（尽管它们也可以用于多播路由）。下面是它的工作原理： 队列使用路由密钥K绑定到交换机 当具有路由键R的新消息到达直接交换时，如果K = R，则交换会将其路由到队列 直接交换通常
Direct exchange
一个菜鸡的博客
07-23 1832
routingKey来表示也可称该参数为bindingkey，创建绑定我们用代码channel.queueBind(queueName,EXCHANGE_NAME,"routingKey");绑定之后的意义由其交换类型决定。Fanout这种交换类型并不能给我们带来很大的灵活性-它只能进行无意识的广播，在这里我们将使用direct这种类型来进行替换，这种类型的工作方式是，消息只去到它绑定的routingKey队列中去。...
RabbitMQ消息模型之DirectExchange消息模型实战
收破烂的小熊猫
04-09 1618
RabbitMQ多种消息模型实战 前面我们学习了RabbitMQ的核心基础组件，了解了基本消息模型由队列、交换机、路由构成。而在RabbitMQ的核心组件体系中，主要有4种消息模型： 基于HeadersExchange、DirectExchange、FanoutExchange、TopicExchange的消息模型；在实际生产环境中应用最广泛的莫过于后3中消息模型。 本篇文章主要介绍DirectE...
RabbitMQ之Direct（直连）Exchange解读
一个菜鸡的博客
10-07 638
在rabbitmq中，生产者发信息不会直接将信息投递到队列中，而是先将信息投递到交换机中，在交换机转发在具体的队列，队列再将信息推送或者拉取消费者进行消费路由键（Routingkey）生产者将信息发送给交换机的时候 会指定Routingkey指定路由规则绑定键（Bindingkey)通过绑定键将交换机与队列关联起来，这样rabbtamq就知道如何正确的将信息路由到队列Direct（直连）Exchange。
SpringCloud示例：Spring Cloud学习教程
01-29
Spring Cloud对RabbitMQ提供了良好的支持，通过`spring-cloud-starter-amqp`起步依赖，我们可以方便地在Spring Boot应用中集成并使用RabbitMQ。 Consul作为服务发现和配置管理工具，是Spring Cloud生态系统中的关键...
Spring Boot介绍内容.zip
最新发布
04-01
这个框架的主要目标是让开发者能够快速地“起步并运行”（因此得名Spring Boot）。它通过提供默认配置和自动配置特性，消除了大量的XML配置，使得开发过程更加简洁高效。 在Spring Boot项目中，我们通常会看到以下...
SpringBoot:学习Springboot
05-09
在SpringBoot中，核心概念包括起步依赖、自动配置、内嵌Web服务器和命令行接口等。 1. **起步依赖（Starter Dependency）** 起步依赖是SpringBoot的一个创新设计，它是一种Maven或Gradle的依赖管理方式。通过引入...
SpringBoot基础框架demo
02-02
引入`lombok`依赖，并在IDE中安装Lombok插件，即可使用`@Data`、`@Setter`、`@Getter`等注解自动生成getter、setter等方法。 6. **Maven的使用** Maven是Java项目的构建工具，SpringBoot项目通常基于Maven进行构建...
RabbitMq中交换器（Exchange）类型详解
技术人集结地
04-04 6744
RabbitMQ是工作中经常使用的一个开源消息队列，它是通过Erlang语言来开发的，RabbitMQ中有一个非常常见且重要的概念叫交换器（Exchange），所有生产者提交的消息都是通过Exchange进行接收，然后通过特定的路由策略转发对特定的队列（Queue）中，然后消费者通过绑定特定的队列，将队列中的信息进行消费处理。我们如果是通过RabbitMQ的客户端来进行创建Exchange的话，一定需要你选择一个特定的Exchange类型的，这个时候如果不了解每一种类型的特性，就很容易选择错误，造成整
RabbitMQ四种Exchange类型之Direct (Java)
活着离开这世界
12-28 1546
我的个人博客网站云诺说上线啦！所有文章都搬到新地址了，点击围观吧！ Direct类型的Exchange是不处理路由键，需要将一个队列绑定到交换机上，要求该消息与一个特定的路由键完全匹配。这是一个完整的匹配。如果一个队列绑定到该交换机上要求路由键为“logs”，则只有路由键为“logs”的消息才被转发，不会转发路由键为"logs.error"，只会转发路由键为"logs"。 如下图： ...
消息队列之路由模式(exchange:direct)
qq_40950803的博客
05-31 639
文章目录消息队列之路由模式(exchange)1、路由模式(direct)1、概念2、生产者3、消费者 消息队列之路由模式(exchange) 1、路由模式(direct) 1、概念 前面使用了订阅模式，那种模式会将消息发送给所有人 但是如果有时候我们不想将消息发送给所有人呢 这时候就需要使用到路由模式 所有的队列绑定一个交换机，并且设置一个或多个路由 发送的消息设置好路由发送给交换机 交换机根据绑定的队列且设置了所携带的路由参数将消息发送给符合的队列 前面我们都是没使用exchange的，但是路由参数我
RabbitMQ入门学习系列(五) Exchange的Direct类型
爱码农爱生活
07-05 216
快速阅读利用Exchange的Direct类型，实现对队列的过滤，消费者启动以后，输入相应的key值，攻取该key值对应的在队列中的消息 。从一节知道Exchange有四...
RabbitMQ API（九） Exchange Direct
乌鲁木齐001号程序员
05-14 88
Direct routingKey 要完全匹配； 消费者 这里演示的是发送的 routingKey 和 队列声明的绑定不一致，导致队列收不到消息的情况； package com.bfxy.rabbitmq.api.exchange.direct; import com.bfxy.rabbitmq.Application; import com.r...
RabbitMQ系列--Direct Exchange
撸码社区的博客
08-03 476
RabbitMQ工作流程 左边是生产者，右边是消费者，中间红框内是RabbitMQ服务器，其中包括交换机以及消息队列 消费者发送消息给RabbitMQ服务器，交换机接收到消息，然后根据不同的交换机规则投递给消息队列，消费者订阅消息进行消费 RabbitMQ交换机类型 作用：接收消息，按照路由规则将消息路由到一个或者多个队列。如果路由不到，或者返回给生产者，或者直接丢弃。RabbitMQ常用的交换器常用类型有direct、topic、fanout三种，其他的由于性能不好等原因几乎用不到，后续主要介绍这
rabbitmq中交换机类型direct和topic的区别
feinifi的博客
03-31 7496
rabbitmq主要有三大类交换机：faout,direct,topic，他们从名字上分别是扇区交换机、直连交换机和主题交换机。其实还有headers一类的交换机，这里不去深究。 faout交换机也叫无路由交换机，就是它直接与交换机exchange发生关联，不用routingKey。 direct和topic都加入了routingKey的概念，发送数据的时候，它只跟交换机和路由发生关系，不关心最终的队列queue。就是生产者这里只需要将消息绑定到exchange和routingK...
【RabbitMQ】——三种Exchange模式（Fanout、Direct、Topic)
热门推荐
Jack 架构师之路
05-12 2万+
引言   在上一篇博客中介绍了RabbitMQ中两种队列模式，下面在改博文中将介绍比较常用的三种Exchange模式。   第一种、Fanout Exchange   这种Fanout模式不处理路由键，你需要简单的讲队列绑定到exchange上，一个发送到exchange的消息都会被转发到与该exchange绑定的所有队列上。很像广播子网，每台子网内的主机都获得了一份复制的消息。Fanout
RabbitMQ三种Exchange模式(fanout,direct,topic)简介
涛
07-10 1万+
（一）RabbitMQ基本概念 RabbitMQ是流行的开源消息队列系统，用erlang语言开发。RabbitMQ是 AMQP（高级消息队列协议）的标准实现。 1、概念说明： Broker：简单来说就是消息队列服务器实体。 Exchange：消息交换机，它指定消息按什么规则，路由到哪个队列。 Queue：消息队列载体，每个消息都会被投入到一个或多个队列。 Binding：绑定，它的作用就是把...
一文读懂PHP使用RabbitMQ
12-13
RabbitMQ是一个开源的消息代理队列服务器，用于在分布式系统中存储转发消息。它是基于AMQP（Advanced Message Queuing Protocol）设计的，是一个面向消息的中间件，可以用于解耦组件之间的通信。RabbitMQ的服务器端...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

执于代码

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值