RabbitMQ使用教程

最新推荐文章于 2022-06-07 17:25:33 发布
最新推荐文章于 2022-06-07 17:25:33 发布
阅读量192 收藏
点赞数
文章标签： 大数据 数据库
原文链接：https://my.oschina.net/u/3042999/blog/3072548
版权

 

  • 简单消息队列
    • 模型

python-one.png

官方图例中，P代表消息生产者，中间代表消息队列，C代表消息的消费者。

  • 获取RabbitMQ链接
/**

 * 获取MQ连接

 */

public static Connection getConnection() throws IOException, TimeoutException {

    //定义一个连接工厂

    ConnectionFactory factory = new ConnectionFactory();

    //设置服务地址

    factory.setHost("*.*.*.*");

    // 协议：端口号 AMQP:5672

    factory.setPort(5672);

    //设置数据库

    factory.setVirtualHost("/vhost_haoyuehong");

    //用户名

    factory.setUsername("haoyuehong");

    //密码

    factory.setPassword("123456");

    factory.setConnectionTimeout(30*1000);//默认60秒

    return factory.newConnection();

}

 

  • 发送一个消息
public class Send {

    private static final String QUEUE_NAME = "test_simple_queue";



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

        //获取一个连接

        Connection connection = ConnectionUtils.getConnection();

        //从连接中获取吧通道

        Channel channel = connection.createChannel();

        //创建队列声明（注册）

        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //要发送的消息

        String msg = "hello rabiitmq";

        channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());

        System.out.println("-->send:"+msg);

        channel.close();

        connection.close();

    }

}

运行以上程序，在RabbitMQ web控制面板QUEUE选项卡中可以看到如下：

a2adbec3aca7cb79aa050bdc6ffe03107ad.jpg

说明消息发送成功。

  • 接受（消费）消息
/**
 * 消息的消费者
 */
public class Recv {
    private static final String QUEUE_NAME = "test_simple_queue";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //获取一个连接
        Connection connection = ConnectionUtils.getConnection();
        //从连接中获取通道
        Channel channel = connection.createChannel();
        //定义队列的消费者
        QueueingConsumer consumer = new QueueingConsumer(channel);
        //监听队列
        channel.basicConsume(QUEUE_NAME,true,consumer);
        while (true){
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String s = new String(delivery.getBody());
            System.out.println("<----recv:"+s);
        }
    }
}

172b628d6c5b818b3ad24d195cccf38d433.jpg

消息数量变为0，说明已被消费。

以上方法已过世，修改如下：

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

        //获取一个连接

        Connection connection = ConnectionUtils.getConnection();

        //从连接中获取通道

        Channel channel = connection.createChannel();

        //声明队列

        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //事件机制  有消息时触发

        DefaultConsumer consumer = new DefaultConsumer(channel) {

            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                String msg = new String(body, "UTF-8");

                System.out.println("<------new API recv:" + msg);

            }

        };

        //监听队列

        channel.basicConsume(QUEUE_NAME,true,consumer);

    }
  • 总结：简单消息队列耦合性高，生产者与消费者一一对应，不能让多个消费者同时消费，不能满足分布式场景，且当消费者的对列名变更时，生产者的对列名也要相应变更。
  • Work  Queues工作队列
  • 模型
    1. 轮训分发（Round-Robin dispatch）

我们假设有一个生产者和两个消费者（生产者和消费者的代码和Simple queue一样，只是多了一个消费者），生产者每0.5秒发送一条消息（共发送50条），消费者1每2秒处理一条消息，消费者2每1秒处理一条消息，测试结果发现：消费者1处理的数据数量和消费者2消费的消息数量相同，且消费者1处理奇数条（下角标为奇数）的数据，消费者2处理偶数条（下角标为偶数）的消息，这种方式叫做轮训分发（Round-Robin）

855a55798411a71d704560ce6cef63ea74c.jpg

        2.公平分发（fair dispatch）

消费者每次处理完消息后手动反馈给消息队列，消息队列分发下一条消息给消费者。

代码如下：

  • 生产者：
public class Send {

    private static final String QUEUE_NAME = "test_work_queue";

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

        Connection connection = ConnectionUtils.getConnection();

        Channel channel = connection.createChannel();

        //声明队列

        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //每个消费者在消息确认之前，消息队列不发送消息到消费者，一次只处理一个消息

        int prefetchCount = 1;

        channel.basicQos(prefetchCount);

        //发送50条消息

        for(int i=0;i<50;i++){

            String msg = "hello work queue :"+i;

            channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());

            Thread.sleep(i*20);

        }

        channel.close();

        connection.close();

    }

}
  • 消费者1：
public class Recv1 {

    private static final String QUEUE_NAME = "test_work_queue";

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

        //获取连接

        Connection connection = ConnectionUtils.getConnection();

        //获取通道

        final Channel channel = connection.createChannel();

        //声明队列

        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        channel.basicQos(1);

        //定义消费者

        DefaultConsumer consumer = new DefaultConsumer(channel) {

            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                String s = new String(body, "UTF-8");

                System.out.println("Recv1 <------收到消息："+s);

                try {

                    Thread.sleep(1000*2);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }finally {

                    System.out.println("[1] done");

                    channel.basicAck(envelope.getDeliveryTag(),false);

                }

            }

        };

        //监听队列

        boolean autoAck = false; //自动应答

        channel.basicConsume(QUEUE_NAME,autoAck,consumer);

    }

}
  • 消费者2：
public class Recv2 {

    private static final String QUEUE_NAME = "test_work_queue";

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

        //获取连接

        Connection connection = ConnectionUtils.getConnection();

        //获取通道

        final Channel channel = connection.createChannel();

        //声明队列

        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        channel.basicQos(1);

        //定义消费者

        DefaultConsumer consumer = new DefaultConsumer(channel) {

            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                String s = new String(body, "UTF-8");

                System.out.println("Recv1 <------收到消息："+s);

                try {

                    Thread.sleep(1000*2);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }finally {

                    System.out.println("[1] done");

                    channel.basicAck(envelope.getDeliveryTag(),false);

                }

            }

        };

        //监听队列

        boolean autoAck = false; //自动应答

        channel.basicConsume(QUEUE_NAME,autoAck,consumer);

    }

}

 

  • 轮训分发与公平分发的区别：
  • 每个消费者发送确认消息之前，消息队列不发送下一个消息到消费者，一次只处理一个消息。限制发送给同一个消费者不得超过1条消息；
int prefetchCount = 1;

channel.basicQos(prefetchCount);

 

  • 消费者增加了channel.basicQos(1)控制同一消息消费次数
channel.basicQos(1);

 

  • 将轮询分发时自动应答修改为手动应答
channel.basicAck(envelope.getDeliveryTag(),false);

………………

boolean autoAck = false; //自动应答

channel.basicConsume(QUEUE_NAME,autoAck,consumer);

 

  • 消息应答
boolean autoAck = false; //自动应答

channel.basicConsume(QUEUE_NAME,autoAck,consumer);

autoAck为自动应答，是一个布尔值，

  1. boolean autoAck = true; 自动确认模式

一旦RabbitMQ将消息分发给消费者，就会将消息从内存中删除，这种情况下，如果消息处理过程中发生异常，消息将会丢失，

    2. boolean autoAck = false; 手动确认模式

如果有一个消费者挂掉，消息队列将会将该消息交付给其他消费者，消费者发送消息应答后RabbitMQ将内存中的消息删除

消息应答默认为false，假设一种极端情况，RabbitMQ发生故障宕机了，因为消息存在内存中，RabbitMQ挂掉后，消息也会丢失，这就需要将数据持久化

  • 消息持久化
boolean durable = false; //持久化

channel.queueDeclare(QUEUE_NAME, durable,false,false,null);

注意：声明好的队列不能修改durable，因为已经将队列声明好，RabbitMQ不准许重新定义一个已存在的对列

  • 订阅模式（Publish/Subscribe）
  • 模型

https://www.rabbitmq.com/img/tutorials/python-three.png

                                                                                            X---交换机

    • 一个生产者多个消费者
    • 每个消费者都有自己的对列
    • 生产者没有直接把消息发送到对列，而是发送到交换机（转发器 exchange）
    • 每个队列都要绑定到交换机上
    • 生产者发送的消息经过交换机到达对列，就能实现一个消息被多个消费者消费

生产者：

public class Send {

    private static final String EXCHANGE_NAME = "test_exchange_fanout";

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

        Connection connection = ConnectionUtils.getConnection();

        Channel channel = connection.createChannel();

        //声明交换机

        channel.exchangeDeclare(EXCHANGE_NAME,"fanout"); //1 交换机名字  2 交换机类型

        //发送消息

        String msg = "hello ps";

        channel.basicPublish(EXCHANGE_NAME,"",null,msg.getBytes());

        System.out.println("send msg ----->"+msg);

        channel.close();

        connection.close();

    }

}

运行以上程序，查看控制台：

660e03d4b912327334e70b186881dfe2617.jpg

此时，消息已经丢失，因为交换机没有存储能力，RabbitMQ里面只有对列有存储能力，由于此时没有对列绑定，所以消息丢失了

消费者1：

public class Recv1 {

    private static final String QUEUE_NAME = "test_queue_fanout_email";

    private static final String EXCHANGE_NAME = "test_exchange_fanout";

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

        Connection connection = ConnectionUtils.getConnection();

        final Channel channel = connection.createChannel();

        //对列声明

        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //绑定对列到交换机

        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"");

        channel.basicQos(1);

        //定义消费者

        DefaultConsumer consumer = new DefaultConsumer(channel) {

            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                String s = new String(body, "UTF-8");

                System.out.println("Recv1 <------收到消息："+s);

                try {

                    Thread.sleep(1000*2);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }finally {

                    System.out.println("[1] done");

                    channel.basicAck(envelope.getDeliveryTag(),false);

                }

            }

        };

        //监听队列

        boolean autoAck = false; //自动应答

        channel.basicConsume(QUEUE_NAME,autoAck,consumer);

    }

}

消费者2：

public class Recv1 {

    private static final String QUEUE_NAME = "test_queue_fanout_email";

    private static final String EXCHANGE_NAME = "test_exchange_fanout";

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

        Connection connection = ConnectionUtils.getConnection();

        final Channel channel = connection.createChannel();

        //对列声明

        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //绑定对列到交换机

        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"");

        channel.basicQos(1);

        //定义消费者

        DefaultConsumer consumer = new DefaultConsumer(channel) {

            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                String s = new String(body, "UTF-8");

                System.out.println("Recv2 <------收到消息："+s);

                try {

                    Thread.sleep(1000*2);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }finally {

                    System.out.println("[2] done");

                    channel.basicAck(envelope.getDeliveryTag(),false);

                }

            }

        };

        //监听队列

        boolean autoAck = false; //自动应答

        channel.basicConsume(QUEUE_NAME,autoAck,consumer);

    }

}
  • Exchange(交换机/转发器)
  • 接受生产者消息
  • 向对列推送消息
  • Exchange类型

        交换器的类型，常见的有fanout、direct、topic、headers这四种

  1.     Fanout Exchange : 不处理任何的路由键，它会把所有发送到该交换器的消息路由到所有与该交换器绑定的队列中,如上代码便是Fanout Exchange。

    00efec7a949d2d39d4794cb315b5bb94afe.jpg

    1.1    模式

https://www.rabbitmq.com/img/tutorials/python-three-overall.png

 

 

        2.    Direct Exchange : 直连的方式 把消息路由到那些 BindingKey RoutingKey 完全匹配的队列中

9c9d77c40797a6a48c3b33fc79cfdef2b38.jpg

        2.1    模式

https://www.rabbitmq.com/img/tutorials/python-four.png

生产者：

public class Send {

    private static final String EXCHANGE_NAME = "test_exchange_rounting";

    private static final String ROUNTINGKEY = "key";

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

        Connection connection = ConnectionUtils.getConnection();

        Channel channel = connection.createChannel();

        //声明交换机

        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT.getType());

        String msg = "hello rounting";

        channel.basicPublish(EXCHANGE_NAME,ROUNTINGKEY,null,msg.getBytes());//ROUNTINGKEY声明了路由键 相同的路由键能收到消息

        System.out.println("send msg ----->"+msg);

        channel.close();

        connection.close();

    }

}

 

消费者：

public class Recv1 {

    private static final String QUEUE_NAME = "test_queue_rounting_email";

    private static final String EXCHANGE_NAME = "test_exchange_rounting";

    private static final String ROUNTINGKEY = "key";

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

        Connection connection = ConnectionUtils.getConnection();

        final Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,ROUNTINGKEY); //与生产者声明的路由键相同

        channel.basicQos(1);

        //定义消费者

        DefaultConsumer consumer = new DefaultConsumer(channel) {

            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                String s = new String(body, "UTF-8");

                System.out.println("Recv1 <------收到消息："+s);

                try {

                    Thread.sleep(1000*2);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }finally {

                    System.out.println("[1] done");

                    channel.basicAck(envelope.getDeliveryTag(),false);

                }

            }

        };

        //监听队列

        boolean autoAck = false; //自动应答

        channel.basicConsume(QUEUE_NAME,autoAck,consumer);

    }

}

 

  1. Topic Exchange : 交换器在匹配规则上进行了扩展，它有一定的约束条件：
    1. ​​​​​​​RoutingKey 为一个点号" . “分隔的字符串(被点号”.“分隔开的每段独立的字符串称为一个单词) 如：com.toher.user 和 org.toher.product
    2. BindingKey和RoutingKey同样也是点号”."分隔的字符串;
    3. BindingKey 中可以存在两种特殊字符串 * 和 #，用于做模糊匹配，其中 * 代表一个单词，# 可以用于匹配多规格单词(可以是零个)

1e7d5b922c9fa67305f0329be5c5364c670.jpg

  1. 模式

 

https://www.rabbitmq.com/img/tutorials/python-five.png

 

 

转载于:https://my.oschina.net/u/3042999/blog/3072548

chouying7813
关注
RabbitMQ消费者回调函数handleDelivery无法执行
qq_38668544的博客
09-19 2760
RabbitMQ消费者回调函数handleDelivery无法执行，控制台无输出 背景 在一次学习rabbitmq时，创建了生产者、消费者，在消费者消费消息后在回调函数中打印相关信息，无法执行 代码如下 Consumer consumer = new DefaultConsumer(channel){ @Override public void handleDelivery(String consumerTag, Envelope envelope, AM
HTTP请求时connectionRequestTimeout 、connectionTimeout、socketTimeout三个超时时间的含义
rmkloveme
11-27 8598
connectionRequestTimout：指从连接池获取连接的timeout connetionTimeout：指客户端和服务器建立连接的timeout，就是http请求的三个阶段，一：建立连接；二：数据传送；三，断开连接。超时后会ConnectionTimeOutException socketTimeout：指客户端从服务器读取数据的timeout，超出后会抛出SocketTimeOutException 实战示例： @Configuration @EnableConfiguration
第三章_Java 实现RabbitMQ
sinat_31583645的博客
05-13 3198
默认情况下，RabbitMQ将按顺序将每个消息发送给下一个使用者。平均而言，每个消费者都会收到相同数量的消息。这种分发消息的方式称为循环。
源码分析-netty-channel-channelFuture
一阴一阳之谓道
05-06 1134
ChannelFuture  The result of an asynchronous {@link Channel} I/O operation. 是异步Channel IO的操作结果。 一、异步Channel IO 的2中结果： 1、完成 isDone() = true ,  有3种状态，    （1）成功  isSuccess() = true   （2）失败  , 有失败的
Netty学习笔记(二) Channel和ChannelFuture
猿长大人
11-21 1万+
Channel接口 Channel介绍 Channel的基本方法 关于Channel的释放 ChannelFuture接口 ChannelFuture介绍 ChannelFuture的状态 GenericFutureListener监听接口
rabbitmq使用教程
最新发布
08-29
您可以按照以下步骤学习 RabbitMQ 的使用教程： 1. 首先，您需要安装 RabbitMQ。可以按照引用中的课程提供的教程来进行环境搭建。如果您使用的是命令行方式管理 RabbitMQ，可以按照引用中的命令启用 RabbitMQ 的...
硬核，RabbitMQ入门使用教程，详细到哭
Javanewspaper的博客
12-31 9723
RabbitMQ 简介 RabbitMQ是使用Erlang语言开发的开源消息队列系统，基于AMQP协议来实现。AMQP的主要特征是面向消息、队列、路由(包括点对点和发布/订阅)、可靠性、 安全。AMQP协议更多用在企业系统内，对数据一致性、稳定性和可靠性要求很高的场景，对性能和吞吐量的要求还在其次。 MQ全称为Message Queue, 消息队列(MQ)是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息(针对应用程序的数据)来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在
RabbitMQ系列教程1
08-03
通过本系列教程，我们将探讨如何安装和配置RabbitMQ，以及如何使用AMQP协议创建和管理消息。此外，我们还将学习如何使用RabbitMQ提供的管理界面监控和管理消息队列。在后续教程中，我们将进一步探讨RabbitMQ的高级...
RabbitMQ 入门教程（JAVA）
08-01
通过本教程的学习，我们了解了 RabbitMQ 的基本概念及其在 Java 应用程序中的简单使用方法。RabbitMQ 作为一个高效的消息传递系统，不仅可以帮助开发者构建分布式应用程序，还能提供灵活的消息路由机制。接下来，你...
通俗编程——白话NIO之Channel
Floating Cat
12-16 7350
Channel简介在标准的IO当中，都是基于字节流/字符流进行操作的，而在NIO中则是是基于Channel和Buffer进行操作，其中的Channel的虽然模拟了流的概念，实则大不相同。
消息中间件 -RabbitMQ 消息的拒绝死信交换器DLX （二十八）
日薪灬越亿的博客
12-08 219
RabbitMQ对AMQP规范的一个扩展。被投递消息被拒绝后的一个可选行为，往往用在对问题消息的诊断上。 消息变成死信一般是以下几种情况： 消息被拒绝，并且设置 requeue 参数为 false 消息过期 队列达到最大长度 死信交换器仍然只是一个普通的交换器，创建时并没有特别要求和操作。在创建队列的时候，声明该交换器将用作保存被拒绝的消息即可，相关的参数是x-dead-letter...
RabbitMQ常用的几种消息模型
编程小白养成手记
07-21 899
RabbitMQ常用的几种消息模型你知道哪些？Fanout，Topics，Direct，Routing，Work？对不对呢
RabbitMQ
weixin_56777219的博客
06-07 286
RubbitMQ
RabbitMQ 学习笔记（一）
qq_40597962的博客
02-21 378
RabbitMQ 学习笔记（一） MQ全称 Message Queue（消息队列），是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信。 优势： 应用解耦，提升容错性和可维护性 异步提速 削峰填谷 使用了 MQ 之后，限制消费消息的速度为1000，这样一来，高峰期产生的数据势必会被积压在 MQ 中，高峰就被“削”掉了，但是因为消息积压，在高峰期过后的一段时间内，消费消息的速度还是会维持在1000，直到消费完积压的消息，这就叫做“填谷”。 劣势： 系统可用性降低 系统复杂性
RabbitMQ入门教程(十二)：消息确认Ack
热门推荐
人不风流枉少年
12-03 8万+
一：消费者确认消费者确认或者说消费者应答指的是RabbitMQ需要确认消息到底有没有被收到 - 自动应答boolean autoAck = true; channel.basicConsume(QUEUE_NAME, autoAck, consumer);在订阅消息的时候可以指定应答模式,当自动应答等于true的时候，表示当消费者一收到消息就表示消费者收到了消息，消费者收到了消息就会立即从队列中删
RabbitMQ Consumer获取消息的两种方式(poll,subscribe)解析
云计算、分布式架构、K8S、大数据、机器学习、搜索、推荐、广告
09-01 5万+
Producer和Queue Consumer和Queue 长连接
消息队列（RabbitMQ）
xue_yun_xiang的博客
06-23 2521
一、概述 消息队列作用：解耦、异步、削峰 解耦 解耦，就是将连个应用不是互相之间强依赖关系，一个挂了，两外一个依然可以使用 削峰 削锋，就是可以将高并发的网络请求 缓存到消息队中，慢慢的执行消息对对应的业务 618 秒杀购买商品 生成订单 扣减库存 扣减余额 发货，生成物流 如果以上 步骤都在一个应用的请求中去执行，在每秒 50000个并发的情况下，是否回对应服务造成很大的压力 优化流程 1.先扣减库存 2将对应商品生成订单的消息，发送到消息队列 3.让应用慢的消费消息 完成一下业务
RabbitMQ——入门常用方法参数
qq_43273477的博客
11-28 1694
消息发布端发送消息的方法 channel.basicPublish(exchangeName,routingKey,true,null, msg.getBytes()); void basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body) throws IOException; vo...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值