RabbitMq发送接收消息方式

最新推荐文章于 2024-08-30 03:15:00 发布
最新推荐文章于 2024-08-30 03:15:00 发布
阅读量882 收藏
点赞数 1
分类专栏： JMS 文章标签： rabbitmq direct fanout topic
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45742032/article/details/119204358
版权

目录

RabbitMq发送接收消息方式

RabbitMq不使用交换机

发送方

    public static void main(String[] args) {
        String messageData = "test message, hello!";
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("47.110.157.82");
        factory.setPort(5672);
        factory.setUsername("liu");
        factory.setPassword("123456");
        Connection connection=null;
        Channel channel=null;
        try {
            connection = factory.newConnection();
            channel = connection.createChannel();
            /**
             * 参数1：队列名
             * 参数2：持久化
             * 参数3：是否排外，排外只允许一个消费者监听
             * 参数4：是否自动删除，队列中没有消息并且没有消费者连接时会自动删除
             * 参数4：为队列设置属性，通常为null
             */
            channel.queueDeclare("myqueue",true,false,false,null);

            /**
             * 参数1:交换机名
             * 参数2:队列名或者routingkey，指定了交换机这里就是routingkey
             * 参数3:设置消息属性，通常为null
             * 参数4:消息数据
             */
            channel.basicPublish("","myqueue",null,messageData.getBytes());
            System.out.println("消息发送成功");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }finally {
            if(channel!=null){
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }
            if(connection!=null){
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

接收方

    public static void main(String[] args) {
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("47.110.157.82");
        factory.setPort(5672);
        factory.setUsername("liu");
        factory.setPassword("123456");
        Connection connection=null;
        Channel channel=null;
        try {
            connection = factory.newConnection();
            channel = connection.createChannel();                     
            channel.queueDeclare("myqueue",true,false,false,null);
            /**
             * 参数1 监听队列名
             * 参数2 自动确认
             * 参数3 接受者标签
             * 参数4 消息接收回调方法
             */
            channel.basicConsume("myqueue",true,"",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(message);
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }finally {
        }
    }

RabbitMq-direct

发送方

 public static void main(String[] args) {
        String messageData = "direct message, hello!";
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("47.110.157.82");
        factory.setPort(5672);
        factory.setUsername("liu");
        factory.setPassword("123456");
        Connection connection=null;
        Channel channel=null;
        try {
            connection = factory.newConnection();
            channel = connection.createChannel();
            /**
             * 队列
             * 参数1：队列名
             * 参数2：持久化
             * 参数3：是否排外，排外只允许一个消费者监听
             * 参数4：是否自动删除，队列中没有消息并且没有消费者连接时会自动删除
             * 参数4：为队列设置属性，通常为null
             */
            channel.queueDeclare("myqueue001",true,false,false,null);
            /**
             * 声明一个交换机
             * 参数1交换机名称
             * 参数2交换机类型
             * 参数3是否持久化
             */
            channel.exchangeDeclare("exchange001","direct",true);
            /**
             * 将队列绑定到交换机
             * 参数1队列名称
             * 参数2交换机名称
             * 参数3routingkey（Bindingkey）
             */
            channel.queueBind("myqueue001","exchange001","routingkey001");
            /**
             * 参数1:交换机名
             * 参数2:routingkey
             * 参数3:设置消息属性，通常为null
             * 参数4:消息数据
             */
            channel.basicPublish("exchange001","routingkey001",null,messageData.getBytes());
            System.out.println("消息发送成功");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }finally {
            if(channel!=null){
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }
            if(connection!=null){
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

接收方

 public static void main(String[] args) {
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("47.110.157.82");
        factory.setPort(5672);
        factory.setUsername("liu");
        factory.setPassword("123456");
        Connection connection=null;
        Channel channel=null;

        try {
            connection = factory.newConnection();
            channel = connection.createChannel();
            channel.queueDeclare("myqueue001",true,false,false,null);
            channel.exchangeDeclare("exchange001","direct",true);
            channel.queueBind("myqueue001","exchange001","routingkey001");

            /**
             * 参数1 监听队列名
             * 参数2 自动确认
             * 参数3 接受者标签
             * 参数4 消息接收回调方法
             */
            channel.basicConsume("myqueue001",true,"",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(message);
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }finally {
        }
    }

RabbitMq-fanout

发送方

 public static void main(String[] args) {
        String messageData = "fanout message, hello!";
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("47.110.157.82");
        factory.setPort(5672);
        factory.setUsername("liu");
        factory.setPassword("123456");
        Connection connection=null;
        Channel channel=null;
        try {
            connection = factory.newConnection();
            channel = connection.createChannel();
            channel.exchangeDeclare("exchange002","fanout",true);
            /**
             * 参数1:交换机名
             * 参数2:routingkey
             * 参数3:设置消息属性，通常为null
             * 参数4:消息数据
             */
            channel.basicPublish("exchange002","",null,messageData.getBytes());
            System.out.println("消息发送成功");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }finally {
            if(channel!=null){
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }
            if(connection!=null){
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

接收方01

    public static void main(String[] args) {
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("47.110.157.82");
        factory.setPort(5672);
        factory.setUsername("liu");
        factory.setPassword("123456");
        Connection connection=null;
        Channel channel=null;

        try {
            connection = factory.newConnection();
            channel = connection.createChannel();
            //创建随机队列
            String queue = channel.queueDeclare().getQueue();
            channel.exchangeDeclare("exchange002","fanout",true);
            channel.queueBind(queue,"exchange002","");

            /**
             * 参数1 监听队列名
             * 参数2 自动确认
             * 参数3 接受者标签
             * 参数4 消息接收回调方法
             */
            channel.basicConsume(queue,true,"",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(“消费者01”+message);
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }finally {
        }
    }

接收方02

    public static void main(String[] args) {
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("47.110.157.82");
        factory.setPort(5672);
        factory.setUsername("liu");
        factory.setPassword("123456");
        Connection connection=null;
        Channel channel=null;

        try {
            connection = factory.newConnection();
            channel = connection.createChannel();
            //创建随机队列
            String queue = channel.queueDeclare().getQueue();
            channel.exchangeDeclare("exchange002","fanout",true);
            channel.queueBind(queue,"exchange002","");

            /**
             * 参数1 监听队列名
             * 参数2 自动确认
             * 参数3 接受者标签
             * 参数4 消息接收回调方法
             */
            channel.basicConsume(queue,true,"",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(“消费者02”+message);
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }finally {
        }
    }

RabbitMq-topic

消费者001

  public static void main(String[] args) {
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("47.110.157.82");
        factory.setPort(5672);
        factory.setUsername("liu");
        factory.setPassword("123456");
        Connection connection=null;
        Channel channel=null;

        try {
            connection = factory.newConnection();
            channel = connection.createChannel();
            channel.queueDeclare("topicmyqueue001",true,false,false,null);
            channel.exchangeDeclare("topicexchange001","topic",true);
            channel.queueBind("topicmyqueue001","topicexchange001","aa");
            /**
             * 参数1 监听队列名
             * 参数2 自动确认
             * 参数3 接受者标签
             * 参数4 消息接收回调方法
             */
            channel.basicConsume("topicmyqueue001",true,"",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("消费者001"+message);
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }finally {
        }
    }

消费者002

  public static void main(String[] args) {
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("47.110.157.82");
        factory.setPort(5672);
        factory.setUsername("liu");
        factory.setPassword("123456");
        Connection connection=null;
        Channel channel=null;

        try {
            connection = factory.newConnection();
            channel = connection.createChannel();
            channel.queueDeclare("topicmyqueue002",true,false,false,null);
            channel.exchangeDeclare("topicexchange001","topic",true);
            channel.queueBind("topicmyqueue002","topicexchange001","aa.*");
            /**
             * 参数1 监听队列名
             * 参数2 自动确认
             * 参数3 接受者标签
             * 参数4 消息接收回调方法
             */
            channel.basicConsume("topicmyqueue002",true,"",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("消费者002"+message);
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }finally {
        }
    }

消费者003

  public static void main(String[] args) {
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("47.110.157.82");
        factory.setPort(5672);
        factory.setUsername("liu");
        factory.setPassword("123456");
        Connection connection=null;
        Channel channel=null;

        try {
            connection = factory.newConnection();
            channel = connection.createChannel();
            channel.queueDeclare("topicmyqueue003",true,false,false,null);
            channel.exchangeDeclare("topicexchange001","topic",true);
            channel.queueBind("topicmyqueue003","topicexchange001","aa.#");
            /**
             * 参数1 监听队列名
             * 参数2 自动确认
             * 参数3 接受者标签
             * 参数4 消息接收回调方法
             */
            channel.basicConsume("topicmyqueue003",true,"",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("消费者003"+message);
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }finally {
        }
    }

发送者

public static void main(String[] args) {
        String messageData = "topic message, hello!";
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("47.110.157.82");
        factory.setPort(5672);
        factory.setUsername("liu");
        factory.setPassword("123456");
        Connection connection=null;
        Channel channel=null;
        try {
            connection = factory.newConnection();
            channel = connection.createChannel();
            channel.exchangeDeclare("topicexchange001","topic",true);
            /**
             * 参数1:交换机名
             * 参数2:routingkey
             * 参数3:设置消息属性，通常为null
             * 参数4:消息数据
             */
          //消费者001，消费者003可以接收到消息
          //  channel.basicPublish("topicexchange001","aa",null,messageData.getBytes());
          //消费者002，消费者003可以接收到消息
          //  channel.basicPublish("topicexchange001","aa.bb",null,messageData.getBytes());
          //消费者003可以接收到消息 
              channel.basicPublish("topicexchange001","aa.bb.cc",null,messageData.getBytes());
            System.out.println("消息发送成功");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }finally {
            if(channel!=null){
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }
            if(connection!=null){
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
桀骜浮沉
关注
专栏目录
SpringBoot整合Rabbitmq发送接收消息实战
09-15
SpringBoot整合Rabbitmq发送接收消息实战 另外，博主发起了SpringBoot整合Rabbitmq这一系列的gitchat交流会。刚兴趣的童鞋可以进入交流：https://gitbook.cn/gitchat/activity/5b90f9214fb1bd5c9acd4338 交流QQ：...
RabbitMQ消费者接收Message乱码问题
weixin_45059961的博客
06-07 5480
使用Message来提取具体得消息内容时出现部分数据乱码的现象，byte[]数组用utf-8编码仍然无效 运行结果：没有乱码 并且以json格式出现
RabbitMq消息序列化简述
热门推荐
zhaozhenzuo的专栏
06-24 1万+
涉及网络传输的应用，序列化不可避免。发送端以某种规则将消息转成byte数组进行发送。 接收端则以约定的规则进行byte[]数组的解析。 序列化的选择可以是jdk序列化，hessian，jackson，protobuf等。 其中jdk序列化的缺点是性能及要求发送方与接收方都是java应用。 hessia，protobuf等都是基于压缩重复字段的思想，减少传输数据量以提高性能。 ja
RabbitMQ 入门教程
最新发布
qq_40698086的博客
08-30 1053
RabbitMQ 是一个开源的消息代理和队列服务器，实现了 AMQP 0-9-1 标准。它可以在完全不同的应用程序之间传递消息。本教程将带你从零开始学习如何使用 RabbitMQ。
rabbitmq消费者消费消息为什么变成数字了？
tagerLion的博客
11-15 4135
温馨提示：图片看不清按ctrl+鼠标滚动放大网页 问题描述 2020年11月28号，rabbitmq队列visitLog一直处于阻塞状态，重启consumer，抛出org.springframework.amqp.AmqpException: No method found for class [B。临时解决方案，将@RabbitListener注解移动到方法上： 按照上图方法操作后，consumer能够消费消息，但有500多条消息消费错误，消费者在接受消息时，其中有的消息为字节数组 初次..
干货实战演练-RabbitMQ普通消息模型(字节流接受模式)
杨杨杨~~的博客
04-28 696
文章目录前言实战演练-RabbitMQ普通消息模型(字节流模式)01::前期准备:引入相关依赖02::整合RabbitMQ02::01-加入RabbitMq相关配置02::02-自定义配置RabbitMq相关组件02::03-消息确认配置03::创建简单消息模型:队列、交换机、路由,并绑定03::01 持久化配置04::制作生产者发起消息05::制作消费者监听消费消息05::制作测试代码06::测试06::01启动demo06::02 通过swagger来测试接口本次分享到底结束，感谢观看!!! 前言   
RabbitMQ——消息发送和消息接收机制
★★光亭★★
06-24 9420
RabbitMQ——消息发送和消息接收机制
rabbitmq发送&接收消息
06-01
【标题】：“rabbitmq发送&接收消息” 在IT行业中，消息队列（Message Queue）是一种常用的技术，用于处理异步任务、解耦系统组件以及缓解高并发时的系统压力。RabbitMQ是一款开源的消息代理软件，它基于AMQP...
rabbitMq消息接收与消费
10-31
在RabbitMQ中，生产者是发送消息的应用，消费者是接收消息的应用。中间通过交换机（Exchange）进行消息路由，交换机会根据预定义的绑定规则（Binding）将消息投递到一个或多个队列（Queue）中。队列是存储消息的地方...
.Net使用RabbitMQ即时发消息Demo
10-18
描述中提到，这篇文章会通过示例代码详细讲解如何在.NET应用中使用RabbitMQ发送消息。首先，我们需要了解RabbitMQ的基础知识，包括它的工作原理和AMQP协议。RabbitMQ提供了一种消息队列机制，允许应用程序之间异步...
C# .Net RabbitMQ消息队列发送和接收实例程序
04-21
在本文中，我们将深入探讨如何使用C# .NET 6.0和RabbitMQ.Client....提供的压缩包文件"RabbitMQ发送接收实例.Net"应该包含示例代码，供你参考和学习。实践这些示例，你将能够更好地掌握RabbitMQ在C# .NET环境下的使用。
RabbitMQ消息发送和接收（实例）
weixin_59334478的博客
11-06 1万+
的消息只能被同一个消费者消费，如果没有消费监听队列那么消息会存放到队列中持久化保存，直到有消费者来消费这个消息，如果有消费者监听队列则立即消费发送到队列中的消息。4.模拟连续向队列中放两次消息，这两条消息的队列名称相同，内容不同。再次返回消息队列，此时消息队列已经没有了消息，消息已经模拟出队了。7.此时进入控制台查看队列，发现队列中的消息已经全部取出。修改Idea消息的内容再向队列里发送一次消息。修改Idea消息的内容再向队列里发送一次消息。模拟从队列中取出消息，查看取出的消息内容。
一文详解RabbitMQ的发送与接收。
2301_76607156的博客
04-20 2284
消息队列呢，其实用法都是一样的，只是各个开源消息队列的侧重点稍有不同，我们应该根据我们自己的项目需求来决定我们应该选取什么样的消息队列来为我们的项目服务，这个项目选型的工作一般都是开发组长帮你们做了，一般是轮不到我们来做的，但是面试的时候可能会考察相关知识，所以这几种消息队列我们都应该有所涉猎。上面说了消息队列带来的好处以及问题，而这些不在我们今天这篇的讨论范围之内，我打算之后再写这些，我们今天要做的是搭建出一个消息队列环境，让大家感受一下基础的发消息与消费消息，更高级的问题会放在以后讨论。
RabbitMQ
liang183691的博客
11-27 2385
RabbitMQ 1.RabbitMQ特点 RabbitMQ 是一个由Erlang 语言开发的基于AMQP 标准的开源实现。RabbitMQ 最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。其具体特点包括： 保证可靠性（ Reliabil ity ） 。RabbitMQ 使用一些机制来保证可靠性，如持久化、传输确认、发布确认等。 具有灵活的路由...
C++使用RabbitMQ
cxd1314520的博客
05-16 1万+
1)新建Paint C++ APlication项目，导入rabbitMQ静态库 .pro结果如下 TEMPLATE = app CONFIG += console c++11 CONFIG -= app_bundle CONFIG -= qt SOURCES += \ main.cpp \ rabbitmqclient.cpp HEADERS += \ rab...
RabbitMQ——使用事务控制消息的发送和接收
★★光亭★★
06-30 8352
RabbitMQ——使用事务控制消息的发送和接收
RabbitMQ如何保证消息的发送和接收
wy971744839的博客
01-30 1716
RabbitMQ如何保证消息的发送和接收
C++ rabbitmq 使用例子-发送接收流程
繁星点点~
06-03 7330
1.创建一个新连接 conn = amqp_new_connection(); 2.创建一个新socket socket = amqp_tcp_socket_new(conn); 3.打开socket，设置IP、port等 status = amqp_socket_open(socket, hostname, port); 4.登录服务器 amqp_login(conn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, "guest", "guest")
【微服务-消息中间件】RabbitMQ七种消息收发方式
qq_43843951的博客
08-08 1725
MQ全称为Message Queue，即消息队列。本次学习rabbit消息的收发方式
RabbitMQ发送消息
08-24
在RabbitMQ中，你可以发送消息（publish messages）到特定的交换机（Exchange），然后由交换机根据路由键（Routing Key）将消息路由到相应的队列（Queue）。接收者通过声明的队列来订阅并消费这些消息。 发送消息的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

桀骜浮沉

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

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

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

打赏作者

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

抵扣说明：

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

余额充值