RocetMQ整合SpringBoot

前提

本地已经安装RocketMQ
安装RocketMQ的版本需要和springboot的版本一致
本章演示springboot生产者和消费者

demo

## 生产者
引入依赖

   <!--rocketmq-->
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-spring-boot-starter</artifactId>
            <version>2.1.1</version>
        </dependency>

yml 设置rocketmq地址和组名

server:
  port: 8000

spring:
  application:
    name: nacos-rocket-mq-product
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.174.10:8848 # Nacos 服务注册中心地

rocketmq:
  name-server: 192.168.174.10:9876
  producer:
    group: my-producer-group

发送一条消息

@RunWith(SpringRunner.class)
@SpringBootTest(classes = RocketMqProApp.class)
public class Test {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    @org.junit.Test
    public void test(){
        //设置topic和内容
       Message message = new Message("myTopic","tag","key","你好,Java旅途".getBytes());
       SendResult send = rocketMQTemplate.getProducer().send(message);
    }
}

消费者

依赖

   <!--rocketmq-->
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-spring-boot-starter</artifactId>
            <version>2.1.1</version>
        </dependency>

yml 设置rocketmq地址和组名

server:
  port: 8000

spring:
  application:
    name: nacos-rocket-mq-product
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.174.10:8848 # Nacos 服务注册中心地

rocketmq:
  name-server: 192.168.174.10:9876
  consumer:
    group: my-producer-group

创建监听器

@Component
@RocketMQMessageListener(topic = "myTopic",// topic 必须跟发送者保持一致
        consumerGroup = "consumer", //消费者组名  随便写
        messageModel = MessageModel.CLUSTERING, //BROADCASTING 广播模式   CLUSTERING集群模式
        consumeMode = ConsumeMode.CONCURRENTLY // ORDERLY 顺序消费  CONCURRENTLY 无序消费
   )
public class Consumer implements RocketMQListener<MessageExt> {
    @Override
    public void onMessage(MessageExt s) {
        System.out.println("============="+s);
    }
}

结合springboot 5种发送方式（同步消息，单向消息。异步消息，顺序消息，事务消息）

 <!--rocketmq-->
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-spring-boot-starter</artifactId>
            <version>2.1.1</version>
        </dependency>

#rocketmq配置 生产者
rocketmq:
  name-server: 192.168.174.10:9876
  producer:
    group: my-producer-group

@RunWith(SpringRunner.class)
@SpringBootTest(classes = MqProductApp.class)
public class Test {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    //同步消息
    @org.junit.Test
    public void test(){

        //参数一：topic:tag
        //参数二：消息体内容
        SendResult sendResult = rocketMQTemplate.syncSend("myTopic:tag", "同步消息");
        System.out.println(sendResult);
    }

    //异步步消息
    @org.junit.Test
    public void test2() throws InterruptedException {
        rocketMQTemplate.asyncSend("myTopic1:tag1", "异步消息", new SendCallback() {
            //消息成功方法
            @Override
            public void onSuccess(SendResult sendResult) {
                System.out.println(sendResult);
            }
            //消息成功失败回调方法
            @Override
            public void onException(Throwable throwable) {
                System.out.println("throwable"+throwable);
            }
        });
        System.out.println("==============");
        Thread.sleep(300000000);
    }

    //单向消息
    @org.junit.Test
    public void test3(){
      rocketMQTemplate.sendOneWay("myTopic1:tag2", "单向消息");
    }
 

  //顺序消息（只需保证发送的消息在同一队列即可）
    @org.junit.Test
    public void test4(){
        for (int i = 0; i < 10; i++) {
            //xxx.Orderly就是顺序消息发送 第3个参数保证发送到哪一个队列
            rocketMQTemplate.sendOneWayOrderly("myTopic1:tag2", "单向消息","xxx");
        }
    }
 
}

事务消息
生产者发送事务消息

 @org.junit.Test
    public void test4(){
        TradeOrder order = new TradeOrder();
        order.setGoodsId(1111L);
        order.setGoodsNumber(99);
        //发送半消息
        rocketMQTemplate.sendMessageInTransaction("myTopic:tags"
                , MessageBuilder.withPayload(order).setHeader("txId", "122").build(),
                "arg");

    }

rocketMQ发送消息后会监听来自消费者的消息，

1. 如果发送的半消息已经到达了消费者 将会执行executeLocalTransaction（是消费还是回滚还是提交或者未知）
2. 如果消费者一直得不到生产者的回复将会进行方法回查执行checkLocalTransaction

import org.apache.rocketmq.spring.annotation.RocketMQTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionState;
import org.springframework.messaging.Message;


@RocketMQTransactionListener
public class RocketMQLocalTransactionListen implements RocketMQLocalTransactionListener {

    //执行本地业务逻辑
    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message message, Object o) {
        try {
            System.out.println(o + "============" + message);
            System.out.println("=======执行本地业务逻辑·=====");
        } catch (Exception e) {
            //事务回滚
            return RocketMQLocalTransactionState.ROLLBACK;
        }
        //事务提交
        return RocketMQLocalTransactionState.COMMIT;
    }

    //回查方法
    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(Message message) {
        System.out.println("---------------" + message);

        return RocketMQLocalTransactionState.ROLLBACK;
    }
}

消费者

@Component
@RocketMQMessageListener(topic = "myTopic",// topic 必须跟发送者保持一致
        consumerGroup = "consumer", //消费者组名  随便写
        messageModel = MessageModel.CLUSTERING, //BROADCASTING 广播模式   CLUSTERING集群模式
        consumeMode = ConsumeMode.CONCURRENTLY // ORDERLY 顺序消费  CONCURRENTLY 无序消费
   )
public class SpringTxConsumer implements RocketMQListener<MessageExt> {

    @Override
    public void onMessage(MessageExt s) {
        System.out.println("接收到消息 -> " + s);
    }
}