java操作rabbitmq

已于 2023-06-08 20:24:43 修改
阅读量996 收藏
点赞数 3
分类专栏： 分布式 文章标签： java-rabbitmq rabbitmq java
于 2023-05-09 19:52:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63040701/article/details/130587406
版权

JMS

JMS是JavaEE规范中的一种，类比JDBC

JMS即Java消息服务（JavaMessage Service）应用程序接口，是一个Java平台中关于面向消息中间件的API很多MQ产.品都实现了JMS规范，但RabbitMQ官方并没有实现JMS规范，但是开源社区有JMS的实现包

项目搭建

创建普通maven项目

引入RabbitMQ依赖

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

简单模式

原理

使用默认交换机（direct交换机）

一个生产者对应一个消费者

生产者

public static void producer() throws IOException, TimeoutException {
    //1.建立连接工厂
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("192.168.66.105");//rabbitmq所在ip
    connectionFactory.setPort(5672);//rabbitmq端口号默认5672
    connectionFactory.setUsername("guest");//用户名
    connectionFactory.setPassword("guest");//密码
    connectionFactory.setVirtualHost("/");//采用默认虚拟机
    //2.创建连接
    Connection connection = connectionFactory.newConnection();
    //3.建立信道
    Channel channel = connection.createChannel();
    //4.创建队列(如果队列存在，则使用该队列)
    /**
     * 参数1：队列名
     * 参数2：是否持久化[true:mq重启队列仍在]
     * 参数3：是否私有化[true:只有第一次拥有它的消费者才可以访问]
     * 参数4：是否自动删除[true:不使用队列时自动删除队列]
     * 参数5：其他额外参数
     */
    channel.queueDeclare("simple_queue",false,false,false,null);
    //5.发送消息
    /**
     * 参数1：交换机[""表示默认交换机]
     * 参数2：路由键[简单模式就是队列名]
     * 参数3：其他额外参数
     * 参数4：消息[要转为字节数组]
     */
    String msg="你好 rabbitmq";
    channel.basicPublish("","simple_queue",null,msg.getBytes());
    //6.关闭资源(信道 连接)
    channel.close();
    connection.close();
}

消费者

public static void customer() throws IOException, TimeoutException {
    //1.建立连接工厂
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("192.168.66.105");//rabbitmq所在ip
    connectionFactory.setPort(5672);//rabbitmq端口号默认5672
    connectionFactory.setUsername("guest");//用户名
    connectionFactory.setPassword("guest");//密码
    connectionFactory.setVirtualHost("/");//采用默认虚拟机
    //2.创建连接
    Connection connection = connectionFactory.newConnection();
    //3.建立信道
    Channel channel = connection.createChannel();
    //4.监听队列
    /**
     * 参数1：监听的队列名
     * 参数2：是否自动签收[false：手动确认消息已收到，否则mq会一直发送消息]
     * 参数3：Customer的实现类，重写该类方法表示接收到消息后如何处理消息
     */
    channel.basicConsume("simple_queue",true,new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            String msg= new String(body, "utf-8");
            System.out.println(msg);
        }
    });
}

工作队列模式

原理

使用默认交换机（direct交换机）

一个队列对应多个消费者（一条消息只被一个消费者消费，采用轮询的方式将消息平均发送给消费者）

生产者

public static void producer() throws IOException, TimeoutException {
    //1.建立连接工厂
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("192.168.66.105");//rabbitmq所在ip
    connectionFactory.setPort(5672);//rabbitmq端口号默认5672
    connectionFactory.setUsername("guest");//用户名
    connectionFactory.setPassword("guest");//密码
    connectionFactory.setVirtualHost("/");//采用默认虚拟机
    //2.创建连接
    Connection connection = connectionFactory.newConnection();
    //3.建立信道
    Channel channel = connection.createChannel();
    //4.创建队列(如果队列存在，则使用该队列)
    /**
     * 参数1：队列名
     * 参数2：是否持久化[true:mq重启队列仍在]
     * 参数3：是否私有化[true:只有第一次拥有它的消费者才可以访问]
     * 参数4：是否自动删除[true:不使用队列时自动删除队列]
     * 参数5：其他额外参数
     */
    channel.queueDeclare("work_queue",true,false,false,null);
    //5.发送消息
    /**
     * 参数1：交换机[""表示默认交换机]
     * 参数2：路由键[简单模式就是队列名]
     * 参数3：其他额外参数(MessageProperties.PERSISTENT_TEXT_PLAIN：持久化消息，除了保存在内存还保存在磁盘中)
     * 参数4：消息[要转为字节数组]
     */
    for(int i=1;i<=10;i++){
        channel.basicPublish("","work_queue", MessageProperties.PERSISTENT_TEXT_PLAIN,("你好 rabbitmq-"+i).getBytes());
    }
    //6.关闭资源(信道 连接)
    channel.close();
    connection.close();
}

两个消费者监听同一个对列

Customer1

public static void customer() throws IOException, TimeoutException {
    //1.建立连接工厂
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("192.168.66.105");//rabbitmq所在ip
    connectionFactory.setPort(5672);//rabbitmq端口号默认5672
    connectionFactory.setUsername("guest");//用户名
    connectionFactory.setPassword("guest");//密码
    connectionFactory.setVirtualHost("/");//采用默认虚拟机
    //2.创建连接
    Connection connection = connectionFactory.newConnection();
    //3.建立信道
    Channel channel = connection.createChannel();
    //4.监听队列
    /**
     * 参数1：监听的队列名
     * 参数2：是否自动签收[false：手动确认消息已收到，否则mq会一直发送消息]
     * 参数3：Customer的实现类，重写该类方法表示接收到消息后如何处理消息
     */
    channel.basicConsume("work_queue",true,new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            String msg= new String(body, "utf-8");
            System.out.println("customer1"+msg);
        }
    });
}

Customer2

public static void customer() throws IOException, TimeoutException {
    //1.建立连接工厂
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("192.168.66.105");//rabbitmq所在ip
    connectionFactory.setPort(5672);//rabbitmq端口号默认5672
    connectionFactory.setUsername("guest");//用户名
    connectionFactory.setPassword("guest");//密码
    connectionFactory.setVirtualHost("/");//采用默认虚拟机
    //2.创建连接
    Connection connection = connectionFactory.newConnection();
    //3.建立信道
    Channel channel = connection.createChannel();
    //4.监听队列
    /**
     * 参数1：监听的队列名
     * 参数2：是否自动签收[false：手动确认消息已收到，否则mq会一直发送消息]
     * 参数3：Customer的实现类，重写该类方法表示接收到消息后如何处理消息
     */
    channel.basicConsume("work_queue",true,new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            String msg= new String(body, "utf-8");
            System.out.println("customer2"+msg);
        }
    });
}

发布订阅模式

原理

使用fanout交换机

fanout交换机将消息发送给多个队列

生产者

public static void producer() throws IOException, TimeoutException {
    //1.建立连接工厂
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("192.168.66.105");//rabbitmq所在ip
    connectionFactory.setPort(5672);//rabbitmq端口号默认5672
    connectionFactory.setUsername("guest");//用户名
    connectionFactory.setPassword("guest");//密码
    connectionFactory.setVirtualHost("/");//采用默认虚拟机
    //2.创建连接
    Connection connection = connectionFactory.newConnection();
    //3.建立信道
    Channel channel = connection.createChannel();
    //4.创建交换机
    /**
     * 参数1：交换机名(自定义)
     * 参数2：交换机类型
     * 参数3：交换机持久化[true,mq关闭后交换机仍存在]
     */
    channel.exchangeDeclare("exchange_fanout", BuiltinExchangeType.FANOUT,true);
    //5.创建队列(如果队列存在，则使用该队列)
    /**
     * 参数1：队列名
     * 参数2：是否持久化[true:mq重启队列仍在]
     * 参数3：是否私有化[true:只有第一次拥有它的消费者才可以访问]
     * 参数4：是否自动删除[true:不使用队列时自动删除队列]
     * 参数5：其他额外参数
     */
    channel.queueDeclare("publish_queue1",false,false,false,null);
    channel.queueDeclare("publish_queue2",false,false,false,null);
    channel.queueDeclare("publish_queue3",false,false,false,null);
    //6.交换机绑定队列
    /**
     * 参数1：队列名
     * 参数2：交换机名
     * 参数3：路由关键字(发布订阅模式没有，写成""即可)
     */
    channel.queueBind("publish_queue1","exchange_fanout","");
    channel.queueBind("publish_queue2","exchange_fanout","");
    channel.queueBind("publish_queue3","exchange_fanout","");
    //7.发送消息()
    /**
     * 参数1：交换机[""表示默认交换机]
     * 参数2：路由关键字[简单模式就是队列名,发布订阅模式没有，写成""即可]
     * 参数3：其他额外参数
     * 参数4：消息[要转为字节数组]
     */
   for (int i=1;i<=10;i++){
       channel.basicPublish("exchange_fanout","",null,("msg"+i).getBytes());
   }
    //7.关闭资源(信道 连接)
    channel.close();
    connection.close();
}

两个消费者监听不同队列

Customer1

public static void customer() throws IOException, TimeoutException {
    //1.建立连接工厂
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("192.168.66.105");//rabbitmq所在ip
    connectionFactory.setPort(5672);//rabbitmq端口号默认5672
    connectionFactory.setUsername("guest");//用户名
    connectionFactory.setPassword("guest");//密码
    connectionFactory.setVirtualHost("/");//采用默认虚拟机
    //2.创建连接
    Connection connection = connectionFactory.newConnection();
    //3.建立信道
    Channel channel = connection.createChannel();
    //4.监听队列
    /**
     * 参数1：监听的队列名
     * 参数2：是否自动签收[false：手动确认消息已收到，否则mq会一直发送消息]
     * 参数3：Customer的实现类，重写该类方法表示接收到消息后如何处理消息
     */
    channel.basicConsume("publish_queue1",true,new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            String msg= new String(body, "utf-8");
            System.out.println("customer1"+msg);
        }
    });
}

Customer2

public static void customer() throws IOException, TimeoutException {
    //1.建立连接工厂
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("192.168.66.105");//rabbitmq所在ip
    connectionFactory.setPort(5672);//rabbitmq端口号默认5672
    connectionFactory.setUsername("guest");//用户名
    connectionFactory.setPassword("guest");//密码
    connectionFactory.setVirtualHost("/");//采用默认虚拟机
    //2.创建连接
    Connection connection = connectionFactory.newConnection();
    //3.建立信道
    Channel channel = connection.createChannel();
    //4.监听队列
    /**
     * 参数1：监听的队列名
     * 参数2：是否自动签收[false：手动确认消息已收到，否则mq会一直发送消息]
     * 参数3：Customer的实现类，重写该类方法表示接收到消息后如何处理消息
     */
    channel.basicConsume("publish_queue2",true,new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            String msg= new String(body, "utf-8");
            System.out.println("customer2"+msg);
        }
    });
}

路由模式

原理

使用direct交换机

每个队列绑定路由关键字（交换机根据路由关键字转发到指定队列）

生产者

public static void producer() throws IOException, TimeoutException {
    //1.建立连接工厂
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("192.168.66.105");//rabbitmq所在ip
    connectionFactory.setPort(5672);//rabbitmq端口号默认5672
    connectionFactory.setUsername("guest");//用户名
    connectionFactory.setPassword("guest");//密码
    connectionFactory.setVirtualHost("/");//采用默认虚拟机
    //2.创建连接
    Connection connection = connectionFactory.newConnection();
    //3.建立信道
    Channel channel = connection.createChannel();
    //4.创建交换机
    /**
     * 参数1：交换机名(自定义)
     * 参数2：交换机类型
     * 参数3：交换机持久化[true,mq关闭后交换机仍存在]
     */
    channel.exchangeDeclare("exchange_direct", BuiltinExchangeType.DIRECT,true);
    //5.创建队列(如果队列存在，则使用该队列)
    /**
     * 参数1：队列名
     * 参数2：是否持久化[true:mq重启队列仍在]
     * 参数3：是否私有化[true:只有第一次拥有它的消费者才可以访问]
     * 参数4：是否自动删除[true:不使用队列时自动删除队列]
     * 参数5：其他额外参数
     */
    channel.queueDeclare("routing_queue1",false,false,false,null);
    channel.queueDeclare("routing_queue2",false,false,false,null);
    channel.queueDeclare("routing_queue3",false,false,false,null);
    //6.交换机绑定队列
    /**
     * 参数1：队列名
     * 参数2：交换机名
     * 参数3：路由关键字(自定义关键字名称)
     */
    channel.queueBind("routing_queue1","exchange_direct","key1");
    channel.queueBind("routing_queue2","exchange_direct","key2");
    //7.发送消息()
    /**
     * 参数1：交换机[""表示默认交换机]
     * 参数2：路由关键字[简单模式就是队列名,发布订阅模式没有，写成""即可]
     * 参数3：其他额外参数
     * 参数4：消息[要转为字节数组]
     */
   for (int i=1;i<=10;i++){
       channel.basicPublish("exchange_direct","key1",null,("msg"+i).getBytes());
       channel.basicPublish("exchange_direct","key2",null,("msg"+i).getBytes());
   }
    //7.关闭资源(信道 连接)
    channel.close();
    connection.close();
}

两个消费者，每个消费者对应不同队列

Customer1

public static void customer() throws IOException, TimeoutException {
    //1.建立连接工厂
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("192.168.66.105");//rabbitmq所在ip
    connectionFactory.setPort(5672);//rabbitmq端口号默认5672
    connectionFactory.setUsername("guest");//用户名
    connectionFactory.setPassword("guest");//密码
    connectionFactory.setVirtualHost("/");//采用默认虚拟机
    //2.创建连接
    Connection connection = connectionFactory.newConnection();
    //3.建立信道
    Channel channel = connection.createChannel();
    //4.监听队列
    /**
     * 参数1：监听的队列名
     * 参数2：是否自动签收[false：手动确认消息已收到，否则mq会一直发送消息]
     * 参数3：Customer的实现类，重写该类方法表示接收到消息后如何处理消息
     */
    channel.basicConsume("routing_queue1",true,new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            String msg= new String(body, "utf-8");
            System.out.println("customer1"+msg);
        }
    });
}

Customer2

public static void customer() throws IOException, TimeoutException {
    //1.建立连接工厂
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("192.168.66.105");//rabbitmq所在ip
    connectionFactory.setPort(5672);//rabbitmq端口号默认5672
    connectionFactory.setUsername("guest");//用户名
    connectionFactory.setPassword("guest");//密码
    connectionFactory.setVirtualHost("/");//采用默认虚拟机
    //2.创建连接
    Connection connection = connectionFactory.newConnection();
    //3.建立信道
    Channel channel = connection.createChannel();
    //4.监听队列
    /**
     * 参数1：监听的队列名
     * 参数2：是否自动签收[false：手动确认消息已收到，否则mq会一直发送消息]
     * 参数3：Customer的实现类，重写该类方法表示接收到消息后如何处理消息
     */
    channel.basicConsume("routing_queue2",true,new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            String msg= new String(body, "utf-8");
            System.out.println("customer2"+msg);
        }
    });
}

通配符模式

使用topic交换机

路由关键字由多个单词构成，中间以.分割（#前/后可以匹配任意多个单词，*可以匹配任意一个单词）

生产者

public static void producer() throws IOException, TimeoutException {
    //1.建立连接工厂
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("192.168.66.105");//rabbitmq所在ip
    connectionFactory.setPort(5672);//rabbitmq端口号默认5672
    connectionFactory.setUsername("guest");//用户名
    connectionFactory.setPassword("guest");//密码
    connectionFactory.setVirtualHost("/");//采用默认虚拟机
    //2.创建连接
    Connection connection = connectionFactory.newConnection();
    //3.建立信道
    Channel channel = connection.createChannel();
    //4.创建交换机
    /**
     * 参数1：交换机名(自定义)
     * 参数2：交换机类型
     * 参数3：交换机持久化[true,mq关闭后交换机仍存在]
     */
    channel.exchangeDeclare("exchange_topic", BuiltinExchangeType.TOPIC,true);
    //5.创建队列(如果队列存在，则使用该队列)
    /**
     * 参数1：队列名
     * 参数2：是否持久化[true:mq重启队列仍在]
     * 参数3：是否私有化[true:只有第一次拥有它的消费者才可以访问]
     * 参数4：是否自动删除[true:不使用队列时自动删除队列]
     * 参数5：其他额外参数
     */
    channel.queueDeclare("topic_queue1",false,false,false,null);
    channel.queueDeclare("topic_queue2",false,false,false,null);
    //6.交换机绑定队列
    /**
     * 参数1：队列名
     * 参数2：交换机名
     * 参数3：路由关键字(自定义关键字名称)(#代表前面/后面可以加任意多单词  *)
     */
    channel.queueBind("topic_queue1","exchange_topic","#.key1.#");
    channel.queueBind("topic_queue2","exchange_topic","key2");
    //7.发送消息()
    /**
     * 参数1：交换机[""表示默认交换机]
     * 参数2：路由关键字[简单模式就是队列名,发布订阅模式没有，写成""即可]
     * 参数3：其他额外参数
     * 参数4：消息[要转为字节数组]
     */
   for (int i=1;i<=10;i++){
       channel.basicPublish("exchange_topic","key1.val1",null,("msg"+i).getBytes());
       channel.basicPublish("exchange_topic","key2",null,("msg"+i).getBytes());
   }
    //7.关闭资源(信道 连接)
    channel.close();
    connection.close();
}

两个消费者监听不同队列

Customer1

public static void customer() throws IOException, TimeoutException {
    //1.建立连接工厂
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("192.168.66.105");//rabbitmq所在ip
    connectionFactory.setPort(5672);//rabbitmq端口号默认5672
    connectionFactory.setUsername("guest");//用户名
    connectionFactory.setPassword("guest");//密码
    connectionFactory.setVirtualHost("/");//采用默认虚拟机
    //2.创建连接
    Connection connection = connectionFactory.newConnection();
    //3.建立信道
    Channel channel = connection.createChannel();
    //4.监听队列
    /**
     * 参数1：监听的队列名
     * 参数2：是否自动签收[false：手动确认消息已收到，否则mq会一直发送消息]
     * 参数3：Customer的实现类，重写该类方法表示接收到消息后如何处理消息
     */
    channel.basicConsume("topic_queue1",true,new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            String msg= new String(body, "utf-8");
            System.out.println("customer1"+msg);
        }
    });
}

Customer2

public static void customer() throws IOException, TimeoutException {
    //1.建立连接工厂
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("192.168.66.105");//rabbitmq所在ip
    connectionFactory.setPort(5672);//rabbitmq端口号默认5672
    connectionFactory.setUsername("guest");//用户名
    connectionFactory.setPassword("guest");//密码
    connectionFactory.setVirtualHost("/");//采用默认虚拟机
    //2.创建连接
    Connection connection = connectionFactory.newConnection();
    //3.建立信道
    Channel channel = connection.createChannel();
    //4.监听队列
    /**
     * 参数1：监听的队列名
     * 参数2：是否自动签收[false：手动确认消息已收到，否则mq会一直发送消息]
     * 参数3：Customer的实现类，重写该类方法表示接收到消息后如何处理消息
     */
    channel.basicConsume("topic_queue2",true,new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            String msg= new String(body, "utf-8");
            System.out.println("customer2"+msg);
        }
    });
}

月木@
关注
专栏目录
JAVA操作RabbitMQ
weixin_44080194的博客
09-08 3384
rabbitMQ的单机安装，常见的模型JAVA调用，springboot整合调用
java操作RabbitMQ
EstherLty的博客
09-23 1500
RabbitMQ提供了6种消息模型，但是第6种其实是RPC，并不是MQ,那么也就剩下5种。 但是其实3、4、5这三种都属于订阅模型，只不过进行路由的方式不同。 一、基本消息模型
RabbitMQ配置及其使用（java）
06-08
MQ是消费-生产者模型的一个典型的代表，一端往消息队列中不断写入消息，而另一端则可以读取或者订阅队列中的消息。在项目中，将一些无需即时返回且耗时的操作提取出来，进行了异步处理，而这种异步处理的方式大大的节省了服务器的请求响应时间，从而提高了系统的吞吐量。
java中使用rabbitmq
zjg
03-10 2901
mq常用于业务解耦、流量削峰和异步通信,rabbitmq是使用范围较广,比较稳定的一款开源产品,接下来我们使用springboot的starter来引入rabbitmq,了解mq的几种使用模式,通过几个简单的案例，让你可以快速地了解到该使用哪种模式来对应业务场景，使用rabbitmq看这一篇就够了，下方附安装链接。回到顶部安装看这里官方文档官方网站其他项目，可参考官方案例路漫漫其修远兮，吾将上下而求索。
Java实现 RabbitMQ 消息队列
最新发布
shark_ker的博客
09-18 517
这是对照 RabbitMQ 消息队列实现的 消息队列。
java连接rabbitMQ
y525794266的博客
11-01 3692
maven依赖              &lt;dependency&gt;             &lt;groupId&gt;com.rabbitmq&lt;/groupId&gt;             &lt;artifactId&gt;amqp-client&lt;/artifactId&gt;             &lt;version&gt;5.2.0&lt;/versi...
RabbitMQ在java中的使用、整合
m0_73598900的博客
05-25 2276
学习RabbitMQ作为消息队列中间件，对于理解分布式系统、异步处理、应用解耦和提高系统可扩展性非常有帮助
java 操作rabbitmq
07-12
在Java中操作RabbitMQ，您可以使用RabbitMQ的官方Java客户端库（RabbitMQ Java Client）。下面是一些常见的操作示例： 1. 发送消息到队列： ```java import com.rabbitmq.client.Connection; import ...
java操作rabbitmq消费者示例
feinifi的博客
10-12 6415
rabbitmq是作为消息队列，在实际应用中很常见，生产者将消息发送到某个队列，消费者消费这个队列。 消息在队列中，消费者要消费，需要监听队列，简单的来说，就是注册一个方法到消费者通道，这个方法就会在有消息的时候执行。 下面通过java来操作rabbitmq，给出代码示例。 这里介绍三种消费者示例方法 1、最简单的注册。 直接通过channel.basicConsume()设置callback。 2、模拟一个...
Java使用RabbitMq的一个简单demo
06-21
在IT行业中，消息队列（Message Queue）是一种重要的中间件技术，它允许...在这个简单的demo中，我们学习了如何创建连接、声明交换机和队列、发送和接收消息，这些都是RabbitMQ的基础操作，为更高级的用法打下了基础。
Java使用RabbitMQ完整项目源码.rar
12-28
此项目是java使用RabbitMQ的demo源码，其中详细的展示了java如何使用rabbitMQ。包括连接RabbitMQ服务器，发送消息，处理消息，发送监听，返回监听等。
Java代码连接RabbitMQ服务器
Kristabo的博客
07-31 786
可以发现名称为 "ex_queue_name"的队列中已没有未读消息。如果不知如何启动RabbitMQ服务或登录该管理界面，参考之前文章。Rabbitmq的安装与使用（Linux版）启动Consumer程序。
Rabbitmq在java中的使用
qq_49341576的博客
03-23 2544
如果N个队列绑定到某个扇型交换机上，当有消息发送给此扇型交换机时，交换机会将消息的发送给这所有的N个队列。可以看到，ttl10s的比ttl40s的要30s接收到， 之所以是被死信队列接收，是因为设置的 ttl 分别是10s 和 40s，所以刚好被 死信队列接收。主题交换机（topic exchanges）中，队列通过路由键绑定到交换机上，然后，交换机根据消息里的路由值，将消息路由给一个或多个绑定队列。对于主题交换机，路由规则由路由键决定，只有满足路由键的规则，消息才可以路由到对应的队列上。
Java连接rabbitMQ（三步超简单）
Takina的博客
07-04 3345
Java连接rabbitMQ
使用Java连接Rabbitmq
www.xqijun.top
04-26 4693
MQ全称为Message Queue，即消息队列。“消息队列”是在消息的传输过程中保存消息的容器。它是典型的：生产者、消费者模型。生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。
Mac / Windows 下安装 RabbitMQ
沐淼的博客
07-18 211
Mac / Windows 下安装 RabbitMQMac / Windows 下安装 RabbitMQ什么是 RabbitMQ ？Mac 下安装 RabbitMQ1、安装 HomebrewHomebrew 简介安装 Homebrew卸载 Homebrew2、通过 Homebrew 来安装 RabbitMQWindows 下安装 RabbitMQ Mac / Windows 下安装 RabbitMQ 什么是 RabbitMQ ？ RabbitMQ 是采用 Erlang 语言实现 AMQP（Advanced
java连接rabbitmq_RabbitMQ基础
weixin_39822629的博客
11-27 660
1. 消息中间件概述1.1. 什么是消息中间件MQ全称为Message Queue，消息队列是应用程序和应用程序之间的通信方法。为什么使用MQ在项目中，可将一些无需即时返回且耗时的操作提取出来，进行异步处理，而这种异步处理的方式大大的节省了服务器的请求响应时间，从而提高了系统的吞吐量。开发中消息队列通常有如下应用场景：1、任务异步处理将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

月木@

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

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

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

打赏作者

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

抵扣说明：

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

余额充值