RabbitMQ教程

最新推荐文章于 2024-06-24 20:50:35 发布

hyy_blue

最新推荐文章于 2024-06-24 20:50:35 发布

阅读量1.1k

点赞数 1

分类专栏：大数据文章标签：消息队列，rabbitMQ 队列

本文链接：https://blog.csdn.net/hyy_blue/article/details/109735651

版权

大数据专栏收录该内容

6 篇文章 1 订阅

订阅专栏

rabbitMQ基本结构：

broker: 消息队列服务进程，此进程包括两个部分 Exchange和queue
Exchange：消息对列交换机，按照一定的规则将消息路由转发到某个队列，将消息进行过滤。
Queue：消息队列，存储消息的队列，消息到达队列并转达给指定的消费方。
producer：消息生产者，也就是生产方客户端，生产方客户端将消息发送到MQ
Consumer:消息消费者，即消费者客户端，接受MQ转发的消息。

消息发布接受流程：

-----------发送消息

1、生产者与brocker简历TCP连接。

2、生产者和Broker建立通道。

3、生产者通过通道消息发送给Broker。

4、Exchange将消息转发给指定的queue。

-----------接受消息

1、消费者和broker建立tcp连接

2、消费者和broker建立通道

3、消费者监听指定的queue（队列）

4、当又消息到达queue时，broker默认将消息推送给消费者。

5、消费者接收到消息

操作流程

-----发送端

1）创建连接

2）创建通道

3）声明队列

4）发送消息

-----接受端

1）创建连接

2）创建通道

3）声明队列

4）监听队列

5）接受消息

6）ack回复

常用的消息模型

1）基本消息模型

这是最简单的消息模型

就是生产者将消息发送到队列，消费者从队列中获取消息，队列时存储消息的缓存区。

再演示代码之前，我们先创建一个工程rabbitmq-demo，并编写一个工具类，用于提供与mq服务创建连接

生产者：

package java;

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

/**
 * @ClassName : Send
 * @Description : 生产者发送者
 * @Author : Aaron Huo
 * @Date: 2020-10-29 10:12
 */
public class Send {
    private  static final String QUEUE_NAME = "basic_queue";
    public static void main(String[] args) throws Exception {
        //消息发送端与mq服务创建连接
        Connection connection = ConnectionUtil.getConnection();
        //建立通道
        Channel channel = connection.createChannel();
        //声明队列（）
        /**\
         *
         *channel.queueDeclare(QUEUE_NAME, false, false, false, null);
         *durable：true、false true：在服务器重启时，能够存活,是否持久化
         * exclusive ：是否为当前连接的专用队列，在连接断开后，会自动删除该队列，生产环境中应该很少用到吧。
         * autodelete：当没有任何消费者使用时，自动删除该队列
         *
         * */
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        String message = "hello world";
        channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
        System.out.println("生产者已发送：" + message);
        channel.close();
        connection.close();
    }
}

消费者：

package java;

import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @ClassName : Consumer
 * @Description : 消费者
 * @Author : Aaron Huo
 * @Date: 2020-10-29 10:37
 */
public class Consumer {
    private static final String QUEUE_NAME = "basic_queue";
    public static void main(String[] args) throws Exception {
        //消息消费者与mq服务建立连接
        Connection connection = ConnectionUtil.getConnection();
        //建立通道
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                System.out.println("消费者1接收到消息：" + msg);
            }
        };
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}

消息的接收与消费使用都需要在一个匿名内部类DefaultConsumer中完成

注意：队列需要提前声明，如果未声明就使用队列，则会报错。如果不清楚生产者和消费者谁先声明，为了保证不报错，生产者和消费者都声明队列，队列的创建会保证幂等性，也就是说生产者和消费者都声明同一个队列，则只会创建一个队列

2） Work Queues工作队列模型

在基本的消息模型中，一个生产者对应一个消费者，在很多的生产环境中，往往消息生产者会发送很多的消息，入伙消费者只有一个的话，就会导致消息的堆积，效率很低，因此rabbitmq有另外一种消息模型，这种模型下，一个生产发送消息到队列，允许有多个消费者接收消息，但是一条消息只会被一个消费者获取。

生产者：

和基本消息模型基本一致，这里只是循环执行20条消息

public class Send {
    private static final String QUEUE_NAME = "work_queue";
    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 循环发布任务
        for (int i = 1; i <= 20; i++) {
            // 消息内容
            String message = "task .. " + i;
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            System.out.println("生产者发送消息：" + message);
            Thread.sleep(500);
        }
        channel.close();
        connection.close();
    }
}

消费者1：

public class Consumer1 {
    private static final String QUEUE_NAME = "work_queue";
    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body);
                System.out.println("消费者1接收到消息：" + msg);
                try {
                    Thread.sleep(50);//模拟消费耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}

消费者2

public class Consumer2 {
    private static final String QUEUE_NAME = "work_queue";
    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,byte[] body) throws IOException {
                String msg = new String(body);
                System.out.println("消费者2接收到消息：" + msg);
                try {
                    Thread.sleep(50);//模拟消费耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}

此时有两个消费者监听同一个队列，当两个消费者都工作时，生成者发送消息，就会按照负载均衡算法分配给不同消费者，如下图

2）订阅模型

在之前的模型中，一条消息只能被一个消费者获取，而在订阅模式中，可以实现一条消息被多个消费者获取。在这种模型下，消息传递过程中比之前多了一个exchange交换机，生产者不是直接发送消息到队列，而是先发送给交换机，经由交换机分配到不同的队列，而每个消费者都有自己的队列：

1、1个生产者，多个消费者

2、每一个消费者都有自己的一个队列

3、生产者没有将消息直接发送到队列，而是发送到了交换机

4、每个队列都要绑定到交换机

5、生产者发送的消息，经过交换机到达队列，实现一个消息被多个消费者获取的目的

其中交换机X(Exchange)的类型一种有三种：

Fanout：广播，交换机将消息发送到所有与之绑定的队列中去

Direct：定向，交换机按照指定的Routing Key发送到匹配的队列中去

Topics：通配符，与Direct大致相同，不同在于Routing Key可以根据通配符进行匹配

注意：在发布订阅模型中，生产者只负责发消息到交换机，至于消息该怎么发，以及发送到哪个队列，生产者都不负责。一般由消费者创建队列，并且绑定到交换机

订阅模型之Fanout

在广播模式下，消息发送的流程如下：

可以有多个消费者，每个消费者都有自己的队列
每个队列都要与exchange绑定
生产者发送消息到exchange
exchange将消息把消息发送到所有绑定的队列中去
消费者从各自的队列中获取消息

生产者消费消息：

public class Send {
    private static final String EXCHANGE_NAME = "fanout_exchange";
    
    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        // 声明exchange，指定类型为fanout
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
        String message = "hello world";
        channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes());
        System.out.println("生产者发送消息：" + message);
        channel.close();
        connection.close();
    }
}

消费者消费

public class Consumer1 {
    private static final String QUEUE_NAME = "fanout_queue_1";
    private static final String EXCHANGE_NAME = "fanout_exchange";

    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        //消费者声明自己的队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 声明exchange，指定类型为direct
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
        //消费者将队列与交换机进行绑定
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
        channel.basicConsume(QUEUE_NAME, true, new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body)
                    throws IOException
            {
                String msg = new String(body);
                System.out.println("消费者1获取到消息：" + msg);
            }
        });
    }
}

其他消费者只需修改QUEUE_NAME即可

注意：exchange与队列一样都需要提前声明，如果未声明就使用交换机，则会报错。如果不清楚生产者和消费者谁先声明，为了保证不报错，生产者和消费者都声明交换机，同样的，交换机的创建也会保证幂等性。

订阅模型之Direct

**在fanout模型中，生产者发布消息，所有消费者都可以获取所有消息。**在路由模式（Direct）中，可以实现不同的消息被不同的队列消费，在Direct模式下，交换机不再将消息发送给所有绑定的队列，而是根据Routing Key将消息发送到指定的队列，队列在与交换机绑定时会设定一个Routing Key，而生产者发送的消息时也需要携带一个Routing Key。

如图所示，消费者C1的队列与交换机绑定时设置的Routing Key是“error”，而C2的队列与交换机绑定时设置的Routing Key包括三个：“info”，“error”，“warning”，假如生产者发送一条消息到交换机，并设置消息的Routing Key为“info”，那么交换机只会将消息发送给C2的队列。

生产者：

public class Send {
    private static final String EXCHANGE_NAME = "direct_exchange";

    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        // 声明exchange，指定类型为direct
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        String message = "新增一个订单";
        //生产者发送消息时，设置消息的Routing Key:"insert"
        channel.basicPublish(EXCHANGE_NAME, "insert", null, message.getBytes());
        System.out.println("生产者发送消息：" + message);
        channel.close();
        connection.close();
    }
}

消费者1：

public class Consumer1 {
    private static final String QUEUE_NAME = "direct_queue_1";
    private static final String EXCHANGE_NAME = "direct_exchange";

    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        //消费者声明自己的队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        //消费者将队列与交换机进行绑定，并且设置Routing Key:"insert"
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "insert");
        channel.basicConsume(QUEUE_NAME, true, new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body)
                    throws IOException
            {
                String msg = new String(body);
                System.out.println("消费者1获取到消息：" + msg);
            }
        });
    }
}

消费者2

其他消费者需要修改队列名QUEUE_NAME和Routing Key，上述生成者发送的消息，消费者1是可以获取到的，根据不同的routing key 发送到不同的queue，从而被不同的消费者消费。

发布订阅之Topics

Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符

Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert

通配符规则：

     #：匹配一个或多个词

     *：匹配不多不少恰好1个词

举例：

     audit.#：能够匹配audit.irs.corporate 或者 audit.irs

     audit.*：只能匹配audit.irs

Topics生产者代码与Direct大致相同，只不过子声明交换机时，将类型设为BuiltinExchangeType.TOPIC(topic)，

消费者代码也与Direct大致相同，也是在声明交换机时设置类型为topic，代码不再演示

RabbitMQ如何防止消息丢失

1. 消息确认机制（ACK）

RabbitMQ有一个ACK机制，消费者在接收到消息后会向mq服务发送回执ACK，告知消息已被接收。这种ACK分为两种情况：

自动ACK：消息一旦被接收，消费者会自动发送ACK
手动ACK：消息接收后，不会自动发送ACK，而是需要手动发送ACK

如果消费者没有发送ACK，则消息会一直保留在队列中，等待下次接收。但这里存在一个问题，就是一旦消费者发送了ACK，如果消费者后面宕机，则消息会丢失。因此自动ACK不能保证消费者在接收到消息之后能够正常完成业务功能，因此需要在消息被充分利用之后，手动ACK确认

自动ACK，basicConsume方法中将autoAck参数设为true即可：

手动ack，在匿名内部类中，手动发送ACK：

当然，如果设置了手动ack，但又不手动发送ACK确认，消息会一直停留在队列中，可能造成消息的重复获取

2.持久化

消息确认机制（ACK）能够保证消费者不丢失消息，但假如消费者在获取消息之前mq服务宕机，则消息也会丢失，因此要保证消息在服务端不丢失，则需要将消息进行持久化。队列、交换机、消息都要持久化。

队列持久化

exchange持久化

消息持久化

3. 生产者确认

生成者在发送消息过程中也可能出现错误或者网络延迟灯故障，导致消息未成功发送到交换机或者队列，或重复发送消息，为了解决这个问题，rabbitmq中有多个解决办法：

事务：

用事务将消息发送代码包围起来：

Confirm模式：

如下所示，在发送代码前执行channel.confirmSelect()，如果消息未正常发送，就会进入if代码块，可以进行重发也可以对失败消息进行记录

异步confirm方法：

顾名思义，就是生产者发送消息后不用等待服务端回馈发送状态，可以继续执行后面的代码，对于失败消息重发进行异步处理：

SpringBoot整合RibbitMQ

使用spring-boot-starter-amqp会自动添加spring-rabbit依赖，如下:

<dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring‐boot‐starter‐amqp</artifactId>
   </dependency>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring‐boot‐starter‐test</artifactId>
   </dependency>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring‐boot‐starter‐logging</artifactId>
   </dependency>

配置application.yml

server:
     port: 44000
   spring:
     application:
       name: test‐rabbitmq‐producer
     rabbitmq:
       host: 127.0.0.1
       port: 5672
       username: guest
       passowrd: guest
       virtualHost: /

定义RabbitConfig类，配置Exchange、Queue、及绑定交换机。本例配置Topic交换机。

@Configuration
public class RabbitmqConfig {
    public static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    public static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    public static final String EXCHANGE_TOPICS_INFORM="exchange_topics_inform";

    @Bean(EXCHANGE_TOPICS_INFORM)
    public Exchange EXCHANGE_TOPICS_INFORM() {
      //durable(true)持久化，消息队列重启后交换机仍然存在
      return ExchangeBuilder.topicExchange(EXCHANGE_TOPICS_INFORM).durable(true).build();
    }

      //声明队列
      @Bean(QUEUE_INFORM_SMS)
      public Queue QUEUE_INFORM_SMS() {
        Queue queue = new Queue(QUEUE_INFORM_SMS);
        return queue;
      }

    //声明队列
    @Bean(QUEUE_INFORM_EMAIL)
    public Queue QUEUE_INFORM_EMAIL() {
        Queue queue = new Queue(QUEUE_INFORM_EMAIL);
        return queue;
    }

    //channel.queueBind(INFORM_QUEUE_SMS,"inform_exchange_topic","inform.#.sms.#"); * 绑定队列到交换机 
    @Bean
    public Binding BINDING_QUEUE_INFORM_SMS(@Qualifier(QUEUE_INFORM_SMS) Queue queue,
    @Qualifier(EXCHANGE_TOPICS_INFORM) Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("inform.#.sms.#").noargs();
    }

    @Bean
    public Binding BINDING_QUEUE_INFORM_EMAIL(@Qualifier(QUEUE_INFORM_EMAIL) Queue queue,
    @Qualifier(EXCHANGE_TOPICS_INFORM) Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("inform.#.email.#").noargs();
    }
}

这里声明了两个queue，分别为queue_inform_email，queue_inform_sms，然后分别绑定交换机。

生产端,使用RarbbitTemplate发送消息

   @SpringBootTest
   @RunWith(SpringRunner.class)
   public class Producer05_topics_springboot {
      @Autowired
       RabbitTemplate rabbitTemplate;
       @Test
       public void testSendByTopics(){
           for (int i=0;i<5;i++){
               String message = "sms email inform to user"+I;
               rabbitTemplate.convertAndSend(RabbitmqConfig.EXCHANGE_TOPICS_INFORM,"inform.sms.email",message);
               System.out.println("Send Message is:'" + message + "'");
            }
        }
    }

消费端,使用@RabbitListener注解监听队列。

   @Component
   public class ReceiveHandler {
    //监听email队列
    @RabbitListener(queues = {RabbitmqConfig.QUEUE_INFORM_EMAIL})
    public void receive_email(String msg,Message message,Channel channel){
           System.out.println(msg);
    }

    //监听sms队列
    @RabbitListener(queues = {RabbitmqConfig.QUEUE_INFORM_SMS})
    public void receive_sms(String msg,Message message,Channel channel){
           System.out.println(msg);
     }
}

测试

hyy_blue

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
RabbitMQ教程

RabbitMQ 学习笔记rabbitMQ基本结构：broker: 消息队列服务进程，此进程包括两个部分 Exchange和queueExchange：消息对列交换机，按照一定的规则将消息路由转发到某个队列，将消息进行过滤。Queue：消息队列，存储消息的队列，消息到达队列并转达给指定的消费方。producer：消息生产者，也就是生产方客户端，生产方客户端将消息发送到MQConsumer:消息消费者，即消费者客户端，接受MQ转发的消息。消息发布接受流程：-----------发送消息1
复制链接

扫一扫