SpringBoot集成RocketMQ

已于 2023-09-16 19:23:21 修改
阅读量1.2k 收藏 7
点赞数
分类专栏： # JAVA-SpringBoot 文章标签： java-rocketmq spring boot rocketmq
于 2023-09-01 12:19:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zsx1314lovezyf/article/details/132621484
版权

SpringBoot集成RocketMQ

1、导入依赖(注意启动类上是不需要加其它注解的)

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

2、相关配置

2.1、生产者配置
rocketmq:
  name-server: 192.168.171.128:9876
  producer:
    group: boot-product
2.2、消费者配置
rocketmq:
  name-server: 192.168.171.128:9876

3、发送同步/异步/单向消息

3.1、消息发送方式三种方式
3.1.1、同步消息
package com.xiaoge;

import com.xiaoge.util.OrderStep;
import com.xiaoge.util.OrderUtil;
import org.apache.rocketmq.client.producer.MessageQueueSelector;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.MessageQueue;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.test.context.junit4.SpringRunner;

import java.sql.SQLOutput;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * TODO
 *
 * @author <a href="mailto:1330137071@qq.com">Zhang Xiao</a>
 * @since
 */
@SpringBootTest(classes = RocketMQApplication.class)
@RunWith(SpringRunner.class)
public class TestApplication {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    /**
     * 发送同步消息
     * @throws Exception
     */
    @Test
    public void sendMessage() throws Exception {
        Message msg = MessageBuilder.withPayload("springboot发送同步消息").build();
        rocketMQTemplate.send("helloBoot", msg);
    }
}
3.1.2、异步消息
package com.xiaoge;

import com.xiaoge.util.OrderStep;
import com.xiaoge.util.OrderUtil;
import org.apache.rocketmq.client.producer.MessageQueueSelector;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.MessageQueue;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.test.context.junit4.SpringRunner;

import java.sql.SQLOutput;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * TODO
 *
 * @author <a href="mailto:1330137071@qq.com">Zhang Xiao</a>
 * @since
 */
@SpringBootTest(classes = RocketMQApplication.class)
@RunWith(SpringRunner.class)
public class TestApplication {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    /**
     * 发送异步消息
     * @throws Exception
     */
    @Test
    public void sendAsyncMessage() throws Exception {
        System.out.println("发送前");
        rocketMQTemplate
                .asyncSend("helloBoot", "springboot发送异步消息", new SendCallback() {
                    @Override
                    public void onSuccess(SendResult sendResult) {
                        System.out.println("发送状态:"+sendResult.getSendStatus());
                    }

                    @Override
                    public void onException(Throwable throwable) {
                        System.out.println("消息发送失败!");
                    }
                });

        System.out.println("发送完毕");
        TimeUnit.SECONDS.sleep(5);
    }
}
3.1.3、单向消息
package com.xiaoge;

import com.xiaoge.util.OrderStep;
import com.xiaoge.util.OrderUtil;
import org.apache.rocketmq.client.producer.MessageQueueSelector;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.MessageQueue;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.test.context.junit4.SpringRunner;

import java.sql.SQLOutput;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * TODO
 *
 * @author <a href="mailto:1330137071@qq.com">Zhang Xiao</a>
 * @since
 */
@SpringBootTest(classes = RocketMQApplication.class)
@RunWith(SpringRunner.class)
public class TestApplication {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    /**
     * 发送单向消息
     * @throws Exception
     */
    @Test
    public void sendOneWayMessage() throws Exception {
        rocketMQTemplate
                .sendOneWay("helloBoot", "springboot发送单向消息");
    }
}
3.2、消息消费方
package com.xiaoge.listener;

import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.spring.annotation.MessageModel;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

import java.nio.charset.Charset;
import java.util.Date;

/**
 * TODO
 *
 * @author <a href="mailto:1330137071@qq.com">Zhang Xiao</a>
 * @since
 */
@Component
@RocketMQMessageListener(consumerGroup = "boot-consumer", topic = "helloBoot")
public class HelloBootListener implements RocketMQListener<MessageExt> {
    @Override
    public void onMessage(MessageExt messageExt) {
        System.out.println("收到的消息: " + new String(messageExt.getBody(), Charset.defaultCharset()));
    }
}

4、消息消费方式

4.1、集群
package com.xiaoge.listener;

import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.spring.annotation.MessageModel;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

import java.nio.charset.Charset;
import java.util.Date;

/**
 * TODO
 *      集群 @RocketMQMessageListener(consumerGroup = "boot-consumer", topic = "helloBoot", messageModel = MessageModel.CLUSTERING)
 *      广播 @RocketMQMessageListener(consumerGroup = "boot-consumer", topic = "helloBoot", messageModel = MessageModel.BROADCASTING)
 *
 * @author <a href="mailto:1330137071@qq.com">Zhang Xiao</a>
 * @since
 */
@Component
// todo MessageModel.CLUSTERING(集群-->默认集群)  MessageModel.BROADCASTING(广播)
@RocketMQMessageListener(consumerGroup = "boot-consumer", topic = "helloBoot", messageModel = MessageModel.CLUSTERING)
public class HelloBootListener implements RocketMQListener<MessageExt> {
    @Override
    public void onMessage(MessageExt messageExt) {
        System.out.println("收到的消息: " + new String(messageExt.getBody(), Charset.defaultCharset()) + " " + new Date());
    }
}
4.2、广播
package com.xiaoge.listener;

import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.spring.annotation.MessageModel;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

import java.nio.charset.Charset;
import java.util.Date;

/**
 * TODO
 *      集群 @RocketMQMessageListener(consumerGroup = "boot-consumer", topic = "helloBoot", messageModel = MessageModel.CLUSTERING)
 *      广播 @RocketMQMessageListener(consumerGroup = "boot-consumer", topic = "helloBoot", messageModel = MessageModel.BROADCASTING)
 *
 * @author <a href="mailto:1330137071@qq.com">Zhang Xiao</a>
 * @since
 */
@Component
// todo MessageModel.CLUSTERING(集群-->默认集群)  MessageModel.BROADCASTING(广播)
@RocketMQMessageListener(consumerGroup = "boot-consumer", topic = "helloBoot", messageModel = MessageModel.BROADCASTING)
public class HelloBootListener implements RocketMQListener<MessageExt> {
    @Override
    public void onMessage(MessageExt messageExt) {
        System.out.println("收到的消息: " + new String(messageExt.getBody(), Charset.defaultCharset()) + " " + new Date());
    }
}
4.3、消息发送
package com.xiaoge;

import com.xiaoge.util.OrderStep;
import com.xiaoge.util.OrderUtil;
import org.apache.rocketmq.client.producer.MessageQueueSelector;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.MessageQueue;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.test.context.junit4.SpringRunner;

import java.sql.SQLOutput;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * TODO
 *
 * @author <a href="mailto:1330137071@qq.com">Zhang Xiao</a>
 * @since
 */
@SpringBootTest(classes = RocketMQApplication.class)
@RunWith(SpringRunner.class)
public class TestApplication {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    /**
     * 发送10单向消息, 消费者默认是集群的, 所以默认有负载
     * @throws Exception
     */
    @Test
    public void send10OneWayMessage() throws Exception {
        for (int i = 0; i < 10; i++) {
            rocketMQTemplate
                    .sendOneWay("helloBoot", "springboot发送单向消息" + i);
        }
    }

    
}

5、顺序消息

5.1、生产者
package com.xiaoge.util;

import lombok.Data;
import lombok.ToString;

/**
 * TODO
 *
 * @author <a href="mailto:1330137071@qq.com">Zhang Xiao</a>
 * @since
 */
@Data
@ToString
public class OrderStep {

    private long orderId;
    private String desc;

}


package com.xiaoge.util;

import java.util.ArrayList;
import java.util.List;

public class OrderUtil {
    /**
     * 生成模拟订单数据
     */
    public static <T> List<T> buildOrders() {
        List<OrderStep> orderList = new ArrayList();
  
        OrderStep orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111039L);
        orderDemo.setDesc("创建");
        orderList.add(orderDemo);
  
        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111065L);
        orderDemo.setDesc("创建");
        orderList.add(orderDemo);
  
        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111039L);
        orderDemo.setDesc("付款");
        orderList.add(orderDemo);
  
        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103117235L);
        orderDemo.setDesc("创建");
        orderList.add(orderDemo);
  
        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111065L);
        orderDemo.setDesc("付款");
        orderList.add(orderDemo);
  
        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103117235L);
        orderDemo.setDesc("付款");
        orderList.add(orderDemo);
  
        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111065L);
        orderDemo.setDesc("完成");
        orderList.add(orderDemo);
  
        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111039L);
        orderDemo.setDesc("推送");
        orderList.add(orderDemo);
  
        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103117235L);
        orderDemo.setDesc("完成");
        orderList.add(orderDemo);
  
        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111039L);
        orderDemo.setDesc("完成");
        orderList.add(orderDemo);
  
        return (List<T>) orderList;
    }
}

package com.xiaoge;

import com.xiaoge.util.OrderStep;
import com.xiaoge.util.OrderUtil;
import org.apache.rocketmq.client.producer.MessageQueueSelector;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.MessageQueue;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.test.context.junit4.SpringRunner;

import java.sql.SQLOutput;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * TODO
 *
 * @author <a href="mailto:1330137071@qq.com">Zhang Xiao</a>
 * @since
 */
@SpringBootTest(classes = RocketMQApplication.class)
@RunWith(SpringRunner.class)
public class TestApplication {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    /**
     * 发送顺序消息
     * @throws Exception
     */
    @Test
    public void sendOrderlyMessage() throws Exception {
        // 设置队列选择器
        rocketMQTemplate.setMessageQueueSelector(new MessageQueueSelector() {
            @Override
            public MessageQueue select(List<MessageQueue> list, org.apache.rocketmq.common.message.Message message, Object o) {
                String orderStr = (String) o;
                Long orderId = Long.valueOf(orderStr);
                int index = (int)(orderId % list.size());
                // 获取选择的队列返回
                return list.get(index);
            }
        });

        List<OrderStep> orderSteps = OrderUtil.buildOrders();

        // String.valueOf(orderStep.getOrderId())就是你用来决定去拉格队列的值, 它会传递给上面的Object o
        orderSteps.forEach(orderStep -> {
            rocketMQTemplate.sendOneWayOrderly("orderlyTopicBoot", orderStep.toString(), String.valueOf(orderStep.getOrderId()));
        });
    }
}
5.2、消费者
package com.xiaoge.listener;

import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.spring.annotation.ConsumeMode;
import org.apache.rocketmq.spring.annotation.MessageModel;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

import java.nio.charset.Charset;

/**
 * TODO 顺序消息的消费
 *      consumeMode = ConsumeMode.ORDERLY 表示 一个队列对应一个线程
 *
 * @author <a href="mailto:1330137071@qq.com">Zhang Xiao</a>
 * @since
 */
@Component
@RocketMQMessageListener(consumerGroup = "orderly-consumer", topic = "orderlyTopicBoot", consumeMode = ConsumeMode.ORDERLY)
public class OrderlyTopicListener implements RocketMQListener<MessageExt> {
    @Override
    public void onMessage(MessageExt messageExt) {
        System.out.println("收到的消息: " + new String(messageExt.getBody(), Charset.defaultCharset()));
    }
}

6、延时消息

6.1、生产者
package com.xiaoge;

import com.xiaoge.util.OrderStep;
import com.xiaoge.util.OrderUtil;
import org.apache.rocketmq.client.producer.MessageQueueSelector;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.MessageQueue;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.test.context.junit4.SpringRunner;

import java.sql.SQLOutput;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * TODO
 *
 * @author <a href="mailto:1330137071@qq.com">Zhang Xiao</a>
 * @since
 */
@SpringBootTest(classes = RocketMQApplication.class)
@RunWith(SpringRunner.class)
public class TestApplication {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    /**
     * 发送延时消息
     * @throws Exception
     */
    @Test
    public void sendDelayMessage() throws Exception {
        Message msg = MessageBuilder.withPayload("springboot发送延时消息" + new Date()).build();
        // 发送超时时间 3000(3秒钟)  rocketmq超时等级3
        rocketMQTemplate.syncSend("helloBoot", msg, 3000, 3);
    }
 
}
6.2、消费者
package com.xiaoge.listener;

import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.spring.annotation.MessageModel;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

import java.nio.charset.Charset;
import java.util.Date;

/**
 * TODO
 *
 * @author <a href="mailto:1330137071@qq.com">Zhang Xiao</a>
 * @since
 */
@Component
@RocketMQMessageListener(consumerGroup = "boot-consumer", topic = "helloBoot")
public class HelloBootListener implements RocketMQListener<MessageExt> {
    @Override
    public void onMessage(MessageExt messageExt) {
        System.out.println("收到的消息: " + new String(messageExt.getBody(), Charset.defaultCharset()) + " " + new Date());
    }
}

7、消息过滤

7.1、TAG过滤
7.1.1、生产者
package com.xiaoge;

import com.xiaoge.util.OrderStep;
import com.xiaoge.util.OrderUtil;
import org.apache.rocketmq.client.producer.MessageQueueSelector;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.MessageQueue;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.test.context.junit4.SpringRunner;

import java.sql.SQLOutput;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * TODO
 *
 * @author <a href="mailto:1330137071@qq.com">Zhang Xiao</a>
 * @since
 */
@SpringBootTest(classes = RocketMQApplication.class)
@RunWith(SpringRunner.class)
public class TestApplication {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

   
    /**
     * 发送tag消息过滤
     * todo tag只能跟topic写在一起用:分割
     * @throws Exception
     */
    @Test
    public void sendTagFilterMessage() throws Exception {
        Message msg1 = MessageBuilder.withPayload("消息A").build();
        // todo 它的tag标签只能写在topic中用:分割, :左边是主题, :右边是tag, 所以我们在命令主题的时候不要带:
        rocketMQTemplate.sendOneWay("tagFilterBoot:TagA", msg1);
        Message msg2 = MessageBuilder.withPayload("消息B").build();
        rocketMQTemplate.sendOneWay("tagFilterBoot:TagB", msg2);
        Message msg3 = MessageBuilder.withPayload("消息C").build();
        rocketMQTemplate.sendOneWay("tagFilterBoot:TagC", msg3);
    }
}
7.1.2、消费者
package com.xiaoge.listener;

import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.spring.annotation.ConsumeMode;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

import java.nio.charset.Charset;

/**
 * TODO
 *      接收消息tag过滤, selectorExpression写过滤规则
 *
 * @author <a href="mailto:1330137071@qq.com">Zhang Xiao</a>
 * @since
 */
@Component
@RocketMQMessageListener(consumerGroup = "tag-consumer", topic = "tagFilterBoot", selectorExpression = "TagA || TagC")
public class TagFilterListener implements RocketMQListener<MessageExt> {
    @Override
    public void onMessage(MessageExt message) {
        System.out.println("收到的消息: " + new String(message.getBody(), Charset.defaultCharset()));
    }
}
7.2、SQL92过滤
7.2.1、在broker.conf配置添加如下配置, 开始SQL92过滤
enablePropertyFilter = true
7.2.2、生产者
package com.xiaoge;

import com.xiaoge.util.OrderStep;
import com.xiaoge.util.OrderUtil;
import org.apache.rocketmq.client.producer.MessageQueueSelector;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.MessageQueue;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.test.context.junit4.SpringRunner;

import java.sql.SQLOutput;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * TODO
 *
 * @author <a href="mailto:1330137071@qq.com">Zhang Xiao</a>
 * @since
 */
@SpringBootTest(classes = RocketMQApplication.class)
@RunWith(SpringRunner.class)
public class TestApplication {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;


    /**
     * 发送sql92消息过滤
     * todo sql过滤属性只能写在setHeader里面, message没有对应的put
     * @throws Exception
     */
    @Test
    public void sendSql92FilterMessage() throws Exception {
        Message msg1 = MessageBuilder.withPayload("美女A, 年龄22, 体重45")
                .setHeader("age", 22)
                .setHeader("weight", 45)
                .build();

        rocketMQTemplate.sendOneWay("SQL92FilterBoot", msg1);
        Message msg2 = MessageBuilder.withPayload("美女B, 年龄25, 体重60")
                .setHeader("age", 25)
                .setHeader("weight", 60)
                .build();
        rocketMQTemplate.sendOneWay("SQL92FilterBoot", msg2);
        Message msg3 = MessageBuilder.withPayload("美女C, 年龄40, 体重70")
                .setHeader("age", 40)
                .setHeader("weight", 70)
                .build();
        rocketMQTemplate.sendOneWay("SQL92FilterBoot", msg3);
    }
}
7.2.3、消费者
package com.xiaoge.listener;

import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.annotation.SelectorType;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

import java.nio.charset.Charset;

/**
 * TODO
 *      接收消息SQL92过滤, selectorType = SelectorType.SQL92(使用SQL92的方式)   selectorExpression = "age > 23 and weight > 60" (写过滤规则)
 *
 * @author <a href="mailto:1330137071@qq.com">Zhang Xiao</a>
 * @since
 */
@Component
@RocketMQMessageListener(consumerGroup = "sql92-consumer", topic = "SQL92FilterBoot", selectorType = SelectorType.SQL92, selectorExpression = "age > 23 and weight > 60")
public class Sql92FilterListener implements RocketMQListener<MessageExt> {
    @Override
    public void onMessage(MessageExt message) {
        System.out.println("收到的消息: " + new String(message.getBody(), Charset.defaultCharset()));
    }
}

8、事务消息(案例是退款, 积分增加, 修改订单状态保持最终一致性)

8.1、生产者
package com.xiaoge.service.impl;

import com.xiaoge.domain.OperateIntergralVo;
import com.xiaoge.domain.OrderInfo;
import com.xiaoge.mapper.OrderInfoMapper;
import com.xiaoge.service.IOrderInfoService;
import org.apache.rocketmq.client.producer.LocalTransactionState;
import org.apache.rocketmq.client.producer.TransactionSendResult;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * TODO
 *
 * @author <a href="mailto:1330137071@qq.com">Zhang Xiao</a>
 * @since
 */
@Service
public class OrderInfoServiceImpl implements IOrderInfoService {
    @Autowired
    private RocketMQTemplate rocketMQTemplate;
    @Autowired
    private OrderInfoMapper orderInfoMapper;
    @Override
    public String refund(String orderNo) {
        System.out.println("发送消息");
        OrderInfo orderInfo = orderInfoMapper.select(orderNo);
        OperateIntergralVo vo = new OperateIntergralVo();
        vo.setUserId(orderInfo.getUserId());
        vo.setValue(orderInfo.getIntergral());
        // setHeader可以额外添加值
        Message<OperateIntergralVo> message = MessageBuilder.withPayload(vo).setHeader("orderNo",orderNo).build();
        //发送事务消息
        TransactionSendResult result = rocketMQTemplate.sendMessageInTransaction("tx_group", "tx_topic", message, orderNo);
        System.out.println("发送的状态:"+result.getSendStatus());
        System.out.println("本地事务执行结果:"+ result.getLocalTransactionState());
        int i = 1/0;
        if(LocalTransactionState.COMMIT_MESSAGE.equals(result.getLocalTransactionState())){
            return "退款成功";
        }else{
            return "退款失败";
        }
    }

    @Override
    @Transactional
    public void updateRefundStatus(String orderNo) {
        orderInfoMapper.changeRefundStatus(orderNo,OrderInfo.STATUS_REFUND);
    }

    @Override
    public OrderInfo find(String orderNo) {
        return orderInfoMapper.select(orderNo);
    }
}

发送事务消息

// tx_group 事务生产者
// tx_topic 主题
// message 消息
// orderNo 本地事务方法参数(注意mq调用本地事务方法会带这个参数, 回查方法不会带, 如果回查方法业务要这个参数, 那就放在消息setHeader里面)
TransactionSendResult result = rocketMQTemplate.sendMessageInTransaction("tx_group", "tx_topic", message, orderNo);
8.2、消费者

正常监听消费, 只有事务状态为commit的时候, 半消息才会变成全消息, 这时候消费者监听才能监听到消息, 事务状态为rollback把mq中的半消息删除, 但是, 这里要注意, 有可能我们消费了, 告诉mq我们消费了这条消息时, 网络断了, 这样mq就会没收到回复, 走重试消息, 这样消费者继续消费这个消息, 这样重复消费了, 所以一定要保证幂等性。

package com.xiaoge.mq;

import com.xiaoge.domain.OperateIntergralVo;
import com.xiaoge.service.IIntegralService;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;


@Component
@RocketMQMessageListener(consumerGroup = "consumer-order",topic = "tx_topic")
public class OrderInfoListener implements RocketMQListener<OperateIntergralVo> {
    @Autowired
    private IIntegralService iIntegralService;
    @Override
    public void onMessage(OperateIntergralVo message) {
        System.out.println("12.消费消息");
        iIntegralService.incrIntergral(message);
    }
}

本地事务方法和回查方法 类必须实现这个RocketMQLocalTransactionListener监听

package com.xiaoge.mq;

import com.xiaoge.domain.OperateIntergralVo;
import com.xiaoge.domain.OrderInfo;
import com.xiaoge.service.IOrderInfoService;
import com.alibaba.fastjson.JSON;
import org.apache.rocketmq.spring.annotation.RocketMQTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionState;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.stereotype.Component;

import java.nio.charset.Charset;


@Component
@RocketMQTransactionListener(txProducerGroup = "tx_group")
public class OrderTransactionMessageListener implements RocketMQLocalTransactionListener {
    @Autowired
    private IOrderInfoService orderInfoService;
    //执行本地事务
    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message message, Object o) {
        System.out.println("执行本地事务方法");
        byte[] contents = (byte[]) message.getPayload();
        String objStr = new String(contents, Charset.defaultCharset());
        OperateIntergralVo vo = JSON.parseObject(objStr,OperateIntergralVo.class);
        System.out.println(vo);
        String orderNo = (String) o;
        try{
            //本地业务逻辑
            orderInfoService.updateRefundStatus(orderNo);
            System.out.println("执行成功");
            // return RocketMQLocalTransactionState.UNKNOWN; 这里返回UNKNOWN, mq会调用回查方法
            return RocketMQLocalTransactionState.COMMIT; // 把mq中的半消息变成全消息, 这样consumer才能正常消费
        }catch(Exception e){
            e.printStackTrace();
            System.out.println("执行失败");
            // 删除mq中的半消息
            return RocketMQLocalTransactionState.ROLLBACK;
        }
    }
    //回查方法
    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(Message message) {
        System.out.println("回查方法");
        String orderNo = (String) message.getHeaders().get("orderNo");
        OrderInfo orderInfo = orderInfoService.find(orderNo);
        if(OrderInfo.STATUS_REFUND.equals(orderInfo.getStatus())){
            //已经退款成功,说明本地事务执行成功
            return RocketMQLocalTransactionState.COMMIT;  // 把mq中的半消息变成全消息, 这样consumer才能正常消费
        }else{
            //说明本地事务执行失败.
            return RocketMQLocalTransactionState.ROLLBACK; // 删除mq中的半消息
        }
    }
}

在这里插入图片描述

在这里插入图片描述
事务消息demo下载地址: https://download.csdn.net/download/zsx1314lovezyf/88347191

9、RocketMQ消息走向

9.1、集群模式

多个消费组监听同一个topic, 每个消费组都会读取获取该topic中的消息, 如果对应的消费组做了集群, 那么消息是分开发送的, 如果又有新的消费组监听该topic由于它的offset为0, 但是由于以前有消费组它们的offset为3的话, 新的消费组也会直接拿到0-3的消息, offset会跟老的消费组同步

在这里插入图片描述

在这里插入图片描述

9.2、广播模式

广播模式的话没什么特别的, 都是一起发同样的消息, 不管消费组做没做集群

在这里插入图片描述
demo下载地址: https://download.csdn.net/download/zsx1314lovezyf/88282585

只因为你温柔
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
RocketMQ（一）：Linux安装RocketMQ和常用命令
qq_28834355的博客
01-30 1131
下载安装 版本：4.8.0 下载地址：https://www.apache.org/dyn/closer.cgi?path=rocketmq/4.8.0/rocketmq-all-4.8.0-source-release.zip 下载成功后，上传到 /opt 目录，并解压
Springboot 整合RocketMQ
lisaihang96的博客
10-24 3662
因为已经保存用户的基本信息，保存上状态标志位（0），消费者计算完后，根据id更新该数据标志位（1），计算异常问题更新标志位（2），每日定时任务对异常数据进行批量推送重新计算。根据用户提交的手机号计算用户数据，计算用户实时数据比较长数据量大的3-5分钟，数据小的1分钟上下，移动端不需要实时放回用户计算数据，所以接口保存完用户基本信息。此机制只能针对 消息队列宕机 网络异常或队列数据丢失问题。业务场景：该接口为H5、小程序提供，收集用户信息姓名、手机号、身份证号、地区等信息。4. 监听器事务配置。
【SpringBoot高级篇】SpringBoot集成RocketMQ消息队列
热门推荐
输入技术、输出想法
01-18 1万+
RocketMQ是阿里巴巴2016年MQ中间件，使用Java语言开发，在阿里内部，RocketMQ承接了例如“双11”等高并发场景的消息流转，能够处理万亿级别的消息。
Springboot 整合 RocketMQ
原名：@程序员大禹
06-25 1633
pull方式里，取消息的过程需要用户自己写，首先通过打算消费的Topic拿到MessageQueue的集合，遍历MessageQueue集合，然后针对每个MessageQueue批量取消息，一次取完后，记录该队列下一次要取的开始offset，直到取完了，再换另一个MessageQueue。缺点：消费者从server端拉消息，主动权在消费端，可控性好，但是时间间隔不好设置，间隔太短，则空请求会多，浪费资源，间隔太长，则消息不能及时处理。推荐使用PushConsumer，直接上代码！
SpringBoot整合RocketMQ
上善若泪
05-08 5685
先看看每次发送消息或者消费消息消息发送成功或者失败要打印消息日志，用于业务排查问题。如果消息量较少，建议在消费入口方法打印消息，消费耗时等，方便后续排查问题。RocketMQ无法避免消息重复（），所以如果业务对消费重复非常敏感，务必要在业务层面进行去重处理。可以借助关系数据库进行去重。首先需要确定消息的唯一键，可以是msgId，也可以是消息内容中的唯一标识字段，例如订单Id等。接下来讨论的是在RocketMQ中发送消息时选择何种消息类型最为合适。在RocketMQ发送Json对象。
springboot 集成 rocketmq
Heyyouare的博客
09-21 225
1.添加依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-client</artifactId> <version>${rocketmq.version}</version> //<rocketmq.version>4.3.0&l
【SpringBoot深入浅出系列】SpringBoot之集成RocketMQ_springboot 集成rocketmq
2401_84520245的博客
04-21 1188
在面试前我整理归纳了一些面试学习资料，文中结合我的朋友同学面试美团滴滴这类大厂的资料及案例由于篇幅限制，文档的详解资料太全面，细节内容太多，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！大家看完有什么不懂的可以在下方留言讨论也可以关注。网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以添加V获取：xhs1999xhs（备注Java）一个人可以走的很快，但一群人才能走的更远！
springboot整合rocketmq源码
04-22
【标题】：SpringBoot整合RocketMQ源码解析 在当今的微服务架构中，消息队列（Message Queue）已经成为解耦、异步处理以及提高系统可靠性的关键组件。本主题将深入探讨如何在SpringBoot应用中整合Apache RocketMQ，...
SpringBoot整合RocketMq，rocketMq
08-24
SpringBoot整合RocketMq
springboot集成RocketMQ消息队列demo源码案例演示
最新发布
07-23
一、简介 二、环境部署 1、编译打包 2、修改配置 3、服务启动 4、控制台安装 三、工程搭建 1、工程结构 2、依赖管理 3、配置文件 4、配置类 四、基础用法 1、消息生产 2、消息消费 五、参考源码
springboot集成rocketmq
猴子哥哥的博客
02-17 1304
  本文是springboot集成rocketmq的入门篇，主要介绍单机环境下安装rocketmq，并集成到springboot框架中，实现字符串类型消息的生产和消费。   1）高可用集群部署方案请参考 待更新。。。   2）更多使用方式请参考 待更新。。。 一、下载、安装、启动 1、下载 http://rocketmq.apache.org/dowloading/releases/ 2、安装 ...
Springboot整合RocketMQ
GSON的博客
04-17 2916
顺序消息是 Apache RocketMQ 提供的一种高级消息类型，支持消费者按照发送消息的先后顺序获取消息，从而实现业务场景中的顺序处理。普通消息为 Apache RocketMQ 中最基础的消息 ， 普通消息一般应用于微服务解耦、事件驱动、数据集成等场景，这些场景大多数要求数据传输通道具有可靠传输的能力，且对消息的处理时机、处理顺序没有特别要求。封装了RocketMQ的生产者API，提供了一系列简单易用的方法，用于发送不同类型的消息， 后面的例子都会用到它。
Spring 整合 RocketMQ
weixin_30336061的博客
07-15 350
1. 引入jar包 <!-- RocketMQ --> <dependency> <groupId>com.alibaba.rocketmq</groupId> <artifactId>rocketmq-all</artifact...
SpringBoot 集成 RocketMQ
魂-淡
03-20 7769
RocketMQ 主要由 Producer、Broker、Consumer 三部分组成，其中 Producer 负责生产消息，Consumer 负责消费消息，Broker 负责存储消息。Broker 在实际部署过程中对应一台服务器，每个 Broker 可以存储多个 Topic 的消息，每个Topic 的消息也可以分片存储于不同的 Broker。消息中转角色，负责存储消息、转发消息。表示一类消息的集合，每个主题包含若干条消息，每条消息只能属于一个主题，是RocketMQ 进行消息订阅的基本单位。
6-rocketmq-springboot整合
Link的博客
01-07 469
官方手册 https://github.com/apache/rocketmq-spring/wiki/用户手册 引包 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-spring-boot-starter</artifa...
rocketmq5.1高可用部署
07-27
RocketMQ 5.1 支持高可用部署，可以通过以下步骤进行配置： 1. 部署多个 RocketMQ Broker：在不同的服务器上部署多个 Broker 实例，每个 Broker 实例都需要有自己的配置文件、日志目录和存储目录。确保每个 Broker 实例的 `brokerName` 和 `brokerId` 唯一。 2. 配置主从同步：为了实现高可用，每个 Broker 实例都需要配置主从同步。在配置文件中设置 `brokerRole=ASYNC_MASTER`，同时指定 `namesrvAddr` 参数指向 NameServer 地址。 3. 配置消息复制策略：通过配置 `messageStoreConfig` 参数，指定消息复制策略。可以选择同步复制或异步复制，以满足不同的需求。 4. 配置高可用的 NameServer：为了实现高可用，可以部署多个 NameServer 实例，并在配置文件中指定多个 NameServer 地址，以提高系统的可靠性。 5. 配置客户端负载均衡：在客户端使用 RocketMQ 的时候，可以配置多个 NameServer 地址，以实现负载均衡和故障切换。 6. 监控和告警：使用 RocketMQ 提供的监控工具和告警机制，及时发现和解决系统中的异常情况。 这些步骤可以帮助您实现 RocketMQ 5.1 的高可用部署。具体的配置参数和部署方式可以参考 RocketMQ 的官方文档或者相关的技术博客。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

只因为你温柔

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值