低版本的springboot(1.5.3)如何集成rocketmq呀，有做过的给个案例么？

对于低版本的 Spring Boot（如 1.5.3），你可以通过以下步骤来集成 RocketMQ：

1. 添加依赖：在 Maven 或 Gradle 配置文件中添加 RocketMQ 的客户端依赖。根据你使用的消息队列版本选择相应的依赖，例如：

   • 对于 Apache RocketMQ：

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

   • 对于 Alibaba RocketMQ（RocketMQ 的分支）：

     <dependency>
         <groupId>com.aliyun.openservices</groupId>
         <artifactId>ons-client</artifactId>
         <version>1.8.0</version>
     </dependency>
     

   请注意，确保选择与你所使用的 RocketMQ 版本兼容的客户端依赖。

2. 配置 RocketMQ：在 Spring Boot 的配置文件中添加 RocketMQ 的相关配置。具体配置项可能会有所不同，取决于你使用的 RocketMQ 版本和实际需求。以下是一个示例配置：

   # RocketMQ Name Server 地址
   spring.rocketmq.name-server=127.0.0.1:9876
   # RocketMQ Producer 组名
   spring.rocketmq.producer.group=my-group
   # RocketMQ Consumer 组名
   spring.rocketmq.consumer.group=my-group
   

3. 编写生产者代码：创建一个 RocketMQ 生产者，并使用 RocketMQTemplate 发送消息。示例代码如下：

   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.messaging.Message;
   import org.springframework.messaging.support.MessageBuilder;
   import org.springframework.stereotype.Component;
   import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
   import org.springframework.cloud.stream.annotation.EnableBinding;
   import org.springframework.cloud.stream.messaging.Source;
   import org.springframework.messaging.MessageChannel;
   
   @Component
   @EnableBinding(Source.class)
   public class RocketMQProducer {
   
       @Autowired
       private MessageChannel output;
   
       public void sendMessage(String message) {
           Message<String> msg = MessageBuilder.withPayload(message).build();
           output.send(msg);
       }
   }
   

4. 编写消费者代码：创建一个 RocketMQ 消费者，通过 RocketMQMessageListener 监听消息。示例代码如下：

   import org.apache.rocketmq.spring.core.RocketMQListener;
   import org.springframework.stereotype.Component;
   
   @Component
   public class RocketMQConsumer implements RocketMQListener<String> {
   
       @Override
       public void onMessage(String message) {
           System.out.println("Received message: " + message);
           // 处理消息逻辑
       }
   }
   

请根据你的实际需求和具体 RocketMQ 版本进行相应的配置和代码编写。以上是一个简单的示例，你可以根据自己的业务需求进行更复杂的集成。

注意，如果你使用的是 Alibaba RocketMQ，还需要设置 spring.rocketmq.name-server 和 spring.rocketmq.access-key 等额外的配置项以连接阿里云的 RocketMQ 服务。

在Spring Boot 1.5.3版本中，可以使用Apache RocketMQ的Java客户端进行集成。以下是一个简单的示例：
首先，需要在项目的pom.xml文件中添加RocketMQ的依赖：

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

然后，需要创建一个配置类，用于配置RocketMQ的连接信息：

@Configuration
public class RocketMQConfig {

    @Value("${rocketmq.brokerUrl}")
    private String brokerUrl;

    @Value("${rocketmq.namesrvAddr}")
    private String namesrvAddr;

    @Value("${rocketmq.consumerGroup}")
    private String consumerGroup;

    @Value("${rocketmq.consumerName}")
    private String consumerName;

    @Bean
    public MessageConsumer messageConsumer() throws MQClientException {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(consumerName);
        consumer.setNamesrvAddr(namesrvAddr);
        consumer.subscribe("topicTest", "*");
        consumer.setMessageModel(MessageModel.BROADCASTING);
        consumer.start();
        return consumer;
    }
}

在上述代码中，使用了Spring Boot的配置类，配置了RocketMQ的连接信息，包括brokerUrl、namesrvAddr、consumerGroup和consumerName等。
然后，需要创建一个消息处理器，用于处理接收到的消息：

@Component
public class RocketMQMessageListener implements MessageListenerConcurrently {

    @Override
    public void onMessage(MessageExt msgExt) {
        System.out.println("receive message: " + new String(msgExt.getBody()));
    }
}

在上述代码中，创建了一个消息处理器，实现了MessageListenerConcurrently接口，用于处理接收到的消息。
最后，需要在启动类中启动RocketMQ的消息监听器：

@SpringBootApplication
public class Application {

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

    @Bean
    public MessageListenerConcurrently messageListenerConcurrently(RocketMQConfig rocketMQConfig) {
        RocketMQMessageListener listener = new RocketMQMessageListener();
        listener.setRocketMQConfig(rocketMQConfig);
        return listener;
    }
}

在上述代码中，创建了一个启动类，启动了RocketMQ的消息监听器。在启动类中，通过@Bean方法，将RocketMQ的配置信息注入到了消息处理器中。
以上就是一个简单的Spring Boot 1.5.3版本集成RocketMQ的示例。

SpringBoot 1.5.3版本相对较旧，但依旧可以集成RocketMQ。以下是一个基本的示例：

首先，你需要在你的pom.xml文件中添加RocketMQ的依赖：

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

然后，你可以创建一个配置类来配置RocketMQ：

@Configuration
public class RocketMQConfig {
    @Value("${rocketmq.namesrv.addr}")
    private String namesrvAddr;
    @Value("${rocketmq.producer.group}")
    private String producerGroup;

    @Bean
    public ProducerFactory<String, String> producerFactory() {
        DefaultProducerFactory<String, String> factory = new DefaultProducerFactory<>(producerGroup);
        return factory;
    }

    @Bean
    public RocketMQTemplate rocketMQTemplate() {
        RocketMQTemplate template = new RocketMQTemplate();
        template.setNamesrvAddr(namesrvAddr);
        template.setProducerFactory(producerFactory());
        return template;
    }
}

在这个配置类中，我们首先设置了RocketMQ的名字服务地址和生产者组名。然后，我们创建了一个ProducerFactory实例，并设置了名字服务地址和生产组名。最后，我们创建了一个RocketMQTemplate实例，并设置了名字服务地址和ProducerFactory。

接下来，你可以创建一个服务类来发送消息：

@Service
public class RocketMQService {
    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    public void sendMessage(String topic, String message) {
        Message msg = new Message(topic, message.getBytes(StandardCharsets.UTF_8));
        SendResult sendResult = rocketMQTemplate.send(msg);
        System.out.println("Send result: " + sendResult);
    }
}

在这个服务类中，我们首先注入了RocketMQTemplate实例。然后，我们创建了一个Message实例，并设置了主题和消息内容。最后，我们使用RocketMQTemplate的send方法发送消息，并打印出发送结果。

以上就是一个基本的SpringBoot集成RocketMQ的示例。你可以根据你的实际需求进行修改和扩展。