RocketMQ入门（3）拉取消息

最新推荐文章于 2023-12-12 03:57:15 发布

wbj0110

最新推荐文章于 2023-12-12 03:57:15 发布

阅读量157

点赞数

分类专栏： RocketMQ 文章标签： RocketMQ

本文链接：https://blog.csdn.net/wbj0110/article/details/84605872

版权

RocketMQ 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

本文详细介绍RocketMQ中PullConsumer的使用方式，包括初始化配置、拉取消息队列及处理流程。通过具体代码示例解释如何实现消息拉取，并解析PullResult对象，深入探讨offsetTable在消息拉取中的作用。

摘要由CSDN通过智能技术生成

RocketMQ不止可以直接推送消息，在消费端注册监听器进行监听，还可以由消费端决定自己去拉取数据

      
          1 
        
          2 
        
          3 
        
          4 
        
          5 
        
          6 
        
          7 
        
          8 
        
          9 
        
          10 
        
          11 
        
          12 
        
          13 
        
          14 
        
          15 
        
          16 
        
          17 
        
          18 
        
          19 
        
          20 
        
          21 
        
          22 
        
          23 
        
          24 
        
          25 
        
          26 
        
          27 
        
          28 
        
          29 
        
          30 
        
          31 
        
          32 
        
          33 
        
          34 
        
          35 
        
          36 
        
          37 
        
          38 
        
          39 
        
          40 
        
          41 
        
          42 
        
          43 
        
          44 
        
          45 
        
          46 
        
          47 
        
          48 
        
          49 
        
          50 
        
          51 
        
          52 
        
          53 
        
          54 
        
          55 
        
          56 
        
          57 
        
          58 
        
          59 
        
          60 
        
          61 
        
          62 
        
          63 
        
          64 
        
          65 
        
          66 
        
          67 
        
         /** 
        
          * PullConsumer，订阅消息 
        
          */ 
        
         public 
         class 
         PullConsumer 
         { 
        
         //Java缓存 
        
         private 
         static 
         final 
         Map 
         < 
         MessageQueue 
         , 
         Long 
         > 
         offseTable 
         = 
         new 
         HashMap 
         < 
         MessageQueue 
         , 
         Long 
         > 
         ( 
         ) 
         ; 
        
         public 
         static 
         void 
         main 
         ( 
         String 
         [ 
         ] 
         args 
         ) 
         throws 
         MQClientException 
         { 
        
         DefaultMQPullConsumer  
         consumer 
         = 
         new 
         DefaultMQPullConsumer 
         ( 
         "PullConsumerGroup" 
         ) 
         ; 
        
         consumer 
         . 
         setNamesrvAddr 
         ( 
         "127.0.0.1:9876" 
         ) 
         ; 
        
         consumer 
         . 
         start 
         ( 
         ) 
         ; 
        
         //拉取订阅主题的队列，默认队列大小是4 
        
         Set 
         <MessageQueue> 
         mqs 
         = 
         consumer 
         . 
         fetchSubscribeMessageQueues 
         ( 
         "TopicTestMapBody" 
         ) 
         ; 
        
         for 
         ( 
         MessageQueue  
         mq 
         : 
         mqs 
         ) 
         { 
        
         System 
         . 
         out 
         . 
         println 
         ( 
         "Consume from the queue: " 
         + 
         mq 
         ) 
         ; 
        
         SINGLE_MQ 
         : 
         while 
         ( 
         true 
         ) 
         { 
        
         try 
         { 
        
         PullResult  
         pullResult 
         = 
        
         consumer 
         . 
         pullBlockIfNotFound 
         ( 
         mq 
         , 
         null 
         , 
         getMessageQueueOffset 
         ( 
         mq 
         ) 
         , 
         32 
         ) 
         ; 
        
         List 
         <MessageExt> 
         list 
         = 
         pullResult 
         . 
         getMsgFoundList 
         ( 
         ) 
         ; 
        
         if 
         ( 
         list 
         != 
         null 
         && 
         list 
         . 
         size 
         ( 
         ) 
         < 
         100 
         ) 
         { 
        
         for 
         ( 
         MessageExt  
         msg 
         : 
         list 
         ) 
         { 
        
         System 
         . 
         out 
         . 
         println 
         ( 
         SerializableInterface 
         . 
         deserialize 
         ( 
         msg 
         . 
         getBody 
         ( 
         ) 
         ) 
         ) 
         ; 
        
         } 
        
         } 
        
         System 
         . 
         out 
         . 
         println 
         ( 
         pullResult 
         . 
         getNextBeginOffset 
         ( 
         ) 
         ) 
         ; 
        
         putMessageQueueOffset 
         ( 
         mq 
         , 
         pullResult 
         . 
         getNextBeginOffset 
         ( 
         ) 
         ) 
         ; 
        
         switch 
         ( 
         pullResult 
         . 
         getPullStatus 
         ( 
         ) 
         ) 
         { 
        
         case 
         FOUND 
         : 
        
         // TODO 
        
         break 
         ; 
        
         case 
         NO_MATCHED_MSG 
         : 
        
         break 
         ; 
        
         case 
         NO_NEW_MSG 
         : 
        
         break 
         SINGLE_MQ 
         ; 
        
         case 
         OFFSET_ILLEGAL 
         : 
        
         break 
         ; 
        
         default 
         : 
        
         break 
         ; 
        
         } 
        
         } 
        
         catch 
         ( 
         Exception 
         e 
         ) 
         { 
        
         e 
         . 
         printStackTrace 
         ( 
         ) 
         ; 
        
         } 
        
         } 
        
         } 
        
         consumer 
         . 
         shutdown 
         ( 
         ) 
         ; 
        
         } 
        
         private 
         static 
         void 
         putMessageQueueOffset 
         ( 
         MessageQueue  
         mq 
         , 
         long 
         offset 
         ) 
         { 
        
         offseTable 
         . 
         put 
         ( 
         mq 
         , 
         offset 
         ) 
         ; 
        
         } 
        
         private 
         static 
         long 
         getMessageQueueOffset 
         ( 
         MessageQueue  
         mq 
         ) 
         { 
        
         Long 
         offset 
         = 
         offseTable 
         . 
         get 
         ( 
         mq 
         ) 
         ; 
        
         if 
         ( 
         offset 
         != 
         null 
         ) 
         { 
        
         System 
         . 
         out 
         . 
         println 
         ( 
         offset 
         ) 
         ; 
        
         return 
         offset 
         ; 
        
         } 
        
         return 
         0 
         ; 
        
         }