rabbitmq java客户端如何使用

最新推荐文章于 2024-09-21 09:42:53 发布
最新推荐文章于 2024-09-21 09:42:53 发布
阅读量367 收藏
点赞数
分类专栏： 分布式&微服务 # MQ 文章标签： 队列 java rabbitmq queue mq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wufagang/article/details/107704843
版权

rabbitmq java客户端如何使用

增加依赖

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

模型

目前官网提供7重模型我们就用java实现

hello

在这里插入图片描述
p: 消息生成者
c: 消息消费者
红色:消息队列,进行消息存放和缓存的地方
生成者:

public static void main(String[] args) throws IOException, TimeoutException {
        //创建一个连接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接主机
        connectionFactory.setHost("ip");
        //设置端口
        connectionFactory.setPort(5672);
        //设置虚拟主机
        connectionFactory.setVirtualHost("test");
        connectionFactory.setPassword("test");
        connectionFactory.setUsername("test");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();
        //获取连接中通道
        Channel channel = connection.createChannel();

        channel.queueDeclare("hello",false,false,false,null);

        channel.basicPublish("","hello",null,"hello rabbitmq".getBytes());

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


    }

消费者

 public static void main(String[] args) throws IOException, TimeoutException {
        //创建一个连接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接主机
        connectionFactory.setHost("ip");
        //设置端口
        connectionFactory.setPort(5672);
        //设置虚拟主机
        connectionFactory.setVirtualHost("test");
        connectionFactory.setPassword("test");
        connectionFactory.setUsername("test");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();
        //获取连接中通道
        Channel channel = connection.createChannel();
         /**
         * 信道绑定队列
         * 参数1: 队列名称
         * 参数2:是否持久化
         * 参数3:是否独占队列
         * 参数4:使用完成是否自动删除队列
         * 参数5:额外参数附近配置
         */
        channel.queueDeclare("hello",false,false,false,null);

        /**
         * 发布消息
         * 参数1:交换机名称
         * 参数2:队列名称
         * 参数3:传递消息的额外配置
         * 参数4:具体的消息
         */
        channel.basicConsume("hello",true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                System.out.println(new String(body) );
            }
        });
    }

工具的封装

public static Connection getConnection() throws IOException, TimeoutException {
        //创建一个连接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接主机
        connectionFactory.setHost("ip");
        //设置端口
        connectionFactory.setPort(5672);
        //设置虚拟主机
        connectionFactory.setVirtualHost("test");
        connectionFactory.setPassword("test");
        connectionFactory.setUsername("test");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();
        return connection;
    }

    public static void close(Connection connection, Channel channel) throws IOException, TimeoutException {
        if(connection!=null) {connection.close();}
        if (channel!=null) {channel.close();}

    }

ConnectionFactory 创建工厂是很重的,我们不能使用一次创建一次放到静态块里面吧还是

public class MQUtil {

    private static ConnectionFactory connectionFactory;

    static {
        //创建一个连接工厂对象
        connectionFactory = new ConnectionFactory();
        //设置连接主机
        connectionFactory.setHost("ip");
        //设置端口
        connectionFactory.setPort(5672);
        //设置虚拟主机
        connectionFactory.setVirtualHost("test");
        connectionFactory.setPassword("test");
        connectionFactory.setUsername("test");
    }
    public static Connection getConnection() throws IOException, TimeoutException {


        //获取连接对象
        Connection connection = connectionFactory.newConnection();
        return connection;
    }

    public static void close(Connection connection, Channel channel) throws IOException, TimeoutException {
        if(connection!=null) {connection.close();}
        if (channel!=null) {channel.close();}

    }
}

work

在这里插入图片描述
从上图可以看到一个消息生产者,多个消息消费者:目的就是解决当生产者生产消息比较快,消费者消费比较慢,这样消息越积越多,所以需要多个消费者进行消费,work模型:将多个消费者绑定消息队列,消息一旦消费就会消失,所以也不会出现一个消息被多个消费者进行消费

生产者:

public class Provider {

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

        Channel channel = connection.createChannel();

        channel.queueDeclare("work",false,false,false,null);

        for (int i = 0; i <10 ; i++) {
            channel.basicPublish("","work",null,(i+"work 队列").getBytes());
        }

        MQUtil.close(connection,channel);

    }
}

消费者1:

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

        channel.queueDeclare("work",false,false,false,null);

        channel.basicConsume("work", true, new DefaultConsumer(channel) {

            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1: = "+new String(body));
            }
        });

    }
}

消费者2:

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

        channel.queueDeclare("work",false,false,false,null);

        channel.basicConsume("work",true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2: ="+ new String(body));
            }
        });
    }
}

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

这么一看是平均主义,如果有的能力强,有的能力弱,一定存在累死的和闲死的
不妨把消费者2睡眠3s,看看效果

能者多劳

Doing a task can take a few seconds. You may wonder what happens if one of the consumers starts a long task and dies with it only partly done. With our current code, once RabbitMQ delivers a message to the consumer it immediately marks it for deletion. In this case, if you kill a worker we will lose the message it was just processing. We’ll also lose all the messages that were dispatched to this particular worker but were not yet handled.

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

        channel.queueDeclare("work",false,false,false,null);
        //每次只能消费一个消息
        channel.basicQos(1);
        //关闭自动确认
        channel.basicConsume("work",false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者2: ="+ new String(body));
                /**
                 * 消息确认
                 * 参数1: 指定具体消费哪个消息
                 * 参数2: 是否同时确认多个消息
                 */
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });
    }
}

//每次只能消费一个消息
channel.basicQos(1);
//关闭自动确认
channel.basicConsume(“work”,false,new DefaultConsumer(channel)

/**
* 消息确认
* 参数1: 指定具体消费哪个消息
* 参数2: 是否同时确认多个消息
*/
channel.basicAck(envelope.getDeliveryTag(),false);

fanout 广播

publish/subscribe

在这里插入图片描述

  • 可以有多个消费者
  • 每个消费者有自己的quene队列
  • 每个队列都要绑定到Exchange(交换机)
  • 生成者发送的消息,只能发送到交换机,交换机来决定要发个哪个队列,生产者无法决定
  • 队列的消费者都能拿到消息,实现一条消息被多个消费者消费

注意: 消费者需要先启动,如果没有启动的消费者不会消费之前的消息

生产者:

public class Provider {
    private static final String EXCHANGE_NAME = "logs";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = MQUtil.getConnection();
        Channel channel = connection.createChannel();
        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        channel.basicPublish(EXCHANGE_NAME, "", null, "fanout type message".getBytes("UTF-8"));
    }
}

消费者1:

public class Consumer1 {
    private static final String EXCHANGE_NAME = "logs";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = MQUtil.getConnection();
        Channel channel = connection.createChannel();
        //绑定交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        //获取队列
        String queueName = channel.queueDeclare().getQueue();
        //fanout 类型的交换机 routingKey 没多大意义
        channel.queueBind(queueName, EXCHANGE_NAME, "");

        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1: =="+new String(body));
            }
        });
    }
}

消费者2:

public class Consumer2 {
    private static final String EXCHANGE_NAME = "logs";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = MQUtil.getConnection();
        Channel channel = connection.createChannel();
        //绑定交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        //获取队列
        String queueName = channel.queueDeclare().getQueue();
        //fanout 类型的交换机 routingKey 没多大意义
        channel.queueBind(queueName, EXCHANGE_NAME, "");

        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2: =="+new String(body));
            }
        });
    }
}

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

direct

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

fanout模型我们知道,交换机将消息给所有绑定的队列,如果我们想不同的消息被不同的队列进行消费就需要使用direct模型

  • 队列和交换机不能任意绑定,需要指定一个rountingkey
  • 消息向交换机发送消息时也必须指定rountingkey
  • 交换机不再把消息推送个所有绑定的队列了,而是根据消息的rountingkey和队列的rounting可以完全一致,才进行推送(订阅模式)

生产者

public class Provider {
    private static final String EXCHANGE_NAME = "direct_logs";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = MQUtil.getConnection();
        Channel channel = connection.createChannel();

        channel.exchangeDeclare(EXCH
        ANGE_NAME,"direct");

        channel.basicPublish(EXCHANGE_NAME,"info",null,"routingKey info ".getBytes());

        channel.basicPublish(EXCHANGE_NAME,"error",null,"routingKey error ".getBytes());


    }
}

消费者ConsumerError1 :

public class ConsumerError1 {
    private static final String EXCHANGE_NAME = "direct_logs";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = MQUtil.getConnection();
        Channel channel = connection.createChannel();
        //绑定交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        //获取队列
        String queueName = channel.queueDeclare().getQueue();
       
        channel.queueBind(queueName, EXCHANGE_NAME, "error");

        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1error: =="+new String(body));
            }
        });
    }
}

消费者2ConsumerError2

public class ConsumerError2 {
    private static final String EXCHANGE_NAME = "direct_logs";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = MQUtil.getConnection();
        Channel channel = connection.createChannel();
        //绑定交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        //获取队列
        String queueName = channel.queueDeclare().getQueue();
        //fanout 类型的交换机 routingKey 没多大意义
        channel.queueBind(queueName, EXCHANGE_NAME, "error");

        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者error2: =="+new String(body));
            }
        });
    }
}

消费者3 ConsumerInfo1

public class ConsumerInfo1 {
    private static final String EXCHANGE_NAME = "direct_logs";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = MQUtil.getConnection();
        Channel channel = connection.createChannel();
        //绑定交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        //获取队列
        String queueName = channel.queueDeclare().getQueue();
        //fanout 类型的交换机 routingKey 没多大意义
        channel.queueBind(queueName, EXCHANGE_NAME, "info");

        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者info1: =="+new String(body));
            }
        });
    }
}

消费者4 ConsumerInfo2

public class ConsumerInfo2 {
    private static final String EXCHANGE_NAME = "direct_logs";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = MQUtil.getConnection();
        Channel channel = connection.createChannel();
        //绑定交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        //获取队列
        String queueName = channel.queueDeclare().getQueue();
        //fanout 类型的交换机 routingKey 没多大意义
        channel.queueBind(queueName, EXCHANGE_NAME, "info");

        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者info2: =="+new String(body));
            }
        });
    }
}

topic

topic和direct差不多,路由键可以是用通配符来进行匹配

在这里插入图片描述

*(star) can substitute for exactly one word.
#(hash) can substitute for zero or more words.

*匹配一个字符
#匹配0个或者多个字符

*不过这个地方我们还是应该注意下,当时自己没仔细看官方文档:
和# 都是一单词位单位说的,什么意思就是匹配 …直接的单词个数 原来我还以为是字符所以我写成了info和inf0 这种匹配结果不起作用,还是得多看官方文档说明

生产者:

public class TopicProducer {
    public static final String EXCHANENAME="topic_logs";
    public static void main(String[] args) throws IOException, TimeoutException {

        Channel channel = MQUtils.getChannel();
        //声明交换机
        channel.exchangeDeclare(EXCHANENAME,"topic");

        channel.basicPublish(EXCHANENAME,"log.info.leve2",null, "log.info.leve2".getBytes());
        channel.basicPublish(EXCHANENAME,"log.info.leve1",null, "log.info.leve1".getBytes());
        channel.basicPublish(EXCHANENAME,"log.info.leve1.aa.ee.cc",null, "log.info.leve1.aa.ee.cc".getBytes());

    }
}

消费者1:

public class TopicConstomer1 {

    public static void main(String[] args) throws IOException, TimeoutException {

        Channel channel = MQUtils.getChannel();

        channel.exchangeDeclare(TopicProducer.EXCHANENAME,"topic");

        String queue = channel.queueDeclare().getQueue();
        System.out.println("消费者1 队列  "+ queue);
        channel.queueBind(queue, TopicProducer.EXCHANENAME,"log.info.*");

        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1 log.info.*: =="+new String(body));
            }
        });
    }
}

在这里插入图片描述
消费者2:

public class TopicConstomer2 {

    public static void main(String[] args) throws IOException, TimeoutException {

        Channel channel = MQUtils.getChannel();

        channel.exchangeDeclare(TopicProducer.EXCHANENAME,"topic");

        String queue = channel.queueDeclare().getQueue();
        System.out.println("消费者2 队列  "+ queue);
        channel.queueBind(queue, TopicProducer.EXCHANENAME,"log.*.*");

        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2 log.*.*: =="+new String(body));
            }
        });
    }
}

在这里插入图片描述
消费者3:

public class TopicConstomer3 {

    public static void main(String[] args) throws IOException, TimeoutException {

        Channel channel = MQUtils.getChannel();

        channel.exchangeDeclare(TopicProducer.EXCHANENAME,"topic");

        String queue = channel.queueDeclare().getQueue();
        System.out.println("消费者3 队列  "+ queue);
        channel.queueBind(queue, TopicProducer.EXCHANENAME,"log.#");

        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者3 log.#: =="+new String(body));
            }
        });
    }
}

在这里插入图片描述
消费者4:

public class TopicConstomer4 {

    public static void main(String[] args) throws IOException, TimeoutException {

        Channel channel = MQUtils.getChannel();

        channel.exchangeDeclare(TopicProducer.EXCHANENAME,"topic");

        String queue = channel.queueDeclare().getQueue();
        System.out.println("消费者4 队列  "+ queue);
        channel.queueBind(queue, TopicProducer.EXCHANENAME,"*.info.#");

        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者4 *.info.*: =="+new String(body));
            }
        });
    }
}

在这里插入图片描述

吴法刚
关注
专栏目录
rabbitmq-java-client：RabbitMQ Java客户端
02-03
RabbitMQ Java客户端 该存储库包含源代码。 该客户由的维护。 依赖关系（Maven神器） Maven工件通过上的 。 还有一个的。 。 Maven 5.x系列 该客户端版本独立于RabbitMQ服务器版本，可以与RabbitMQ服务器3.x一起...
RabbitMQ使用教程
热门推荐
Mr. Wu's blog
10-07 1万+
RabbitMQ使用教程，一文解决入门难题
RabbitMQ的详解和使用
创作不易，请多支持，将为本站提供更多「有价值的文章」。
04-10 1万+
一、AMQP协议 1、AMQP协议介绍 AMQP，即Advanced Message Queuing Protocol，一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同的开发语言等条件的限制。Erlang中的实现有RabbitMQ等。 2、功能范围 存储转发（多个消息发送者，单个消息接收者） 分布式事务（多个消息发送者，多个消息接收者） 发布订阅（多个消息发送者，多个消息
RabbitMQ Java项目实战入门与详解
最新发布
weixin_35189483的博客
09-21 1071
本文还有配套的精品资源，点击获取 简介：RabbitMQ是一个开源的消息队列系统，基于AMQP协议，广泛应用于分布式系统中处理异步任务和消息通信。本文通过一个Java项目，详细讲解了如何安装配置RabbitMQ服务器、引入Java客户端库、创建连接和通道、声明交换机和队列、以及消息的发布与消费等核心操作。同时，介绍了如何确保消息的可靠传递和处理项目中的异常情况，帮助Java...
RabbitMQ最全使用教程-小白也能看懂
2401_84557521的博客
04-25 5657
我还通过一些渠道整理了一些大厂真实面试主要有：蚂蚁金服、拼多多、阿里云、百度、唯品会、携程、丰巢科技、乐信、软通动力、OPPO、银盛支付、中国平安等初，中级，高级Java面试题集合，附带超详细答案，希望能帮助到大家。还有专门针对JVM、SPringBoot、SpringCloud、数据库、Linux、缓存、消息中间件、源码等相关面试题。
RabbitMQ基础用法
u010369832的博客
07-27 582
rabbitmq发布订阅模式用法案例
rabbitmq如何使用
weixin_42608299的博客
02-11 349
RabbitMQ 是一个开源的消息代理和队列管理系统，支持多种消息协议，可以用来在分布式系统中进行消息传递。 使用 RabbitMQ 的步骤大致如下： 安装 RabbitMQ 服务器：可以在本地安装或使用云服务商提供的 RabbitMQ 服务。 创建交换器：交换器是消息的中转站，接收到消息后决定将消息发送到哪个队列。 创建队列：队列是存储消息的地方，可以有多个消费者同时从队列中消费消息。 ...
RabbitMQ Java测试客户端
07-16
在这个“RabbitMQ Java测试客户端”项目中，我们可以看到它包含了Java客户端的实现，这对于理解和使用RabbitMQ与Java应用程序的集成至关重要。 首先，我们要理解Java在RabbitMQ中的作用。Java客户端库允许开发者在...
rabbitMQ java客户端入门
08-17
通过本篇文章，我们深入了解了RabbitMQ的基本概念及其Java客户端的使用方法，并通过一个简单的“Hello World”示例展示了如何利用Java客户端与RabbitMQ服务器进行交互。这对于理解RabbitMQ的工作原理以及如何将其...
amqp-client:用Scala编写的，基于Akka和RabbitMQ Java客户端的简单容错AMQP客户端
04-24
简单的Scala AMQP客户端基于 Java客户端的Scala / Akka中的简单客户端。概述该客户端提供了一个简单的API，用于通过AMQP发布和使用消息设置RPC客户端和服务器自动重新连接它基于 2.0框架。局限性和兼容性问题此...
rabbitMq客户端服务
11-17
在3.6.5版本中，你可以通过各种编程语言的客户端库来创建生产者，如Java、Python、Ruby等。 3. **消费者**：消费者是接收并处理消息的客户端。消费者可以设置为轮询队列或者使用推送模式，等待RabbitMQ将消息推送给...
RabbitMQ使用 详解
lxlsygxs2017的博客
04-06 1516
RabbitMQ单机安装 RabbitMQ消息模型：基本消息队列、工作消息队列、发布订阅（Fanout、Direct、Topic） RabbitMQ集群部署 RabbitMQ生产者消息确认 RabbitMQ消费者消息确认 RabbitMQ消息失败重试机制 RabbitMQ死信交换机 RabbitMQ惰性队列 RabbitMQ消息延迟发送 RabbitMQ镜像集群 RabbitMQ仲裁队列 RabbitMQ集群扩容
RabbitMQ的使用（JAVA）
..............
11-15 1万+
Java快速上手的MQ上线！
RabbitMQ的使用详解
Zero摄氏度的博客
07-12 3414
MQ（message queue），本质是个队列，FIFO先入先出。只不过队列中放的是message，是一种跨进程的通信机制，用于上下游传递消息。在互联网架构中，MQ是一种非常常见的上下游解耦的消息通信服务。使用了MQ之后，消息发送上游只需要依赖MQ，不用依赖其他服务。
RabbitMQ的使用
qq_47387991的博客
03-03 1390
1.初识MQ 1.1.同步和异步通讯 微服务间通讯有同步和异步两种方式： 同步通讯：就像打电话，需要实时响应。 异步通讯：就像发邮件，不需要马上回复。
rabbitMQ入门指南：基于Java客户端的详细使用说明
dougsu的博客
07-18 1971
这是一篇关于RabbitMQ Java客户端使用的全面指南。文章详细讲解了从环境配置到连接创建，再到exchange和queue的声明，以及消息的发送和接收等步骤，配合代码示例进行深度解析。对于希望全面了解和精通RabbitMQ的读者，这篇文章将是一份理想的参考。
RabbitMQ基本使用详解及示例
OceanSky的专栏
10-19 1万+
RabbitMQ简介 AMQP,即Advanced Message Queuing Protocol,高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布订阅）、可靠性、安全。RabbitMQ是一个开源的AMQP实现，服务端用Erlang语言...
花了3天总结的RabbitMQ实用技巧，有点东西
weixin_50666791的博客
10-14 150
以前看过的关于RabbitMQ核心消息模式的文章都是基于Java API的，最近看了下官方文档，发现这些核心消息模式都可以通过Spring AMQP来实现。于是总结了下RabbitMQ的实用技巧，包括RabbitMQ在Windows和Linux下的安装、5种核心消息模式的Spring AMQP实现，相信对于想要学习和回顾RabbitMQ的朋友都会有所帮助。 简介 RabbitMQ是最受欢迎的开源消息中间件之一，在全球范围内被广泛应用。RabbitMQ是轻量级且易于部署的，能支持多种消息协议。Rabb.
RabbitMQ安装和使用详细教程
沐雨橙风ιε的博客
07-24 6409
RabbitMQ入门，springboot整合RabbitMQ
RabbitMQ java客户端怎么重发消息
05-16
在 RabbitMQ 中，当消息发送失败时，可以使用以下两种方式进行重发： 1. 自动重试：可以在发送消息时设置重试次数和重试间隔时间，如果消息发送失败，则自动重试发送。这种方式可以通过 RabbitMQ 的 Retry 插件来实现。 2. 手动重发：如果消息发送失败或者未被确认，则可以手动重新发送消息。具体实现方式是在发送消息时，将消息设置为可重发状态，并将其保存在一个队列中，然后按照一定的规则从队列中取出消息进行重发。 以下是手动重发消息的代码示例： ```java ConnectionFactory factory = new ConnectionFactory(); factory.setHost("localhost"); Connection connection = factory.newConnection(); Channel channel = connection.createChannel(); String exchangeName = "test-exchange"; String routingKey = "test-routing-key"; String message = "Hello RabbitMQ!"; try { channel.basicPublish(exchangeName, routingKey, null, message.getBytes()); } catch (IOException e) { // 发送消息失败，将消息设置为可重发状态，并保存到队列中 channel.basicPublish(exchangeName, routingKey, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes()); } // 从队列中取出消息进行重发 GetResponse response = channel.basicGet(queueName, false); if (response != null) { try { channel.basicPublish(exchangeName, routingKey, null, response.getBody()); } catch (IOException e) { // 重发消息失败，将消息再次设置为可重发状态，并保存到队列中 channel.basicPublish(exchangeName, routingKey, MessageProperties.PERSISTENT_TEXT_PLAIN, response.getBody()); } finally { channel.basicAck(response.getEnvelope().getDeliveryTag(), false); } } channel.close(); connection.close(); ``` 在上述示例中，如果发送消息失败，则将消息设置为可重发状态，并保存到队列中。然后从队列中取出消息进行重发，如果重发失败，则再次将消息设置为可重发状态并保存到队列中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值