RabbitMQ交换机

最新推荐文章于 2022-11-16 21:56:02 发布
最新推荐文章于 2022-11-16 21:56:02 发布
阅读量204 收藏
点赞数
分类专栏： RabbitMQ 文章标签： rabbitmq 队列 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37714489/article/details/103785294
版权

交换机，接收消息，根据路由键转发消息到绑定的队列。

在这里插入图片描述

交换机类型

<dependency>
	<groupId>com.rabbitmq</groupId>
	<artifactId>amqp-client</artifactId>
	<version>3.6.5</version>
</dependency>

1.direct

在这里插入图片描述

所有发送到Direct Exchange的消息被转发到RouteKey中指定的Queue，
RouteKey用于队列和交换机绑定，全匹配
注意：Direct模式可以使用RabbitMQ自带的Exchange：default Exchange，所以不需要将Exchange进行任何绑定操作，消息传递时，RouteKey必须完全匹配才会被队列接收，否则该消息会被抛弃。

ProducerExchange

package com.example.rabbit.exchange.direct;

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

public class ProducerExchange {

    public static void main(String[] args) throws Exception {
        //1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.200.128");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        //2.通过连接工厂创建连接
        Connection connection = connectionFactory.newConnection();
        //3.通过connection创建一个channel
        Channel channel = connection.createChannel();
        //4.通过channel发送数据
        String exchangeName="test_direct_exchange";
        String routingKey="test.direct";
        String exchangeType="direct";
        //声明一个交换机
        channel.exchangeDeclare(exchangeName,exchangeType,true,false,false,null);
        for(int i=1;i<=5;i++){
            String msg="Produce direct_exchange生产的第"+i+"条消息";
            channel.basicPublish(exchangeName,routingKey,null,msg.getBytes());
        }
        //5.关闭相关连接
        channel.close();
        connection.close();

    }
}

ConsumerExchange

package com.example.rabbit.exchange.direct;

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

public class ConsumerExchange {
    public static void main(String[] args) throws Exception {
        //1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.200.128");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        //2.通过连接工厂创建连接
        Connection connection = connectionFactory.newConnection();
        //3.通过connection创建一个channel
        Channel channel = connection.createChannel();
        //4.声明（创建）一个队列
        //参数1：队列名称；参数2：是否持久化；参数3：是否独占；参数4：是否自动删除；参数5：扩展参数
        String exchangeName="test_direct_exchange";
        String exchangeType="direct";
        //用于交换机和队列绑定
        String routingKey="test.direct";
        String queueName = "test_direct_queue1";

        //声明一个交换机
        channel.exchangeDeclare(exchangeName,exchangeType,true,false,false,null);
        //声明一个队列
        channel.queueDeclare(queueName,true,false,false,null);
        //建立一个绑定关系
        channel.queueBind(queueName,exchangeName,routingKey);
        //5.创建一个消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        //6.设置Channel
        channel.basicConsume(queueName,true,queueingConsumer);
        //7.获取消息
        while (true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            String msg = new String(delivery.getBody());
            System.out.println("Consumer消费的消息："+msg);
        }

    }
}

2.topic

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
ConsumerTopicExchange1

package com.example.rabbit.exchange.topic;

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

/**
 * ConsumerTopicExchange1
 */
public class ConsumerTopicExchange1 {
    public static void main(String[] args) throws Exception {
        //1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.200.128");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        //2.通过连接工厂创建连接
        Connection connection = connectionFactory.newConnection();
        //3.通过connection创建一个channel
        Channel channel = connection.createChannel();
        //4.声明（创建）一个队列
        //参数1：队列名称；参数2：是否持久化；参数3：是否独占；参数4：是否自动删除；参数5：扩展参数
        String exchangeName="test_topic_exchange";
        String exchangeType="topic";
        //先测试user.#，在测试user.*，会同时绑定两个，需要去控制台Exchange先去解绑，才能测试出效果
        String routingKey="user.#";//#匹配一个或多个词
        //String routingKey="user.*";//*匹配一个词
        //String queueName = "test_topic_queue02";
        String queueName = "test_topic_queue01";

        //声明一个交换机
        channel.exchangeDeclare(exchangeName,exchangeType,true,false,false,null);
        //声明一个队列
        channel.queueDeclare(queueName,true,false,false,null);
        //建立一个绑定关系
        channel.queueBind(queueName,exchangeName,routingKey);
        //5.创建一个消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        //6.设置Channel
        channel.basicConsume(queueName,true,queueingConsumer);
        //7.获取消息
        while (true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            String msg = new String(delivery.getBody());
            System.out.println("Consumer消费的消息："+msg);
            //Envelope envelope = delivery.getEnvelope();
        }

    }
}

ConsumerTopicExchange2

package com.example.rabbit.exchange.topic;

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

public class ConsumerTopicExchange2 {
    public static void main(String[] args) throws Exception {
        //1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.200.128");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        //2.通过连接工厂创建连接
        Connection connection = connectionFactory.newConnection();
        //3.通过connection创建一个channel
        Channel channel = connection.createChannel();
        //4.声明（创建）一个队列
        //参数1：队列名称；参数2：是否持久化；参数3：是否独占；参数4：是否自动删除；参数5：扩展参数
        String exchangeName="test_topic_exchange";
        String exchangeType="topic";
        //先测试user.#，在测试user.*，会同时绑定两个，需要去控制台Exchange先去解绑，才能测试出效果
        //String routingKey="user.#";//#匹配一个或多个词
        String routingKey="user.*";//*匹配一个词
        String queueName = "test_topic_queue02";
        //String queueName = "test_topic_queue01";

        //声明一个交换机
        channel.exchangeDeclare(exchangeName,exchangeType,true,false,false,null);
        //声明一个队列
        channel.queueDeclare(queueName,true,false,false,null);
        //建立一个绑定关系
        channel.queueBind(queueName,exchangeName,routingKey);
        //5.创建一个消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        //6.设置Channel
        channel.basicConsume(queueName,true,queueingConsumer);
        //7.获取消息
        while (true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            String msg = new String(delivery.getBody());
            System.out.println("Consumer消费的消息："+msg);
            //Envelope envelope = delivery.getEnvelope();
        }

    }
}

ConsumerTopicExchange3

package com.example.rabbit.exchange.topic;

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

public class ConsumerTopicExchange3 {
    public static void main(String[] args) throws Exception {
        //1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.200.128");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        //2.通过连接工厂创建连接
        Connection connection = connectionFactory.newConnection();
        //3.通过connection创建一个channel
        Channel channel = connection.createChannel();
        //4.声明（创建）一个队列
        //参数1：队列名称；参数2：是否持久化；参数3：是否独占；参数4：是否自动删除；参数5：扩展参数
        String exchangeName="test_topic_exchange";
        String exchangeType="topic";
        //先测试user.#，在测试user.*，会同时绑定两个，需要去控制台Exchange先去解绑，才能测试出效果
        //String routingKey="user.#";//#匹配一个或多个词
        String routingKey="#.save";//*匹配一个词
        String queueName = "test_topic_queue03";
        //String queueName = "test_topic_queue01";

        //声明一个交换机
        channel.exchangeDeclare(exchangeName,exchangeType,true,false,false,null);
        //声明一个队列
        channel.queueDeclare(queueName,true,false,false,null);
        //建立一个绑定关系
        channel.queueBind(queueName,exchangeName,routingKey);
        //5.创建一个消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        //6.设置Channel
        channel.basicConsume(queueName,true,queueingConsumer);
        //7.获取消息
        while (true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            String msg = new String(delivery.getBody());
            System.out.println("Consumer消费的消息："+msg);  
        }

    }
}

ProducerTopicExchange

package com.example.rabbit.exchange.topic;

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


public class ProducerTopicExchange {

    public static void main(String[] args) throws Exception {
        //1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.200.128");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        //2.通过连接工厂创建连接
        Connection connection = connectionFactory.newConnection();
        //3.通过connection创建一个channel
        Channel channel = connection.createChannel();
        //4.通过channel发送数据
        String exchangeName="test_topic_exchange";
        String routingKey1="user.save";
        String routingKey2="user.update";
        String routingKey3="user.delete.abc";
        String routingKey4="order.save";

        String msg1="Producer topic_exchange生产的消息"+routingKey1;
        String msg2="Producer topic_exchange生产的消息"+routingKey2;
        String msg3="Producer topic_exchange生产的消息"+routingKey3;
        String msg4="Producer topic_exchange生产的消息"+routingKey4;
        channel.basicPublish(exchangeName,routingKey1,null,msg1.getBytes());
        channel.basicPublish(exchangeName,routingKey2,null,msg2.getBytes());
        channel.basicPublish(exchangeName,routingKey3,null,msg3.getBytes());
        channel.basicPublish(exchangeName,routingKey4,null,msg4.getBytes());

        //5.关闭相关连接
        channel.close();
        connection.close();

    }
}

3.fanout
在这里插入图片描述

在这里插入图片描述
ConsumerFanoutExchange

package com.example.rabbit.exchange.fanout;

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

public class ConsumerFanoutExchange {
    public static void main(String[] args) throws Exception {
        //1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.200.128");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        //2.通过连接工厂创建连接
        Connection connection = connectionFactory.newConnection();
        //3.通过connection创建一个channel
        Channel channel = connection.createChannel();
        //4.声明（创建）一个队列
        //参数1：队列名称；参数2：是否持久化；参数3：是否独占；参数4：是否自动删除；参数5：扩展参数
        String exchangeName="test_fanout_exchange";
        String exchangeType="fanout";
        String routingKey="";//不设置路由键
        String queueName = "test_fanout_queue";

        //声明一个交换机
        channel.exchangeDeclare(exchangeName,exchangeType,true,false,false,null);
        //声明一个队列
        channel.queueDeclare(queueName,true,false,false,null);
        //建立一个绑定关系
        channel.queueBind(queueName,exchangeName,routingKey);
        //5.创建一个消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        //6.设置Channel
        channel.basicConsume(queueName,true,queueingConsumer);
        //7.获取消息
        while (true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            String msg = new String(delivery.getBody());
            System.out.println("Consumer消费的消息："+msg);
        }

    }
}

ProducerFanoutExchange

package com.example.rabbit.exchange.fanout;

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

public class ProducerFanoutExchange {

    public static void main(String[] args) throws Exception {
        //1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.200.128");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        //2.通过连接工厂创建连接
        Connection connection = connectionFactory.newConnection();
        //3.通过connection创建一个channel
        Channel channel = connection.createChannel();
        //4.通过channel发送数据
        String exchangeName="test_fanout_exchange";
        String routingKey="123";//设置不设置路由键都无所谓

        for(int i=1;i<=5;i++){
            String msg="Procuder2 direct_exchange生产的第"+i+"条消息";
            channel.basicPublish(exchangeName,routingKey,null,msg.getBytes());
        }
        //5.关闭相关连接
        channel.close();
        connection.close();

    }
}

在这里插入图片描述
在这里插入图片描述

照亮me
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMq笔记整理
weixin_45694230的博客
10-27 1075
RabbitMq笔记整理 rabbitmq简介： mq全称为message queue，即消息队列，rabbitmq是由erlang语言开发，基于AMQP（Advanced Message Queue高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法。 开发中消息队列通常有如下应用场景： 1，任务异步处理：将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行处理，提高了应用程序的响应时间。 2，应用程序解耦合：MQ相当于一个中介，生产方通过MQ与消费方交互，它将应用程序进行解
rabbitMQ的结构以及每个组件的作用
weixin_54517901的博客
04-19 433
结构图： 介绍： Broker：接收和分发消息的应用，RabbitMQ Server就是 Message Broker Virtual host：出于多租户和安全因素设计的，把 AMQP 的基本组件划分到一个虚拟的分组中，类似于网络中的 namespace 概念。当多个不同的用户使用同一个 RabbitMQ server 提供的服务时，可以划分出多个vhost，每个用户在自己的 vhost 创建 exchange／queue 等 Connection：publisher／consumer 和
rabbitmq详细入门文档+springboot结合使用
jingke_1524的博客
09-23 916
在介绍RabbitMQ之前，我们先来看下面一个电商项目的场景： 商品的原始数据保存在数据库中，增删改查都在数据库中完成。 搜索服务数据来源是索引库（Elasticsearch），如果数据库商品发生变化，索引库数据不能及时更新。 商品详情做了页面静态化处理，静态页面数据也不会随着数据库商品更新而变化。 如果我们在后台修改了商品的价格，搜索页面和商品详情页显示的依然是旧的价格，这样显然不对。该如何解决？ 我们可能会想到这么做： 方案1：每当后台对商品做增删改操作，同时修.
Spring Boot学习笔记-------（九）RabbitMQ相关
huaya1127的专栏
04-28 147
一、工程创建。 在创建需要RabbitMQ支持的工程时，需在依赖选择页面中选择Messaging中的Spring for RabbitMQ选项。 对于已创建的项目也可以在pom.xml中新增以下依赖效果一样。 ##rabbitmq需要相关依赖 <dependency> <groupId>org.springframework.boot&...
RabbitMQ消费者分组与消息分区
tian830937的专栏
11-14 5140
rabbitmq多实例消费同⼀个queue数据,消息分组与消息分区
批量删除rabbitmq的队列或交换机
06-29
采用python编写的批量删除rabbitmq的队列或交换机。 1.修改rabbitmq_delete.py中rabbitmq的配置； 2.执行以下命令： 删除队列: python3 rabbitmq_delete.py -k ‘udata.climb’ -d 1 删除交换机: python3 rabbitmq_...
rabbitmq开发规范
07-04
交换机的持久化有助于保证RabbitMQ服务重启后，Exchange仍然存在，避免因服务重启导致的消息丢失。在Java和Spring中声明Exchange时，设置`durable`属性为`true`： - **Java方式**： ```java private static final...
Jemter JMeter-Rabbit-AMQP插件升级版，支持rabbitmq交换机类型“x-consistent-hash”
12-02
Jemter测试MQ的插件 JMeter-Rabbit-AMQP在github上17年便停止更新了，不支持rabbitmq的交换机类型“x-consistent-hash”，为此我更改了源码使其支持"x-consistent-hash
springboot+RabbitMq交换器Direct的demo
03-21
标题中的“springboot+RabbitMq交换器Direct的demo”指的是使用Spring Boot框架集成RabbitMQ，并通过Direct交换器实现消息的发送和接收。这是一个实际操作的示例，用于展示如何在Spring Boot应用中配置和使用...
rabbitmq队列和交换机的实现
02-20
在这个话题中，我们将深入探讨RabbitMQ中的队列和交换机的实现，以及相关的概念。 首先，让我们了解RabbitMQ中的基本组件。队列是消息的容器，存储生产者发送的消息，直到消费者将它们取出并处理。交换机则是消息...
Rabbitmq
最新发布
qq_33807380的博客
11-16 1633
RabbitMQ是使用Erlang语言开发并基于AMQP协议来实现的开源消息队列系统。其主要目的是为了解决传统的消息传输上管理困难,效率不高的问题。docker拉取RabbitMQ镜像使用官方定义的端口启动RabbitMQ容器进入刚启动的容器在容器交互页面执行下面命令下载插件打开浏览器，输入服务器ip+端口号回车，进入客户端登录页面，输入默认的账号密码：guest/guest就可以登录到RabbitMQ服务了。
RabbitMQ详解
Janet的博客
04-02 3376
RabbitMQ相关知识
RabbitMQ详解（二）-----RabbitMQ简介和简单使用
zhouhuahao的博客
04-09 331
一.简单案例 1.创建Maven工程，pom.xml引入依赖 <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.6.0</version> </dependency&g...
RabbitMQ教程(安装与使用详解,Spring集成)
热门推荐
鸟哥哥的专栏
12-26 50万+
RabbitMQ教程，面试题。消息队列(MQ)，本质是个队列，队列中存放的内容是message。MQ用于不同进程Process/线程Thread之间通信。本文介绍RabbitMQ的使用。RabbitMQ实战教程。
rabbitmq生产者topic模式简单使用记录
LIURONGTAI的博客
05-30 1116
1.maven项目添加mq需要的依赖 <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>3.6.5&lt...
RabbitMQ 基本使用
weixin_41910059的博客
07-18 290
学习五种队列 1.简单队列 图示 P：消息的生产者 C：消息的消费者 红色：队列 生产者将消息发送到队列，消费者从队列中获取消息。 导入RabbitMQ的客户端依赖 <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</art...
JMS、AMQP实例讲解
Stay Hungry, Stay Foolish
03-14 333
  使用Git从GitHub上将samples代码拷贝到本机，然后导入到IDE中 git clone git://github.com/stephansun/samples.git samples包含7个模块，分别为 samples-jms-plain：使用JMS原生API; samples-jms-spring：使用Spring对JMS原生API封装后的spring-...
RabbitMQ（一）
BraneZ的博客
09-14 245
一、项目导包 &lt;dependency&gt; &lt;groupId&gt;com.rabbitmq&lt;/groupId&gt; &lt;artifactId&gt;amqp-client&lt;/artifactId&gt; &lt;version&gt;3.6.5&lt;/version&gt; &lt;/dependency&am
rabbitmq创建简单的生产和消费者
lhp534的专栏
09-14 2592
参考《rabbitmq实战指南》 1、首先项目中引入rabbit-client jar包 &lt;dependency&gt; &lt;groupId&gt;com.rabbitmq&lt;/groupId&gt; &lt;artifactId&gt;amqp-client&lt;/artifactId&gt; &lt;version&gt;4.4.2&lt;/versi...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值