springboot + rocketmq

1、pom文件

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

2、配置文件

#rocketmq 相关配置
#服务端地址
rocketmq.name-server=
#消息生产者组
rocketmq.producer.group=SI_ZJXT_REPORT
#生产者主题
rocketmq.producer.topic=ZJ_REPORT
#tag1
rocketmq.tag.approval=approval
#tag2
rocketmq.tag.archive=archive
# 消息体的最大允许大小。。默认为 4 * 1024 * 1024B
rocketmq.producer.max-message-size=4194304
# 同步发送消息时，失败重试次数。默认为 2 次。
rocketmq.producer.retry-times-when-send-failed=2 
# 异步发送消息时，失败重试次数。默认为 2 次
rocketmq.producer.retry-times-when-send-async-failed=2
#发送消息超时时间，单位：毫秒。默认为 3000
rocketmq.producer.send-message-timeout=3000

#密钥配置
rocketmq.producer.access-key=
rocketmq.producer.secret-key=
rocketmq.consumer.access-key=
rocketmq.consumer.secret-key=

3、生产者

package com.zhuoyue.mq;

import cn.hutool.core.lang.UUID;
import cn.hutool.json.JSONUtil;
import com.zhuoyue.auth.exception.ZYException;
import org.apache.rocketmq.client.producer.*;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.apache.rocketmq.spring.support.RocketMQHeaders;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * 生产者组件
 * @Author daijie
 * @Date 2022/4/18 17:03
 * @Version 1.0
 */
@Component
public class ProducerComponent {
    protected Logger logger = LoggerFactory.getLogger(getClass());

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

    @Autowired
    private RocketMQTemplate rocketMQTemplate;


    /**
     * 发送同步消息(String)
     * 有返回值 SendStatus.SEND_OK = sendResult.getSendStatus()返回成功
     * @param tag
     * @param msg
     * @return
     */
    public SendResult syncSend(String tag,String msg){
        return rocketMQTemplate.syncSend(topic+":"+tag,msg);
    }

    /**
     * 发送同步消息(Map)
     * 消息发送方发出数据后，会在收到接收方发回响应之后才发下一个数据包的通讯方式
     * @param tag
     * @param map
     * @return
     */
    public SendResult syncSend(String tag, Map<String,Object>map){
        return rocketMQTemplate.syncSend(topic+":"+tag, MessageBuilder.withPayload(map).build());
    }

    /**
     * 发送异步消息（String）
     *
     * @param tag
     * @param msg
     */
    public void asyncSend(String tag,String msg){
        rocketMQTemplate.asyncSend(topic + ":" + tag, MessageBuilder.withPayload(msg).build(), new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                logger.info(topic + ":" + tag+"---异步消息发送成功"+ JSONUtil.toJsonStr(sendResult));
            }

            @Override
            public void onException(Throwable e) {
                logger.info(topic + ":" + tag+"---异步消息发送失败"+ e.getMessage());
                throw new ZYException("服务器异常，请联系管理员处理！");
            }
        });
    }

    /**
     * 发送异步消息（map）
     * 异步消息
     *      指发送方发出数据后，不等接收方发回响应，接着发送下个数据包
     *      关键实现异步发送回调接口（SendCallback）
     *      在执行消息的异步发送时应用不需要等待服务器响应即可直接返回，通过回调接口接收务器响应，并对服务器的响应结果进行处理
     *      这种方式任然需要返回发送消息任务的执行结果，异步不影响后续任务，不会造成阻塞
     * @param tag
     * @param map
     */
    public void asyncSend(String tag,Map<String,Object>map){
        rocketMQTemplate.asyncSend(topic + ":" + tag, MessageBuilder.withPayload(map).build(), new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                logger.info(topic + ":" + tag+"---异步消息发送成功"+ JSONUtil.toJsonStr(sendResult));
            }

            @Override
            public void onException(Throwable e) {
                logger.info(topic + ":" + tag+"---异步消息发送失败"+ e.getMessage());
                throw new ZYException("服务器异常，请联系管理员处理！");
            }
        });
    }

    /**
     * 分布式事务消息
     *生产者需要一个监听自己的类
     */
    public void transactionMQSend(String tag,Map<String,Object>map) {
        Message<Map<String,Object>> message=MessageBuilder
                .withPayload(map)
                .setHeader(RocketMQHeaders.TRANSACTION_ID, UUID.randomUUID())
                .build();
        TransactionSendResult result=rocketMQTemplate.sendMessageInTransaction(topic + ":" + tag, message, null);
        if(result.getLocalTransactionState().equals(LocalTransactionState.COMMIT_MESSAGE)
                &&
                result.getSendStatus().equals(SendStatus.SEND_OK)){
            logger.info("事务消息发送成功");

        }
        logger.info("事务消息发送结果:{}",result);
    }

    /**
     * 顺序消息
     *使用hashcode对topic队列数量取模得到对应队列
     * 使消息按照顺序被消费，顺序与生产出来的顺序一致
     * 比如同一个订单生成，付费顺序需要一致，可以按照订单id来当作hashkey
     */
    public void orderlyMQMessageSend(String id,String tag,Map<String,Object>map) {
        Message<Map<String,Object>> message=MessageBuilder
                .withPayload(map)
                .setHeader(RocketMQHeaders.TRANSACTION_ID, UUID.randomUUID())
                .build();
        //同步顺序，也可以是其他类型比如异步顺序，单向顺序
        rocketMQTemplate.syncSendOrderly(topic + ":" + tag, message,id);
        logger.info("单向消息已发送");
    }

    /**
     * 延迟消息
     * rocketMQ的延迟消息发送其实是已发送就已经到broker端了，然后消费端会延迟收到消息。
     * RocketMQ 目前只支持固定精度的定时消息。
     * 固定等级：1到18分别对应1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
     * 延迟的底层方法是用定时任务实现的。
     */
    public void delayedSendMQMessageSend(String tag,Map<String,Object>map) {
        SendCallback sc=new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                logger.info("发送异步延时消息成功");
            }

            @Override
            public void onException(Throwable throwable) {
                logger.info("发送异步延时消息失败:{}",throwable.getMessage());
            }
        };
        Message<Map<String,Object>> message=MessageBuilder.withPayload(map).build();
        //异步延时
        rocketMQTemplate.asyncSend(topic + ":" + tag, message, sc, 3000, 3);
        //同步延时（少一个sendCallback）
        SendResult result=rocketMQTemplate.syncSend(topic + ":" + tag, message, 3000, 3);
        logger.info("发送同步延时消息成功:{}",result);
    }

    /**
     * 单向消息
     * 特点为只负责发送消息，不等待服务器回应且没有回调函数触发，即只发送请求不等待应答
     * 此方式发送消息的过程耗时非常短，一般在微秒级别
     * 应用场景：适用于某些耗时非常短，但对可靠性要求并不高的场景，例如日志收集
     */
    public void oneWaySendMQMessageSend(String tag,Map<String,Object>map) {
        rocketMQTemplate.sendOneWay(topic + ":" + tag, map);
        logger.info("单向消息已发送");
    }


}

4、消费者

package com.zhuoyue.mq;

import cn.hutool.core.map.MapUtil;
import com.zhuoyue.common.ReportPdfComponent;
import com.zhuoyue.zyreport.dao.GgBgpzdjmDao;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.annotation.SelectorType;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * 消费消息
 * 同步消息消费者
 * 异步消息消费者
 * 单向消息消费者
 * 延时消息消费者
 * @Author daijie
 * @Date 2022/4/18 17:52
 * @Version 1.0
 */
/*
消费类型
consumeMode = ConsumeMode.ORDERLY 顺序消费
ConsumeMode.CONCURRENTLY--------->其他消息
过滤标签
SelectorType.TAG ----->selectorExpression = “tagName”
SelectorType.SQL92 --------->selectorExpression =“sql语法条件”
topic
指定主题
consumerGroup
指定消费者组名称，通常对应一个topic
 */
@RocketMQMessageListener(
        selectorType = SelectorType.TAG,
        consumerGroup = "${rocketmq.producer.group}",
        topic = "${rocketmq.producer.topic}",
        selectorExpression = "${rocketmq.tag.approval}")
@Component
public class ReportApprovalConsumer implements RocketMQListener<Map<String,Object>> {

    protected Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private ReportPdfComponent reportPdfComponent;

    @Autowired
    private GgBgpzdjmDao ggBgpzdjmDao;

    @Override
    public void onMessage(Map<String, Object> message) {
        String bgbh = MapUtil.getStr(message,"bgbh");
        String sbzl = MapUtil.getStr(message,"sblb");
        String inputType = MapUtil.getStr(message,"inputType");
        String jynr = MapUtil.getStr(message,"jynr");
        String dah = MapUtil.getStr(message,"dah");

        //reportPdfComponent.approveFileSeal(bgbh,sbzl,inputType,jynr,dah);
    }
}

package com.zhuoyue.mq;
import org.apache.rocketmq.spring.annotation.RocketMQTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionState;
import org.apache.rocketmq.spring.support.RocketMQHeaders;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.messaging.Message;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 事物消息消费者
 * 发送方向 MQ 服务端发送消息。
 * MQ Server 将消息持久化成功之后，向发送方 ACK 确认消息已经发送成功，此时消息为半消息。
 * 发送方开始执行本地事务逻辑。
 * 发送方根据本地事务执行结果向 MQ Server 提交二次确认（Commit 或是 Rollback），MQ Server 收到 Commit 状态则将半消息标记为可投递，订阅方最终将收到该消息；MQ Server 收到 Rollback 状态则删除半 消息，订阅方将不会接受该消息。
 * 在断网或者是应用重启的特殊情况下，上述步骤4提交的二次确认最终未到达 MQ Server，经过固定时间后 MQ Server 将对该消息发起消息回查。
 * 发送方收到消息回查后，需要检查对应消息的本地事务执行的最终结果。
 * 发送方根据检查得到的本地事务的最终状态再次提交二次确认，MQ Server 仍按照步骤4对半消息进行操作。
 *
 * producer需要一个监听类
 * @Author daijie
 * @Date 2022/4/19 8:56
 * @Version 1.0
 */
@RocketMQTransactionListener
public class TransactionListner implements RocketMQLocalTransactionListener {
    protected Logger logger = LoggerFactory.getLogger(getClass());
    //保障线程安全且保证高性能的hashmap，用来记录执行结果
    private static Map<String,RocketMQLocalTransactionState> transStateMap=new ConcurrentHashMap<>();
    //执行本地事务
    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message message, Object o) {
        //方法里的object o这个对象是生产者发送消息方法最后一个参数的值
        String transId=(String)message.getHeaders().get(RocketMQHeaders.TRANSACTION_ID);
        logger .info("事务id:{}",transId);
        try {
            //模拟执行任务
            Thread.sleep(10000);
            //执行成功后记录执行结果
            transStateMap.put(transId, RocketMQLocalTransactionState.COMMIT);
            return RocketMQLocalTransactionState.COMMIT;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //try以外执行失败后
        transStateMap.put(transId, RocketMQLocalTransactionState.ROLLBACK);
        return RocketMQLocalTransactionState.ROLLBACK;
    }

    //回查
    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(Message message) {
        String transId = (String)message.getHeaders().get(RocketMQHeaders.TRANSACTION_ID);
         logger .info("回查消息");
        return transStateMap.get(transId);
    }
}