RabbitMQ（4）：springboot整合rabbitmq

qq_2537071370

已于 2022-10-05 08:39:21 修改

阅读量549

点赞数

分类专栏： # RabbitMQ 文章标签： java-rabbitmq rabbitmq spring boot

于 2022-10-04 22:43:10 首次发布

本文链接：https://blog.csdn.net/qq_2537071370/article/details/127163076

版权

RabbitMQ 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

springboot-Spring AMQP

Spring有很多不同的项目，其中就有对AMQP的支持：
在这里插入图片描述

Spring AMQP的页面 https://spring.io/projects/spring-amqp
Spring-amqp是对AMQP协议的抽象实现，而spring-rabbit 是对协议的具体实现，也是目前的唯一实现。底层使用的就是RabbitMQ。

springboot整合rabbitmq

源码：

链接：https://pan.baidu.com/s/1PT_d64NuUSQhzNPpx_WDMw?pwd=4mur
提取码：4mur

创建springboot项目

添加AMQP的依赖

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

在application.yml中添加RabbitMQ配置：

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtualHost: /

基本消息模型

RabbitmqConfig 配置类

@Configuration
public class RabbitmqConfig {
    //创建基本队列
    @Bean
    public Queue basicQueue(){
        //name队列名称；durable 是否持久化 false不持久化； exclusive是否独有的  ；autoDelete 是否自动删除 ;argument  参数
        //return new Queue("common-queue"); 上面也就是默认的 默认 持久化，非独占，不是自动删除；
         return new Queue("hello",true,false,false,null);
    }

生产者：

@RestController
public class BasicProducer {
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @RequestMapping("/basicProducer")
    public void producer(){
        System.out.println("发送基本模型消息");
        rabbitTemplate.convertAndSend("hello","基本模型消息");
       /**
         * convertAndSend比较常用参数：
         * exchange  指定交换机、
         * RoutingKey 路由key、
         * object 消息体、
         */
    }
}

消费者

@Component
public class BasicConsumer {
    @RabbitListener(queues = "hello")
    public void listener(String msg){
        System.out.println("监听到的消息==="+msg);
    }
}

word消息模型

相较于基本消息模型，word消息模型可以有2个以上消费者共同消费队列中的消息

RabbitmqConfig 配置类

与基本消息模型一样

生产者

	与基本消息模型一样

消费者

写2个以上消费者
消费者共同消费队列中的消息
默认公平轮询；

怎么能者多劳？

在yml中添加以下配置。

listener:
      simple:
        # 公平分发
        prefetch: 1

在这里插入图片描述

订阅模型-Fanout （广播）

将消息交给所有绑定到交换机的队列

RabbitmqConfig 配置类

创建一个交换机多个队列

@Configuration
public class RabbitmqConfig {
 //创建fanout交换机
    @Bean
    public FanoutExchange fanoutExchange() {
        // System.out.println("交换机");
        return new FanoutExchange("fanout-exchange");
    }

    //创建fanout队列
    @Bean
    public Queue fanoutQueue1(){
        return new Queue("fanout-queue1",true,false,false,null);
    }
    //创建fanout队列
    @Bean
    public Queue fanoutQueue2(){
        return new Queue("fanout-queue2",true,false,false,null);
    }

    //把队列绑定到交换机
    @Bean
    public Binding fanoutQueueTofanoutExchange(){
        return  BindingBuilder.bind(fanoutQueue1()).to(fanoutExchange());
    }
    @Bean
    public Binding fanoutQueueTofanoutExchange2(){
        return  BindingBuilder.bind(fanoutQueue2()).to(fanoutExchange());
    }

生产者

@RestController
public class FanoutProducer {

    @Autowired
    RabbitTemplate rabbitTemplate;
    /**
     * fanout广播
     */
    @RequestMapping("/fanoutProducer")
    public void fanoutProducer(){
        for(int i=0;i<10;i++){
        rabbitTemplate.convertAndSend("fanout-exchange","","广播消息");
          }
        System.out.println("发送成功");
    }

}

消费者

@Component
public class FanoutConsumer {

    /**
     * fanout 消息模型
     */
    @RabbitListener(queues = "fanout-queue1")
    public void listenerFanout1(String msg) {
        System.out.println("fanout接受消息1" + msg);
    }

    /**
     * fanout 消息模型
     */
    @RabbitListener(queues = "fanout-queue2")
    public void listenerFanout2(String msg) {
        System.out.println("fanout接受消息2" + msg);
    }
}

订阅模型-Direct（定向）

把消息交给符合指定routing key 的队列

RabbitmqConfig 配置类

创建一个交换机多个队列

@Configuration
public class RabbitmqConfig {
 //创建direct交换机
    @Bean
    public DirectExchange directExchange() {
        // System.out.println("交换机");
        return new DirectExchange("direct-exchange");
    }

    //创建direct队列
    @Bean
    public Queue directQueue1(){
        return new Queue("direct-queue1",true,false,false,null);
    }
    @Bean
    public Queue directQueue2(){
        return new Queue("direct-queue2",true,false,false,null);
    }

    //把direct队列绑定到交换机
    @Bean
    public Binding directQueueTodirectExchange1(){
        return  BindingBuilder.bind(directQueue1()).to(directExchange()).with("error");
    }
    @Bean
    public Binding directQueueTodirectExchange2(){
        return  BindingBuilder.bind(directQueue2()).to(directExchange()).with("info");
    }

生产者

根据不同的routingkey 将消息发送不同的队列中

@RestController
public class DirectProducer {

    @Autowired
    RabbitTemplate rabbitTemplate;
    /**
     * direct定向
     * */
    @RequestMapping("/directProducer")
    public void directProducer(){
        rabbitTemplate.convertAndSend("direct-exchange","info","定向消息error");
        System.out.println("发送成功");
    }
}

消费者

@Component
public class DirectConsumer {
    /**
     * direct 消息模型
     */
    @RabbitListener(queues = "direct-queue1")
    public void listenerDirect1(String msg){
        System.out.println("direct接受消息1" + msg);
    }
    /**
     * direct 消息模型
     */
    @RabbitListener(queues = "direct-queue2")
    public void listenerDirect2(String msg){
        System.out.println("direct接受消息2" + msg);
    }
}

订阅模型-Topics（通配符）

把消息交给符合routing pattern（路由模式）的队列

RabbitmqConfig 配置类

创建一个交换机多个队列

@Configuration
public class RabbitmqConfig {
   //创建Topic交换机
    @Bean
    public TopicExchange topicExchange() {
        // System.out.println("交换机");
        return new TopicExchange("topic-exchange");
    }

    //创建topic队列
    @Bean
    public Queue topicQueueInfo(){

        return new Queue("topic-queue-info",true,false,false,null);
        //return new Queue("common-queue"); 上面也就是默认的
    }
    //创建topic队列
    @Bean
    public Queue topicQueueError(){

        return new Queue("topic-queue-error",true,false,false,null);
        //return new Queue("common-queue"); 上面也就是默认的
    }

    //把topic队列绑定到交换机
    @Bean
    public Binding InfoQueueToTopicExchange(){
        return  BindingBuilder.bind(topicQueueInfo()).to(topicExchange()).with("info.*");
    }
    @Bean
    public Binding ErrorQueueToTopicExchange(){
        return  BindingBuilder.bind(topicQueueError()).to(topicExchange()).with("common.*");
    }

生产者

根据不同的routingkey 将消息发送不同的队列中

@RestController
public class TopicProducer {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @RequestMapping("/send")
    public void send(String msg){
        System.out.println(msg);
        rabbitTemplate.convertAndSend("topic-exchange","info.one",msg);
    }

消费者

@Component
public class TopicConsumer {
    @RabbitListener(queues="topic-queue-info")
    public void listenerInfo(String msg, Message message, Channel channel) throws IOException {
        System.out.println("进入消费者info"+msg);
    }

    @RabbitListener(queues="topic-queue-error")
    public void listenerError(String msg, Message message, Channel channel) throws IOException {
        System.out.println("进入消费者Error"+msg);
    }
}