（1）RabbitMQ入门

最新推荐文章于 2023-01-27 23:59:29 发布
最新推荐文章于 2023-01-27 23:59:29 发布
阅读量206 收藏
点赞数 1
分类专栏： rabbitMQ 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/scryihao/article/details/105929072
版权

rabbitMQ模型
在这里插入图片描述

初识RabbitMQ:

rabbitMQ是一个开源的消息代理和队列服务器，通过AMQP协议来完成不同应用之间的数据共享。
rabbitMQ是通过elang语言来开发。

什么是AMQP协议

（Advanced message queue protocol）高级消息队列
1）是一个二进制协议
2）AMQP是一个应用层协议的规范，可以有很多不同的消息中间件产品（中间件都需要遵循改规范）
server：是消息队列节点
virtual host：虚拟主机
exchange：交换机（消息投递到交换机上）
message queue：消息队列（被消费者监听消费）
交换机和消息队列有一个绑定关系

AMQP的核心概念

1.server：又称broker，接收客户端连接，实现AMQP实体服务
2.Connection：连接，应用程序与server/broker建立网络连接
3.channel：网络通道,几乎所有的操作都是在channel中进行的，是进行消息对象的通道，客户端可以建立多个channel，每一个channel表示一个会话任务
4.message：服务器与应用程序之间传递数据的载体，有properties（消息属性，用来修饰消息，比如消息的优先级，延时投递等）和Body（消息体）
5.virtual host：虚拟主机
6.exchange：交换机，消息直接投递到交换机上，然后交换机根据消息的路由key来路由到对应绑定的队列上
7.queue：队列，用来保存消息的载体，有消费者监听，然后消费消息
8.bingding：绑定exchange和queue的虚拟连接，bingding中可以包含route_key
9.route_key：路由key，他的作用是在交换机上通过route_key来把消息路由到哪个队列上

RabbitMQ安装教程
https://segmentfault.com/a/1190000018916099?utm_source=tag-newest

简单使用RabbitMQ

生产者：消息生产者

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("test-virtual");
        connectionFactory.setUsername("yihao");
        connectionFactory.setPassword("yihao");

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

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

        //通过channel发送消息
        for (int i=0;i<10;i++){
            String message = "hello yihao------"+i;
            //void basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body) throws IOException;
            /**
             * exchange:交换机名称(这里我没有指定交换机，那我们的消息会发送到默认的交换机上)
             * routingKey：路由key
             * props：消息属性
             * body：消息体
             */
            channel.basicPublish("","yihao-queue",null,message.getBytes());
        }
        channel.close();
        connection.close();
    }
}

消费者
消息消费者

public class RabbitMQConsumer {
    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("test-virtual");
        connectionFactory.setUsername("yihao");
        connectionFactory.setPassword("yihao");

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

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

        //声明队列
        String queueName ="yihao-queue";
        /**
         *queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete,
         *Map<String, Object> arguments) throws IOException;
         * queue:队列名称
         * durable：是否持久化，队列的声明默认是保存在内存中的，如果rabbitMQ重启会丢失，如果想重启之后还存在则开启持久化
         * exclusive：当连接关闭时，该队列是否会自动删除
         * autoDelete：是否自动删除，如最后一个消费者断开连接之后队列是否自动被删除
         * arguments:队列的其他属性，是map
         */
        channel.queueDeclare(queueName,true,false,true,null);

        //将消费者与channel绑定
        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
		    StringBuilder sb = new StringBuilder();
                for (byte b : body) {
                    sb.append((char) b);
                }
                System.out.println(sb.toString());
                //channel.basicAck(envelope.getDeliveryTag(), false);//这个可以确认是否处理消息
            }
        }); 
    }
}

效果展示
在这里插入图片描述

交换机属性详解

1.作用：接受生产者的消息，然后根据路由键，把消息投递到跟交换机绑定的对应的队列上

2.交换机的属性：
name：交换机的名称
Type：交换机的类型（direct，topic，fanout，hreaders）
Durability：是否需要持久化
autoDelete：假如没有队列绑定到该交换机，那么该交换机是否自动删除
Internal：不常用，默认为false
argurements：扩展参数，用户扩展AMQP定制化协议

3.交换机的类型
3.1直接交换机
所有发送到direct exchange的消息都被被投递到与routekey名称相同的queue上。
在 direct模式下，可以使用自带的默认的exchange，即default exchange，所以不需要交换机和任何队列绑定，消息将会投递到route_key名称和队列相同的队列上。
在这里插入图片描述

**代码演示：
直连交换机生产者 DirectExchangeProducter**

public class DirectExchangeProducter {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接
        Connection connection = MyConnectionFactory.getConnection();

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

        //定义交换机名称
        String exchangeName="yihao.directExchange";

        //定义路由key
        String routingKey="yihao.directExchange.key";

        //消息定义
        String messageBody="hello yihao";
        channel.basicPublish(exchangeName,routingKey,null,messageBody.getBytes());

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

直连交换机消费者DirectExchangeConsumer

public class DirectExchangeConsumer {
    public static void main(String[] args) throws IOException {
        //创建连接
        Connection connection = MyConnectionFactory.getConnection();

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

        //定义交换机名称
        String exchangeName="yihao.directExchange";

        //交换机类型
        String exchangeType="direct";

        //队列名称
        String queueName="yihao.directQueue";

        //定义路由key
        String routingKey="yihao.directExchange.key";

        //声明一个交换机
        channel.exchangeDeclare(exchangeName,exchangeType,true,false,null);

        //声明一个队列
        channel.queueDeclare(queueName,true,false,false,null);

        //交换机和队列绑定(根据队列名称和交换机名称，通过路由key绑定)
        channel.queueBind(queueName,exchangeName,routingKey);

        //将消费者与channel绑定
        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                StringBuilder sb = new StringBuilder();
                for (byte b : body) {
                    sb.append((char) b);
                }
                System.out.println(sb.toString());
                //channel.basicAck(envelope.getDeliveryTag(), false);//这个可以确认是否处理消息
            }
        });
    }
}

3.2主题交换机topic exchange
就是在队列上设置绑定到topic交换机上的路由key，可以通过通配符来匹配。规则是：
比如：log.#:可以匹配一个单词，也可以匹配多个单词，比如可以匹配到log.a,log.b,log.a.b;
log.*：可以匹配一个单词，比如log.a,log.b,但是不能匹配log.a.b
在这里插入图片描述

代码示例：
主题交换机生产者TopicExchangeProducter：

public class TopicExchangeProducter {
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = MyConnectionFactory.getConnection();

        Channel channel = connection.createChannel();

        String topicExchangeName="topic.exchange";

        String routingKey1="topic.key.1";

        String routingKey2="topic.key.2";

        channel.basicPublish(topicExchangeName,routingKey1,null,"topic测试交换机1".getBytes());

        channel.basicPublish(topicExchangeName,routingKey2,null,"topic测试交换机2".getBytes());

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

主题交换机消费者TopicExchangeConsumer

public class TopicExchangeConsumer {

    public static void main(String[] args) throws IOException {
        Connection connection = MyConnectionFactory.getConnection();
        Channel channel = connection.createChannel();
        String topicExchangeName="topic.exchange";
        String queueName="topic.queue";
        String exchangeType="topic";
        String routingKey="topic.#";
        //声明交换机
        channel.exchangeDeclare(topicExchangeName,exchangeType,true,true,false,null);
        //声明一个队列
        channel.queueDeclare(queueName,true,false,true,null);
        //队列绑定到交换机
        channel.queueBind(queueName,topicExchangeName,routingKey);

        //将消费者与channel绑定
        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                StringBuilder sb = new StringBuilder();
                for (byte b : body) {
                    sb.append((char) b);
                }
                System.out.println(sb.toString());
                //channel.basicAck(envelope.getDeliveryTag(), false);//这个可以确认是否处理消息
            }
        });
    }
}

3.3扇形交换机 fanout exchange
就是消息通过从交换机到队列上不会通过路由key，所以该模式是最快的，只要和交换机绑定的，那么消息就会分发到与之绑定的队列上
在这里插入图片描述

代码演示
扇形交换机消息生产者FanoutExchangeProducter

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

        String fanoutExchangeName="fanout.exchange";

        String routingKey="fanout.key";

        channel.basicPublish(fanoutExchangeName,routingKey,null,"fanout测试扇形交换机".getBytes());

        channel.close();

        connection.close();

    }
}

扇形交换机消息消费者FanoutExchangeConsumer

public class FanoutExchangeConsumer {
    public static void main(String[] args) throws IOException {
        Connection connection = MyConnectionFactory.getConnection();
        Channel channel = connection.createChannel();
        String fanoutExchangeName="fanout.exchange";
        String exchangeType="fanout";
        String queueName ="";
        //这里的routingKey是什么都无所谓，不会起作用到
        String routingKey="";
        channel.exchangeDeclare(fanoutExchangeName,exchangeType,true,true,false,null);
        channel.queueDeclare(queueName,true,false,true,null);
        channel.queueBind(queueName,fanoutExchangeName,routingKey);
        //将消费者与channel绑定
        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                StringBuilder sb = new StringBuilder();
                for (byte b : body) {
                    sb.append((char) b);
                }
                System.out.println(sb.toString());
                //channel.basicAck(envelope.getDeliveryTag(), false);//这个可以确认是否处理消息
            }
        });
    }
}
scryihao
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一、RabbitMQ概述
wang_luwei的博客
03-19 753
文章目录1、RabbitMQ 的概念2、四大核心组成3、RabbitMQ 六大核心部分（模式）4、各个名词介绍5、安装 1、RabbitMQ 的概念 RabbitMQ 是一个消息中间件：它接受并转发消息。 你可以把它当做一个快递站点，当你要发送一个包裹时，你把你的包裹放到快递站，快递员最终会把你的快递送到收件人那里，按照这种逻辑 RabbitMQ 是一个快递站，一个快递员帮你传递快件。RabbitMQ 与快递站的主要区别在于：它不处理快件而是接收，存储和转发消息数据。 2、四大核心组成 生产者：产生数据，
1.RabbitMQ简介
EdSheeran的博客
12-10 1817
文章目录*RabbitMQ**Introduction**Hello, world(using the java client)**Sending**Receiving* RabbitMQ Introduction RabbitMQ是一个消息代理：它接受并转发消息。你可以把它想象成一个邮局：当你把你想寄出的邮件放在一个邮箱里时，你可以确定送信人最终会把邮件寄给你的收件人。在这个类比中，rabbitMQ是一个邮箱、一个邮局和一个信件载体。 RabbitMQ和邮局之间的主要区别在于，它不处理纸张，而是接受、存
1.RabbitMQ 简介
自能生羽翼，何必仰云梯
07-19 371
  RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）   RabbitMQ服务器是用Erlang语言编写的，而集群和故障转移是构建在开放电信平台框架上的。所有主要的编程语言均有与代理接口通讯的客户端库。 基本概念：   RabbitMQ是一套开源（MPL）的消息队列服务软件，是由 LShift 提供的一个 Advanced Message Queuing Protocol (AMQP) 的开源实现，由以高性能、健壮以及可伸缩性出名的 Erlang 写成。 Rab
RabbitMQ学习1.1：RabbitMQ基础简介
叶落自飘零的博客
07-10 239
摘要说明： 消息队列（MQ）：MQ全称为Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如远程过程调用的技术。排队指的是应用程序通过 队列来通信。队列的使用除去了接收和发送应用...
RabbitMQ系列之一 RabbitMQ简介
程序猿的博客
11-15 809
一、什么是MQ MQ全称为Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如远程过程调用的技术。MQ是消费-生产者模型的一个典型的代表，一端往消息队列中不断写入消息，而另一端则可...
RabbitMQ入门视频
最新发布
04-05
在“RabbitMQ入门视频”中，你将学习到以下关键知识点： 1. **AMQP协议**：首先，了解AMQP协议的基础知识是非常重要的。AMQP定义了一种标准的、面向消息的中间件协议，支持多种语言和平台。它提供了一种可靠的消息...
rabbitMq入门
08-08
【标题】：“rabbitMQ入门” 在IT行业中，消息队列是一种常见的中间件技术，用于解耦应用程序组件，提高系统的可扩展性和可靠性。RabbitMQ是一个开源的消息代理和队列服务器，广泛应用于分布式系统中。本篇文章将带...
Rabbitmq入门到精通.doc
08-21
Rabbitmq入门到精通全套教程
RabbitMQ入门
01-20
生产者: public class Producer01 { private final static String QUENE=hello_word; public static void main(String[] args) { //通过连接工厂创建新的连接和mq建立连接 ConnectionFactory connectionFactory=...
rabbitmq基础入门
04-01
RabbitMQ基础入门主要涵盖了MQ的基本概念、使用MQ的原因、MQ的分类以及RabbitMQ的详细知识。MQ，即Message Queue，是一种基于FIFO（先进先出）原则的消息队列服务，用于不同进程间的通信，尤其在互联网架构中，它起...
1. rabbitmq的安装及基本概念
u010895694的博客
01-17 90
转载1. rabbitmq的安装及基本概念 - 简书 安装 centos 看这个老哥的吧,https://www.cnblogs.com/rmxd/p/11583932.html 基本概念 连接 首先作为客户端（无论是生产者还是消费者），你如果要与 RabbitMQ 通讯的话，你们之间必须创建一条 TCP 连接，当然同时建立连接后，客户端还必须发送一条“问候语”让彼此知道我们都是符合AMQP的语言的，比如你跟别人打招呼一般会说“你好！”，你跟国外的美女一般会说“hello!”一样。你们确认好“语
channel.QueueDeclare各个参数详解
热门推荐
吕秀军的博客
10-11 1万+
channel.QueueDeclare(name, durable, autoDelete, exclusive, noWait, args) name:队列名字 durable：是否持久化, 队列的声明默认是存放到内存中的，如果rabbitmq重启会丢失，如果想重启之后还存在就要使队列持久化，保存到Erlang自带的Mnesia数据库中，当rabbitmq重启之后会读取该数据...
RabbitMQ队列声明channel.queueDeclare()参数解析
AwayFuture的博客
12-05 7314
  channel.queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments) 1. queue： 队列的名称 ； 2. durable： 是否持久化 ； 当durable = false时，队列非持久化。...
ActiveMQ
hit、run
09-14 326
Spring与ActiveMQ的整合及用JmsTemplate发送消息 1.pom文件: <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-activemq</artifactId> </dependency> <!--消息队列连接池-->
RabbitMQ-客户端源码之ConnectionFactory
二师兄撒欢之地
01-27 731
之后if(isAutomaticRecoveryEnabled()){}之内的方法是建立可自动恢复连接的，这个可以忽略，直接看else里面的代码，因为if和else大体功能上一致，else里的更通用一些，也是默认的。”返回的是SocketFrameHandler对象，这个对象是对Socket的一个封装，完全可以看成是一个Socket对象。这个是用来处理client与broker之间的通信帧（Frame）的，包括建立通信链路（java的原生socket，注意这里没有NIO也没有netty）。
史上最全 RabbitMQ入门教程，从零开始带你深入♂学习（十一）——死信队列
爱分享的板栗老哥
08-17 528
RabbitMQ（十一）——死信队列 死信队列简介 先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer 将消息投递到 broker 或者直接到 queue 里了，consumer 从 queue 取出消息进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。 应用场景:为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息
rabbitmq学习7:ConntectionFactory与Conntection的认知
野四 永无止境
04-19 570
    从前面几小节的学习，我们可能知道在发送和接收消息重要的类ConnectionFactory， Connection，Channel和 QueueingConsumer。   ConntectionFactory类是方便创建与AMQP代理相关联的Connection；下面来看看ConntectionFactory是如何创建一个Contention.   首先通过new Conn...
用两个栈实现一个队列&用两个队列实现一个栈
大鹏小站的博客
07-16 371
思路：栈：先进后出，队列：先进先出 如果转化： 1.将内容先push进一个栈inStack， 2.判断outStack是否为空，空：将栈inStack中的元素pop（删除并返回数组的最后一个元素）并push进outStack，非空：直接出栈 3.出栈时，先push进inStack先从outStack出来，即：实现了先进先出 Stack<Integer> stack1 = new Stack<Integer>(); Stack<Integer> stack2 =
RabbitMQ
fantasyleaves的博客
03-27 190
Message Queue 消息队列，又称消息中间件，是典型的生产者和消费者模型，生产者不断向队列中生产消息，消费者不断从队列中获取消息。因为消息的生产和消费都是异步进行的，所以只需要关心消息的发送和接收，没有业务逻辑的侵入，轻松实现系统间的解耦。 AMQP Advanced Message Queue Protocol（高级消息队列协议），AMQP不是从API层面进行限定的，而是直接定义网络交换的数据格式。 创建虚拟机时，虚拟机的命名必须是以“/”开头，生产者可以将消息发送给交换机，也可以
rabbitmq入门
07-27
- *1* *2* *3* [超详细的RabbitMQ入门](https://blog.csdn.net/Rok728/article/details/123106242)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值