rabbitMQ-基于SpringBoot推送消息

整一个空项目：

配置类
RabbitMqConfig.java

package com.dragon.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMqConfig {



      // 创建队列
      @Bean
      public Queue orderQueue() {
            /*
             * durable:是否持久化,默认是false
             * exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
             * autoDelete:是否自动删除
             * arguments 附加参数
             */
            return new Queue("order-queue", true, false, false, null);
      }


      @Bean
      public Queue dianzibiaoshiQueue() {
            /*
             * durable:是否持久化,默认是false
             * exclusive:是否独占，默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
             * autoDelete:是否自动删除
             * arguments 附加参数
             */
            return new Queue("dianzibiaoshi", true, false, false, null);
      }

      // 创建交换机
      @Bean
      public DirectExchange directExchange() {
            // 交换机名称，是否持久化，是否自动删除，附加参数
            return new DirectExchange("direct-exchange", true, false, null);
      }

      // 绑定交换机和队列
      @Bean
      public Binding bindingDirect1() {
            return BindingBuilder.bind(orderQueue()).to(directExchange()).with("order");
      }


      @Bean
      public Binding bindingDirect2() {
            return BindingBuilder.bind(dianzibiaoshiQueue()).to(directExchange()).with("dianzibiaoshi");
      }


}

Service层

MyTestConsumerService.java

package com.dragon.service;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;

import java.nio.charset.StandardCharsets;

public class MyTestConsumerService {


    @RabbitListener(queues = "order-queue")
    public void orderConsumer(Message message) {
        System.out.println("orderConsumer收到消息: " + new String(message.getBody(), StandardCharsets.UTF_8));
    }
    @RabbitListener(queues = "dianzibiaoshi")
    public void dianzibiaoshiConsumer(Message message) {
        System.out.println("dianzibiaoshiConsumer收到消息: " + new String(message.getBody(), StandardCharsets.UTF_8));
    }
}

测试：
Test2Controller.java

package com.dragon.controller;


import cn.hutool.core.io.FileUtil;
import cn.hutool.core.text.csv.*;
import cn.hutool.core.util.CharsetUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.Data;
import lombok.Getter;
import lombok.Setter;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import java.io.*;
import java.lang.reflect.Field;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Random;


@Api(value = "测试2")
@RestController
@RequestMapping("/test2")
@Component
public class Test2Controller {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 获取并组装导出数据
     */
    @ApiOperation(value = "测试连通性", httpMethod = "GET")
    @ResponseBody
    @RequestMapping(value = "/test2", method = RequestMethod.GET)
    @Scheduled(cron ="*/1 * * * * ? ")
    public void getUserList() {


        List<String> demoList =  new ArrayList<>();
        demoList.add("消息体1");
        demoList.add("消息体2");
        demoList.add("消息体3");
        demoList.add("消息体4");           
        demoList.add("消息体5");
        demoList.add("消息体6");
        demoList.add("消息体7");
        demoList.add("消息体8");       
        
        Random random = new Random();
        int n = random.nextInt(demoList.size());
        String pushData = demoList.get(n);


        rabbitTemplate.convertAndSend("direct-exchange","dianzibiaoshi",pushData);


        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("消息推送成功-> time:"+ df.format(System.currentTimeMillis()));
    }

}

这里我们用了定时器
别忘了程序入口@EnableScheduling

@EnableScheduling
public class RabbitMQApplication {

    public static void main(String[] args) {
        SpringApplication.run(RabbitMQApplication.class, args);
    }

}

然后得到了每隔一秒的推送消息

消息推送成功-> time:2022-05-31 13:58:37
消息推送成功-> time:2022-05-31 13:58:38
消息推送成功-> time:2022-05-31 13:58:39
消息推送成功-> time:2022-05-31 13:58:40