java 使用RabbitMQ

最新推荐文章于 2024-05-25 19:51:54 发布
最新推荐文章于 2024-05-25 19:51:54 发布
阅读量1.1k 收藏
点赞数
分类专栏： rabbitMQ java 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42572322/article/details/120108390
版权

简单模式：生产者发布Publish消息到队列，消费者从队列消费Consume消息

生产者代码：

package com.example.simple;

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 SimpleProvider {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建链接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置RabbitMQ服务主机地址，默认localhost
        connectionFactory.setHost("localhost");
        //设置端口，默认5672
        connectionFactory.setPort(5672);
        //设置虚拟主机名，默认/
        connectionFactory.setVirtualHost("/mytest");
        //设置用户名密码
        connectionFactory.setUsername("test");
        connectionFactory.setPassword("123456");

        //创建链接
        Connection connection = connectionFactory.newConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //声明队列
        //参数1：消息队列名称
        //参数2，是否持久化
        //参数3，是否独占本次connection链接
        //参数4，是否自动删除消息
        //参数5，是否需要传递额外的队列数据Map
        channel.queueDeclare("simple_queue1",true,false,false,null);
        //创建消息
        String msg = "hello";
        //发布消息
        //参数1，使用指定的交换机，不设置则使用默认交换机
        //参数2，指定路由器key，如果是简单模式直接给队列名就行
        //参数3，发生消息时是否需要额外的消息数据
        //参数4，消息内容
        channel.basicPublish("","simple_queue1",null,msg.getBytes());
        //关闭资源
        channel.close();
        connection.close();
    }
}

 消费者代码

package com.example.simple;

import com.rabbitmq.client.*;

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

public class SimpleConsumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建链接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置RabbitMQ服务主机地址，默认localhost
        connectionFactory.setHost("localhost");
        //设置端口，默认5672
        connectionFactory.setPort(5672);
        //设置虚拟主机名，默认/
        connectionFactory.setVirtualHost("/mytest");
        //设置用户名密码
        connectionFactory.setUsername("test");
        connectionFactory.setPassword("123456");

        //创建链接
        Connection connection = connectionFactory.newConnection();
        //创建频道
        Channel channel = connection.createChannel();

        //声明队列
        //参数1：消息队列名称
        //参数2，是否持久化
        //参数3，是否独占本次connection链接
        //参数4，是否自动删除消息
        //参数5，是否需要传递额外的队列数据Map
        channel.queueDeclare("simple_queue1",true,false,false,null);
        //创建消费者，并且设置消息处理
        //指定频道
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            /**
             *
             * @param consumerTag 消费者名称，如果之前没有指定，则会自动生成一个
             * @param envelope  消息一些额外的参数 channel.basicPublish("","simple_queue1",null,msg.getBytes());
             * @param properties  另外的数据所封装的属性对象 null
             * @param body  消息本身
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //实现消费的业务逻辑
                System.out.println("consumerTag"+consumerTag);
                System.out.println("交换机："+envelope.getExchange()+"----RoutingKey："+envelope.getRoutingKey()+"----DeliveryTag："+envelope.getDeliveryTag());
                System.out.println("消息本身："+new String(body,"UTF-8"));
            }
        };
        //监听消息
        //参数1，指定要监听的队列的名称
        //参数2，设置消息的应答模式，true自动应答（性能好，消息有可能丢失），false手动应答
        //参数3，
        channel.basicConsume("simple_queue1",true,defaultConsumer);


        //关闭资源，建议不关闭一直监听
    }
}

 工作模式：多个消费者消费多个不同的消息，创建多个消费者即可

订阅-广播模式：同一个消息被多个消费者消费。上面两个模式只有三个角色分别是生产者，队列，消费者。而在订阅模式中多了一个角色，那就是exchange交换机角色。

订阅模式大概过程是：生产者生产消息后，发送给交换机，然后由交换机转发给各个队列，在这之前队列需要和交换机进行绑定。     .

 生产者代码

package com.example.fanout;

import com.rabbitmq.client.BuiltinExchangeType;
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 FanoutProvider {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建链接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置RabbitMQ服务主机地址，默认localhost
        connectionFactory.setHost("localhost");
        //设置端口，默认5672
        connectionFactory.setPort(5672);
        //设置虚拟主机名，默认/
        connectionFactory.setVirtualHost("/mytest");
        //设置用户名密码
        connectionFactory.setUsername("test");
        connectionFactory.setPassword("123456");

        //创建链接
        Connection connection = connectionFactory.newConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //声明队列
        //参数1：消息队列名称
        //参数2，是否持久化
        //参数3，是否独占本次connection链接
        //参数4，是否自动删除消息
        //参数5，是否需要传递额外的队列数据Map
        channel.queueDeclare("fanout_queue1",true,false,false,null);
        //声明两个队列
        channel.queueDeclare("fanout_queue2",true,false,false,null);

        //声明交换机
        //参数1 交换机名称
        //参数2，指定交换机的类型 BuiltinExchangeType.FANOUT（广播）
        channel.exchangeDeclare("fanout_exchange", BuiltinExchangeType.FANOUT);
        //将队列绑定到指定的交换机
        //参数1，指定要绑定的队列
        //参数2，指定绑定的交换机
        //参数3，指定routingkey，广播模式可以不写
        channel.queueBind("fanout_queue1","fanout_exchange","");
        channel.queueBind("fanout_queue2","fanout_exchange","");

        //创建消息
        String msg = "hello";
        //发布消息
        //参数1，使用指定的交换机，不设置则使用默认交换机
        //参数2，指定路由器key，如果是简单模式直接给队列名就行，广播模式指定为空
        //参数3，发生消息时是否需要额外的消息数据
        //参数4，消息内容
        channel.basicPublish("fanout_exchange","",null,msg.getBytes());
        //关闭资源
        channel.close();
        connection.close();
    }
}

消费者1

package com.example.fanout;

import com.rabbitmq.client.*;

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

public class FanoutConsumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建链接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置RabbitMQ服务主机地址，默认localhost
        connectionFactory.setHost("localhost");
        //设置端口，默认5672
        connectionFactory.setPort(5672);
        //设置虚拟主机名，默认/
        connectionFactory.setVirtualHost("/mytest");
        //设置用户名密码
        connectionFactory.setUsername("test");
        connectionFactory.setPassword("123456");

        //创建链接
        Connection connection = connectionFactory.newConnection();
        //创建频道
        Channel channel = connection.createChannel();

        //声明队列
        //参数1：消息队列名称
        //参数2，是否持久化
        //参数3，是否独占本次connection链接
        //参数4，是否自动删除消息
        //参数5，是否需要传递额外的队列数据Map
        channel.queueDeclare("fanout_queue1",true,false,false,null);
        //创建消费者，并且设置消息处理
        //指定频道
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            /**
             *
             * @param consumerTag 消费者名称，如果之前没有指定，则会自动生成一个
             * @param envelope  消息一些额外的参数 channel.basicPublish("","simple_queue1",null,msg.getBytes());
             * @param properties  另外的数据所封装的属性对象 null
             * @param body  消息本身
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //实现消费的业务逻辑
                System.out.println("consumerTag"+consumerTag);
                System.out.println("交换机："+envelope.getExchange()+"----RoutingKey："+envelope.getRoutingKey()+"----DeliveryTag："+envelope.getDeliveryTag());
                System.out.println("消息本身："+new String(body,"UTF-8"));
            }
        };
        //监听消息
        //参数1，指定要监听的队列的名称
        //参数2，设置消息的应答模式，true自动应答（性能好，消息有可能丢失），false手动应答
        //参数3，
        channel.basicConsume("fanout_queue1",true,defaultConsumer);


        //关闭资源，建议不关闭一直监听
    }
}

消费者2

package com.example.fanout;

import com.rabbitmq.client.*;

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

public class FanoutConsumer2 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建链接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置RabbitMQ服务主机地址，默认localhost
        connectionFactory.setHost("localhost");
        //设置端口，默认5672
        connectionFactory.setPort(5672);
        //设置虚拟主机名，默认/
        connectionFactory.setVirtualHost("/mytest");
        //设置用户名密码
        connectionFactory.setUsername("test");
        connectionFactory.setPassword("123456");

        //创建链接
        Connection connection = connectionFactory.newConnection();
        //创建频道
        Channel channel = connection.createChannel();

        //声明队列
        //参数1：消息队列名称
        //参数2，是否持久化
        //参数3，是否独占本次connection链接
        //参数4，是否自动删除消息
        //参数5，是否需要传递额外的队列数据Map
        channel.queueDeclare("fanout_queue2",true,false,false,null);
        //创建消费者，并且设置消息处理
        //指定频道
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            /**
             *
             * @param consumerTag 消费者名称，如果之前没有指定，则会自动生成一个
             * @param envelope  消息一些额外的参数 channel.basicPublish("","simple_queue1",null,msg.getBytes());
             * @param properties  另外的数据所封装的属性对象 null
             * @param body  消息本身
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //实现消费的业务逻辑
                System.out.println("consumerTag"+consumerTag);
                System.out.println("交换机："+envelope.getExchange()+"----RoutingKey："+envelope.getRoutingKey()+"----DeliveryTag："+envelope.getDeliveryTag());
                System.out.println("消息本身："+new String(body,"UTF-8"));
            }
        };
        //监听消息
        //参数1，指定要监听的队列的名称
        //参数2，设置消息的应答模式，true自动应答（性能好，消息有可能丢失），false手动应答
        //参数3，
        channel.basicConsume("fanout_queue2",true,defaultConsumer);


        //关闭资源，建议不关闭一直监听
    }
}

订阅-Routing路由模式：

生产者代码

package com.example.routingkey;

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

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;

public class RoutingKeyProvider {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建链接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置RabbitMQ服务主机地址，默认localhost
        connectionFactory.setHost("localhost");
        //设置端口，默认5672
        connectionFactory.setPort(5672);
        //设置虚拟主机名，默认/
        connectionFactory.setVirtualHost("/mytest");
        //设置用户名密码
        connectionFactory.setUsername("test");
        connectionFactory.setPassword("123456");

        //创建链接
        Connection connection = connectionFactory.newConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //声明队列
        //参数1：消息队列名称
        //参数2，是否持久化
        //参数3，是否独占本次connection链接
        //参数4，是否自动删除消息
        //参数5，是否需要传递额外的队列数据Map
        channel.queueDeclare("routingkey_queue1",true,false,false,null);
        //声明两个队列
        channel.queueDeclare("routingkey_queue2",true,false,false,null);

        //声明交换机
        //参数1 交换机名称
        //参数2，指定交换机的类型 BuiltinExchangeType.FANOUT（广播） BuiltinExchangeType.DIRECT(路由模式)
        channel.exchangeDeclare("routingkey_exchange", BuiltinExchangeType.DIRECT);
        //将队列绑定到指定的交换机
        //参数1，指定要绑定的队列
        //参数2，指定绑定的交换机
        //参数3，指定routingkey，广播模式可以不写, routingkey模式要写
        channel.queueBind("routingkey_queue1","routingkey_exchange","item.insert");
        channel.queueBind("routingkey_queue2","routingkey_exchange","item.delete");

        //创建消息
        String msg = "增加操作";
        //发布消息
        //参数1，使用指定的交换机，不设置则使用默认交换机
        //参数2，指定路由器key，如果是简单模式直接给队列名就行，广播模式指定为空
        //参数3，发生消息时是否需要额外的消息数据
        //参数4，消息内容
        channel.basicPublish("routingkey_exchange","item.insert",null,msg.getBytes(StandardCharsets.UTF_8));
        String msg2 = "删除操作";
        //发布消息
        //参数1，使用指定的交换机，不设置则使用默认交换机
        //参数2，指定路由器key，如果是简单模式直接给队列名就行，广播模式指定为空
        //参数3，发生消息时是否需要额外的消息数据
        //参数4，消息内容
        channel.basicPublish("routingkey_exchange","item.delete",null,msg2.getBytes(StandardCharsets.UTF_8));
        //关闭资源
        channel.close();
        connection.close();
    }
}

消费者代码还跟上面一样，改一下对应的队列名就行

订阅-Topics通配符模式(主题模式)

RoutingKey一般是由一个或者多个单词组成，多个单词之间以.分割。例如：item.insert

通配符规则：

#：匹配一个或者多个词

*：匹配不多不少一个词

angen2018
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java使用rabbitMq服务
04-24
【Java使用RabbitMQ服务】 RabbitMQ是一款开源的消息队列系统，广泛应用于分布式系统中的消息传递。本文将简要介绍如何在Java环境中使用RabbitMQ，包括安装、基本结构、消息发送模式以及高级特性。 ### 1. 安装 在...
RabbitMQ的使用（JAVA）
热门推荐
..............
11-15 1万+
Java快速上手的MQ上线！
Rabbitmq在java中的使用
qq_49341576的博客
03-23 2348
如果N个队列绑定到某个扇型交换机上，当有消息发送给此扇型交换机时，交换机会将消息的发送给这所有的N个队列。可以看到，ttl10s的比ttl40s的要30s接收到， 之所以是被死信队列接收，是因为设置的 ttl 分别是10s 和 40s，所以刚好被 死信队列接收。主题交换机（topic exchanges）中，队列通过路由键绑定到交换机上，然后，交换机根据消息里的路由值，将消息路由给一个或多个绑定队列。对于主题交换机，路由规则由路由键决定，只有满足路由键的规则，消息才可以路由到对应的队列上。
RabbitMQ在java中的使用、整合
最新发布
m0_73598900的博客
05-25 1223
学习RabbitMQ作为消息队列中间件，对于理解分布式系统、异步处理、应用解耦和提高系统可扩展性非常有帮助
java操作RabbitMQ
hello PHP的博客
03-30 1298
java操作rabbitmq
RabbitMQ消息队列实战（2）—— Java调用RabbitMQ的三种方式
Hyman的博客
02-01 5216
spring cloud stream的强大之处就在于它的封装，但是不足之处也在于它的封装，封装的太强，必然增加了学习成本和调试难度，而且类似RabbitMQ和Kafka这种中间件的使用，一般在系统创建之处就一定确定，进行无缝切换就显得有些鸡肋了。第5个参数是队列的一些结构化信息，比如声明死信队列、磁盘队列会用到。第12行，创建了一个bind对象，将交换机和队列进行绑定，queueBind的三个参数中：第1个参数指定了队列名称，第2个参数指定了交换机名称，第3个参数是路由键，在直连模式下为队列名称。
RabbitMQ消息队列入门篇（环境配置+Java实例+基础概念）
weixin_30480651的博客
01-09 1359
一、消息队列使用场景或者其好处 消息队列一般是在项目中，将一些无需即时返回且耗时的操作提取出来，进行了异步处理，而这种异步处理的方式大大的节省了服务器的请求响应时间，从而提高了系统的吞吐量。 在项目启动之初来预测将来项目会碰到什么需求，是极其困难的。消息队列在处理过程中间插入了一个隐含的、基于数据的接口层，两边的处理过程都要实现这一接口。这允许你独立的扩展或修改两边的处理过...
java使用rabbitmq demo
05-26
RabbitMQ是当前广泛使用的开源消息队列系统，它基于AMQP（Advanced Message Queuing Protocol）协议，适用于多种编程语言，包括Java。本教程将深入探讨如何在Java中使用RabbitMQ。 首先，你需要在你的开发环境中...
Java使用RabbitMq的一个简单demo
06-21
RabbitMQ是当前广泛使用的开源消息队列系统，它基于AMQP（Advanced Message Queuing Protocol）协议，适用于多种编程语言，包括Java。本篇文章将深入探讨如何在Java环境下使用RabbitMQ实现一个简单的示例。 首先，...
使用Java编写的RabbitMQ连接池方法
11-22
RabbitMQ客户连接池的Java实现。我们刚开始也是采用这种方式来实现的，但做压力测试时，发现这种每次新建Connection和新建Channel是非常耗时的，在大并发下，一般都要8毫秒左右，慢的话，好多都是几十毫秒。因此我们...
Java使用RabbitMQ完整项目源码.rar
12-28
在本项目中，"Java使用RabbitMQ完整项目源码.rar" 提供了一个全面的示例，演示了如何在Java应用程序中集成并有效利用RabbitMQ消息队列系统。RabbitMQ是一个开源的消息代理和队列服务器，它使得应用程序之间可以进行...
Java中使用RabbitMQ(持续更新中)
2301_79957017的博客
01-03 1494
RabbitMQ
java中使用rabbitmq
zjg
03-10 1899
mq常用于业务解耦、流量削峰和异步通信,rabbitmq是使用范围较广,比较稳定的一款开源产品,接下来我们使用springboot的starter来引入rabbitmq,了解mq的几种使用模式,通过几个简单的案例，让你可以快速地了解到该使用哪种模式来对应业务场景，使用rabbitmq看这一篇就够了，下方附安装链接。回到顶部安装看这里官方文档官方网站其他项目，可参考官方案例路漫漫其修远兮，吾将上下而求索。
【RabbitMQ】Java操作RabbitMQ之入门Demo
qq_61903414的博客
04-14 840
由之前文章里我们了解到RabbitMQ的通信如下图，我们要想将生产者生产的消息存入队列，我们就一个先获得Connection（连接）然后通过连接获取到channel，然后选择虚拟机交换机以及队列等最后关闭连接。此时我们需要去在MQ里创建队列，通过channel里的queueDelclare方法来创建该方法有以下参数。此时我们就可以通过channel里的basicPublish方法进行发送消息，该方法有以下参数。我们获取连接是通过连接工厂进行获取的所以此时我们先要去创建连接工厂并给他配置相应的信息。
RabbitMQ核心内容：实战教程（java）
TracyCoder的博客
02-19 2161
RabbitMQ的基础、六大模式、java实战
硬卷消息中间件系列（十五）：RabbitMQ 之 Java 调用的三种方式
weixin_44421461的博客
10-06 420
????这是一个或许对你有用的社群????一对一交流/面试小册/简历优化/求职解惑，欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料：《项目实战（视频）》：从书中学，往事中“练”《互联网高频面试题》：面朝简历学习，春暖花开《架构 x 系统设计》：摧枯拉朽，掌控面试高频场景题《精进 Java 学习指南》：系统学习，互联网主流技术栈《必读 Java 源码专栏》：知其然，知其所以然????这是一个或许...
RabbitMQ教程大全看这一篇就够了-java版本
又逢乱世
11-06 2913
rabbitmq
RabbitMQ入门案例-Java
qq_50523945的博客
05-30 1743
Q全称为Message Queue，消息队列是应用程序和应用程序之间的通信方法。
RabbitMQ的使用（Java语言传统操作）
can_meng_yun的博客
10-05 1490
简单看一下RabbitMQ的工作原理图，无论是生产者还是消费者都需要与RabbitMQ建立连接Connection，但是可以看到一个Connection内部有很多个Channel，实际上生产者和消费者是通过Channel与Broker（RabbitMQ Server本身）进行交互的。在实际应用中，创建连接的操作会被封装成一个工具类，并不是每次获取Channel都需要重新创建连接，使用已经创建好的Connection可以有效的减少连接带来的开销。创建连接通常，配置必要属性，获取连接，在通过连接创建信道。
java 使用 rabbitmq
04-26
在使用Java和RabbitMQ实现消息队列时，应用程序使用RabbitMQ提供的客户端API与RabbitMQ服务器进行交互。应用程序将消息发送到RabbitMQ服务器的消息队列中，然后RabbitMQ服务器负责将消息传递给订阅该消息队列的消费...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值