rabbitmq简单示例

L_ukly

已于 2023-05-04 21:08:26 修改

阅读量189

点赞数

文章标签： rabbitmq

于 2023-05-04 18:13:00 首次发布

本文链接：https://blog.csdn.net/L_ukly/article/details/130491901

版权

1.pom文件引入rabbitmq

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

2.配置连接参数

Exchange的四种类型：fanout、direct、topic、headers

1.fanout 类型：类似于广播，群发。接收到的消息，会分发给所有绑定的队列。如下图所示，每个队列都会得到全部得消息。

2.direct 类型：消息生产者投递消息到 Exchange 时，给出两个信息：一个是消息本体，一个是消息的路由键（RoutingKey）。类似与我们电子邮件时，邮件的内容（消息本体）和接收人的邮件地址（路由键）。队列和和 Exchange 绑定时，需要指定一个绑定键（BindingKey）关联。当Exchange投递消息时，会把消息投递到绑定键和路由键相等的队列里。

3.topic 类型：消息生产者投递消息到 Exchange 时，给出两个信息：一个是消息本体，一个是消息的路由键（RoutingKey）。路由键可以使用 “.” 字符做为分割符，如：cn.beijing.tongzhou。此时路由键可以理解为按 “.”分割的单词cn、beijing、tongzhou，同时这个绑定键还可以使用 “” 做单个单词的模糊匹配；用“#”做多个单词的模糊匹配。

例如cn.beijing. 绑定键的队列接收路由键cn.beijing.tongzhou、cn.beijing.chaoyang 等等以cn.beijing. 开头，后面跟任何字符串做路由键（不含“.”）的消息。
cn.# 绑定键的队列接收路由键 cn.beijing.tongzhou、cn.beijing cn.beijing.changyang.wangjing 等等以 cn. 开头，后面跟任何字符串做路由键（包含“.”）的消息。

4.headers类型：消息生产者发送消息时，指定headers（键对值形式），队列和 Exchange 绑定时指定headers的匹配形式;

匹配规则x-match有下列两种类型：

x-match = all ：表示所有的键值对都匹配才能接受到消息
x-match = any ：表示只要有键值对匹配就能接受到消息

代码实现direct类型：

首先添加一个配置类文件:配置类里的代码如下:绑定交换机和队列和路由key

package com.springboot.rabbitmq.demo.config;
 
import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class RabbitmqDirectConfig {
 
    public static final String QUEUE_NAME = "QUEUE_DEMO_DIRECT";
 
    public static final String EXCHANGE_NAME = "direct_exchange";
 
    public static final String ROUTING_KEY = "ROUTING_KEY_01";
 
    @Bean("bootDirectExchange")
    public Exchange bootDirectExchange(){
        return ExchangeBuilder.directExchange(EXCHANGE_NAME).durable(true).build();
    }
 
    @Bean("bootDirectQueue")
    public Queue bootDirectQueue(){
        return QueueBuilder.durable(QUEUE_NAME).build();
    }
 
    @Bean
    public Binding bindDirectQueueExchange(@Qualifier("bootDirectQueue") Queue queue, @Qualifier("bootDirectExchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with(ROUTING_KEY).noargs();
    }
 
}

创建一个消费类，监听队列：


package com.rabbitmq.demo.consumer;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
 
 
@Component
public class RabbitmqListener {
 
  private Logger logger= LoggerFactory.getLogger(RabbitmqListener.class);
 
 
    @RabbitListener(queues = "QUEUE_DEMO_DIRECT")
    public void ListenerQueue01(Message message){
        System.out.println("mess===="+message);
        logger.info("[onMessage][线程编号:{} 消息内容：{}]", Thread.currentThread().getId(), 
    message);
    }
}

启动启动类后监听生效，使用测试类实现代码发送测试。测试类，发送消息到交换机，交换机绑定的队列就能收到消息进行消费消息:

package com.rabbitmq.demo;
 
import com.rabbitmq.demo.config.RabbitmqDirectConfig;
import com.rabbitmq.demo.config.RabbitmqFanoutConfig;
import com.rabbitmq.demo.config.RabbitmqTopicConfig;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
 
@RunWith(SpringRunner.class)
@SpringBootTest
public class DemoApplicationTests {
 
    @Autowired
    private RabbitTemplate rabbitTemplate;
 
    @Test
    public void DirectExchange() {
        rabbitTemplate.convertAndSend(RabbitmqDirectConfig.EXCHANGE_NAME,RabbitmqDirectConfig.ROUTING_KEY,"boot mq hello Direct");
    }
}

运行结果如下

代码实现Topic类型：

配置类

package com.springboot.rabbitmq.demo.config;
 
import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class RabbitmqTopicConfig {
    private static final String QUEUE_NAME="QUEUE_DEMO_TOPIC";
    public static final String EXCHANGE_NAME="topic_exchange";
 
 
    @Bean("bootTopicExchange")
    public Exchange bootTopicExchange(){
        return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
    }
 
    @Bean("bootTopicQueue")
    public Queue bootTopicQueue(){
        return QueueBuilder.durable(QUEUE_NAME).build();
    }
 
    @Bean
    public Binding bindTopicQueueExchange(@Qualifier("bootTopicQueue") Queue queue, @Qualifier("bootTopicExchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("boot.#").noargs();
    } 
}

消费者，监听器

@RabbitListener(queues = "QUEUE_DEMO_TOPIC")
    public void ListenerQueue2(Message message){
        System.out.println("mess===="+message);
        logger.info("[onMessage][线程编号:{} 消息内容：{}]", Thread.currentThread().getId(), 
     message);
    }

生产者，发送消息

 @Test
   public void TopicExchange() {
        rabbitTemplate.convertAndSend(RabbitmqTopicConfig.EXCHANGE_NAME,"boot.haha","boot 
      mq hello Topic");
    }

代码实现fanout类型：

配置类

package com.springboot.rabbitmq.demo.config;
 
import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class RabbitmqTopicConfig {
    private static final String QUEUE_NAME="QUEUE_DEMO_TOPIC";
    public static final String EXCHANGE_NAME="topic_exchange";
 
 
    @Bean("bootTopicExchange")
    public Exchange bootTopicExchange(){
        return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
    }
 
    @Bean("bootTopicQueue")
    public Queue bootTopicQueue(){
        return QueueBuilder.durable(QUEUE_NAME).build();
    }
 
    @Bean
    public Binding bindTopicQueueExchange(@Qualifier("bootTopicQueue") Queue queue, @Qualifier("bootTopicExchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("boot.#").noargs();
    }
}

消费者，监听器

 @RabbitListener(queues = "QUEUE_DEMO_FANOUT_A")
    public void ListenerQueueA(Message message){
        System.out.println("QUEUE_DEMO_FANOUT_A======="+message);
        logger.info("[onMessage][线程编号:{} 消息内容：{}]", Thread.currentThread().getId(), message);
    }
    @RabbitListener(queues = "QUEUE_DEMO_FANOUT_B")
    public void ListenerQueueB(Message message){
        System.out.println("QUEUE_DEMO_FANOUT_B======="+message);
        logger.info("[onMessage][线程编号:{} 消息内容：{}]", Thread.currentThread().getId(), message);
    }

生产者，发送消息

 @Test
    public void FanoutExchange(){
        for(int i=0;i<4;i++){
            rabbitTemplate.convertAndSend(RabbitmqFanoutConfig.EXCHANGE_NAME,"",i+"===boot mq 
          hello Fanout");
        }
 
    }

rabbitMq测试demo样例完成