springboot-rocketMQ-stater源码解析及优雅的整合方式

最新推荐文章于 2024-08-21 10:39:19 发布
置顶 最新推荐文章于 2024-08-21 10:39:19 发布
阅读量1.6k 收藏 7
点赞数 5
分类专栏： RocketMQ 文章标签： spring boot rabbitmq java 后端 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Heron22/article/details/105692351
版权

springboot-rocketMQ-stater源码解析及优雅的整合方式

1.springboot与rocketMQ优雅整合

在springboot中使用RocketMQ消息队列，可以使用rocketmq-spring-boot-starter的依赖进行整合，这种整合方式的好处是简单便捷，只需要简单配置就可以使用，同时也屏蔽了对RocketMQ Client API的了解，需要去了解封装后的API 。在学习RocketMQ的时候大家都会了解RocketMQ Client 的API ，再学封装后的API费时费力，同时也不利于对底层API的了解。下面介绍简单优雅的整合RocketMQ Client到SpringBoot项目中的方式，保留使用RocketMQ Client 原生API的方式。需要将RocketMQ的依赖添加到项目中，依赖如下：

<dependency>
   <groupId>org.apache.rocketmq</groupId>
     <artifactId>rocketmq-client</artifactId>
     <version>4.6.0</version>
 </dependency>

 <!--权限控制依赖包(非必须的依赖，使用到acl的时候才需要)-->
 <dependency>
     <groupId>org.apache.rocketmq</groupId>
     <artifactId>rocketmq-acl</artifactId>
     <version>4.6.0</version>
 </dependency>

配置整合代码如下：

@Configuration
public class RocketMQConfig{

    @Bean(initMethod = "start",destroyMethod = "shutdown")
    public DefaultMQProducer getProducer(){
        DefaultMQProducer producer = new DefaultMQProducer("hr_unique_test_group");
        producer.setNamesrvAddr("192.168.31.67:9876;192.168.31.68:9876");
        //当一个JVM启动多个produce的时候，通过实例名称区分
        //producer.setInstanceName("instance1");
        //producer.setRetryTimesWhenSendAsyncFailed();
        //producer.setRetryTimesWhenSendAsyncFailed();
        System.out.println("create producer ok");
        return  producer ;
    }


	@Bean(initMethod = "start" ,destroyMethod = "shutdown")
    public DefaultMQPushConsumer init() throws MQClientException {
        //下面使用的push的消费方式，pull的使用 new DefaultLitePullConsumer()，拉的方式需要自己保存偏移量和队列的关系
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("hr_consumer_test");
        consumer.setNamesrvAddr("192.168.31.67:9876;192.168.31.68:9876");
		consumer.setMessageModel(MessageModel.BROADCASTING);
        consumer.setConsumeMessageBatchMaxSize(2);

        // 设置消费的topic ,需要过滤的tag , * 代表不过滤
        consumer.subscribe("TopicTest", "TagSpring");
        //注册消费的方式：这里是并发消费 ，还可以设置顺序消费 MessageListenerOrderly
        consumer.registerMessageListener(new MessageListenerConcurrently() {

            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                                                            ConsumeConcurrentlyContext context) {
                //默认情况下，每次都只是一条数据
                for (MessageExt messageExt : msgs) {
                    System.out.println("收到消息:\t"+new String(messageExt.getBody()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });

        System.out.printf("Consumer Started.%n");
        return consumer;
    }

}

使用方式：

@Autowired
private DefaultMQProducer producer ;

@RequestMapping("/{key}")
public Object getResult(@PathVariable("key")String key) throws 
UnsupportedEncodingException, RemotingException, 
MQClientException, InterruptedException {
    Message message = new Message("TopicTest", "TagSpring", key, ("self spring RocketMQ msg " + key).getBytes(RemotingHelper.DEFAULT_CHARSET));
    producer.send(message, new SendCallback() {
        @Override
        public void onSuccess(SendResult sendResult) {
            System.out.println(JSON.toJSONString(sendResult));
        }

        @Override
        public void onException(Throwable throwable) {
            System.out.println("onException");
        }
    });
    System.out.println("send ok");
    return "ok";
}

以上整合方式是直接将生产者和消费者注册到Spring容器中，同时必须执行Bean初始化和销毁的时候分别调用 start() 和shutdown()方法。在配置类中，可以使用注入的方式将NamesrvAddr，topic等参数写在配置文件中进行管理。使用生产者的时候直接注入 DefaultMQProducer 生产者对象即可，保留使用原生API对象的方式进行消息的发送和消费。

2.rocketmq-spring-boot-starter源码解析

spring-boot-starter 是模块化编程的方式，添加依赖就可以实现自动装配，自动装配需要实现接口配在配置文件中，这就是模块化编程中提倡的面向接口编程。在 rocketmq-spring-boot-starter源码中 的rocketmq-spring-boot模块下，找到resources文件夹，下的META-INF文件夹下有一个spring.factories的文件。这里配置了自动装配的类，也就是这个模块被整合时候的程序入口。如下图，这是spring标准的配置整合方式
在这里插入图片描述

2.1 RocketMQAutoConfiguration自动装配入口类

查看RocketMQAutoConfiguration类，有一大堆注解进行了标注，如下：

@Configuration
@EnableConfigurationProperties(RocketMQProperties.class)
@ConditionalOnClass({MQAdmin.class})
@ConditionalOnProperty(prefix = "rocketmq", value = "name-server", matchIfMissing = true)
@Import({MessageConverterConfiguration.class, ListenerContainerConfiguration.class, ExtProducerResetConfiguration.class, RocketMQTransactionConfiguration.class})
@AutoConfigureAfter({MessageConverterConfiguration.class})
@AutoConfigureBefore({RocketMQTransactionConfiguration.class})

public class RocketMQAutoConfiguration {

@EnableConfigurationProperties(RocketMQProperties.class) 这个注解触发自动导入项目配置文件中RocketMQ的配置，封装到 RocketMQProperties这个类中注入到spring中，这个类中可以查看nameServer等配置项和默认配置项等参数。

@ConditionalOnClass({MQAdmin.class})
@ConditionalOnProperty(prefix = “rocketmq”, value = “name-server”, matchIfMissing = true)
这两个注解标注了触发这个模块自动装配的条件。

@Import({MessageConverterConfiguration.class, ListenerContainerConfiguration.class, ExtProducerResetConfiguration.class, RocketMQTransactionConfiguration.class})
@AutoConfigureAfter({MessageConverterConfiguration.class})
@AutoConfigureBefore({RocketMQTransactionConfiguration.class})
这三个注解标识了自动装配的时候需要初始化导入的类和，初始化的导入顺序。

2.2 整合生产者的源码分析

RocketMQAutoConfiguration入口类中可以看到如下两个方法

@Bean
@ConditionalOnMissingBean(DefaultMQProducer.class)
@ConditionalOnProperty(prefix = "rocketmq", value = {"name-server", "producer.group"})
public DefaultMQProducer defaultMQProducer(RocketMQProperties rocketMQProperties) {
    RocketMQProperties.Producer producerConfig = rocketMQProperties.getProducer();
    String nameServer = rocketMQProperties.getNameServer();
    String groupName = producerConfig.getGroup();
    Assert.hasText(nameServer, "[rocketmq.name-server] must not be null");
    Assert.hasText(groupName, "[rocketmq.producer.group] must not be null");

    String accessChannel = rocketMQProperties.getAccessChannel();

    String ak = rocketMQProperties.getProducer().getAccessKey();
    String sk = rocketMQProperties.getProducer().getSecretKey();
    boolean isEnableMsgTrace = rocketMQProperties.getProducer().isEnableMsgTrace();
    String customizedTraceTopic = rocketMQProperties.getProducer().getCustomizedTraceTopic();

    DefaultMQProducer producer = RocketMQUtil.createDefaultMQProducer(groupName, ak, sk, isEnableMsgTrace, customizedTraceTopic);

    producer.setNamesrvAddr(nameServer);
    if (!StringUtils.isEmpty(accessChannel)) {
        producer.setAccessChannel(AccessChannel.valueOf(accessChannel));
    }
    producer.setSendMsgTimeout(producerConfig.getSendMessageTimeout());
    producer.setRetryTimesWhenSendFailed(producerConfig.getRetryTimesWhenSendFailed());
    producer.setRetryTimesWhenSendAsyncFailed(producerConfig.getRetryTimesWhenSendAsyncFailed());
    producer.setMaxMessageSize(producerConfig.getMaxMessageSize());
    producer.setCompressMsgBodyOverHowmuch(producerConfig.getCompressMessageBodyThreshold());
    producer.setRetryAnotherBrokerWhenNotStoreOK(producerConfig.isRetryNextServer());

    return producer;
}

@Bean(destroyMethod = "destroy")
@ConditionalOnBean(DefaultMQProducer.class)
@ConditionalOnMissingBean(name = ROCKETMQ_TEMPLATE_DEFAULT_GLOBAL_NAME)
public RocketMQTemplate rocketMQTemplate(DefaultMQProducer mqProducer,
    RocketMQMessageConverter rocketMQMessageConverter) {
    RocketMQTemplate rocketMQTemplate = new RocketMQTemplate();
    rocketMQTemplate.setProducer(mqProducer);
    rocketMQTemplate.setMessageConverter(rocketMQMessageConverter.getMessageConverter());
    return rocketMQTemplate;
}

从上面两个方法中可以看到，public DefaultMQProducer defaultMQProducer(RocketMQProperties rocketMQProperties)这个方法先是创建了生产者对象注册到了spring容器中，这个方法又使用了@EnableConfigurationProperties(RocketMQProperties.class)注解引入的配置文件中的配置项来创建生产者。

public RocketMQTemplate rocketMQTemplate(DefaultMQProducer mqProducer, RocketMQMessageConverter rocketMQMessageConverter)方法则是使用上一个方法创建的 DefaultMQProducer 生产者对象和@Import注解引入的MessageConverterConfiguration对象。创建 RocketMQTemplate 对象封装 DefaultMQProducer 生产者对象 和 MessageConverterConfiguration对象，然后注册到容器中。这也就是为什么使用@Autowired注入RocketMQTemplate对象就能够发送消息的原因，其实就是进行简单封装后底层还是调用DefaultMQProducer 生产者对象发送消息。

看到这里，你是不是有点疑惑，创建RocketMQTemplate 的时候指定了销毁的时候@Bean(destroyMethod = “destroy”)指定了要调用的方法，实际还是调用producer的shutdown()方法释放资源，可是创建生产者的时候并没有指明调用 producer.start()方法？

查看 RocketMQTemplate 类 可以发送，这个类实现了InitializingBean这个接口，实现方法如下：

@Override
public void afterPropertiesSet() throws Exception {
    if (producer != null) {
        producer.start();
    }
}

看到这里就可以知道了，当创建完RocketMQTemplate这个类，设置完成属性后，会回调这个方法，这时候会调用生产者的start()方法，这时候就能使用RocketMQTemplate发送消息了。

2.3 整合消费者的源码解析

使用过 rocketmq-spring-boot-starter应该了解，实现消费者需要类实现RocketMQListener接口 并且要使用@RocketMQMessageListener标准消费者的信息 和@Service向Spring注册服务，就实现了消息消费的监听。

上面开始介绍入口的时候@Import 注解中有导入ListenerContainerConfiguration.class这个类，看类名就知道这个应该跟消息消费监听有关。查看这个类，空参构造方法没有进行相关初始化操作，但是类实现了两个接口如下：

@Configuration
public class ListenerContainerConfiguration implements ApplicationContextAware, SmartInitializingSingleton

ApplicationContextAware 接口可以获取到spring容器的上下文对象，SmartInitializingSingleton接口实现的方法在是会在这个类对象实例化完成后调用这个接口的方法的。ListenerContainerConfiguration这个类是@Configuration修饰的配置类，是由spring进行实例会操作管理的，所以会自动调用到SmartInitializingSingleton接口实现的方法:

public void afterSingletonsInstantiated() {
   Map<String, Object> beans = this.applicationContext.getBeansWithAnnotation(RocketMQMessageListener.class)
       .entrySet().stream().filter(entry -> !ScopedProxyUtils.isScopedTarget(entry.getKey()))
       .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

   beans.forEach(this::registerContainer);
}

这个方法中我们可以看到applicationContext.getBeansWithAnnotation(RocketMQMessageListener.class)获取到了Spring管理对象中被RocketMQMessageListener注解标注的所有对象。这也是我们上面说的实现消费者监听需要满足的三个条件中的两个：使用@RocketMQMessageListener注解 和使用@Service注解向Spring注册服务。
向下查看代码，获取到Bean名称和Bean类的映射集合后循环调用registerContainer方法, 方法主要逻辑如下（被我去除了校验）：

private void registerContainer(String beanName, Object bean) {
   Class<?> clazz = AopProxyUtils.ultimateTargetClass(bean);
   RocketMQMessageListener annotation = clazz.getAnnotation(RocketMQMessageListener.class);
   String containerBeanName = String.format("%s_%s", DefaultRocketMQListenerContainer.class.getName(),
       counter.incrementAndGet());
   GenericApplicationContext genericApplicationContext = (GenericApplicationContext) applicationContext;

   genericApplicationContext.registerBean(containerBeanName, DefaultRocketMQListenerContainer.class,
       () -> createRocketMQListenerContainer(containerBeanName, bean, annotation));
   DefaultRocketMQListenerContainer container = genericApplicationContext.getBean(containerBeanName,
       DefaultRocketMQListenerContainer.class);
   if (!container.isRunning()) {
       try {
           container.start();
       } catch (Exception e) {
           log.error("Started container failed. {}", container, e);
           throw new RuntimeException(e);
       }
   }
}

上面方法流程总结如下：

  1. 获取到RocketMQMessageListener注解
  2. 生成注入到Spring容器中的Bean的名字
  3. 向spring注册DefaultRocketMQListenerContainer类的Bean
  4. 获取到容器中的Bean,开启消费者监听

这里流程看上去似乎跟消费者有点关系，但是又不太有联系。

genericApplicationContext.registerBean(containerBeanName, DefaultRocketMQListenerContainer.class,() -> createRocketMQListenerContainer(containerBeanName, bean, annotation));
DefaultRocketMQListenerContainer container = genericApplicationContext.getBean(containerBeanName,DefaultRocketMQListenerContainer.class);

查看这两行代码，第一行注册Bean的时候要调用这个() -> createRocketMQListenerContainer(containerBeanName, bean, annotation)匿名的方法，这里是不会触发调用的，实际还没有初始化 DefaultRocketMQListenerContainer对象。

genericApplicationContext.getBean这里执行的时候会触发上面提到的那个方法，查看createRocketMQListenerContainer方法如下：

private DefaultRocketMQListenerContainer createRocketMQListenerContainer(String name, Object bean,
        RocketMQMessageListener annotation) {
    DefaultRocketMQListenerContainer container = new DefaultRocketMQListenerContainer();

    container.setRocketMQMessageListener(annotation);

    String nameServer = environment.resolvePlaceholders(annotation.nameServer());
    nameServer = StringUtils.isEmpty(nameServer) ? rocketMQProperties.getNameServer() : nameServer;
    String accessChannel = environment.resolvePlaceholders(annotation.accessChannel());
    container.setNameServer(nameServer);
    if (!StringUtils.isEmpty(accessChannel)) {
        container.setAccessChannel(AccessChannel.valueOf(accessChannel));
    }
    container.setTopic(environment.resolvePlaceholders(annotation.topic()));
    String tags = environment.resolvePlaceholders(annotation.selectorExpression());
    if (!StringUtils.isEmpty(tags)) {
        container.setSelectorExpression(tags);
    }
    container.setConsumerGroup(environment.resolvePlaceholders(annotation.consumerGroup()));
    if (RocketMQListener.class.isAssignableFrom(bean.getClass())) {
        container.setRocketMQListener((RocketMQListener) bean);
    } else if (RocketMQReplyListener.class.isAssignableFrom(bean.getClass())) {
        container.setRocketMQReplyListener((RocketMQReplyListener) bean);
    }
    container.setMessageConverter(rocketMQMessageConverter.getMessageConverter());
    container.setName(name);

    return container;
}

从这个方法中可以看到，从RocketMQMessageListener注解获取到了用户设置的参数值，如consumerGroup ,topic ,tags,nameServer等值，最后都被封装到了DefaultRocketMQListenerContainer 对象中，然后将这个对象注册到了spring容器中。重点要注意的代码如下, 注解标注的类（我们实现的消费者接口的类）被复制给了DefaultRocketMQListenerContainer 中的引用。

if (RocketMQListener.class.isAssignableFrom(bean.getClass())) {
	container.setRocketMQListener((RocketMQListener) bean);
} else if (RocketMQReplyListener.class.isAssignableFrom(bean.getClass())) {
    container.setRocketMQReplyListener((RocketMQReplyListener) bean);
}

这时候查看DefaultRocketMQListenerContainer 对象，发现它实现了我们上面提到的InitializingBean接口，DefaultRocketMQListenerContainer 对象所以初始化设置完成后会调用到afterPropertiesSet()方法，方法实现如下:

@Override
public void afterPropertiesSet() throws Exception {
    initRocketMQPushConsumer();
    this.messageType = getMessageType();
    this.methodParameter = getMethodParameter();
    log.debug("RocketMQ messageType: {}", messageType);
}

看方法名就知道第一行代码对消费者进行初始化，到这里终于找到消费者的影子了。initRocketMQPushConsumer（）方法很长，我不贴出来了，方法里面创建消费者对象，并根据上面获取到的注解信息，设置订阅的topic 、过滤条件、广播消费还是并发消费等等。

查看代码中的一段如下：

 switch (consumeMode) {
     case ORDERLY:
         consumer.setMessageListener(new DefaultMessageListenerOrderly());
         break;
     case CONCURRENTLY:
         consumer.setMessageListener(new DefaultMessageListenrConcurrently());
         break;
     default:
         throw new IllegalArgumentException("Property 'consumeMode' was wrong.");
 }

这段代码中设置了消费的模式是顺序消费还是并发消费，具体的消费逻辑在这个两个类中实现。查看者两个类中的消费方法 consumeMessage 或者 onMessage方法，最终都是调用的 handleMessage(messageExt)这个方法进行消费。消费的逻辑又指向了rocketMQListener.onMessage(doConvertMessage(messageExt)) 或者rocketMQReplyListener.onMessage(doConvertMessage(messageExt))这就是我们要实现的就接口，这两个对象的复制就是上面提到的重点要关注的代码，将注解标注的类对象赋值给了这两个字段。通过多态的形式，调用接口方法，实际上就调用到了我们的实现类方法中进行消费者逻辑处理了。

3.手写rocketmq-spring-boot-starter原理

下面简单实现 rocketmq-spring-boot-starter原理的流程

3.1 定义配置类

@ConfigurationProperties(prefix = "rocketmq")
public class RocketMQProperties {

    private String nameServer;

    /**
     * Enum type for accessChannel, values: LOCAL, CLOUD
     */
    private String accessChannel;

    private Producer producer;

    public static class Producer{

        private Integer retryTimesWhenSendAsyncFailed ;

        private Integer maxMessageSize;

        private String  group;

        public Integer getRetryTimesWhenSendAsyncFailed() {
            return retryTimesWhenSendAsyncFailed;
        }

        public void setRetryTimesWhenSendAsyncFailed(Integer retryTimesWhenSendAsyncFailed) {
            this.retryTimesWhenSendAsyncFailed = retryTimesWhenSendAsyncFailed;
        }

        public Integer getMaxMessageSize() {
            return maxMessageSize;
        }

        public void setMaxMessageSize(Integer maxMessageSize) {
            this.maxMessageSize = maxMessageSize;
        }

        public String getGroup() {
            return group;
        }

        public void setGroup(String group) {
            this.group = group;
        }
    }

    public String getNameServer() {
        return nameServer;
    }

    public void setNameServer(String nameServer) {
        this.nameServer = nameServer;
    }

    public String getAccessChannel() {
        return accessChannel;
    }

    public void setAccessChannel(String accessChannel) {
        this.accessChannel = accessChannel;
    }

    public Producer getProducer() {
        return producer;
    }

    public void setProducer(Producer producer) {
        this.producer = producer;
    }
}

3.2 定义消费者注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface RocketMQMsgListener {

    String nameAddr() ;

    String consumerGroup();

    String topic();

    String filterTag() default "*";

    boolean isOrderyConsume() default false;

    MessageModel messageModel() default MessageModel.CLUSTERING;

}

3.3 定义消费者实现接口

public interface MsgConsumerListener {

    void onMessage(String message);
}

3.4 定义自动装配入口类实现整合

自动装配类入口代码

@Configuration
@EnableConfigurationProperties(RocketMQProperties.class)
@ConditionalOnProperty(prefix = "rocketmq",value = "name-server",matchIfMissing = true)
@Import(RocketConsumerAutoConfig.class)
public class RocketMQConfiguration {

    @Bean(initMethod = "start" ,destroyMethod = "shutdown")
    @ConditionalOnProperty(prefix = "rocketmq",value = {"name-server","producer.group"})
    public DefaultMQProducer defaultMQProducer(RocketMQProperties properties){
        RocketMQProperties.Producer proconfig = properties.getProducer();
        DefaultMQProducer producer = new DefaultMQProducer(proconfig.getGroup());
        producer.setNamesrvAddr(properties.getNameServer());
        Integer maxMessageSize = proconfig.getMaxMessageSize();
        if (maxMessageSize != null && maxMessageSize > 0 ){
            producer.setMaxMessageSize(maxMessageSize);
        }

        Integer retryTimesWhenSendAsyncFailed = proconfig.getRetryTimesWhenSendAsyncFailed();
        if (retryTimesWhenSendAsyncFailed != null && retryTimesWhenSendAsyncFailed >0 ){
            producer.setRetryTimesWhenSendAsyncFailed(retryTimesWhenSendAsyncFailed);
        }

        return producer;
    }
}

消费者整合配置代码

@Configuration
public class RocketConsumerAutoConfig implements ApplicationContextAware , SmartInitializingSingleton {

    private ConfigurableApplicationContext context;

    private List<DefaultMQPushConsumer> consumerList = new ArrayList();

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.context = (ConfigurableApplicationContext) applicationContext;
    }

    @Override
    public void afterSingletonsInstantiated() {
        //获取到所有注解标记的Bean
        Map<String, Object> beans = this.context.getBeansWithAnnotation(RocketMQMsgListener.class)
                .entrySet().stream().filter(entry -> !ScopedProxyUtils.isScopedTarget(entry.getKey()))
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

        //循环注册Bean
        beans.forEach(this::registerConsumer);
    }

    private AtomicLong counter = new AtomicLong(0);

    private void registerConsumer(String beanName ,Object bean){
        Class<?> clazz = bean.getClass();
        RocketMQMsgListener annotation = clazz.getAnnotation(RocketMQMsgListener.class);


        String containerBeanName = String.format("%s_%s", beanName, counter.incrementAndGet());
        GenericApplicationContext genericApplicationContext = (GenericApplicationContext) context;

        //注册消费者到容器中
        genericApplicationContext.registerBean(containerBeanName, DefaultMQPushConsumer.class,
                () -> createRocketMQConsumer(containerBeanName, bean, annotation));
        DefaultMQPushConsumer consumer = genericApplicationContext.getBean(containerBeanName,
                DefaultMQPushConsumer.class);
        try {
            consumer.start();
        } catch (MQClientException e) {
            e.printStackTrace();
            throw new RuntimeException("consumer.start fail");
        }
    }

    private DefaultMQPushConsumer createRocketMQConsumer(String containerBeanName,Object bean,RocketMQMsgListener annotation){
        String nameAddr = annotation.nameAddr();
        String consumerGroup = annotation.consumerGroup();
        String topic = annotation.topic();
        String tag = annotation.filterTag();
        MessageModel messageModel = annotation.messageModel();

        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(consumerGroup);
        consumer.setNamesrvAddr(nameAddr);
        try {
            consumer.subscribe(topic,tag);
            consumer.setMessageModel(messageModel);


        MsgConsumerListener listener = (MsgConsumerListener)bean;
        if (annotation.isOrderyConsume()){
            //顺序消费
            consumer.registerMessageListener(new MessageListenerOrderly() {
                @Override
                public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
                    //默认情况下，每次都只是一条数据
                    for (MessageExt messageExt : msgs) {
                        System.out.println("顺序消费：\t"+ new String(messageExt.getBody()));
                        listener.onMessage(new String(messageExt.getBody()));
                    }

                    return ConsumeOrderlyStatus.SUCCESS;
                }
            });
        }else {
            //注册消费的方式：这里是并发消费 ，还可以设置顺序消费 MessageListenerOrderly
            consumer.registerMessageListener(new MessageListenerConcurrently() {

                @Override
                public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                                                                ConsumeConcurrentlyContext context) {
                    //默认情况下，每次都只是一条数据
                    for (MessageExt messageExt : msgs) {
                        System.out.println("并发消费：\t"+new String(messageExt.getBody()));
                        listener.onMessage(new String(messageExt.getBody()));
                    }
                    return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
                }
            });
        }
        } catch (MQClientException e) {
            throw new RuntimeException("registerBean consumer fail");
        }
        consumerList.add(consumer);
        return consumer;
    }

    @PreDestroy
    private void destroy(){
        for (DefaultMQPushConsumer consumer : consumerList){
            System.out.println("shutdown");
            consumer.shutdown();
        }
    }
}

3.5编写配置文件

配置如下 resources\META-INF\spring.factories 固定路径和文件名，
配置中的key固定，value就是配置入口类的类名

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.heron.config.RocketMQConfiguration

在这里插入图片描述

3.6 pom文件依赖

   <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.7.RELEASE</version>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-client</artifactId>
            <version>4.6.0</version>
        </dependency>

        <!--权限控制依赖包-->
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-acl</artifactId>
            <version>4.6.0</version>
        </dependency>

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

    </dependencies>

3.7 生产者和消费者使用方式

生产者使用：

@Autowired
private DefaultMQProducer producer

消费者使用：

@Service
@RocketMQMsgListener(topic = "testTopic", consumerGroup = "consumer", nameAddr= "192.168.31.67:9876;192.168.31.68:9876")
public class MyConsumer implements MsgConsumerListener{
    @Override
    public void onMessage(String message) {
        System.out.printf("------- StringConsumer received: %s \n", message);
    }

}
不惧不惑
关注
专栏目录
rocketmq-spring-boot-starter：rocketmq-spring-boot-starter
01-30
rocketmq-spring-boot-starter 阿里云RocketMQSpring图书版 支持功能： 发送普通消息的三种模式：同步，异步和单向 订阅消息群集，广播 发送和接收顺序消息 交易讯息 延迟讯息 接收和接收定时消息 定时消息和延迟消息： 延迟消息和定时消息：在官方情况下，延迟新闻与常规新闻几乎相同，本质上是普通新闻。 如果需要延迟消息和计时消息，建议使用计时任务（计时任务调度平台） 以达到延迟或定时的目的。 交易留言： 在框架中，对事务消息的操作越来越简单。 您只能通过注释来完成交易消息。 无论是事务消息，分布式事务解决方案还是跨平台语言解决方案，事务解决方案的核心问题是确保可以发送消息，并且消费者可以使用它们。 可靠性保证 1.添加@TransactionMessage批注，内核保证，本地事务错误，不发送消息，正确执行，发送消息，即默认提交。 2.默认情况下采用可靠性保证，并核对默认提交。 原因来自先前的因素，该因素保证本地交易不会出错。 快速开始 <!-- Adding dependencies to pom. XML -->
rocketmq源码解析springboot整合
qq_23283355的博客
08-26 515
说在前面 springboot整合 源码解析 springboot应用启动会先加载spring.factories org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ org.apache.rocketmq.spring.autoconfigure.RocketMQAutoConfiguration @Configur...
从零到一：Spring Boot 与 RocketMQ 的完美集成指南
最新发布
qq_51447436的博客
08-21 3706
从零到一：Spring Boot 与 RocketMQ 的完美集成指南
rocketmq-spring-boot-starter：RocketMQ的Spring Boot启动器
01-30
RocketMQ的Spring启动启动器 项目介绍 是由阿里巴巴团队开发并幸存给apache团队的优秀消息中间件，承受过历年双十一大促的考验。 你可以通过本项目轻松的集成Rocketmq到你的SpringBoot项目中。本项目主要包含以下特性 同步发送消息 初步发送消息 广播发送消息 有序发送和消费消息 发送延迟消息 消息标签和密钥支持 自动序列化和反序列化消息体 消息的实际消费方IP跟随 发送事务消息（NEW） ... 发送即忘消息（可能由于直接抛弃所有异常导致消息静默丢失，弃用） 拉取方式消费（配置方式复杂，位点可能发生偏移，弃用） 简单入门实例 1.添加maven依赖： < dependency> < groupId> com . maihaoche < / groupId > < artifactId> spring - boot - starter - rocketmq < / artifactId > < version> 0.1 . 0 < / version > < / dependency > 2.添加配置： spring :
SpringBoot整合RocketMQ，三种测试附带源码【rocketmq-spring-boot-starter】
小道仙的后宫
03-07 3213
我们整合boot项目的时候都是引入 xxx-start 依赖，但是现在大多数的整合RocketMQ都还不是这样。 我花了一天时间使用rocketmq-spring-boot-starter整合，使得操作起来更加简单。 1、说明 1-1：rocketmq-spring-boot-starter 提供了一个 rocketMQTemplate 使得发消息更加简单，它底层也还是基于DefaultMQP...
2、RocketMQ 源码解析之 与 Spring Boot 集成
carl.zhao的专栏
12-21 606
上一篇文章分析了一下 RocketMQ 的基本架构、概念、安装以及使用方式。现在大多数项目都是基于 Spring Boot。因为它很方便的自动装配机制，所以现在构建项目都是基于 Spring Boot。下面我们来分析一下 RocketMQ 是如何集成 Spring Boot 的。 RocketMQ主要由 Producer、Broker、Consumer 三部分组成，其中Producer 负责生产消息，Consumer 负责消费消息，Broker 负责存储消息。Broker 在实际部署过程中对应一台服务器
RocketMQ最佳实践（三）开发spring-boot-starter-rocketmq实现与spring boot项目的整合
热门推荐
jayjjb的专栏
04-28 4万+
不要以为这只是spring boot与RocketMQ的简单整合，本篇文章还为各位看官呈现以下知识点的最佳实践： 自定义一个spring boot 的starter使用spring的事件传播机制实现bean与bean之间基于事件驱动的通信自定义注解、组合注解 先来撩点故事背景^_^ 最近在使用spring boot/spring cloud搭建做微服务架构，发现spring boot
common-spring-boot-stater：基于SpringBoot的Web开发公共模块
02-08
基于SpringBoot的Web开发公共服务 一，统一异常处理 1.1异常处理器 1.1.1基础异常处理器 基础异常处理器，负责处理一些基础的异常： 异常类型 响应码 响应文本 BusinessException 可自定义 可自定义 空指针异常 500 ...
SpringBoot-加密组件jasypt-spring-boot-starter
zym_1321的博客
01-04 7121
1、pom.xml增加依赖 <dependency> <groupId>com.github.ulisesbocchio</groupId> <artifactId>jasypt-spring-boot-starter</artifactId> <version>3.0.3</version> </dependency> 2、yml增加配置 jasypt: encryptor: alg
SpringBoot--自定义Starter的几种方式
wendy专栏
04-07 694
1、方式一--main方法可以扫描到的包下 main在com.mooc.house下 自定义starter在com.mooc.house.autoconfig下 添加依赖 <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpclien...
retrofit-spring-boot-starter：用于改进的springboot启动器，并支持许多功能增强，从而大大简化了开发。（实现了Retrofit与spring-boot框架快速整合，并支持了众多功能增强，极大简化了开发）
01-30
而spring-boot是使用最广泛的Java开发框架，但是Retrofit官方没有支持与spring-boot框架快速整合，因此我们开发了retrofit-spring-boot-starter 。 retrofit-spring-boot-starter实现了Retrofit与spring-boot框架...
spring-boot-starter-rocketmq
04-28
自己写的一个spring-boot整合rocketmq的starter，以及一个用来测试的项目rocketmq-starter-test。 涉及以下知识的最佳实践： 1、自定义spring boot starter； 2、使用spring的事件传播机制实现bean与bean之间基于事件驱动的通信 3、自定义注解、组合注解 相关资料参考我写的博文：http://blog.csdn.net/jayjjb/article/details/70906511 1个最佳实践1分，很划算的^_^
rocketmq-spring-boot-starter:RocketMQ客户端封装类，基于最新版本4.5.2
05-26
spring boot starter for RocketMQ 项目介绍 是由阿里巴巴团队开发并捐赠给apache团队的优秀消息中间件，目前已经是apache的顶级项目之一，承受过历年双十一大促的考验。 你可以通过本项目轻松的集成Rocketmq到你的SpringBoot项目中。 本项目主要包含以下特性 同步发送消息 异步发送消息 广播发送消息 有序发送和消费消息 发送延时消息 消息tag和key支持 自动序列化和反序列化消息体 发送事务消息(NEW) ... 简单入门实例 模块介绍： rocketmq-spring-boot-starter：组件的依赖入口 rocketmq-spring-boot-autoconfigure： 自动配置模块 rocketmq-spring-boot-app：Demo示例，里面包含了最基本功能的用法 1. 添加maven依赖： <de
springboot整合rocketmq源码
04-22
springboot整合rocketmq 下载就可上手 已经实现异步消息发送接收 顺序消息发送接收
rocketmq-spring-2.0.0 源码分析（一）
lonsonlee的专栏
12-14 366
时间仓促 先给出第一版，总体来说 还是需要多实践 可以看做类似jdbcTemplate的东东 20多个文件 不算多 但是设计思想可以参考
一文详解RocketMQ-Spring的源码解析与实战
华为云官方博客
04-24 684
这篇文章主要介绍 Spring Boot 项目使用 rocketmq-spring SDK 实现消息收发的操作流程，同时笔者会从开发者的角度解读 SDK 的设计逻辑。
SpringBoot基于starter整合RocketMQ (附源码)
WannaRunning的博客
03-28 469
目录 引入Starter依赖 Yml配置 发送消息 全局的RocketMQTemplate 发送事务消息 @ExtRocketMQTemplateConfiguration @RocketMQTransactionListener 消息消费 @RocketMQMessageListener Apache官方提供了rocket-spring-starter用于SpringBoot项目中集成RocketMQ使用,其实是基于rocketmq-client的依赖进行封装的,而且starter有时
Rocketmq源码--3--整合springboot
qq_33012981的博客
05-29 219
Rocketmq源码–3–整合springboot 文章目录`Rocketmq`源码--`3`--整合`springboot`1 准备工作2 发送一条同步消息并消费2.1 向`Rocketmq`发送消息2.2 消费`Rocketmq`的消息3 发送一条异步消息并消费4 发送一条单向消息并消费5 发送一条`json`消息并消费6 发送一条延时消息并消费7 消费重试 1 准备工作 这里我们创建一个父工程，他下面有两个子工程，分别是消费者和生产者工程。 在父工程中导入依赖 <parent> &
SpringBoot如何优雅的使用RocketMQ
python_doris的博客
12-29 497
SpringBoot如何优雅的使用RocketMQ MQ，是一种跨进程的通信机制，用于上下游传递消息。在传统的互联网架构中通常使用MQ来对上下游来做解耦合。 举例：当A系统对B系统进行消息通讯，如A系统发布一条系统公告，B系统可以订阅该频道进行系统公告同步，整个过程中A系统并不关系B系统会不会同步，由订阅该频道的系统自行处理。 什么是RocketMQ？ 官方说明: 随着使用越来越多的队列和虚...
校园二手交易平台开发：SpringBoot+MyBatis+MySql源码解析
SpringBoot的核心特性包括独立的Spring应用程序、嵌入式服务器（如Tomcat、Jetty或Undertow）、提供了大量的Stater依赖以简化构建配置。在本项目中，SpringBoot用于快速搭建项目骨架，简化了配置过程。 知识点二：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值