SpringBoot 整合RabbitMQ

最新推荐文章于 2024-04-24 21:55:52 发布

smartera

最新推荐文章于 2024-04-24 21:55:52 发布

阅读量142

点赞数

分类专栏： # 消息中间件文章标签： rabbitmq activemq

本文链接：https://blog.csdn.net/wmlwml0000/article/details/104840210

版权

消息中间件专栏收录该内容

2 篇文章 0 订阅

订阅专栏

SpringBoot 整合RabbitMQ

1、导包

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <!--这个是rabbitMQ的这个使用的包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

2、编写properties文件

#给应用取名字
spring.application.name=springboot-rabbitmq
#ip地址
spring.rabbitmq.host=127.0.0.1
#端口
spring.rabbitmq.port=5672
#用户名
spring.rabbitmq.username=12
#密码
spring.rabbitmq.password=12345678
#开启消息确认机制
spring.rabbitmq.publisher-confirms=true
#开始return机制
spring.rabbitmq.publisher-returns=true
#整个虚拟机
spring.rabbitmq.virtual-host=/

#消息采用手动确认
spring.rabbitmq.listener.direct.acknowledge-mode=manual


#消费者最小数量
spring.rabbitmq.listener.simple.concurrency=1
#消费之最大数量
spring.rabbitmq.listener.simple.max-concurrency=10


#在单个请求中处理的消息个数，(unack的最大数量)
spring.rabbitmq.listener.simple.prefetch=2


#消费者自动启动
#spring.rabbitmq.listener.simple.auto-startup=true
#消费者消费失败，自动重新入队
#spring.rabbitmq.listener.simple.default-requeue-rejected=true
#启用发送重试 队列满了发不进去时启动重试
#spring.rabbitmq.template.retry.enabled=true
#1秒钟后重试一次
#spring.rabbitmq.template.retry.initial-interval=1000ms
#最大重试次数 3次
#spring.rabbitmq.template.retry.max-attempts=3
#最大间隔 10秒钟
#spring.rabbitmq.template.retry.max-interval=10000ms
#等待间隔 的倍数。如果为2  第一次 乘以2 等1秒， 第二次 乘以2 等2秒 ，第三次 乘以2 等4秒
#spring.rabbitmq.template.retry.multiplier=1.0

3、编写配置文件

@SpringBootConfiguration
public class RabbitMQConfig {

    //work模式
    @Bean
    public Queue queueWork(){
        return new Queue("queueWork1");
    }


    /*玩下发布订阅模式*/
    //首先得申明两个队列

    @Bean
    public Queue queueFanout1(){
        return new Queue("queueFanout1");
    }
    @Bean
    public Queue queueFanout2(){
        return new Queue("queueFanout2");
    }

    //准备一个交换机
    @Bean
    public FanoutExchange fanoutExchange1(){
        return new FanoutExchange("fanoutExchange1");
    }

    //将队列绑定到交换机
    @Bean
    public Binding bindingExchange1(Queue queueFanout1,FanoutExchange fanoutExchange1){
       return BindingBuilder.bind(queueFanout1).to(fanoutExchange1);
    }

    @Bean
    public Binding bindingExchange2(Queue queueFanout2,FanoutExchange fanoutExchange1){
       return BindingBuilder.bind(queueFanout2).to(fanoutExchange1);
    }


    //玩下路由模型
    //首先要准备两个队列
    @Bean
    public Queue queueRouting1(){
        return new Queue("queueRouting1");
    }
    @Bean
    public Queue queueRouting2(){
        return new Queue("queueRouting2");
    }

    //准备一个交换机
    @Bean
    public DirectExchange directExchange1(){
       return new DirectExchange("directExchange1");
    }
    //接下来进行绑定
    @Bean
    public Binding bindingDirectExchange1(Queue queueRouting1,DirectExchange directExchange1){
        return BindingBuilder.bind(queueRouting1).to(directExchange1).with("xiaobobo");
    }

    @Bean
    public Binding bindingDirectExchange2(Queue queueRouting2,DirectExchange directExchange1){
        return BindingBuilder.bind(queueRouting2).to(directExchange1).with("xiaowangzi");
    }
}

4、编写manager

@Component
public class RabbitMQManager {

//    @Autowired
//    private AmqpTemplate amqpTemplate;

      @Autowired
      private RabbitTemplate rabbitTemplate;

    /**
     * 发送消息到工作模型中
     */
    public void sendWork(){
//       rabbitTemplate.convertAndSend("queueWork","我是工作模型测试的值小波波");
//       rabbitTemplate.convertAndSend("queueWork","我是工作模型测试的值小波波");
        for (int i = 0; i <100 ; i++) {
            rabbitTemplate.convertAndSend("queueWork",new User(i,"小波波","123"));
        }
    }

    /**
     * 向发布订阅模式里面发送消息
     */
    public void sendPublishWork(){
        rabbitTemplate.convertSendAndReceive("fanoutExchange1","","发布订阅模式的值");
    }
    /**
     * 向路由模型里面发送请求
     */
    public void sendDirectExchange(){
        rabbitTemplate.convertSendAndReceive("directExchange1","xiaowangzi","路由模型的值");
    }

    /**
     * Confirm机制
     */
    final RabbitTemplate.ConfirmCallback confirmCallback=new RabbitTemplate.ConfirmCallback(){
        @Override
        public void confirm(CorrelationData correlationData, boolean b, String s) {
            System.out.println("确认机制........");
        }
    };

    /**
     * return机制
     */
    RabbitTemplate.ReturnCallback returnCallback=new RabbitTemplate.ReturnCallback(){
        @Override
        public void returnedMessage(Message message, int i, String s, String s1, String s2) {
            System.out.println("return机制收到消息了.....");
        }
    };



    /**
     * 发送数据的第二种方式
     */
    public void sendWork1(Object message, Map<String,Object> properties){

//        MessageProperties messageProperties = new MessageProperties();
//        //添加属性...
//        Message message1 = new Message("内容".getBytes(), messageProperties);
//        //现在用下  return 机制    confirm机制....
//
//        rabbitTemplate.setMandatory(true);
//
//        rabbitTemplate.setConfirmCallback(confirmCallback);
//        //用下return机制
//        rabbitTemplate.setReturnCallback(returnCallback);
        //这里需要时间戳  每一条消息 都有一个时间戳

        // 作业：
        // 把rabbitmq中的其他功能
        //  手动确认      重回队列       限流       dlx死信队列玩一把
        //rabbitTemplate.convertAndSend("queueWork","我是工作模型测试的值小波波");
    }
}

5、编写service

@Service
public class RabbitMQService implements IRabbitMQService {

    @Autowired
    private RabbitMQManager rabbitMQManager;

    @Override
    public void sendMsg() {
        rabbitMQManager.sendWork();
    }

    @Override
    public void sendPublishWork() {
        rabbitMQManager.sendPublishWork();
    }
    @Override
    public void sendDirectExchange() {
        rabbitMQManager.sendDirectExchange();
    }
}

6、编写controller

@RestController
public class RabbitMQController {

    @Autowired
    private IRabbitMQService rabbitMQService;

    /**
     * 测试工作模型的发消息
     * @return
     */
    @RequestMapping("sendData")
    public Object sendMsg(){
        rabbitMQService.sendMsg();
        return "发送成功....";
    }

    /**
     * 向发布订阅模式 发送值
     * @return
     */
    @RequestMapping("sendPublishData")
    public Object sendPublishData(){

        rabbitMQService.sendPublishWork();
        return "发送成功....";
    }


    //路由模型的玩法
    /**
     * 向发布订阅模式 发送值
     * @return
     */
    @RequestMapping("sendDirectData")
    public Object sendDirectData(){
        rabbitMQService.sendDirectExchange();
        return "发送成功....";
    }   
}

7、编写work的消费者

@Component
public class WorkReciveListener {

    @RabbitListener(queues = {"queueWork"})
    public void reciveMessage(User user, Channel channel, Message message2){
        System.out.println("111收到消息了:"+user);
        System.out.println("111通道是:"+channel);
        System.out.println("111传输数据封装:"+message2);

//        message2.getMessageProperties().getDeliveryTag();

//        channel.basicAck(message2.getMessageProperties().getDeliveryTag(),false);
//        channel.basicNack();
    }


    @RabbitListener(queues = {"queueWork"})
    public void reciveMessage1(User user, Channel channel, Message message2){
        System.out.println("222收到消息了:"+user);
        System.out.println("222通道是:"+channel);
        System.out.println("222传输数据封装:"+message2);

//        message2.getMessageProperties().getDeliveryTag();

//        channel.basicAck(message2.getMessageProperties().getDeliveryTag(),false);
//        channel.basicNack();
    }

}

8、编写发布订阅模式的消费者

@Component
public class PublishReciveListener {

    @RabbitListener(queues = {"queueFanout1"})
    public void reciveMessage(String str, Channel channel, Message message2){
        System.out.println("111收到消息了:"+str);

    }

    @RabbitListener(queues = {"queueFanout2"})
    public void reciveMessage1(String str, Channel channel, Message message2){
        System.out.println("222收到消息了:"+str);
    }
}

9、编写路由模型的消费者

@Component
public class DirectReciveListener {
    @RabbitListener(queues = {"queueRouting1"})
    public void reciveMessage(String str, Channel channel, Message message2){
        System.out.println("111收到消息了:"+str);
    }
    @RabbitListener(queues = {"queueRouting2"})
    public voi reciveMessage1(String str, Channel channel, Message message2){
        System.out.println("222收到消息了:"+str);
    }
}

smartera

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot 整合RabbitMQ

SpringBoot 整合RabbitMQ1、导包 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <...
复制链接

扫一扫